chati-dev 4.3.1 → 4.4.1

package/src/quality/test-runner.js

@@ -1,366 +0,0 @@
-/**
- * @fileoverview Real code execution validation.
- *
- * Detects test runners, executes tests and lint commands,
- * and parses output for structured results.
- *
- * Constitution Article XIV — Framework Registry Governance.
- */
-
-import { existsSync, readFileSync } from 'fs';
-import { join } from 'path';
-import { execSync } from 'child_process';
-
-// ---------------------------------------------------------------------------
-// Test Runner Detection
-// ---------------------------------------------------------------------------
-
-/**
- * @typedef {object} TestDetection
- * @property {string|null} command - Test command to run
- * @property {string} runner - Detected runner name (node:test|jest|vitest|mocha|unknown)
- * @property {boolean} detected - Whether a test setup was found
- */
-
-/**
- * Detect the test command and runner for a project.
- *
- * Detection order:
- * 1. package.json scripts.test
- * 2. vitest.config.* presence
- * 3. jest.config.* presence
- * 4. .mocharc.* presence
- *
- * @param {string} projectDir - Project root directory
- * @returns {TestDetection}
- */
-export function detectTestCommand(projectDir) {
-  const pkgPath = join(projectDir, 'package.json');
-
-  // Check package.json scripts.test
-  if (existsSync(pkgPath)) {
-    try {
-      const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
-      const testScript = pkg.scripts?.test;
-
-      if (testScript && testScript !== 'echo "Error: no test specified" && exit 1') {
-        const runner = detectRunnerFromScript(testScript);
-        return { command: 'npm test', runner, detected: true };
-      }
-    } catch { /* expected: package.json may be malformed or missing */
-    }
-  }
-
-  // Check for vitest.config.*
-  const vitestConfigs = ['vitest.config.ts', 'vitest.config.js', 'vitest.config.mts'];
-  for (const cfg of vitestConfigs) {
-    if (existsSync(join(projectDir, cfg))) {
-      return { command: 'npx vitest run', runner: 'vitest', detected: true };
-    }
-  }
-
-  // Check for jest.config.*
-  const jestConfigs = ['jest.config.ts', 'jest.config.js', 'jest.config.json'];
-  for (const cfg of jestConfigs) {
-    if (existsSync(join(projectDir, cfg))) {
-      return { command: 'npx jest', runner: 'jest', detected: true };
-    }
-  }
-
-  // Check for .mocharc.*
-  const mochaConfigs = ['.mocharc.yml', '.mocharc.yaml', '.mocharc.json', '.mocharc.js'];
-  for (const cfg of mochaConfigs) {
-    if (existsSync(join(projectDir, cfg))) {
-      return { command: 'npx mocha', runner: 'mocha', detected: true };
-    }
-  }
-
-  return { command: null, runner: 'unknown', detected: false };
-}
-
-/**
- * Detect runner from a test script string.
- *
- * @param {string} script
- * @returns {string}
- */
-function detectRunnerFromScript(script) {
-  if (/node\s+--test/.test(script)) return 'node:test';
-  if (/vitest/.test(script)) return 'vitest';
-  if (/jest/.test(script)) return 'jest';
-  if (/mocha/.test(script)) return 'mocha';
-  if (/tap/.test(script)) return 'tap';
-  return 'unknown';
-}
-
-// ---------------------------------------------------------------------------
-// Test Execution
-// ---------------------------------------------------------------------------
-
-/**
- * @typedef {object} TestResult
- * @property {boolean} success - All tests passed
- * @property {number} total - Total test count
- * @property {number} passed - Tests passed
- * @property {number} failed - Tests failed
- * @property {number} skipped - Tests skipped
- * @property {number} duration - Execution time in ms
- * @property {string} rawOutput - Full command output
- * @property {string} runner - Detected runner
- */
-
-/**
- * Run tests in a project directory.
- *
- * @param {string} projectDir
- * @param {{ timeout?: number, command?: string }} [options={}]
- * @returns {TestResult}
- */
-export function runTests(projectDir, options = {}) {
-  const detection = detectTestCommand(projectDir);
-  const command = options.command || detection.command;
-  const timeout = options.timeout || 120_000;
-
-  if (!command) {
-    return {
-      success: false,
-      total: 0,
-      passed: 0,
-      failed: 0,
-      skipped: 0,
-      duration: 0,
-      rawOutput: 'No test command detected',
-      runner: 'unknown',
-    };
-  }
-
-  const start = Date.now();
-  let rawOutput, exitCode;
-
-  try {
-    rawOutput = execSync(command, {
-      cwd: projectDir,
-      encoding: 'utf-8',
-      timeout,
-      stdio: ['pipe', 'pipe', 'pipe'],
-    });
-    exitCode = 0;
-  } catch (err) {
-    exitCode = err.status || 1;
-    rawOutput = (err.stdout || '') + (err.stderr || '');
-  }
-
-  const duration = Date.now() - start;
-  const parsed = parseTestOutput(rawOutput, detection.runner);
-
-  return {
-    success: exitCode === 0 && parsed.failed === 0,
-    total: parsed.total,
-    passed: parsed.passed,
-    failed: parsed.failed,
-    skipped: parsed.skipped,
-    duration,
-    rawOutput: rawOutput.slice(0, 5000),
-    runner: detection.runner,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Lint Execution
-// ---------------------------------------------------------------------------
-
-/**
- * @typedef {object} LintResult
- * @property {boolean} success - No lint errors
- * @property {number} errors - Error count
- * @property {number} warnings - Warning count
- * @property {string} rawOutput - Full command output
- */
-
-/**
- * Run lint in a project directory.
- *
- * @param {string} projectDir
- * @param {{ timeout?: number, command?: string }} [options={}]
- * @returns {LintResult}
- */
-export function runLint(projectDir, options = {}) {
-  const timeout = options.timeout || 60_000;
-  let command = options.command;
-
-  // Auto-detect lint command
-  if (!command) {
-    const pkgPath = join(projectDir, 'package.json');
-    if (existsSync(pkgPath)) {
-      try {
-        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
-        if (pkg.scripts?.lint) {
-          command = 'npm run lint';
-        }
-      } catch { /* expected: package.json may be malformed */
-      }
-    }
-  }
-
-  if (!command) {
-    return { success: true, errors: 0, warnings: 0, rawOutput: 'No lint command detected' };
-  }
-
-  let rawOutput, exitCode;
-
-  try {
-    rawOutput = execSync(command, {
-      cwd: projectDir,
-      encoding: 'utf-8',
-      timeout,
-      stdio: ['pipe', 'pipe', 'pipe'],
-    });
-    exitCode = 0;
-  } catch (err) {
-    exitCode = err.status || 1;
-    rawOutput = (err.stdout || '') + (err.stderr || '');
-  }
-
-  const { errors, warnings } = parseLintOutput(rawOutput);
-
-  return {
-    success: exitCode === 0 && errors === 0,
-    errors,
-    warnings,
-    rawOutput: rawOutput.slice(0, 5000),
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Output Parsing
-// ---------------------------------------------------------------------------
-
-/**
- * Parse test output to extract counts.
- *
- * @param {string} output
- * @param {string} runner
- * @returns {{ total: number, passed: number, failed: number, skipped: number }}
- */
-export function parseTestOutput(output, runner) {
-  if (!output) {
-    return { total: 0, passed: 0, failed: 0, skipped: 0 };
-  }
-
-  switch (runner) {
-    case 'node:test':
-      return parseNodeTestOutput(output);
-    case 'jest':
-      return parseJestOutput(output);
-    case 'vitest':
-      return parseVitestOutput(output);
-    case 'mocha':
-      return parseMochaOutput(output);
-    default:
-      return parseGenericOutput(output);
-  }
-}
-
-/**
- * Parse node:test TAP-like output.
- */
-function parseNodeTestOutput(output) {
-  const testsMatch = output.match(/# tests (\d+)/);
-  const passMatch = output.match(/# pass (\d+)/);
-  const failMatch = output.match(/# fail (\d+)/);
-  const skipMatch = output.match(/# skipped (\d+)/);
-
-  const total = testsMatch ? parseInt(testsMatch[1], 10) : 0;
-  const passed = passMatch ? parseInt(passMatch[1], 10) : 0;
-  const failed = failMatch ? parseInt(failMatch[1], 10) : 0;
-  const skipped = skipMatch ? parseInt(skipMatch[1], 10) : 0;
-
-  return { total, passed, failed, skipped };
-}
-
-/**
- * Parse Jest output.
- */
-function parseJestOutput(output) {
-  // Jest format: "Tests:  3 failed, 47 passed, 50 total"
-  const totalMatch = output.match(/(\d+)\s+total/);
-  const passedMatch = output.match(/(\d+)\s+passed/);
-  const failMatch = output.match(/(\d+)\s+failed/);
-  const skipMatch = output.match(/(\d+)\s+skipped/);
-
-  const total = totalMatch ? parseInt(totalMatch[1], 10) : 0;
-  const passed = passedMatch ? parseInt(passedMatch[1], 10) : 0;
-  const failed = failMatch ? parseInt(failMatch[1], 10) : 0;
-  const skipped = skipMatch ? parseInt(skipMatch[1], 10) : 0;
-
-  return { total, passed, failed, skipped };
-}
-
-/**
- * Parse Vitest output.
- */
-function parseVitestOutput(output) {
-  const passMatch = output.match(/(\d+)\s+passed/);
-  const failMatch = output.match(/(\d+)\s+failed/);
-  const skipMatch = output.match(/(\d+)\s+skipped/);
-
-  const passed = passMatch ? parseInt(passMatch[1], 10) : 0;
-  const failed = failMatch ? parseInt(failMatch[1], 10) : 0;
-  const skipped = skipMatch ? parseInt(skipMatch[1], 10) : 0;
-  const total = passed + failed + skipped;
-
-  return { total, passed, failed, skipped };
-}
-
-/**
- * Parse Mocha output.
- */
-function parseMochaOutput(output) {
-  const passMatch = output.match(/(\d+)\s+passing/);
-  const failMatch = output.match(/(\d+)\s+failing/);
-  const pendMatch = output.match(/(\d+)\s+pending/);
-
-  const passed = passMatch ? parseInt(passMatch[1], 10) : 0;
-  const failed = failMatch ? parseInt(failMatch[1], 10) : 0;
-  const skipped = pendMatch ? parseInt(pendMatch[1], 10) : 0;
-  const total = passed + failed + skipped;
-
-  return { total, passed, failed, skipped };
-}
-
-/**
- * Generic fallback parser.
- */
-function parseGenericOutput(output) {
-  const passMatch = output.match(/(\d+)\s+pass/i);
-  const failMatch = output.match(/(\d+)\s+fail/i);
-
-  const passed = passMatch ? parseInt(passMatch[1], 10) : 0;
-  const failed = failMatch ? parseInt(failMatch[1], 10) : 0;
-  const total = passed + failed;
-
-  return { total, passed, failed, skipped: 0 };
-}
-
-/**
- * Parse lint output for error/warning counts.
- *
- * @param {string} output
- * @returns {{ errors: number, warnings: number }}
- */
-function parseLintOutput(output) {
-  // ESLint format: "X problems (Y errors, Z warnings)"
-  const eslintMatch = output.match(/(\d+)\s+problems?\s*\((\d+)\s+errors?,\s*(\d+)\s+warnings?\)/);
-  if (eslintMatch) {
-    return {
-      errors: parseInt(eslintMatch[2], 10),
-      warnings: parseInt(eslintMatch[3], 10),
-    };
-  }
-
-  // Count error/warning lines
-  const errorLines = (output.match(/error/gi) || []).length;
-  const warningLines = (output.match(/warning/gi) || []).length;
-
-  return { errors: errorLines, warnings: warningLines };
-}

package/src/tasks/executor.js

@@ -1,195 +0,0 @@
-/**
- * Task Executor — Executes a task definition with PRISM context injection.
- *
- * The executor prepares the full execution context for an agent by:
- * 1. Loading the task definition
- * 2. Injecting PRISM context layers
- * 3. Building the instruction payload
- * 4. Validating criteria post-execution (for autonomous mode)
- */
-
-/**
- * Build the execution payload for a task.
- *
- * This produces the complete context that gets injected into
- * the agent's prompt when executing a task.
- *
- * @param {object} task - Task definition from loader
- * @param {object} options
- * @param {object} [options.prismContext] - PRISM context output (xml, bracket, layers)
- * @param {object} [options.handoff] - Handoff data from previous agent
- * @param {object} [options.sessionState] - Current session state
- * @param {string} [options.mode] - Execution mode ('human-in-the-loop' | 'autonomous')
- * @returns {{ payload: object, warnings: string[] }}
- */
-export function buildExecutionPayload(task, options = {}) {
-  const warnings = [];
-
-  if (!task) {
-    return { payload: null, warnings: ['No task provided to executor.'] };
-  }
-
-  const mode = options.mode || 'human-in-the-loop';
-  const isAutonomous = mode === 'autonomous';
-
-  // Warn if task requires input but we're in autonomous mode
-  if (task.requires_input && isAutonomous) {
-    warnings.push(
-      `Task '${task.id}' requires user input but running in autonomous mode. ` +
-      'Gate will pause for input.'
-    );
-  }
-
-  // Warn if task doesn't support autonomous gate but mode is autonomous
-  if (isAutonomous && !task.autonomous_gate) {
-    warnings.push(
-      `Task '${task.id}' does not have autonomous_gate enabled. ` +
-      'Human validation will be required.'
-    );
-  }
-
-  const payload = {
-    task: {
-      id: task.id,
-      agent: task.agent,
-      phase: task.phase,
-      instructions: task.instructions,
-      criteria: task.criteria,
-      outputs: task.outputs,
-      handoff_to: task.handoff_to,
-    },
-    context: {
-      prism: options.prismContext || null,
-      handoff: options.handoff || null,
-      session: sanitizeSessionState(options.sessionState),
-    },
-    execution: {
-      mode,
-      autonomous_gate: task.autonomous_gate,
-      requires_input: task.requires_input,
-      parallelizable: task.parallelizable,
-    },
-  };
-
-  return { payload, warnings };
-}
-
-/**
- * Validate task execution results against criteria.
- *
- * Each criterion is a string describing what must be true.
- * The validator returns a structured result for the orchestrator
- * to decide whether to proceed or require intervention.
- *
- * @param {object} task - Task definition
- * @param {object} results - Execution results to validate
- * @param {string[]} [results.completedCriteria] - Criteria marked as met
- * @param {string[]} [results.outputs] - Produced output files
- * @param {number} [results.confidence] - Self-reported confidence (0-100)
- * @returns {{ valid: boolean, score: number, unmet: string[], details: string }}
- */
-export function validateResults(task, results = {}) {
-  if (!task || !task.criteria || task.criteria.length === 0) {
-    return { valid: true, score: 100, unmet: [], details: 'No criteria defined.' };
-  }
-
-  const completed = new Set(results.completedCriteria || []);
-  const unmet = [];
-
-  for (const criterion of task.criteria) {
-    if (!completed.has(criterion)) {
-      unmet.push(criterion);
-    }
-  }
-
-  const score = Math.round(((task.criteria.length - unmet.length) / task.criteria.length) * 100);
-
-  // Check outputs
-  const expectedOutputs = task.outputs || [];
-  const producedOutputs = results.outputs || [];
-  const missingOutputs = expectedOutputs.filter(o => !producedOutputs.includes(o));
-
-  if (missingOutputs.length > 0) {
-    unmet.push(`Missing outputs: ${missingOutputs.join(', ')}`);
-  }
-
-  // Confidence check for autonomous mode
-  const confidence = results.confidence ?? 100;
-  const confidenceMet = confidence >= 90;
-
-  const valid = unmet.length === 0 && confidenceMet;
-
-  let details;
-  if (valid) {
-    details = `All ${task.criteria.length} criteria met. Confidence: ${confidence}%.`;
-  } else {
-    const parts = [];
-    if (unmet.length > 0) parts.push(`${unmet.length} unmet criteria`);
-    if (!confidenceMet) parts.push(`Low confidence: ${confidence}%`);
-    details = parts.join('. ');
-  }
-
-  return { valid, score, unmet, details };
-}
-
-/**
- * Determine the post-execution action based on validation results.
- *
- * @param {object} validation - Result from validateResults
- * @param {string} mode - 'autonomous' | 'human-in-the-loop'
- * @param {object} task - Task definition
- * @returns {{ action: string, reason: string }}
- *   action: 'proceed' | 'retry' | 'escalate' | 'gate'
- */
-export function determinePostAction(validation, mode, task) {
-  // Human-in-the-loop always gates
-  if (mode !== 'autonomous') {
-    return {
-      action: 'gate',
-      reason: 'Human-in-the-loop mode requires user approval.',
-    };
-  }
-
-  // Autonomous mode with autonomous gate
-  if (validation.valid) {
-    return {
-      action: 'proceed',
-      reason: `All criteria met (score: ${validation.score}%). Proceeding to ${task.handoff_to || 'next'}.`,
-    };
-  }
-
-  // Partial pass — try to determine severity
-  if (validation.score >= 90) {
-    return {
-      action: 'gate',
-      reason: `Score ${validation.score}% is close but below threshold. Human review recommended.`,
-    };
-  }
-
-  if (validation.score >= 50) {
-    return {
-      action: 'retry',
-      reason: `Score ${validation.score}%. ${validation.unmet.length} criteria unmet. Retry with focused attention.`,
-    };
-  }
-
-  return {
-    action: 'escalate',
-    reason: `Score ${validation.score}%. Major gaps detected. Escalating to orchestrator.`,
-  };
-}
-
-/**
- * Sanitize session state to remove sensitive or oversized data.
- */
-function sanitizeSessionState(state) {
-  if (!state) return null;
-
-  return {
-    mode: state.mode || 'discover',
-    current_agent: state.current_agent || null,
-    pipeline_position: state.pipeline_position || null,
-    completed_agents: state.completed_agents || [],
-    phase: state.phase || null,
-  };
-}

package/src/tasks/index.js

@@ -1,4 +0,0 @@
-export { loadTask, parseTaskContent, loadAllTasks, getAgentTasks, getTaskSummary } from './loader.js';
-export { TaskRouter, createRouter } from './router.js';
-export { buildExecutionPayload, validateResults, determinePostAction } from './executor.js';
-export { buildHandoff, formatHandoff, saveHandoff, loadHandoff, parseHandoffContent } from './handoff.js';