ccgx-workflow 2.4.1 → 2.5.0

package/templates/scripts/ccg-team-schedule.cjs

@@ -0,0 +1,328 @@
+#!/usr/bin/env node
+// CCG Team Schedule CLI — P1-6 (team-exec 任务级拓扑分波的权威导出器).
+//
+// Standalone Node CJS reimplementation of the task-wave section of
+// src/utils/wave-scheduler.ts (buildTaskWaves / splitWaveByFileOverlap /
+// validateTaskGraph). The TS version ships in ccgx-workflow's dist for
+// package consumers; but /ccg:team-exec Step 2 runs in the USER's project,
+// which has no ccgx-workflow npm dependency.
+//
+// installer.ts copies this file to ~/.claude/.ccg/scripts/ccg-team-schedule.cjs.
+// Command templates call:
+//
+//   node ~/.claude/.ccg/scripts/ccg-team-schedule.cjs --tasks <json-file>
+//
+// Input JSON (snake_case, aligned with the plan file `tasks:` yaml block):
+//   [{"id":"T1","files":["src/a.ts"],"depends_on":[],"wave":1,"status":"pending"}]
+//   - `wave` / `status` optional (status defaults to "pending")
+//
+// stdout: {"waves":[["T1","T2"],["T3"]],"skipped":[],"warnings":[]}
+// Exit 0 = success. Exit 1 = invalid graph (cycle / unknown depends_on
+// reference / duplicate id, listed on stderr) or bad args / IO error.
+//
+// Logic must stay in lockstep with src/utils/wave-scheduler.ts. The shared
+// fixtures in __tests__/teamScheduleCjs.test.ts pin both implementations.
+
+'use strict';
+
+const fs = require('node:fs');
+
+// ─────────────────────────────────────────────────────────────────
+// Graph validation (mirrors wave-scheduler.ts validateTaskGraph)
+// ─────────────────────────────────────────────────────────────────
+
+function validateTaskGraph(tasks) {
+  const errors = [];
+  const seen = new Set();
+  for (const t of tasks) {
+    if (seen.has(t.id)) errors.push(`duplicate task id "${t.id}"`);
+    seen.add(t.id);
+  }
+  for (const t of tasks) {
+    for (const dep of t.dependsOn) {
+      if (dep === t.id) errors.push(`task "${t.id}" depends on itself`);
+      else if (!seen.has(dep)) errors.push(`task "${t.id}" depends on unknown task "${dep}"`);
+    }
+  }
+  return errors;
+}
+
+// ─────────────────────────────────────────────────────────────────
+// Kahn topological waves (mirrors wave-scheduler.ts buildWaves)
+// ─────────────────────────────────────────────────────────────────
+
+function buildWaves(phases) {
+  if (phases.length === 0) return [];
+
+  const idToPhase = new Map();
+  for (const p of phases) idToPhase.set(p.id, p);
+
+  for (const p of phases) {
+    for (const dep of p.dependsOn) {
+      if (!idToPhase.has(dep)) {
+        throw new Error(`wave-scheduler: Phase ${p.id} depends on unknown Phase ${dep}`);
+      }
+    }
+  }
+
+  const remaining = new Set(phases.map((p) => p.id));
+  const remainingDeps = new Map();
+  for (const p of phases) remainingDeps.set(p.id, new Set(p.dependsOn));
+
+  const waves = [];
+  while (remaining.size > 0) {
+    const ready = [];
+    for (const p of phases) {
+      if (!remaining.has(p.id)) continue;
+      const deps = remainingDeps.get(p.id);
+      if (!deps || deps.size === 0) ready.push(p.id);
+    }
+    if (ready.length === 0) {
+      const stuck = Array.from(remaining).join(', ');
+      throw new Error(`wave-scheduler: dependency cycle detected among phases: ${stuck}`);
+    }
+    waves.push(ready);
+    for (const id of ready) {
+      remaining.delete(id);
+      for (const set of remainingDeps.values()) set.delete(id);
+    }
+  }
+  return waves;
+}
+
+// ─────────────────────────────────────────────────────────────────
+// Cascade skip (mirrors wave-scheduler.ts cascadeSkip)
+// ─────────────────────────────────────────────────────────────────
+
+function cascadeSkip(phases) {
+  const blocked = new Set();
+  for (const p of phases) {
+    if (p.status === 'failed' || p.status === 'skipped') blocked.add(p.id);
+  }
+
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const p of phases) {
+      if (blocked.has(p.id)) continue;
+      for (const dep of p.dependsOn) {
+        if (blocked.has(dep)) {
+          blocked.add(p.id);
+          changed = true;
+          break;
+        }
+      }
+    }
+  }
+
+  const result = [];
+  for (const p of phases) {
+    if (blocked.has(p.id) && p.status !== 'failed' && p.status !== 'skipped') result.push(p.id);
+  }
+  return result;
+}
+
+// ─────────────────────────────────────────────────────────────────
+// High-level schedule (mirrors wave-scheduler.ts schedule, no batches)
+// ─────────────────────────────────────────────────────────────────
+
+function schedulePhases(phases) {
+  const cascaded = cascadeSkip(phases);
+  const cascadedSet = new Set(cascaded);
+
+  const schedulable = phases.filter((p) => {
+    if (p.status === 'completed') return false;
+    if (p.status === 'failed' || p.status === 'skipped') return false;
+    if (cascadedSet.has(p.id)) return false;
+    return true;
+  });
+
+  const completedSet = new Set(phases.filter((p) => p.status === 'completed').map((p) => p.id));
+  const droppedDeps = new Set([
+    ...cascadedSet,
+    ...phases.filter((p) => p.status === 'failed' || p.status === 'skipped').map((p) => p.id),
+  ]);
+  const finalPhases = schedulable.map((p) => ({
+    ...p,
+    dependsOn: p.dependsOn.filter((d) => !completedSet.has(d) && !droppedDeps.has(d)),
+  }));
+
+  return { waves: buildWaves(finalPhases), skipped: cascaded };
+}
+
+// ─────────────────────────────────────────────────────────────────
+// File-overlap split (mirrors wave-scheduler.ts splitWaveByFileOverlap)
+// ─────────────────────────────────────────────────────────────────
+
+function normalizeTaskFile(p) {
+  return String(p).replace(/\\/g, '/').trim();
+}
+
+function splitWaveByFileOverlap(waveTaskIds, filesById) {
+  const subWaves = [];
+  const subWaveFiles = [];
+  for (const id of waveTaskIds) {
+    const files = (filesById.get(id) || []).map(normalizeTaskFile);
+    let placed = false;
+    for (let i = 0; i < subWaves.length; i++) {
+      if (!files.some((f) => subWaveFiles[i].has(f))) {
+        subWaves[i].push(id);
+        for (const f of files) subWaveFiles[i].add(f);
+        placed = true;
+        break;
+      }
+    }
+    if (!placed) {
+      subWaves.push([id]);
+      subWaveFiles.push(new Set(files));
+    }
+  }
+  return subWaves;
+}
+
+function findFileConflict(taskId, orderedIds, filesById) {
+  const files = new Set((filesById.get(taskId) || []).map(normalizeTaskFile));
+  for (const otherId of orderedIds) {
+    if (otherId === taskId) break;
+    for (const f of (filesById.get(otherId) || []).map(normalizeTaskFile)) {
+      if (files.has(f)) return { otherId, file: f };
+    }
+  }
+  return null;
+}
+
+// ─────────────────────────────────────────────────────────────────
+// buildTaskWaves (mirrors wave-scheduler.ts buildTaskWaves)
+// ─────────────────────────────────────────────────────────────────
+
+function buildTaskWaves(tasks) {
+  const errors = validateTaskGraph(tasks);
+  if (errors.length > 0) {
+    throw new Error(`wave-scheduler: invalid task graph:\n- ${errors.join('\n- ')}`);
+  }
+
+  const phases = tasks.map((t) => ({
+    id: t.id,
+    name: t.id,
+    status: t.status || 'pending',
+    dependsOn: [...t.dependsOn],
+  }));
+  const { waves: rawWaves, skipped } = schedulePhases(phases);
+
+  const filesById = new Map();
+  for (const t of tasks) filesById.set(t.id, t.files);
+
+  const warnings = [];
+  const finalWaves = [];
+  for (let w = 0; w < rawWaves.length; w++) {
+    const wave = rawWaves[w];
+    const subWaves = splitWaveByFileOverlap(wave, filesById);
+    if (subWaves.length > 1) {
+      for (let k = 1; k < subWaves.length; k++) {
+        for (const id of subWaves[k]) {
+          const conflict = findFileConflict(id, wave, filesById);
+          if (conflict) {
+            warnings.push(`wave ${w + 1} split: ${conflict.otherId}/${id} share file ${conflict.file}`);
+          }
+        }
+      }
+    }
+    finalWaves.push(...subWaves);
+  }
+
+  const derivedWaveById = new Map();
+  finalWaves.forEach((wave, i) => {
+    for (const id of wave) derivedWaveById.set(id, i + 1);
+  });
+  for (const t of tasks) {
+    if (typeof t.declaredWave !== 'number') continue;
+    const derived = derivedWaveById.get(t.id);
+    if (derived !== undefined && derived !== t.declaredWave) {
+      warnings.push(`task ${t.id}: declared wave ${t.declaredWave} but derived wave ${derived} (derived wins)`);
+    }
+  }
+
+  return { waves: finalWaves, skipped, warnings };
+}
+
+// ─────────────────────────────────────────────────────────────────
+// CLI
+// ─────────────────────────────────────────────────────────────────
+
+const VALID_STATUSES = new Set(['pending', 'in_progress', 'completed', 'failed', 'skipped']);
+
+function parseArgs(argv) {
+  const out = { tasks: null, help: false, bad: false };
+  for (let i = 2; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === '--tasks') {
+      out.tasks = argv[++i] || null;
+    } else if (arg === '--help' || arg === '-h') {
+      out.help = true;
+    } else {
+      process.stderr.write(`ccg-team-schedule: unknown flag ${arg}\n`);
+      out.bad = true;
+    }
+  }
+  return out;
+}
+
+function usage() {
+  return [
+    'Usage: node ccg-team-schedule.cjs --tasks <json-file>',
+    '',
+    'Input JSON: [{"id":"T1","files":["src/a.ts"],"depends_on":[],"wave":1,"status":"pending"}]',
+    'stdout:     {"waves":[["T1"]],"skipped":[],"warnings":[]}',
+    'Exit 1 on invalid graph (cycle / unknown reference / duplicate id) or bad args.',
+  ].join('\n');
+}
+
+/** snake_case plan-yaml shape → camelCase internal PlanTask shape. */
+function normalizeInputTask(raw, index) {
+  if (!raw || typeof raw !== 'object') throw new Error(`task #${index + 1} is not an object`);
+  const id = typeof raw.id === 'string' && raw.id.trim() ? raw.id.trim() : `T${index + 1}`;
+  const files = Array.isArray(raw.files) ? raw.files.map(String) : [];
+  const dependsOn = Array.isArray(raw.depends_on) ? raw.depends_on.map(String) : [];
+  const status = typeof raw.status === 'string' && VALID_STATUSES.has(raw.status) ? raw.status : 'pending';
+  const task = { id, files, dependsOn, status };
+  if (typeof raw.wave === 'number') task.declaredWave = raw.wave;
+  return task;
+}
+
+function main(argv) {
+  const args = parseArgs(argv);
+  if (args.help) {
+    process.stderr.write(usage() + '\n');
+    return 0;
+  }
+  if (args.bad || !args.tasks) {
+    process.stderr.write(usage() + '\n');
+    return 1;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(fs.readFileSync(args.tasks, 'utf-8'));
+  } catch (err) {
+    process.stderr.write(`ccg-team-schedule: cannot read tasks file: ${err.message}\n`);
+    return 1;
+  }
+  if (!Array.isArray(parsed)) {
+    process.stderr.write('ccg-team-schedule: tasks JSON must be an array\n');
+    return 1;
+  }
+  try {
+    const tasks = parsed.map(normalizeInputTask);
+    const result = buildTaskWaves(tasks);
+    process.stdout.write(JSON.stringify(result) + '\n');
+    return 0;
+  } catch (err) {
+    process.stderr.write(`ccg-team-schedule: ${err.message}\n`);
+    return 1;
+  }
+}
+
+module.exports = { buildTaskWaves, splitWaveByFileOverlap, validateTaskGraph, parseArgs, main };
+
+if (require.main === module) {
+  process.exit(main(process.argv));
+}