claude-mycelium 2.0.0 → 2.1.0

package/src/task/acceptance.ts

@@ -0,0 +1,267 @@
+/**
+ * Acceptance Criteria Validation
+ * Per ROADMAP §Phase 5 Week 6 Day 5-6: Acceptance Criteria
+ *
+ * Validates task completion against acceptance criteria including
+ * file existence, test execution, lint checks, and custom validation.
+ */
+
+import { Task, AcceptanceCriterion } from '../types/index.js';
+import { fileExists } from '../utils/file-utils.js';
+import { logDebug, logError } from '../utils/logger.js';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+/**
+ * Validate all acceptance criteria for a task
+ */
+export async function validateAcceptance(task: Task): Promise<boolean> {
+  logDebug('Validating acceptance criteria', {
+    taskId: task.id,
+    criteriaCount: task.acceptance_criteria.length,
+  });
+
+  let allMet = true;
+
+  for (const criterion of task.acceptance_criteria) {
+    const met = await validateCriterion(criterion);
+    criterion.met = met;
+
+    if (!met) {
+      allMet = false;
+      logDebug('Acceptance criterion not met', {
+        taskId: task.id,
+        type: criterion.type,
+        description: criterion.description,
+      });
+    }
+  }
+
+  logDebug('Acceptance validation complete', {
+    taskId: task.id,
+    allMet,
+    metCount: task.acceptance_criteria.filter(c => c.met).length,
+  });
+
+  return allMet;
+}
+
+/**
+ * Validate a single acceptance criterion
+ */
+async function validateCriterion(criterion: AcceptanceCriterion): Promise<boolean> {
+  try {
+    switch (criterion.type) {
+      case 'file_exists':
+        return await checkFileExists(criterion.check);
+
+      case 'test_passes':
+        return await runTests(criterion.check);
+
+      case 'no_lint_errors':
+        return await checkLintErrors(criterion.check);
+
+      case 'custom':
+        return await runCustomValidation(criterion.check);
+
+      default:
+        logError('Unknown criterion type', new Error('Invalid type'), {
+          type: criterion.type,
+        });
+        return false;
+    }
+  } catch (error) {
+    const errorObj = error instanceof Error ? error : new Error(String(error));
+    logError('Criterion validation failed', errorObj, {
+      type: criterion.type,
+      check: criterion.check,
+    });
+    return false;
+  }
+}
+
+/**
+ * Check if a file exists
+ */
+export async function checkFileExists(filePath: string): Promise<boolean> {
+  const exists = fileExists(filePath);
+  logDebug('File existence check', { filePath, exists });
+  return exists;
+}
+
+/**
+ * Run specific tests and check if they pass
+ */
+export async function runTests(testPattern: string): Promise<boolean> {
+  logDebug('Running tests', { pattern: testPattern });
+
+  try {
+    // Run vitest with specific pattern
+    const command = `npm test -- --run ${testPattern}`;
+    const { stdout, stderr } = await execAsync(command, {
+      timeout: 60000, // 60 second timeout
+    });
+
+    // Check for test failures in output
+    const output = stdout + stderr;
+    const hasFailed = output.includes('FAILED') ||
+                     output.includes('failed') ||
+                     output.includes('Error:');
+
+    logDebug('Test execution result', {
+      pattern: testPattern,
+      passed: !hasFailed,
+    });
+
+    return !hasFailed;
+  } catch (error) {
+    // exec throws on non-zero exit code
+    const errorObj = error instanceof Error ? error : new Error(String(error));
+    logError('Test execution failed', errorObj, { pattern: testPattern });
+    return false;
+  }
+}
+
+/**
+ * Check if file has lint errors
+ */
+async function checkLintErrors(filePath: string): Promise<boolean> {
+  logDebug('Checking lint errors', { filePath });
+
+  try {
+    // Run eslint on specific file
+    const command = `npx eslint ${filePath} --format json`;
+    const { stdout } = await execAsync(command, {
+      timeout: 30000, // 30 second timeout
+    });
+
+    // Parse eslint JSON output
+    const results = JSON.parse(stdout);
+
+    // Check if there are any errors
+    const totalErrors = results.reduce(
+      (sum: number, result: any) => sum + result.errorCount,
+      0
+    );
+
+    const noErrors = totalErrors === 0;
+    logDebug('Lint check result', {
+      filePath,
+      errors: totalErrors,
+      passed: noErrors,
+    });
+
+    return noErrors;
+  } catch (error) {
+    // eslint returns non-zero exit code when errors found
+    // Try to parse the output to get error count
+    if (error instanceof Error && 'stdout' in error) {
+      try {
+        const results = JSON.parse((error as any).stdout);
+        const totalErrors = results.reduce(
+          (sum: number, result: any) => sum + result.errorCount,
+          0
+        );
+        return totalErrors === 0;
+      } catch {
+        // Failed to parse, assume errors
+        return false;
+      }
+    }
+
+    const errorObj = error instanceof Error ? error : new Error(String(error));
+    logError('Lint check failed', errorObj, { filePath });
+    return false;
+  }
+}
+
+/**
+ * Run custom validation command
+ */
+async function runCustomValidation(command: string): Promise<boolean> {
+  logDebug('Running custom validation', { command });
+
+  try {
+    await execAsync(command, {
+      timeout: 60000, // 60 second timeout
+    });
+
+    logDebug('Custom validation passed', { command });
+    return true;
+  } catch (error) {
+    const errorObj = error instanceof Error ? error : new Error(String(error));
+    logError('Custom validation failed', errorObj, { command });
+    return false;
+  }
+}
+
+/**
+ * Generate default acceptance criteria for a task
+ */
+export function generateDefaultCriteria(task: Task): AcceptanceCriterion[] {
+  const criteria: AcceptanceCriterion[] = [];
+
+  // If task plan exists, generate criteria based on files
+  if (task.plan) {
+    // Check that all created files exist
+    const createSteps = task.plan.steps.filter(s => s.mode === 'create');
+    for (const step of createSteps) {
+      criteria.push({
+        description: `File ${step.target_file} exists`,
+        type: 'file_exists',
+        check: step.target_file,
+        met: false,
+      });
+
+      // If it's a test file, add a test_passes criterion
+      if (step.target_file.includes('.test.')) {
+        criteria.push({
+          description: `Tests in ${step.target_file} pass`,
+          type: 'test_passes',
+          check: step.target_file,
+          met: false,
+        });
+      }
+    }
+
+    // Add lint check for all touched files
+    const allFiles = new Set([
+      ...createSteps.map(s => s.target_file),
+      ...task.plan.steps.filter(s => s.mode !== 'create').map(s => s.target_file),
+    ]);
+
+    for (const file of allFiles) {
+      // Only check non-test files for lint
+      if (!file.includes('.test.')) {
+        criteria.push({
+          description: `No lint errors in ${file}`,
+          type: 'no_lint_errors',
+          check: file,
+          met: false,
+        });
+      }
+    }
+  }
+
+  return criteria;
+}
+
+/**
+ * Check if task can be marked as completed
+ */
+export function canCompleteTask(task: Task): boolean {
+  // All steps must be completed
+  if (task.steps_completed < task.steps_total) {
+    return false;
+  }
+
+  // All acceptance criteria must be met
+  if (task.acceptance_criteria.length > 0) {
+    return task.acceptance_criteria.every(c => c.met);
+  }
+
+  // If no criteria defined, task is complete when all steps done
+  return true;
+}