タスクの循環依存を着手前に発見｜GASで前後関係をdry-run監査

const CONFIG = Object.freeze({
  DRY_RUN: true,
  SHEET_NAME: 'タスク依存関係',
  MAX_ROWS: 200,
  LOG_TASK_NAME: false,
  ALLOWED_STATUS: ['backlog', 'ready', 'doing', 'done', 'hold']
});

function auditTaskDependencyPlanFree() {
  if (CONFIG.DRY_RUN !== true) {
    throw new Error('安全のためDRY_RUNはtrue固定です');
  }
  if (!Number.isInteger(CONFIG.MAX_ROWS) ||
      CONFIG.MAX_ROWS < 1 || CONFIG.MAX_ROWS > 200) {
    throw new Error('MAX_ROWSは1〜200で指定してください');
  }

  const sheet = SpreadsheetApp.getActiveSpreadsheet()
    .getSheetByName(CONFIG.SHEET_NAME);
  if (!sheet) {
    throw new Error('タスク依存関係シートが見つかりません');
  }

  const values = sheet.getDataRange().getValues();
  if (values.length < 2) {
    throw new Error('確認するタスクを1件以上入力してください');
  }

  const expectedHeaders = [
    'task_id', 'task_name', 'depends_on',
    'status', 'due_date', 'owner_role'
  ];
  const actualHeaders = values[0].map(value => String(value).trim());
  if (expectedHeaders.some((header, index) => actualHeaders[index] !== header)) {
    throw new Error('1行目の見出しを指定どおりにしてください');
  }

  const issues = [];
  const taskMap = new Map();
  const rows = values.slice(1, CONFIG.MAX_ROWS + 1);

  rows.forEach((row, index) => {
    const rowNumber = index + 2;
    const taskId = String(row[0] || '').trim();
    const taskName = String(row[1] || '').trim();
    const dependencyIds = String(row[2] || '')
      .split(',')
      .map(value => value.trim())
      .filter(Boolean);
    const status = String(row[3] || '').trim().toLowerCase();
    const dueDate = row[4];

    if (!taskId) {
      issues.push({ row: rowNumber, taskId: '', reason: 'task_idが空欄' });
      return;
    }
    if (taskMap.has(taskId)) {
      issues.push({ row: rowNumber, taskId, reason: 'task_idが重複' });
      return;
    }
    if (!taskName) {
      issues.push({ row: rowNumber, taskId, reason: 'task_nameが空欄' });
    }
    if (!CONFIG.ALLOWED_STATUS.includes(status)) {
      issues.push({ row: rowNumber, taskId, reason: 'statusが許可値外' });
    }
    if (dueDate && !(dueDate instanceof Date) &&
        Number.isNaN(Date.parse(String(dueDate)))) {
      issues.push({ row: rowNumber, taskId, reason: 'due_dateを日付として解釈できない' });
    }
    if (dependencyIds.includes(taskId)) {
      issues.push({ row: rowNumber, taskId, reason: '自分自身へ依存' });
    }

    taskMap.set(taskId, {
      row: rowNumber,
      taskName,
      dependencyIds: [...new Set(dependencyIds)],
      status
    });
  });

  taskMap.forEach((task, taskId) => {
    task.dependencyIds.forEach(dependencyId => {
      if (!taskMap.has(dependencyId)) {
        issues.push({
          row: task.row,
          taskId,
          reason: '依存先task_idが存在しない',
          dependencyId
        });
        return;
      }
      const dependency = taskMap.get(dependencyId);
      if (task.status === 'done' && dependency.status !== 'done') {
        issues.push({
          row: task.row,
          taskId,
          reason: '未完了の依存先があるのにdone',
          dependencyId
        });
      }
    });
  });

  const visiting = new Set();
  const visited = new Set();
  const cycleKeys = new Set();

  function visit(taskId, route) {
    if (visiting.has(taskId)) {
      const start = route.indexOf(taskId);
      const cycle = [...route.slice(start), taskId];
      const cycleKey = cycle.join('>');
      if (!cycleKeys.has(cycleKey)) {
        cycleKeys.add(cycleKey);
        issues.push({
          row: taskMap.get(taskId).row,
          taskId,
          reason: '循環依存',
          route: cycle
        });
      }
      return;
    }
    if (visited.has(taskId) || !taskMap.has(taskId)) {
      return;
    }

    visiting.add(taskId);
    const task = taskMap.get(taskId);
    task.dependencyIds.forEach(dependencyId => {
      visit(dependencyId, [...route, taskId]);
    });
    visiting.delete(taskId);
    visited.add(taskId);
  }

  taskMap.forEach((value, taskId) => visit(taskId, []));

  const result = {
    status: issues.length ? 'HOLD' : 'PASS',
    dryRun: CONFIG.DRY_RUN,
    checkedCount: taskMap.size,
    issueCount: issues.length,
    issues
  };

  if (CONFIG.LOG_TASK_NAME === true) {
    result.warning = 'タスク名をログへ出す設定です。機密情報がないか確認してください。';
  }

  Logger.log(JSON.stringify(result));
  if (issues.length) {
    throw new Error('タスクの前後関係にHOLDがあります');
  }
}