@dtlabs/ai-toolkit 0.10.0 → 0.11.0

package/.claude/scripts/tests/verify-us-03-t04.js

@@ -1,262 +0,0 @@
-'use strict';
-
-/**
- * US-03-T04: Semantic Validator Output Schema Verification
- *
- * Reads a JSON file produced by (or simulating) the validate-work-breakdown-semantic
- * agent and verifies that it conforms to the declared output contract:
- *
- *   {
- *     "valid": boolean,
- *     "findings": [
- *       {
- *         "taskId":       string,
- *         "type":         "hidden_multiplicity"|"scope_creep"|"estimate_incompatible"|"bundled_verifiable"|"other",
- *         "severity":     "error"|"warning",
- *         "blocking":     boolean,
- *         "splitRequired": boolean,
- *         "description":  string
- *       }
- *     ]
- *   }
- *
- * Invariants:
- *   - valid === false  iff  any finding has blocking === true
- *   - severity === "error"   when blocking === true
- *   - severity === "warning" when blocking === false
- *
- * Usage:
- *   node verify-us-03-t04.js <path-to-output.json>
- *
- * Exit 0 = all checks pass; Exit 1 = one or more checks fail.
- */
-
-const fs   = require('fs');
-const path = require('path');
-
-// ─── Constants ────────────────────────────────────────────────────────────────
-
-const VALID_TYPES = new Set([
-  'hidden_multiplicity',
-  'scope_creep',
-  'estimate_incompatible',
-  'bundled_verifiable',
-  'other',
-]);
-
-const VALID_SEVERITIES = new Set(['error', 'warning']);
-
-// ─── CLI argument ─────────────────────────────────────────────────────────────
-
-const filePath = process.argv[2];
-if (!filePath) {
-  console.error('Usage: node verify-us-03-t04.js <path-to-output.json>');
-  process.exit(2);
-}
-
-const resolved = path.resolve(filePath);
-
-// ─── Report accumulators ─────────────────────────────────────────────────────
-
-const passes   = [];
-const failures = [];
-
-function pass(label) {
-  passes.push(label);
-}
-
-function fail(label, detail) {
-  failures.push({ label, detail });
-}
-
-// ─── Load and parse the output JSON ──────────────────────────────────────────
-
-let output;
-try {
-  const raw = fs.readFileSync(resolved, 'utf8');
-  output = JSON.parse(raw);
-} catch (err) {
-  console.error(`FATAL: Cannot read or parse file at ${resolved}`);
-  console.error(`       ${err.message}`);
-  process.exit(2);
-}
-
-// ─── Check 1: top-level "valid" field is a boolean ───────────────────────────
-
-if (typeof output.valid === 'boolean') {
-  pass('Check 1 — "valid" is a boolean');
-} else {
-  fail(
-    'Check 1 — "valid" is a boolean',
-    `Expected boolean, got: ${JSON.stringify(typeof output.valid)} (value: ${JSON.stringify(output.valid)})`
-  );
-}
-
-// ─── Check 2: top-level "findings" field is an array ─────────────────────────
-
-if (Array.isArray(output.findings)) {
-  pass(`Check 2 — "findings" is an array (${output.findings.length} item(s))`);
-} else {
-  fail(
-    'Check 2 — "findings" is an array',
-    `Expected array, got: ${JSON.stringify(typeof output.findings)}`
-  );
-}
-
-// ─── Per-finding checks (only when findings is an array) ─────────────────────
-
-const findings = Array.isArray(output.findings) ? output.findings : [];
-
-// Check 3: every finding has all 6 required fields with correct types
-
-{
-  const REQUIRED_FIELDS = ['taskId', 'type', 'severity', 'blocking', 'splitRequired', 'description'];
-  let allPresent = true;
-
-  for (let i = 0; i < findings.length; i++) {
-    const finding = findings[i];
-    const label   = finding.taskId ? `finding[${i}] (taskId="${finding.taskId}")` : `finding[${i}]`;
-
-    for (const field of REQUIRED_FIELDS) {
-      if (!(field in finding)) {
-        fail(
-          'Check 3 — every finding has all 6 required fields',
-          `${label} is missing field "${field}"`
-        );
-        allPresent = false;
-      }
-    }
-
-    // Type-check the boolean fields
-    if ('blocking' in finding && typeof finding.blocking !== 'boolean') {
-      fail(
-        'Check 3 — every finding has all 6 required fields',
-        `${label}: "blocking" must be boolean, got ${JSON.stringify(typeof finding.blocking)}`
-      );
-      allPresent = false;
-    }
-
-    if ('splitRequired' in finding && typeof finding.splitRequired !== 'boolean') {
-      fail(
-        'Check 3 — every finding has all 6 required fields',
-        `${label}: "splitRequired" must be boolean, got ${JSON.stringify(typeof finding.splitRequired)}`
-      );
-      allPresent = false;
-    }
-  }
-
-  if (allPresent) {
-    pass(`Check 3 — every finding has all 6 required fields with correct types`);
-  }
-}
-
-// Check 4: every finding.type is one of the allowed values
-
-{
-  let allValid = true;
-  for (let i = 0; i < findings.length; i++) {
-    const finding = findings[i];
-    if (!VALID_TYPES.has(finding.type)) {
-      fail(
-        'Check 4 — every finding.type is a valid enum value',
-        `finding[${i}] (taskId="${finding.taskId}") has type "${finding.type}"; ` +
-        `allowed: ${[...VALID_TYPES].join(', ')}`
-      );
-      allValid = false;
-    }
-  }
-  if (allValid) {
-    pass('Check 4 — every finding.type is a valid enum value');
-  }
-}
-
-// Check 5: every finding.severity is "error" or "warning"
-
-{
-  let allValid = true;
-  for (let i = 0; i < findings.length; i++) {
-    const finding = findings[i];
-    if (!VALID_SEVERITIES.has(finding.severity)) {
-      fail(
-        'Check 5 — every finding.severity is "error" or "warning"',
-        `finding[${i}] (taskId="${finding.taskId}") has severity "${finding.severity}"`
-      );
-      allValid = false;
-    }
-  }
-  if (allValid) {
-    pass('Check 5 — every finding.severity is "error" or "warning"');
-  }
-}
-
-// Check 6: valid === false iff any finding has blocking === true
-
-{
-  const hasBlockingFinding = findings.some(f => f.blocking === true);
-  const validField         = output.valid;
-
-  const expectedValid = !hasBlockingFinding;
-
-  if (typeof validField === 'boolean' && validField === expectedValid) {
-    pass(
-      `Check 6 — valid === false iff any finding has blocking:true ` +
-      `(blocking findings: ${findings.filter(f => f.blocking).length})`
-    );
-  } else {
-    fail(
-      'Check 6 — valid === false iff any finding has blocking:true',
-      `hasBlockingFinding=${hasBlockingFinding}, so valid should be ${expectedValid}, but got ${JSON.stringify(validField)}`
-    );
-  }
-}
-
-// Check 7: severity === "error" when blocking === true; "warning" when blocking === false
-
-{
-  let allConsistent = true;
-  for (let i = 0; i < findings.length; i++) {
-    const finding = findings[i];
-
-    if (finding.blocking === true && finding.severity !== 'error') {
-      fail(
-        'Check 7 — severity is "error" when blocking:true, "warning" when blocking:false',
-        `finding[${i}] (taskId="${finding.taskId}") has blocking:true but severity="${finding.severity}" (expected "error")`
-      );
-      allConsistent = false;
-    }
-
-    if (finding.blocking === false && finding.severity !== 'warning') {
-      fail(
-        'Check 7 — severity is "error" when blocking:true, "warning" when blocking:false',
-        `finding[${i}] (taskId="${finding.taskId}") has blocking:false but severity="${finding.severity}" (expected "warning")`
-      );
-      allConsistent = false;
-    }
-  }
-
-  if (allConsistent) {
-    pass('Check 7 — severity is "error" when blocking:true, "warning" when blocking:false');
-  }
-}
-
-// ─── Print report ─────────────────────────────────────────────────────────────
-
-console.log('\n=== Semantic Validator Output — Schema Contract Verification ===\n');
-console.log(`File: ${resolved}\n`);
-
-for (const p of passes) {
-  console.log(`  PASS  ${p}`);
-}
-
-if (failures.length > 0) {
-  console.log('');
-  for (const f of failures) {
-    console.log(`  FAIL  ${f.label}`);
-    console.log(`          ${f.detail}`);
-  }
-  console.log(`\nResult: FAIL — ${failures.length} failure(s), ${passes.length} check(s) passed\n`);
-  process.exit(1);
-} else {
-  console.log(`\nResult: PASS — all ${passes.length} checks passed\n`);
-  process.exit(0);
-}

package/.claude/scripts/tests/wb-render.checks-md-csv-deps.test.js

@@ -1,337 +0,0 @@
-'use strict'
-
-const { spawnSync } = require('child_process')
-const os   = require('os')
-const fs   = require('fs')
-const path = require('path')
-
-const RENDER  = path.resolve(__dirname, '../wb-render.js')
-const FIXTURE = path.resolve(__dirname, 'fixtures/wb-valid.json')
-const TMPDIR  = os.tmpdir()
-const PREFIX  = 'WB-TEST'
-
-function runRender(jsonPath, prefix, destDir) {
-  const args = [jsonPath, prefix]
-  if (destDir) args.push(destDir)
-  return spawnSync(process.execPath, [RENDER, ...args], { encoding: 'utf8' })
-}
-
-function mdPath(dir, prefix) { return path.join(dir, `${prefix}-Work-Breakdown.md`) }
-function csvPath(dir, prefix) { return path.join(dir, `${prefix}-Work-Breakdown.csv`) }
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Group 1: Exit codes and file creation
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('wb-render.js — Group 1: exit codes and file creation', () => {
-
-  // ── Test 1: exits 0 and writes both output files ─────────────────────────────
-
-  test('exits 0 and writes both MD and CSV output files when given a valid fixture', () => {
-    // Arrange
-    const tmpDir = fs.mkdtempSync(path.join(TMPDIR, 'wb-render-g1a-'))
-    try {
-      // Act
-      const result = runRender(FIXTURE, PREFIX, tmpDir)
-
-      // Assert
-      expect(result.status).toBe(0)
-      expect(fs.existsSync(mdPath(tmpDir, PREFIX))).toBe(true)
-      expect(fs.existsSync(csvPath(tmpDir, PREFIX))).toBe(true)
-    } finally {
-      fs.rmSync(tmpDir, { recursive: true, force: true })
-    }
-  })
-
-  // ── Test 2: exits 1 when JSON file missing ────────────────────────────────────
-
-  test('exits 1 when the JSON file path does not exist', () => {
-    // Arrange: path points to a file that does not exist on disk
-    const nonExistentPath = path.join(TMPDIR, `no-such-wb-file-${Date.now()}.json`)
-
-    // Act
-    const result = runRender(nonExistentPath, PREFIX)
-
-    // Assert
-    expect(result.status).toBe(1)
-  })
-
-  // ── Test 3: exits 1 when JSON file contains invalid JSON ─────────────────────
-
-  test('exits 1 when the JSON file contains invalid JSON', () => {
-    // Arrange
-    const tmpFile = path.join(TMPDIR, `wb-render-bad-json-${Date.now()}.json`)
-    fs.writeFileSync(tmpFile, '{bad json')
-    try {
-      // Act
-      const result = runRender(tmpFile, PREFIX)
-
-      // Assert
-      expect(result.status).toBe(1)
-    } finally {
-      try { fs.unlinkSync(tmpFile) } catch (_) {}
-    }
-  })
-
-  // ── Test 4: exits 2 when schemaVersion is wrong ───────────────────────────────
-
-  test('exits 2 when schemaVersion is not 2', () => {
-    // Arrange
-    const tmpFile = path.join(TMPDIR, `wb-render-bad-schema-${Date.now()}.json`)
-    const wb = { schemaVersion: 1, feature: 'TEST', phases: [] }
-    fs.writeFileSync(tmpFile, JSON.stringify(wb))
-    try {
-      // Act
-      const result = runRender(tmpFile, PREFIX)
-
-      // Assert
-      expect(result.status).toBe(2)
-    } finally {
-      try { fs.unlinkSync(tmpFile) } catch (_) {}
-    }
-  })
-})
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Groups 2, 3, 4 — share a single render run against the standard fixture
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('wb-render.js — Groups 2/3/4: output content', () => {
-  let tmpDir
-  let csvContent
-  let mdContent
-  let csvRows   // array of string arrays (each row split on '|'), header excluded
-
-  beforeAll(() => {
-    // Arrange: render once into a unique temp directory
-    tmpDir = fs.mkdtempSync(path.join(TMPDIR, 'wb-render-shared-'))
-    runRender(FIXTURE, PREFIX, tmpDir)
-    csvContent = fs.readFileSync(csvPath(tmpDir, PREFIX), 'utf8')
-    mdContent  = fs.readFileSync(mdPath(tmpDir, PREFIX), 'utf8')
-    const allLines = csvContent.split('\n').filter(l => l.trim() !== '')
-    // Exclude the header row; parse each data row into columns
-    csvRows = allLines.slice(1).map(l => l.split('|'))
-  })
-
-  afterAll(() => {
-    if (tmpDir) fs.rmSync(tmpDir, { recursive: true, force: true })
-  })
-
-  // ───────────────────────────────────────────────────────────────────────────
-  // Group 2: CSV structure
-  // ───────────────────────────────────────────────────────────────────────────
-
-  describe('Group 2: CSV structure', () => {
-
-    // ── Test 5: CSV header is exact ─────────────────────────────────────────────
-
-    test('CSV header line is exactly "phase_id|phase_title|commit_message|depends_on|task_id|task_title|domain|agent_type"', () => {
-      // Arrange: csvContent contains the full file including the header row
-
-      // Act
-      const headerLine = csvContent.split('\n')[0]
-
-      // Assert
-      expect(headerLine).toBe('phase_id|phase_title|commit_message|depends_on|task_id|task_title|domain|agent_type')
-    })
-
-    // ── Test 6: every data row has exactly 8 columns ────────────────────────────
-
-    test('every non-header data row contains exactly 8 pipe-separated columns', () => {
-      // Arrange: csvRows are already parsed non-header rows (header excluded in beforeAll)
-      expect(csvRows.length).toBeGreaterThan(0)
-
-      // Act & Assert — one logical assertion group per row
-      for (const row of csvRows) {
-        expect(row).toHaveLength(8)
-      }
-    })
-
-    // ── Test 7: phase_id repeats within a phase ──────────────────────────────────
-
-    test('all rows whose task_id starts with "INFRA-" have phase_id "INFRA"', () => {
-      // Arrange: filter rows by task_id column (index 4)
-      const infraTaskRows = csvRows.filter(row => row[4].startsWith('INFRA-'))
-
-      // Act (filtering already done)
-
-      // Assert
-      expect(infraTaskRows.length).toBeGreaterThan(0)
-      for (const row of infraTaskRows) {
-        expect(row[0]).toBe('INFRA')
-      }
-    })
-
-    // ── Test 8: depends_on is empty for INFRA ────────────────────────────────────
-
-    test('all INFRA phase rows have an empty depends_on column', () => {
-      // Arrange: filter rows by task_id column (index 4)
-      const infraTaskRows = csvRows.filter(row => row[4].startsWith('INFRA-'))
-
-      // Act (filtering already done)
-
-      // Assert — depends_on is column index 3
-      expect(infraTaskRows.length).toBeGreaterThan(0)
-      for (const row of infraTaskRows) {
-        expect(row[3]).toBe('')
-      }
-    })
-
-    // ── Test 9: depends_on contains INFRA for US-01 ─────────────────────────────
-
-    test('all US-01 phase rows have depends_on containing "INFRA"', () => {
-      // Arrange: filter rows by task_id column (index 4)
-      const us01Rows = csvRows.filter(row => row[4].startsWith('US-01-'))
-
-      // Act (filtering already done)
-
-      // Assert — depends_on is column index 3
-      expect(us01Rows.length).toBeGreaterThan(0)
-      for (const row of us01Rows) {
-        expect(row[3]).toContain('INFRA')
-      }
-    })
-
-    // ── Test 10: commit_message contains the prefix argument ─────────────────────
-
-    test('all CSV data rows have a commit_message column that contains the prefix argument', () => {
-      // Arrange: csvRows are all non-header data rows; PREFIX = 'WB-TEST'
-      expect(csvRows.length).toBeGreaterThan(0)
-
-      // Act & Assert — commit_message is column index 2
-      for (const row of csvRows) {
-        expect(row[2]).toContain(PREFIX)
-      }
-    })
-  })
-
-  // ───────────────────────────────────────────────────────────────────────────
-  // Group 3: Markdown structure
-  // ───────────────────────────────────────────────────────────────────────────
-
-  describe('Group 3: Markdown structure', () => {
-
-    // ── Test 11: required section headers ───────────────────────────────────────
-
-    test('MD output contains the required top-level section headers', () => {
-      // Arrange: mdContent is the full Markdown file text
-
-      // Act & Assert
-      expect(mdContent).toContain('# Work Breakdown')
-      expect(mdContent).toContain('## Document Info')
-      expect(mdContent).toContain('## Summary')
-      expect(mdContent).toContain('## Statistics')
-    })
-
-    // ── Test 12: Document Info table rows ───────────────────────────────────────
-
-    test('MD Document Info table contains a Feature row and a "Schema | v2" row', () => {
-      // Arrange: mdContent is the full Markdown file text
-
-      // Act & Assert
-      expect(mdContent).toContain('| Feature |')
-      expect(mdContent).toContain('| Schema | v2 |')
-    })
-
-    // ── Test 13: Summary table has all 7 required rows ──────────────────────────
-
-    test('MD Summary table contains all 7 required metric rows', () => {
-      // Arrange: mdContent is the full Markdown file text
-
-      // Act & Assert
-      expect(mdContent).toContain('| Total tasks |')
-      expect(mdContent).toContain('| Total phases |')
-      expect(mdContent).toContain('| Within target')
-      expect(mdContent).toContain('| Above target')
-      expect(mdContent).toContain('| Warning')
-      expect(mdContent).toContain('| Split required')
-      expect(mdContent).toContain('| Domain distribution |')
-    })
-
-    // ── Test 14: Infrastructure Phase section ───────────────────────────────────
-
-    test('MD output contains the Infrastructure Phase section when the INFRA phase exists in the fixture', () => {
-      // Arrange: the standard fixture has an INFRA phase
-
-      // Act & Assert
-      expect(mdContent).toContain('## Infrastructure Phase (INFRA)')
-    })
-
-    // ── Test 15: User Story Phases section ──────────────────────────────────────
-
-    test('MD output contains the User Story Phases section when non-INFRA phases exist in the fixture', () => {
-      // Arrange: the standard fixture has a US-01 phase (non-INFRA)
-
-      // Act & Assert
-      expect(mdContent).toContain('## User Story Phases')
-    })
-
-    // ── Test 16: Statistics table has domain rows and Total row ─────────────────
-
-    test('MD Statistics table contains rows for all domain categories and a Total row', () => {
-      // Arrange: mdContent is the full Markdown file text
-
-      // Act & Assert
-      expect(mdContent).toContain('| BE |')
-      expect(mdContent).toContain('| FE |')
-      expect(mdContent).toContain('| DB |')
-      expect(mdContent).toContain('| INFRA |')
-      expect(mdContent).toContain('| TEST |')
-      expect(mdContent).toContain('| **Total** |')
-    })
-  })
-
-  // ───────────────────────────────────────────────────────────────────────────
-  // Group 4: Phase-level dependency aggregation
-  // ───────────────────────────────────────────────────────────────────────────
-
-  describe('Group 4: phase-level dependency aggregation', () => {
-
-    // ── Test 17: INFRA phase has no external deps ────────────────────────────────
-
-    test('INFRA phase rows have an empty depends_on, confirming no external phase dependencies are aggregated', () => {
-      // Arrange: filter rows by phase_id column (index 0)
-      const infraRows = csvRows.filter(row => row[0] === 'INFRA')
-
-      // Act (filtering already done)
-
-      // Assert — depends_on is column index 3
-      expect(infraRows.length).toBeGreaterThan(0)
-      for (const row of infraRows) {
-        expect(row[3]).toBe('')
-      }
-    })
-
-    // ── Test 18: US-01 depends on INFRA ─────────────────────────────────────────
-
-    test('US-01 phase rows have depends_on "INFRA" because US-01 tasks reference INFRA-phase tasks', () => {
-      // Arrange: filter rows by phase_id column (index 0)
-      // The fixture has US-01-TASK-BE-01 depending on INFRA-TASK-INFRA-02 (INFRA phase)
-      const us01Rows = csvRows.filter(row => row[0] === 'US-01')
-
-      // Act (filtering already done)
-
-      // Assert — depends_on is column index 3
-      expect(us01Rows.length).toBeGreaterThan(0)
-      for (const row of us01Rows) {
-        expect(row[3]).toContain('INFRA')
-      }
-    })
-
-    // ── Test 19: intra-phase deps excluded from depends_on ───────────────────────
-
-    test('intra-phase dependencies within US-01 are excluded from depends_on so "US-01" never appears in that column', () => {
-      // Arrange: filter rows by phase_id column (index 0)
-      // US-01-TASK-BE-02 depends on US-01-TASK-BE-01 — these are intra-phase and must be excluded
-      const us01Rows = csvRows.filter(row => row[0] === 'US-01')
-
-      // Act (filtering already done)
-
-      // Assert — depends_on (column 3) must NOT contain 'US-01'
-      expect(us01Rows.length).toBeGreaterThan(0)
-      for (const row of us01Rows) {
-        expect(row[3]).not.toContain('US-01')
-      }
-    })
-  })
-})