@dtlabs/ai-toolkit 0.9.0 → 0.10.0

package/.claude/scripts/tests/wb-validate.checks-1-7.test.js

@@ -0,0 +1,330 @@
+'use strict';
+
+const { spawnSync } = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const VALIDATE = path.resolve(__dirname, '../wb-validate.js');
+const FIXTURES = path.resolve(__dirname, 'fixtures');
+
+/**
+ * Run wb-validate.js as a subprocess and return exit code, stdout, stderr,
+ * and the parsed JSON report (or null if stdout is not valid JSON).
+ */
+function runValidator(wbPath, reqPath) {
+  const args = [VALIDATE, wbPath];
+  if (reqPath) args.push(reqPath);
+  const result = spawnSync('node', args, { encoding: 'utf8' });
+  let report = null;
+  try { report = JSON.parse(result.stdout); } catch (_) {}
+  return { exitCode: result.status, stdout: result.stdout, stderr: result.stderr, report };
+}
+
+/**
+ * Minimal valid work breakdown JSON that passes all checks 1–23 when no
+ * requirements file is provided.  Used as a base for inline fixtures.
+ */
+const MINIMAL_VALID_WB = {
+  schemaVersion: 2,
+  phases: [
+    {
+      id: 'US-01',
+      type: 'user-story',
+      title: 'Test phase',
+      commit: 'feat(US-01): test',
+      tasks: [
+        {
+          id: 'US-01-TASK-BE-01',
+          title: 'A task',
+          outcome: 'Something is done',
+          domain: 'BE',
+          agentType: 'developer-backend',
+          dependsOn: [],
+          acceptanceCriteria: [],
+          verification: { commands: ['node --version'] },
+          estimate: { agentMinutes: 10, tokens: 5000 },
+          outputCount: 1,
+          groupingRationale: 'Single responsibility',
+          commit: { subject: 'feat(US-01): implement task' },
+        },
+      ],
+    },
+  ],
+};
+
+// ── helper — write a WB object to a temp file and return the path ─────────────
+
+function writeTmp(tmpFile, wb) {
+  fs.writeFileSync(tmpFile, JSON.stringify(wb));
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe('wb-validate.js — checks 1–7', () => {
+
+  // ── Check 1: missing file argument ──────────────────────────────────────────
+
+  describe('check 1 — missing file argument', () => {
+    test('exits with code 2 and reports "missing required argument" to stderr when no path argument is given', () => {
+      // Arrange: invoke the validator with no arguments at all
+      // Act
+      const result = spawnSync('node', [VALIDATE], { encoding: 'utf8' });
+      // Assert
+      expect(result.status).toBe(2);
+      expect(result.stderr).toContain('missing required argument');
+    });
+  });
+
+  // ── Check 2: schema version ──────────────────────────────────────────────────
+
+  describe('check 2 — schema version', () => {
+    let tmpFile;
+
+    beforeEach(() => {
+      tmpFile = path.join(os.tmpdir(), `wb-test-${Date.now()}.json`);
+    });
+
+    afterEach(() => {
+      try { fs.unlinkSync(tmpFile); } catch (_) {}
+    });
+
+    test('exits 0 and report.valid is true when schemaVersion is exactly 2', () => {
+      // Arrange
+      writeTmp(tmpFile, MINIMAL_VALID_WB);
+      // Act
+      const { exitCode, report } = runValidator(tmpFile);
+      // Assert
+      expect(exitCode).toBe(0);
+      expect(report.valid).toBe(true);
+    });
+
+    test('exits 1, report.valid is false, and schema_version_invalid is reported when schemaVersion is 1', () => {
+      // Arrange
+      writeTmp(tmpFile, { ...MINIMAL_VALID_WB, schemaVersion: 1 });
+      // Act
+      const { exitCode, report } = runValidator(tmpFile);
+      // Assert
+      expect(exitCode).toBe(1);
+      expect(report.valid).toBe(false);
+      expect(report.errors.some(e => e.category === 'schema_version_invalid')).toBe(true);
+    });
+
+    test('exits 1, report.valid is false, and schema_version_invalid is reported when schemaVersion is null', () => {
+      // Arrange
+      writeTmp(tmpFile, { ...MINIMAL_VALID_WB, schemaVersion: null });
+      // Act
+      const { exitCode, report } = runValidator(tmpFile);
+      // Assert
+      expect(exitCode).toBe(1);
+      expect(report.valid).toBe(false);
+      expect(report.errors.some(e => e.category === 'schema_version_invalid')).toBe(true);
+    });
+  });
+
+  // ── Check 3: unique task IDs ─────────────────────────────────────────────────
+
+  describe('check 3 — unique task IDs', () => {
+    test('exits 1, report.valid is false, and unique_id_violation is reported when the same task ID appears in multiple phases', () => {
+      // Arrange: fixture has INFRA-TASK-INFRA-01 in both the INFRA and US-01 phases
+      const wbPath = path.join(FIXTURES, 'wb-invalid-duplicate-id.json');
+      // Act
+      const { exitCode, report } = runValidator(wbPath);
+      // Assert
+      expect(exitCode).toBe(1);
+      expect(report.valid).toBe(false);
+      expect(report.errors.some(e => e.category === 'unique_id_violation')).toBe(true);
+    });
+
+    test('exits 0, report.valid is true, and no unique_id_violation errors are present for a valid work breakdown', () => {
+      // Arrange
+      const wbPath = path.join(FIXTURES, 'wb-valid.json');
+      // Act
+      const { exitCode, report } = runValidator(wbPath);
+      // Assert
+      expect(exitCode).toBe(0);
+      expect(report.valid).toBe(true);
+      expect(report.errors.filter(e => e.category === 'unique_id_violation')).toHaveLength(0);
+    });
+  });
+
+  // ── Check 4: required fields ─────────────────────────────────────────────────
+
+  describe('check 4 — required fields', () => {
+    test('exits 1, report.valid is false, and missing_field with field "outcome" is reported when outcome is absent from a task', () => {
+      // Arrange: fixture has INFRA-TASK-INFRA-01 with the "outcome" field omitted
+      const wbPath = path.join(FIXTURES, 'wb-invalid-missing-field.json');
+      // Act
+      const { exitCode, report } = runValidator(wbPath);
+      // Assert
+      expect(exitCode).toBe(1);
+      expect(report.valid).toBe(false);
+      const outcomeError = report.errors.find(
+        e => e.category === 'missing_field' && e.field === 'outcome',
+      );
+      expect(outcomeError).toBeDefined();
+    });
+
+    test('exits 0, report.valid is true, and no missing_field errors are present for a valid work breakdown', () => {
+      // Arrange
+      const wbPath = path.join(FIXTURES, 'wb-valid.json');
+      // Act
+      const { exitCode, report } = runValidator(wbPath);
+      // Assert
+      expect(exitCode).toBe(0);
+      expect(report.valid).toBe(true);
+      expect(report.errors.filter(e => e.category === 'missing_field')).toHaveLength(0);
+    });
+
+    // W3 regression guard — groupingRationale must be enforced by check 4
+    // Before fix: groupingRationale was in REQUIRED_TASK_FIELDS but absent from
+    // topLevelFields, so a task without the field passed check 4 with exit 0.
+
+    test('W3: exits 1 and missing_field with field "groupingRationale" is reported when groupingRationale is absent from a task', () => {
+      const { groupingRationale: _drop, ...taskWithoutRationale } = MINIMAL_VALID_WB.phases[0].tasks[0];
+      const wb = {
+        ...MINIMAL_VALID_WB,
+        phases: [{ ...MINIMAL_VALID_WB.phases[0], tasks: [taskWithoutRationale] }],
+      };
+      const tmpPath = path.join(os.tmpdir(), `wb-w3-${Date.now()}.json`);
+      writeTmp(tmpPath, wb);
+      try {
+        const { exitCode, report } = runValidator(tmpPath);
+        expect(exitCode).toBe(1);
+        expect(report.valid).toBe(false);
+        const err = report.errors.find(e => e.category === 'missing_field' && e.field === 'groupingRationale');
+        expect(err).toBeDefined();
+      } finally {
+        try { fs.unlinkSync(tmpPath); } catch (_) {}
+      }
+    });
+
+    test('W3: exits 0 and no missing_field for groupingRationale when the field is present and non-empty', () => {
+      // MINIMAL_VALID_WB already includes groupingRationale — use it directly
+      const wbPath = path.join(FIXTURES, 'wb-valid.json');
+      const { exitCode, report } = runValidator(wbPath);
+      expect(exitCode).toBe(0);
+      expect(report.errors.filter(e => e.category === 'missing_field' && e.field === 'groupingRationale')).toHaveLength(0);
+    });
+  });
+
+  // ── Check 5: task ID format ──────────────────────────────────────────────────
+
+  describe('check 5 — task ID format', () => {
+    let tmpFile;
+
+    beforeEach(() => {
+      tmpFile = path.join(os.tmpdir(), `wb-test-${Date.now()}.json`);
+    });
+
+    afterEach(() => {
+      try { fs.unlinkSync(tmpFile); } catch (_) {}
+    });
+
+    test('exits 1, report.valid is false, and invalid_id_format is reported when a non-INFRA task ID does not match the expected pattern', () => {
+      // Arrange: replace the task id with a string that matches no expected pattern
+      const wb = {
+        ...MINIMAL_VALID_WB,
+        phases: [
+          {
+            ...MINIMAL_VALID_WB.phases[0],
+            tasks: [
+              { ...MINIMAL_VALID_WB.phases[0].tasks[0], id: 'BAD-FORMAT' },
+            ],
+          },
+        ],
+      };
+      writeTmp(tmpFile, wb);
+      // Act
+      const { exitCode, report } = runValidator(tmpFile);
+      // Assert
+      expect(exitCode).toBe(1);
+      expect(report.valid).toBe(false);
+      expect(report.errors.some(e => e.category === 'invalid_id_format')).toBe(true);
+    });
+
+    test('exits 0, report.valid is true, and no invalid_id_format errors are present for a valid work breakdown', () => {
+      // Arrange
+      const wbPath = path.join(FIXTURES, 'wb-valid.json');
+      // Act
+      const { exitCode, report } = runValidator(wbPath);
+      // Assert
+      expect(exitCode).toBe(0);
+      expect(report.valid).toBe(true);
+      expect(report.errors.filter(e => e.category === 'invalid_id_format')).toHaveLength(0);
+    });
+  });
+
+  // ── Check 6: domain whitelist ────────────────────────────────────────────────
+
+  describe('check 6 — domain whitelist', () => {
+    test('exits 1, report.valid is false, and invalid_domain is reported when a task has an unrecognised domain value', () => {
+      // Arrange: fixture has domain "BACKEND" which is not in the VALID_DOMAINS list
+      const wbPath = path.join(FIXTURES, 'wb-invalid-bad-domain.json');
+      // Act
+      const { exitCode, report } = runValidator(wbPath);
+      // Assert
+      expect(exitCode).toBe(1);
+      expect(report.valid).toBe(false);
+      expect(report.errors.some(e => e.category === 'invalid_domain')).toBe(true);
+    });
+
+    test('exits 0, report.valid is true, and no invalid_domain errors are present for a valid work breakdown', () => {
+      // Arrange
+      const wbPath = path.join(FIXTURES, 'wb-valid.json');
+      // Act
+      const { exitCode, report } = runValidator(wbPath);
+      // Assert
+      expect(exitCode).toBe(0);
+      expect(report.valid).toBe(true);
+      expect(report.errors.filter(e => e.category === 'invalid_domain')).toHaveLength(0);
+    });
+  });
+
+  // ── Check 7: agentType whitelist ─────────────────────────────────────────────
+
+  describe('check 7 — agentType whitelist', () => {
+    let tmpFile;
+
+    beforeEach(() => {
+      tmpFile = path.join(os.tmpdir(), `wb-test-${Date.now()}.json`);
+    });
+
+    afterEach(() => {
+      try { fs.unlinkSync(tmpFile); } catch (_) {}
+    });
+
+    test('exits 1, report.valid is false, and invalid_agent_type is reported when a task has an unrecognised agentType', () => {
+      // Arrange: replace agentType with a value that is not in the VALID_AGENT_TYPES list
+      const wb = {
+        ...MINIMAL_VALID_WB,
+        phases: [
+          {
+            ...MINIMAL_VALID_WB.phases[0],
+            tasks: [
+              { ...MINIMAL_VALID_WB.phases[0].tasks[0], agentType: 'unknown-agent' },
+            ],
+          },
+        ],
+      };
+      writeTmp(tmpFile, wb);
+      // Act
+      const { exitCode, report } = runValidator(tmpFile);
+      // Assert
+      expect(exitCode).toBe(1);
+      expect(report.valid).toBe(false);
+      expect(report.errors.some(e => e.category === 'invalid_agent_type')).toBe(true);
+    });
+
+    test('exits 0, report.valid is true, and no invalid_agent_type errors are present for a valid work breakdown', () => {
+      // Arrange
+      const wbPath = path.join(FIXTURES, 'wb-valid.json');
+      // Act
+      const { exitCode, report } = runValidator(wbPath);
+      // Assert
+      expect(exitCode).toBe(0);
+      expect(report.valid).toBe(true);
+      expect(report.errors.filter(e => e.category === 'invalid_agent_type')).toHaveLength(0);
+    });
+  });
+});

package/.claude/scripts/tests/wb-validate.checks-11.test.js

@@ -0,0 +1,166 @@
+'use strict';
+
+const { spawnSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+const VALIDATE = path.resolve(__dirname, '../wb-validate.js');
+const FIXTURES = path.resolve(__dirname, 'fixtures');
+
+function runValidator(wbPath) {
+  const result = spawnSync('node', [VALIDATE, wbPath], { encoding: 'utf8' });
+  let report = null;
+  try { report = JSON.parse(result.stdout); } catch (_) {}
+  return { exitCode: result.status, report, stderr: result.stderr };
+}
+
+// ── Shared temp-file lifecycle ────────────────────────────────────────────────
+
+let tmpFile;
+
+beforeEach(() => { tmpFile = path.join(os.tmpdir(), `wb-t17-${Date.now()}.json`); });
+afterEach(() => { try { fs.unlinkSync(tmpFile); } catch (_) {} });
+
+function writeFixture(obj) { fs.writeFileSync(tmpFile, JSON.stringify(obj, null, 2)); return tmpFile; }
+
+// ── Domain builders ───────────────────────────────────────────────────────────
+
+function makeTask(id, dependsOn = []) {
+  return {
+    id,
+    title: `Task ${id}`,
+    outcome: 'Done',
+    domain: 'BE',
+    agentType: 'developer-backend',
+    dependsOn,
+    acceptanceCriteria: [],
+    verification: { commands: ['node --version'] },
+    estimate: { agentMinutes: 10, tokens: 5000 },
+    outputCount: 1,
+    groupingRationale: 'Single',
+    commit: { subject: `feat: ${id}` },
+  };
+}
+
+function makePhase(id, tasks) {
+  return { id, type: 'user-story', title: `Phase ${id}`, commit: `feat(${id}): done`, tasks };
+}
+
+function makeWB(phases) { return { schemaVersion: 2, phases }; }
+
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe('wb-validate.js — check 11 — task cycle detection (DFS gray/black coloring)', () => {
+
+  // ── Test A: existing cycle fixture ───────────────────────────────────────────
+
+  test('exits 1 and reports at least one task_cycle_detected error when the existing wb-invalid-cycle.json fixture is validated', () => {
+    // Arrange: use the pre-existing cycle fixture (INFRA-TASK-INFRA-01 ↔ INFRA-TASK-INFRA-02)
+    const wbPath = path.join(FIXTURES, 'wb-invalid-cycle.json');
+
+    // Act
+    const { exitCode, report } = runValidator(wbPath);
+
+    // Assert
+    expect(exitCode).toBe(1);
+    expect(report.errors.some(e => e.category === 'task_cycle_detected')).toBe(true);
+  });
+
+  // ── Test B: two-node mutual cycle A→B, B→A ───────────────────────────────────
+
+  test('exits 1, reports task_cycle_detected, and details.cycleMembers contains both task IDs for a two-node cycle (A→B, B→A)', () => {
+    // Arrange
+    const wb = makeWB([makePhase('US-01', [
+      makeTask('US-01-TASK-BE-01', ['US-01-TASK-BE-02']),
+      makeTask('US-01-TASK-BE-02', ['US-01-TASK-BE-01']),
+    ])]);
+    writeFixture(wb);
+
+    // Act
+    const { exitCode, report } = runValidator(tmpFile);
+
+    // Assert
+    expect(exitCode).toBe(1);
+    const cycleErr = report.errors.find(e => e.category === 'task_cycle_detected');
+    expect(cycleErr).toBeDefined();
+    expect(Array.isArray(cycleErr.details.cycleMembers)).toBe(true);
+    expect(cycleErr.details.cycleMembers).toContain('US-01-TASK-BE-01');
+    expect(cycleErr.details.cycleMembers).toContain('US-01-TASK-BE-02');
+  });
+
+  // ── Test C: three-node cycle A→B→C→A ────────────────────────────────────────
+
+  test('exits 1, reports task_cycle_detected, and details.cycleMembers has at least 3 elements for a three-node cycle (A→B→C→A)', () => {
+    // Arrange
+    const wb = makeWB([makePhase('US-01', [
+      makeTask('US-01-TASK-BE-01', ['US-01-TASK-BE-02']),
+      makeTask('US-01-TASK-BE-02', ['US-01-TASK-BE-03']),
+      makeTask('US-01-TASK-BE-03', ['US-01-TASK-BE-01']),
+    ])]);
+    writeFixture(wb);
+
+    // Act
+    const { exitCode, report } = runValidator(tmpFile);
+
+    // Assert
+    expect(exitCode).toBe(1);
+    const cycleErr = report.errors.find(e => e.category === 'task_cycle_detected');
+    expect(cycleErr).toBeDefined();
+    expect(Array.isArray(cycleErr.details.cycleMembers)).toBe(true);
+    expect(cycleErr.details.cycleMembers.length).toBeGreaterThanOrEqual(3);
+  });
+
+  // ── Test D: acyclic diamond graph — no cycles ────────────────────────────────
+
+  test('exits 0, reports no task_cycle_detected errors, and report.dependencies.taskCycles is an empty array for an acyclic diamond graph (A→B, A→C, B→D, C→D)', () => {
+    // Arrange
+    const wb = makeWB([makePhase('US-01', [
+      makeTask('US-01-TASK-BE-01', []),
+      makeTask('US-01-TASK-BE-02', ['US-01-TASK-BE-01']),
+      makeTask('US-01-TASK-BE-03', ['US-01-TASK-BE-01']),
+      makeTask('US-01-TASK-BE-04', ['US-01-TASK-BE-02', 'US-01-TASK-BE-03']),
+    ])]);
+    writeFixture(wb);
+
+    // Act
+    const { exitCode, report } = runValidator(tmpFile);
+
+    // Assert
+    expect(exitCode).toBe(0);
+    expect(report.errors.filter(e => e.category === 'task_cycle_detected')).toHaveLength(0);
+    expect(report.dependencies.taskCycles).toEqual([]);
+  });
+
+  // ── Test E: cross-phase cycle ────────────────────────────────────────────────
+
+  test('exits 1 and reports task_cycle_detected when a mutual dependency cycle spans two phases (US-01-A→US-02-B, US-02-B→US-01-A)', () => {
+    // Arrange: task in US-01 depends on task in US-02, which depends back on US-01 task
+    const wb = makeWB([
+      makePhase('US-01', [makeTask('US-01-TASK-BE-01', ['US-02-TASK-BE-01'])]),
+      makePhase('US-02', [makeTask('US-02-TASK-BE-01', ['US-01-TASK-BE-01'])]),
+    ]);
+    writeFixture(wb);
+
+    // Act
+    const { exitCode, report } = runValidator(tmpFile);
+
+    // Assert
+    expect(exitCode).toBe(1);
+    expect(report.errors.some(e => e.category === 'task_cycle_detected')).toBe(true);
+  });
+
+  // ── Test F: taskCycles always present in report ──────────────────────────────
+
+  test('report.dependencies.taskCycles is always an array even when there are no cycles (valid fixture exits 0)', () => {
+    // Arrange: use the pre-existing valid fixture which has no dependency cycles
+    const wbPath = path.join(FIXTURES, 'wb-valid.json');
+
+    // Act
+    const { exitCode, report } = runValidator(wbPath);
+
+    // Assert
+    expect(exitCode).toBe(0);
+    expect(Array.isArray(report.dependencies.taskCycles)).toBe(true);
+  });
+});