@dtlabs/ai-toolkit 0.10.0 → 0.11.0

package/.claude/scripts/tests/pm-phase2.orchestration-flow.test.js

@@ -1,276 +0,0 @@
-'use strict';
-
-const {
-  wbValidatorPassed,
-  canRunSemantic,
-  canRunRender,
-  gate2IsBlocked,
-} = require('./helpers/pm-phase2-flow');
-
-// ─── shared fixtures ──────────────────────────────────────────────────────────
-
-const REPORT_VALID   = { valid: true,  errors: [] };
-const REPORT_INVALID = { valid: false, errors: [{ category: 'schema_version_invalid', message: 'bad schema' }] };
-
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('pm-phase2 orchestration flow — pure predicates', () => {
-
-  // ── Group 1: wbValidatorPassed ─────────────────────────────────────────────
-
-  describe('wbValidatorPassed()', () => {
-
-    test('returns true when validateFailed is false and report is valid with empty errors', () => {
-      // Arrange
-      const validateFailed = false;
-      const report = { valid: true, errors: [] };
-      // Act
-      const result = wbValidatorPassed(validateFailed, report);
-      // Assert
-      expect(result).toBe(true);
-    });
-
-    test('returns false when validateFailed is true even though report looks valid (technical failure overrides)', () => {
-      // Arrange
-      const validateFailed = true;
-      const report = { valid: true, errors: [] };
-      // Act
-      const result = wbValidatorPassed(validateFailed, report);
-      // Assert
-      expect(result).toBe(false);
-    });
-
-    test('returns false when validateFailed is false but report has valid=false and structural errors', () => {
-      // Arrange
-      const validateFailed = false;
-      const report = { valid: false, errors: [{ category: 'missing_field', message: 'outcome missing' }] };
-      // Act
-      const result = wbValidatorPassed(validateFailed, report);
-      // Assert
-      expect(result).toBe(false);
-    });
-
-    test('returns false when validateFailed is false and report is null (no result produced)', () => {
-      // Arrange
-      const validateFailed = false;
-      const report = null;
-      // Act
-      const result = wbValidatorPassed(validateFailed, report);
-      // Assert
-      expect(result).toBe(false);
-    });
-
-    test('returns false when validateFailed is false but report has valid=true with non-empty errors array', () => {
-      // Arrange
-      const validateFailed = false;
-      const report = { valid: true, errors: [{ category: 'some_error', message: 'something wrong' }] };
-      // Act
-      const result = wbValidatorPassed(validateFailed, report);
-      // Assert
-      expect(result).toBe(false);
-    });
-
-  });
-
-  // ── Group 2: canRunSemantic ────────────────────────────────────────────────
-
-  describe('canRunSemantic()', () => {
-
-    test('returns true (semantic can run) when wb-validate passed with a clean valid report', () => {
-      // Arrange
-      const validateFailed = false;
-      const report = REPORT_VALID;
-      // Act
-      const result = canRunSemantic(validateFailed, report);
-      // Assert
-      expect(result).toBe(true);
-    });
-
-    test('returns false (semantic is skipped) when wb-validate failed technically', () => {
-      // Arrange
-      const validateFailed = true;
-      const report = REPORT_VALID;
-      // Act
-      const result = canRunSemantic(validateFailed, report);
-      // Assert
-      expect(result).toBe(false);
-    });
-
-    test('returns false (semantic is skipped) when wb-validate exit 1 due to structural errors in the report', () => {
-      // Arrange
-      const validateFailed = false;
-      const report = REPORT_INVALID;
-      // Act
-      const result = canRunSemantic(validateFailed, report);
-      // Assert
-      expect(result).toBe(false);
-    });
-
-  });
-
-  // ── Group 3: canRunRender ──────────────────────────────────────────────────
-
-  describe('canRunRender()', () => {
-
-    test('returns true when wb-validate passed and semantic did not fail', () => {
-      // Arrange
-      const validateFailed = false;
-      const report         = REPORT_VALID;
-      const semanticFailed = false;
-      // Act
-      const result = canRunRender(validateFailed, report, semanticFailed);
-      // Assert
-      expect(result).toBe(true);
-    });
-
-    test('returns false when wb-validate passed but semantic did fail', () => {
-      // Arrange
-      const validateFailed = false;
-      const report         = REPORT_VALID;
-      const semanticFailed = true;
-      // Act
-      const result = canRunRender(validateFailed, report, semanticFailed);
-      // Assert
-      expect(result).toBe(false);
-    });
-
-    test('returns false when wb-validate failed technically regardless of semantic outcome', () => {
-      // Arrange
-      const validateFailed = true;
-      const report         = REPORT_VALID;
-      const semanticFailed = false;
-      // Act
-      const result = canRunRender(validateFailed, report, semanticFailed);
-      // Assert
-      expect(result).toBe(false);
-    });
-
-    test('returns false when wb-validate exit 1 (structural errors) regardless of semantic outcome', () => {
-      // Arrange
-      const validateFailed = false;
-      const report         = REPORT_INVALID;
-      const semanticFailed = false;
-      // Act
-      const result = canRunRender(validateFailed, report, semanticFailed);
-      // Assert
-      expect(result).toBe(false);
-    });
-
-  });
-
-  // ── Group 4: gate2IsBlocked ────────────────────────────────────────────────
-
-  describe('gate2IsBlocked()', () => {
-
-    test('returns false (gate is open) when all steps passed and semantic has no blocking findings', () => {
-      // Arrange
-      const validateFailed  = false;
-      const report          = REPORT_VALID;
-      const semanticFailed  = false;
-      const renderFailed    = false;
-      const semanticResult  = { findings: [{ blocking: false, message: 'style suggestion' }] };
-      // Act
-      const result = gate2IsBlocked(validateFailed, report, semanticFailed, renderFailed, semanticResult);
-      // Assert
-      expect(result).toBe(false);
-    });
-
-    test('returns true when validateFailed is true', () => {
-      // Arrange
-      const validateFailed  = true;
-      const report          = REPORT_VALID;
-      const semanticFailed  = false;
-      const renderFailed    = false;
-      const semanticResult  = null;
-      // Act
-      const result = gate2IsBlocked(validateFailed, report, semanticFailed, renderFailed, semanticResult);
-      // Assert
-      expect(result).toBe(true);
-    });
-
-    test('returns true when wb-validate exit 1 (report.valid is false)', () => {
-      // Arrange
-      const validateFailed  = false;
-      const report          = REPORT_INVALID;
-      const semanticFailed  = false;
-      const renderFailed    = false;
-      const semanticResult  = null;
-      // Act
-      const result = gate2IsBlocked(validateFailed, report, semanticFailed, renderFailed, semanticResult);
-      // Assert
-      expect(result).toBe(true);
-    });
-
-    test('returns true when semanticFailed is true', () => {
-      // Arrange
-      const validateFailed  = false;
-      const report          = REPORT_VALID;
-      const semanticFailed  = true;
-      const renderFailed    = false;
-      const semanticResult  = null;
-      // Act
-      const result = gate2IsBlocked(validateFailed, report, semanticFailed, renderFailed, semanticResult);
-      // Assert
-      expect(result).toBe(true);
-    });
-
-    test('returns true when renderFailed is true', () => {
-      // Arrange
-      const validateFailed  = false;
-      const report          = REPORT_VALID;
-      const semanticFailed  = false;
-      const renderFailed    = true;
-      const semanticResult  = null;
-      // Act
-      const result = gate2IsBlocked(validateFailed, report, semanticFailed, renderFailed, semanticResult);
-      // Assert
-      expect(result).toBe(true);
-    });
-
-    test('returns true when semantic result contains at least one blocking finding', () => {
-      // Arrange
-      const validateFailed  = false;
-      const report          = REPORT_VALID;
-      const semanticFailed  = false;
-      const renderFailed    = false;
-      const semanticResult  = { findings: [{ blocking: true, message: 'critical scope gap' }] };
-      // Act
-      const result = gate2IsBlocked(validateFailed, report, semanticFailed, renderFailed, semanticResult);
-      // Assert
-      expect(result).toBe(true);
-    });
-
-    test('returns false when semantic result has only non-blocking findings (gate allows proceed)', () => {
-      // Arrange
-      const validateFailed  = false;
-      const report          = REPORT_VALID;
-      const semanticFailed  = false;
-      const renderFailed    = false;
-      const semanticResult  = {
-        findings: [
-          { blocking: false, message: 'minor wording suggestion' },
-          { blocking: false, message: 'optional improvement' },
-        ],
-      };
-      // Act
-      const result = gate2IsBlocked(validateFailed, report, semanticFailed, renderFailed, semanticResult);
-      // Assert
-      expect(result).toBe(false);
-    });
-
-    test('returns true when multiple failure conditions are true simultaneously', () => {
-      // Arrange
-      const validateFailed  = true;
-      const report          = REPORT_INVALID;
-      const semanticFailed  = true;
-      const renderFailed    = true;
-      const semanticResult  = { findings: [{ blocking: true, message: 'critical gap' }] };
-      // Act
-      const result = gate2IsBlocked(validateFailed, report, semanticFailed, renderFailed, semanticResult);
-      // Assert
-      expect(result).toBe(true);
-    });
-
-  });
-
-});

package/.claude/scripts/tests/verify-us-01-t03.js

@@ -1,288 +0,0 @@
-'use strict';
-
-/**
- * US-01-T03: Schema v2 Compliance Verification
- *
- * Reads TEST-001-Work-Breakdown.json and performs 9 structural checks
- * derived from the INFRA-T02 constants in wb-validate.js — with no
- * dependency on wb-validate.js itself (runs in parallel with US-02).
- *
- * Uses only Node.js built-ins: fs, path.
- * Exit 0 = all checks pass; Exit 1 = one or more checks fail.
- */
-
-const fs   = require('fs');
-const path = require('path');
-
-// ─── Schema v2 constants (sourced from wb-validate.js — not imported) ────────
-
-const REQUIRED_PHASE_FIELDS = ['id', 'type', 'title', 'commit', 'tasks'];
-
-const REQUIRED_TASK_FIELDS = [
-  'id',
-  'title',
-  'outcome',
-  'domain',
-  'agentType',
-  'dependsOn',
-  'acceptanceCriteria',
-  'verification',
-  'estimate',
-  'outputCount',
-  'groupingRationale',
-  'commit',
-];
-
-const VALID_DOMAINS = ['BE', 'FE', 'DB', 'DevOps', 'INFRA', 'TEST'];
-
-const VALID_AGENT_TYPES = [
-  'developer-backend',
-  'developer-frontend',
-  'developer-testing',
-  'developer-database',
-  'review-solution',
-];
-
-// ─── Fixture path (resolved relative to this script file) ────────────────────
-
-const FIXTURE_PATH = path.join(
-  __dirname,
-  'fixtures',
-  'test-feature',
-  'TEST-001-Work-Breakdown.json'
-);
-
-// ─── Report accumulators ─────────────────────────────────────────────────────
-
-const passes   = [];
-const failures = [];
-
-function pass(label) {
-  passes.push(label);
-}
-
-function fail(label, detail) {
-  failures.push({ label, detail });
-}
-
-// ─── Load and parse fixture ───────────────────────────────────────────────────
-
-let wb;
-try {
-  const raw = fs.readFileSync(FIXTURE_PATH, 'utf8');
-  wb = JSON.parse(raw);
-} catch (err) {
-  console.error(`FATAL: Cannot read or parse fixture at ${FIXTURE_PATH}`);
-  console.error(`       ${err.message}`);
-  process.exit(2);
-}
-
-// ─── Build full task-ID index (used by checks 3, 4, 8) ───────────────────────
-
-const allTaskIds = new Set();
-for (const phase of (wb.phases || [])) {
-  for (const task of (phase.tasks || [])) {
-    if (task.id != null) allTaskIds.add(task.id);
-  }
-}
-
-// ─── Check 1: schemaVersion === 2 ────────────────────────────────────────────
-
-if (wb.schemaVersion === 2) {
-  pass('Check 1 — schemaVersion === 2');
-} else {
-  fail(
-    'Check 1 — schemaVersion === 2',
-    `Expected 2, got: ${JSON.stringify(wb.schemaVersion)}`
-  );
-}
-
-// ─── Check 2: every phase has all REQUIRED_PHASE_FIELDS ──────────────────────
-
-{
-  let ok = true;
-  for (const phase of (wb.phases || [])) {
-    const phaseId = phase.id ?? '(no id)';
-    for (const field of REQUIRED_PHASE_FIELDS) {
-      if (!(field in phase)) {
-        fail(
-          'Check 2 — every phase has all REQUIRED_PHASE_FIELDS',
-          `Phase "${phaseId}" is missing field "${field}"`
-        );
-        ok = false;
-      }
-    }
-  }
-  if (ok) pass('Check 2 — every phase has all REQUIRED_PHASE_FIELDS');
-}
-
-// ─── Check 3: every task has all REQUIRED_TASK_FIELDS ────────────────────────
-
-{
-  let ok = true;
-  for (const phase of (wb.phases || [])) {
-    for (const task of (phase.tasks || [])) {
-      const taskId = task.id ?? '(no id)';
-      for (const field of REQUIRED_TASK_FIELDS) {
-        if (!(field in task)) {
-          fail(
-            'Check 3 — every task has all REQUIRED_TASK_FIELDS',
-            `Task "${taskId}" is missing field "${field}"`
-          );
-          ok = false;
-        }
-      }
-    }
-  }
-  if (ok) pass('Check 3 — every task has all REQUIRED_TASK_FIELDS');
-}
-
-// ─── Check 4: every task.domain is in VALID_DOMAINS ──────────────────────────
-
-{
-  let ok = true;
-  for (const phase of (wb.phases || [])) {
-    for (const task of (phase.tasks || [])) {
-      if (!VALID_DOMAINS.includes(task.domain)) {
-        fail(
-          'Check 4 — every task.domain is in VALID_DOMAINS',
-          `Task "${task.id}" has domain "${task.domain}"; allowed: ${VALID_DOMAINS.join(', ')}`
-        );
-        ok = false;
-      }
-    }
-  }
-  if (ok) pass('Check 4 — every task.domain is in VALID_DOMAINS');
-}
-
-// ─── Check 5: every task.agentType is in VALID_AGENT_TYPES ───────────────────
-
-{
-  let ok = true;
-  for (const phase of (wb.phases || [])) {
-    for (const task of (phase.tasks || [])) {
-      if (!VALID_AGENT_TYPES.includes(task.agentType)) {
-        fail(
-          'Check 5 — every task.agentType is in VALID_AGENT_TYPES',
-          `Task "${task.id}" has agentType "${task.agentType}"; allowed: ${VALID_AGENT_TYPES.join(', ')}`
-        );
-        ok = false;
-      }
-    }
-  }
-  if (ok) pass('Check 5 — every task.agentType is in VALID_AGENT_TYPES');
-}
-
-// ─── Check 6: every task.estimate.agentMinutes exists and is ≤ 15 ────────────
-
-{
-  let ok = true;
-  for (const phase of (wb.phases || [])) {
-    for (const task of (phase.tasks || [])) {
-      const minutes = task.estimate?.agentMinutes;
-      if (minutes == null) {
-        fail(
-          'Check 6 — task.estimate.agentMinutes exists and is <= 15',
-          `Task "${task.id}" is missing estimate.agentMinutes`
-        );
-        ok = false;
-      } else if (typeof minutes !== 'number') {
-        fail(
-          'Check 6 — task.estimate.agentMinutes exists and is <= 15',
-          `Task "${task.id}" has non-numeric estimate.agentMinutes: ${JSON.stringify(minutes)}`
-        );
-        ok = false;
-      } else if (minutes > 15) {
-        fail(
-          'Check 6 — task.estimate.agentMinutes exists and is <= 15',
-          `Task "${task.id}" has agentMinutes=${minutes} which exceeds the 15-minute target`
-        );
-        ok = false;
-      }
-    }
-  }
-  if (ok) pass('Check 6 — every task.estimate.agentMinutes exists and is <= 15');
-}
-
-// ─── Check 7: every task.verification.commands is a non-empty array ──────────
-
-{
-  let ok = true;
-  for (const phase of (wb.phases || [])) {
-    for (const task of (phase.tasks || [])) {
-      const cmds = task.verification?.commands;
-      if (!Array.isArray(cmds)) {
-        fail(
-          'Check 7 — task.verification.commands is a non-empty array',
-          `Task "${task.id}" has verification.commands that is not an array: ${JSON.stringify(cmds)}`
-        );
-        ok = false;
-      } else if (cmds.length === 0) {
-        fail(
-          'Check 7 — task.verification.commands is a non-empty array',
-          `Task "${task.id}" has an empty verification.commands array`
-        );
-        ok = false;
-      }
-    }
-  }
-  if (ok) pass('Check 7 — every task.verification.commands is a non-empty array');
-}
-
-// ─── Check 8: no task depends on an ID not present in the JSON ───────────────
-
-{
-  let ok = true;
-  for (const phase of (wb.phases || [])) {
-    for (const task of (phase.tasks || [])) {
-      for (const dep of (task.dependsOn || [])) {
-        if (!allTaskIds.has(dep)) {
-          fail(
-            'Check 8 — no dangling dependsOn references',
-            `Task "${task.id}" depends on "${dep}" which does not exist in the JSON`
-          );
-          ok = false;
-        }
-      }
-    }
-  }
-  if (ok) pass('Check 8 — no dangling dependsOn references');
-}
-
-// ─── Check 9: fixture has at least one phase and one task ────────────────────
-//  (sanity guard: catches a structurally empty fixture that would silently pass)
-
-{
-  const phaseCount = (wb.phases || []).length;
-  const taskCount  = allTaskIds.size;
-  if (phaseCount >= 1 && taskCount >= 1) {
-    pass(`Check 9 — fixture is non-trivial (${phaseCount} phases, ${taskCount} tasks)`);
-  } else {
-    fail(
-      'Check 9 — fixture is non-trivial',
-      `Expected at least 1 phase and 1 task; found ${phaseCount} phase(s) and ${taskCount} task(s)`
-    );
-  }
-}
-
-// ─── Print report ─────────────────────────────────────────────────────────────
-
-console.log('\n=== Schema v2 Compliance Report — TEST-001-Work-Breakdown.json ===\n');
-console.log(`Fixture: ${FIXTURE_PATH}\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);
-}