sdd-agent-platform 0.4.2 → 0.5.1

package/node_modules/@sdd-agent-platform/core/src/planning/wave-plan.test.ts

@@ -1,79 +1,79 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtemp, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-
-import { initProject } from '../config/init-project.js';
-import { doctor } from '../doctor/doctor.js';
-import { graphTaskMarkdown, writeBranchDocs } from '../test-support/fixtures.js';
-import { writeVerifyContract } from '../verification/verify-contract.js';
-import { inspectWavePlan } from './wave-plan.js';
-
-test('wave planner builds dependency waves and separates file overlaps', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-wave-valid-'));
-  try {
-    await initProject(root);
-    await writeBranchDocs(root, 'master', `# Tasks\n\n${graphTaskMarkdown('W1', [], ['src/a.ts'], [])}\n${graphTaskMarkdown('W2', [], ['./src/a.ts'], [])}\n${graphTaskMarkdown('W3', ['W1'], ['src/c.ts'], [])}`);
-    await writeVerifyContract(root, { branch: 'master', branchSource: 'cli_option', force: true });
-
-    const plan = await inspectWavePlan(root, { branch: 'master', capabilityId: 'native-file-edit' });
-
-    assert.equal(plan.version, 'phase-3.10-wave-planner-v1');
-    assert.equal(plan.valid, true);
-    assert.deepEqual(plan.waves.map((wave) => wave.tasks.map((task) => task.taskId)), [['W1'], ['W2', 'W3']]);
-    assert.equal(plan.manualGates.length, 0);
-    assert.equal(plan.blockedTasks.length, 0);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('wave planner routes manual gates and downstream blocked tasks', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-wave-manual-'));
-  try {
-    await initProject(root);
-    await writeBranchDocs(root, 'master', `# Tasks\n\n${graphTaskMarkdown('DB1', [], ['db/schema.sql'], ['database'])}\n${graphTaskMarkdown('APP1', ['DB1'], ['src/app.ts'], [])}`);
-    await writeVerifyContract(root, { branch: 'master', branchSource: 'cli_option', force: true });
-
-    const plan = await inspectWavePlan(root, { branch: 'master', capabilityId: 'native-file-edit' });
-
-    assert.equal(plan.valid, false);
-    assert.deepEqual(plan.manualGates.map((gate) => gate.taskId), ['DB1']);
-    assert.deepEqual(plan.blockedTasks.map((gate) => gate.taskId), ['APP1']);
-    assert.match(plan.blockedTasks[0]?.reasons.join(' ') ?? '', /depends on non-plannable task\(s\): DB1/);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('wave planner blocks graph diagnostics', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-wave-blocked-'));
-  try {
-    await initProject(root);
-    await writeBranchDocs(root, 'master', `# Tasks\n\n${graphTaskMarkdown('M1', ['M404'], ['src/m1.ts'], [])}`);
-
-    const plan = await inspectWavePlan(root, { branch: 'master', capabilityId: 'native-file-edit' });
-
-    assert.equal(plan.valid, false);
-    assert.deepEqual(plan.blockedTasks.map((gate) => gate.taskId), ['M1']);
-    assert.equal(plan.diagnostics.some((diagnostic) => /unknown task M404/.test(diagnostic.message)), true);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('doctor reports wave planner contract visibility', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-wave-doctor-'));
-  try {
-    await initProject(root);
-
-    const report = await doctor(root, { latestOnly: true });
-    const check = report.checks.find((item) => item.check === 'wave_planner_contract');
-
-    assert.equal(check?.level, 'PASS');
-    assert.match(check?.message ?? '', /phase-3\.10-wave-planner-v1/);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+
+import { initProject } from '../config/init-project.js';
+import { doctor } from '../doctor/doctor.js';
+import { graphTaskMarkdown, writeBranchDocs } from '../test-support/fixtures.js';
+import { writeVerifyContract } from '../verification/verify-contract.js';
+import { inspectWavePlan } from './wave-plan.js';
+
+test('wave planner builds dependency waves and separates file overlaps', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-wave-valid-'));
+  try {
+    await initProject(root);
+    await writeBranchDocs(root, 'master', `# Tasks\n\n${graphTaskMarkdown('W1', [], ['src/a.ts'], [])}\n${graphTaskMarkdown('W2', [], ['./src/a.ts'], [])}\n${graphTaskMarkdown('W3', ['W1'], ['src/c.ts'], [])}`);
+    await writeVerifyContract(root, { branch: 'master', branchSource: 'cli_option', force: true });
+
+    const plan = await inspectWavePlan(root, { branch: 'master', capabilityId: 'native-file-edit' });
+
+    assert.equal(plan.version, 'phase-3.10-wave-planner-v1');
+    assert.equal(plan.valid, true);
+    assert.deepEqual(plan.waves.map((wave) => wave.tasks.map((task) => task.taskId)), [['W1'], ['W2', 'W3']]);
+    assert.equal(plan.manualGates.length, 0);
+    assert.equal(plan.blockedTasks.length, 0);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('wave planner routes manual gates and downstream blocked tasks', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-wave-manual-'));
+  try {
+    await initProject(root);
+    await writeBranchDocs(root, 'master', `# Tasks\n\n${graphTaskMarkdown('DB1', [], ['db/schema.sql'], ['database'])}\n${graphTaskMarkdown('APP1', ['DB1'], ['src/app.ts'], [])}`);
+    await writeVerifyContract(root, { branch: 'master', branchSource: 'cli_option', force: true });
+
+    const plan = await inspectWavePlan(root, { branch: 'master', capabilityId: 'native-file-edit' });
+
+    assert.equal(plan.valid, false);
+    assert.deepEqual(plan.manualGates.map((gate) => gate.taskId), ['DB1']);
+    assert.deepEqual(plan.blockedTasks.map((gate) => gate.taskId), ['APP1']);
+    assert.match(plan.blockedTasks[0]?.reasons.join(' ') ?? '', /depends on non-plannable task\(s\): DB1/);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('wave planner blocks graph diagnostics', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-wave-blocked-'));
+  try {
+    await initProject(root);
+    await writeBranchDocs(root, 'master', `# Tasks\n\n${graphTaskMarkdown('M1', ['M404'], ['src/m1.ts'], [])}`);
+
+    const plan = await inspectWavePlan(root, { branch: 'master', capabilityId: 'native-file-edit' });
+
+    assert.equal(plan.valid, false);
+    assert.deepEqual(plan.blockedTasks.map((gate) => gate.taskId), ['M1']);
+    assert.equal(plan.diagnostics.some((diagnostic) => /unknown task M404/.test(diagnostic.message)), true);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('doctor reports wave planner contract visibility', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-wave-doctor-'));
+  try {
+    await initProject(root);
+
+    const report = await doctor(root, { latestOnly: true });
+    const check = report.checks.find((item) => item.check === 'wave_planner_contract');
+
+    assert.equal(check?.level, 'PASS');
+    assert.match(check?.message ?? '', /phase-3\.10-wave-planner-v1/);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});

package/node_modules/@sdd-agent-platform/core/src/planning/wave-plan.ts

@@ -1,160 +1,160 @@
-import { WAVE_PLANNER_CONTRACT_VERSION } from '../contracts.js';
-import { resolveSddContext } from '../sdd-docs/context.js';
-import { inspectTaskGraph } from './task-graph.js';
-import type { TaskGraphDiagnostic, TaskGraphNode, TaskGraphPlan } from './task-graph.js';
-import { inspectWorktreeIsolation } from '../worktree/isolation.js';
-import type { WorktreeIsolationDecision, WorktreeIsolationMode } from '../worktree/isolation.js';
-
-export interface WavePlanTask {
-  taskId: string;
-  isolationMode: WorktreeIsolationMode;
-  reasons: string[];
-}
-
-export interface WavePlanWave {
-  index: number;
-  tasks: WavePlanTask[];
-}
-
-export interface WavePlanGate {
-  taskId: string;
-  gate: 'manual' | 'blocked';
-  reasons: string[];
-}
-
-export interface WavePlan {
-  version: typeof WAVE_PLANNER_CONTRACT_VERSION;
-  branch: string;
-  valid: boolean;
-  waves: WavePlanWave[];
-  manualGates: WavePlanGate[];
-  blockedTasks: WavePlanGate[];
-  diagnostics: TaskGraphDiagnostic[];
-  summary: {
-    tasks: number;
-    waves: number;
-    plannedTasks: number;
-    manualTasks: number;
-    blockedTasks: number;
-  };
-}
-
-export async function inspectWavePlan(projectRoot: string, options: { branch?: string; capabilityId?: string } = {}): Promise<WavePlan> {
-  const branch = options.branch ?? (await resolveSddContext(projectRoot)).branch;
-  const capabilityId = options.capabilityId ?? 'native-file-edit';
-  const graph = await inspectTaskGraph(projectRoot, { branch });
-  const taskIds = new Set(graph.nodes.map((node) => node.taskId));
-  const blockingDiagnostics = graph.diagnostics.filter((diagnostic) => diagnostic.severity === 'blocking');
-  const globalBlocking = blockingDiagnostics.filter((diagnostic) => diagnostic.taskId === null);
-  const blockingByTask = new Map<string, string[]>();
-  for (const diagnostic of blockingDiagnostics.filter((candidate) => candidate.taskId !== null)) {
-    const reasons = blockingByTask.get(diagnostic.taskId ?? '') ?? [];
-    reasons.push(diagnostic.message);
-    blockingByTask.set(diagnostic.taskId ?? '', reasons);
-  }
-
-  const decisions = new Map<string, WorktreeIsolationDecision>();
-  await Promise.all(graph.nodes.map(async (node) => {
-    decisions.set(node.taskId, await inspectWorktreeIsolation(projectRoot, { branch, taskId: node.taskId, capabilityId }));
-  }));
-
-  const manualGates: WavePlanGate[] = [];
-  const blockedTasks: WavePlanGate[] = [];
-  const blockedTaskIds = new Set<string>();
-  const manualTaskIds = new Set<string>();
-  const candidates = new Map<string, TaskGraphNode>();
-
-  for (const node of graph.nodes) {
-    const decision = decisions.get(node.taskId);
-    const diagnosticReasons = blockingByTask.get(node.taskId) ?? [];
-    if (globalBlocking.length > 0) {
-      blockedTasks.push({ taskId: node.taskId, gate: 'blocked', reasons: globalBlocking.map((diagnostic) => diagnostic.message) });
-      blockedTaskIds.add(node.taskId);
-    } else if (diagnosticReasons.length > 0) {
-      blockedTasks.push({ taskId: node.taskId, gate: 'blocked', reasons: diagnosticReasons });
-      blockedTaskIds.add(node.taskId);
-    } else if (!decision || decision.mode === 'blocked') {
-      blockedTasks.push({ taskId: node.taskId, gate: 'blocked', reasons: decision?.reasons ?? [`Task ${node.taskId} cannot be inspected for isolation.`] });
-      blockedTaskIds.add(node.taskId);
-    } else if (decision.mode === 'manual') {
-      manualGates.push({ taskId: node.taskId, gate: 'manual', reasons: decision.reasons });
-      manualTaskIds.add(node.taskId);
-    } else {
-      candidates.set(node.taskId, node);
-    }
-  }
-
-  let changed = true;
-  while (changed) {
-    changed = false;
-    for (const [taskId, node] of [...candidates]) {
-      const blockedDependencies = node.dependsOn.filter((dependency) => !taskIds.has(dependency) || blockedTaskIds.has(dependency) || manualTaskIds.has(dependency));
-      if (blockedDependencies.length > 0) {
-        blockedTasks.push({
-          taskId,
-          gate: 'blocked',
-          reasons: [`Task ${taskId} depends on non-plannable task(s): ${blockedDependencies.join(', ')}.`]
-        });
-        blockedTaskIds.add(taskId);
-        candidates.delete(taskId);
-        changed = true;
-      }
-    }
-  }
-
-  const waves: WavePlanWave[] = [];
-  const completed = new Set<string>();
-  const remaining = new Map(candidates);
-  while (remaining.size > 0) {
-    const ready = [...remaining.values()]
-      .filter((node) => node.dependsOn.every((dependency) => completed.has(dependency)))
-      .sort((left, right) => left.taskId.localeCompare(right.taskId));
-    if (ready.length === 0) {
-      for (const taskId of remaining.keys()) {
-        blockedTasks.push({ taskId, gate: 'blocked', reasons: [`Task ${taskId} cannot be placed in a dependency wave.`] });
-        blockedTaskIds.add(taskId);
-      }
-      break;
-    }
-    const waveNodes: TaskGraphNode[] = [];
-    for (const node of ready) {
-      if (!waveNodes.some((candidate) => graphTasksOverlap(graph, candidate.taskId, node.taskId))) {
-        waveNodes.push(node);
-      }
-    }
-    const tasks = waveNodes.map((node): WavePlanTask => ({
-      taskId: node.taskId,
-      isolationMode: decisions.get(node.taskId)?.mode ?? 'blocked',
-      reasons: decisions.get(node.taskId)?.reasons ?? []
-    }));
-    waves.push({ index: waves.length + 1, tasks });
-    for (const node of waveNodes) {
-      remaining.delete(node.taskId);
-      completed.add(node.taskId);
-    }
-  }
-
-  const plannedTasks = waves.reduce((count, wave) => count + wave.tasks.length, 0);
-  return {
-    version: WAVE_PLANNER_CONTRACT_VERSION,
-    branch,
-    valid: graph.valid && blockedTasks.length === 0,
-    waves,
-    manualGates,
-    blockedTasks,
-    diagnostics: graph.diagnostics,
-    summary: {
-      tasks: graph.nodes.length,
-      waves: waves.length,
-      plannedTasks,
-      manualTasks: manualGates.length,
-      blockedTasks: blockedTasks.length
-    }
-  };
-}
-
-function graphTasksOverlap(graph: TaskGraphPlan, leftTaskId: string, rightTaskId: string): boolean {
-  return graph.fileOverlapEdges.some((edge) =>
-    (edge.from === leftTaskId && edge.to === rightTaskId) || (edge.from === rightTaskId && edge.to === leftTaskId)
-  );
-}
+import { WAVE_PLANNER_CONTRACT_VERSION } from '../contracts.js';
+import { resolveSddContext } from '../sdd-docs/context.js';
+import { inspectTaskGraph } from './task-graph.js';
+import type { TaskGraphDiagnostic, TaskGraphNode, TaskGraphPlan } from './task-graph.js';
+import { inspectWorktreeIsolation } from '../worktree/isolation.js';
+import type { WorktreeIsolationDecision, WorktreeIsolationMode } from '../worktree/isolation.js';
+
+export interface WavePlanTask {
+  taskId: string;
+  isolationMode: WorktreeIsolationMode;
+  reasons: string[];
+}
+
+export interface WavePlanWave {
+  index: number;
+  tasks: WavePlanTask[];
+}
+
+export interface WavePlanGate {
+  taskId: string;
+  gate: 'manual' | 'blocked';
+  reasons: string[];
+}
+
+export interface WavePlan {
+  version: typeof WAVE_PLANNER_CONTRACT_VERSION;
+  branch: string;
+  valid: boolean;
+  waves: WavePlanWave[];
+  manualGates: WavePlanGate[];
+  blockedTasks: WavePlanGate[];
+  diagnostics: TaskGraphDiagnostic[];
+  summary: {
+    tasks: number;
+    waves: number;
+    plannedTasks: number;
+    manualTasks: number;
+    blockedTasks: number;
+  };
+}
+
+export async function inspectWavePlan(projectRoot: string, options: { branch?: string; capabilityId?: string } = {}): Promise<WavePlan> {
+  const branch = options.branch ?? (await resolveSddContext(projectRoot)).branch;
+  const capabilityId = options.capabilityId ?? 'native-file-edit';
+  const graph = await inspectTaskGraph(projectRoot, { branch });
+  const taskIds = new Set(graph.nodes.map((node) => node.taskId));
+  const blockingDiagnostics = graph.diagnostics.filter((diagnostic) => diagnostic.severity === 'blocking');
+  const globalBlocking = blockingDiagnostics.filter((diagnostic) => diagnostic.taskId === null);
+  const blockingByTask = new Map<string, string[]>();
+  for (const diagnostic of blockingDiagnostics.filter((candidate) => candidate.taskId !== null)) {
+    const reasons = blockingByTask.get(diagnostic.taskId ?? '') ?? [];
+    reasons.push(diagnostic.message);
+    blockingByTask.set(diagnostic.taskId ?? '', reasons);
+  }
+
+  const decisions = new Map<string, WorktreeIsolationDecision>();
+  await Promise.all(graph.nodes.map(async (node) => {
+    decisions.set(node.taskId, await inspectWorktreeIsolation(projectRoot, { branch, taskId: node.taskId, capabilityId }));
+  }));
+
+  const manualGates: WavePlanGate[] = [];
+  const blockedTasks: WavePlanGate[] = [];
+  const blockedTaskIds = new Set<string>();
+  const manualTaskIds = new Set<string>();
+  const candidates = new Map<string, TaskGraphNode>();
+
+  for (const node of graph.nodes) {
+    const decision = decisions.get(node.taskId);
+    const diagnosticReasons = blockingByTask.get(node.taskId) ?? [];
+    if (globalBlocking.length > 0) {
+      blockedTasks.push({ taskId: node.taskId, gate: 'blocked', reasons: globalBlocking.map((diagnostic) => diagnostic.message) });
+      blockedTaskIds.add(node.taskId);
+    } else if (diagnosticReasons.length > 0) {
+      blockedTasks.push({ taskId: node.taskId, gate: 'blocked', reasons: diagnosticReasons });
+      blockedTaskIds.add(node.taskId);
+    } else if (!decision || decision.mode === 'blocked') {
+      blockedTasks.push({ taskId: node.taskId, gate: 'blocked', reasons: decision?.reasons ?? [`Task ${node.taskId} cannot be inspected for isolation.`] });
+      blockedTaskIds.add(node.taskId);
+    } else if (decision.mode === 'manual') {
+      manualGates.push({ taskId: node.taskId, gate: 'manual', reasons: decision.reasons });
+      manualTaskIds.add(node.taskId);
+    } else {
+      candidates.set(node.taskId, node);
+    }
+  }
+
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const [taskId, node] of [...candidates]) {
+      const blockedDependencies = node.dependsOn.filter((dependency) => !taskIds.has(dependency) || blockedTaskIds.has(dependency) || manualTaskIds.has(dependency));
+      if (blockedDependencies.length > 0) {
+        blockedTasks.push({
+          taskId,
+          gate: 'blocked',
+          reasons: [`Task ${taskId} depends on non-plannable task(s): ${blockedDependencies.join(', ')}.`]
+        });
+        blockedTaskIds.add(taskId);
+        candidates.delete(taskId);
+        changed = true;
+      }
+    }
+  }
+
+  const waves: WavePlanWave[] = [];
+  const completed = new Set<string>();
+  const remaining = new Map(candidates);
+  while (remaining.size > 0) {
+    const ready = [...remaining.values()]
+      .filter((node) => node.dependsOn.every((dependency) => completed.has(dependency)))
+      .sort((left, right) => left.taskId.localeCompare(right.taskId));
+    if (ready.length === 0) {
+      for (const taskId of remaining.keys()) {
+        blockedTasks.push({ taskId, gate: 'blocked', reasons: [`Task ${taskId} cannot be placed in a dependency wave.`] });
+        blockedTaskIds.add(taskId);
+      }
+      break;
+    }
+    const waveNodes: TaskGraphNode[] = [];
+    for (const node of ready) {
+      if (!waveNodes.some((candidate) => graphTasksOverlap(graph, candidate.taskId, node.taskId))) {
+        waveNodes.push(node);
+      }
+    }
+    const tasks = waveNodes.map((node): WavePlanTask => ({
+      taskId: node.taskId,
+      isolationMode: decisions.get(node.taskId)?.mode ?? 'blocked',
+      reasons: decisions.get(node.taskId)?.reasons ?? []
+    }));
+    waves.push({ index: waves.length + 1, tasks });
+    for (const node of waveNodes) {
+      remaining.delete(node.taskId);
+      completed.add(node.taskId);
+    }
+  }
+
+  const plannedTasks = waves.reduce((count, wave) => count + wave.tasks.length, 0);
+  return {
+    version: WAVE_PLANNER_CONTRACT_VERSION,
+    branch,
+    valid: graph.valid && blockedTasks.length === 0,
+    waves,
+    manualGates,
+    blockedTasks,
+    diagnostics: graph.diagnostics,
+    summary: {
+      tasks: graph.nodes.length,
+      waves: waves.length,
+      plannedTasks,
+      manualTasks: manualGates.length,
+      blockedTasks: blockedTasks.length
+    }
+  };
+}
+
+function graphTasksOverlap(graph: TaskGraphPlan, leftTaskId: string, rightTaskId: string): boolean {
+  return graph.fileOverlapEdges.some((edge) =>
+    (edge.from === leftTaskId && edge.to === rightTaskId) || (edge.from === rightTaskId && edge.to === leftTaskId)
+  );
+}

package/node_modules/@sdd-agent-platform/core/src/planning.ts

@@ -1,2 +1,2 @@
-export * from './planning/task-graph.js';
-export * from './planning/wave-plan.js';
+export * from './planning/task-graph.js';
+export * from './planning/wave-plan.js';