@nathapp/nax 0.50.3 → 0.51.2

package/src/pipeline/stages/acceptance-setup.ts

@@ -1,144 +0,0 @@
-/**
- * Acceptance Setup Stage
- *
- * Pre-run pipeline stage that generates acceptance tests from PRD criteria
- * and validates them with a RED gate before story execution begins.
- *
- * RED gate behavior:
- * - exit != 0 (tests fail) → valid RED, continue
- * - exit == 0 (all tests pass) → tests are not testing new behavior, warn and skip
- *
- * Stores results in ctx.acceptanceSetup = { totalCriteria, testableCount, redFailCount }.
- */
-
-import path from "node:path";
-import type { RefinedCriterion } from "../../acceptance/types";
-import { resolveModel } from "../../config";
-import type { UserStory } from "../../prd/types";
-import type { PipelineContext, PipelineStage, StageResult } from "../types";
-
-/**
- * Injectable dependencies for acceptance-setup stage.
- * Allows tests to mock bun test execution, file I/O, and LLM calls.
- * @internal
- */
-export const _acceptanceSetupDeps = {
-  fileExists: async (_path: string): Promise<boolean> => {
-    const f = Bun.file(_path);
-    return f.exists();
-  },
-  writeFile: async (filePath: string, content: string): Promise<void> => {
-    await Bun.write(filePath, content);
-  },
-  runTest: async (_testPath: string, _workdir: string): Promise<{ exitCode: number; output: string }> => {
-    const proc = Bun.spawn(["bun", "test", _testPath], {
-      cwd: _workdir,
-      stdout: "pipe",
-      stderr: "pipe",
-    });
-    const [exitCode, stdout, stderr] = await Promise.all([
-      proc.exited,
-      new Response(proc.stdout).text(),
-      new Response(proc.stderr).text(),
-    ]);
-    return { exitCode, output: `${stdout}\n${stderr}` };
-  },
-  refine: async (
-    _criteria: string[],
-    _context: import("../../acceptance/types").RefinementContext,
-  ): Promise<RefinedCriterion[]> => {
-    const { refineAcceptanceCriteria } = await import("../../acceptance/refinement");
-    return refineAcceptanceCriteria(_criteria, _context);
-  },
-  generate: async (
-    _stories: UserStory[],
-    _refined: RefinedCriterion[],
-    _options: import("../../acceptance/types").GenerateFromPRDOptions,
-  ): Promise<import("../../acceptance/types").AcceptanceTestResult> => {
-    const { generateFromPRD } = await import("../../acceptance/generator");
-    return generateFromPRD(_stories, _refined, _options);
-  },
-};
-
-export const acceptanceSetupStage: PipelineStage = {
-  name: "acceptance-setup",
-
-  enabled(ctx: PipelineContext): boolean {
-    return ctx.config.acceptance.enabled && !!ctx.featureDir;
-  },
-
-  async execute(ctx: PipelineContext): Promise<StageResult> {
-    if (!ctx.featureDir) {
-      return { action: "fail", reason: "[acceptance-setup] featureDir is not set" };
-    }
-
-    const testPath = path.join(ctx.featureDir, "acceptance.test.ts");
-    const fileExists = await _acceptanceSetupDeps.fileExists(testPath);
-
-    let totalCriteria = 0;
-    let testableCount = 0;
-
-    if (!fileExists) {
-      const allCriteria: string[] = ctx.prd.userStories.flatMap((s) => s.acceptanceCriteria);
-      totalCriteria = allCriteria.length;
-
-      const { getAgent } = await import("../../agents");
-      const agent = (ctx.agentGetFn ?? getAgent)(ctx.config.autoMode.defaultAgent);
-
-      let refinedCriteria: RefinedCriterion[];
-
-      if (ctx.config.acceptance.refinement) {
-        refinedCriteria = await _acceptanceSetupDeps.refine(allCriteria, {
-          storyId: ctx.prd.userStories[0]?.id ?? "US-001",
-          codebaseContext: "",
-          config: ctx.config,
-          testStrategy: ctx.config.acceptance.testStrategy,
-          testFramework: ctx.config.acceptance.testFramework,
-        });
-      } else {
-        refinedCriteria = allCriteria.map((c) => ({
-          original: c,
-          refined: c,
-          testable: true,
-          storyId: ctx.prd.userStories[0]?.id ?? "US-001",
-        }));
-      }
-
-      testableCount = refinedCriteria.filter((r) => r.testable).length;
-
-      const result = await _acceptanceSetupDeps.generate(ctx.prd.userStories, refinedCriteria, {
-        featureName: ctx.prd.feature,
-        workdir: ctx.workdir,
-        featureDir: ctx.featureDir,
-        codebaseContext: "",
-        modelTier: ctx.config.acceptance.model ?? "fast",
-        modelDef: resolveModel(ctx.config.models[ctx.config.acceptance.model ?? "fast"]),
-        config: ctx.config,
-        testStrategy: ctx.config.acceptance.testStrategy,
-        testFramework: ctx.config.acceptance.testFramework,
-        adapter: agent ?? undefined,
-      });
-
-      await _acceptanceSetupDeps.writeFile(testPath, result.testCode);
-    }
-
-    if (ctx.config.acceptance.redGate === false) {
-      ctx.acceptanceSetup = { totalCriteria, testableCount, redFailCount: 0 };
-      return { action: "continue" };
-    }
-
-    const { exitCode } = await _acceptanceSetupDeps.runTest(testPath, ctx.workdir);
-
-    if (exitCode === 0) {
-      ctx.acceptanceSetup = { totalCriteria, testableCount, redFailCount: 0 };
-      return {
-        action: "skip",
-        reason:
-          "[acceptance-setup] Acceptance tests already pass — they are not testing new behavior. Skipping acceptance gate.",
-      };
-    }
-
-    ctx.acceptanceSetup = { totalCriteria, testableCount, redFailCount: 1 };
-    return { action: "continue" };
-  },
-};

package/src/pipeline/stages/acceptance.ts

@@ -1,215 +0,0 @@
-/**
- * Acceptance Stage
- *
- * Runs acceptance tests when all stories are complete.
- * Validates the feature against acceptance criteria from spec.md.
- *
- * Only executes when:
- * - All stories in the PRD are complete (status: passed/failed/skipped, not pending/in-progress)
- * - Acceptance validation is enabled in config
- *
- * @returns
- * - `continue`: All acceptance tests pass
- * - `fail`: One or more acceptance tests failed
- *
- * @example
- * ```ts
- * // All stories complete, acceptance tests pass
- * await acceptanceStage.execute(ctx);
- * // Returns: { action: "continue" }
- *
- * // All stories complete, acceptance tests fail
- * await acceptanceStage.execute(ctx);
- * // Returns: { action: "fail", reason: "Acceptance tests failed: AC-2, AC-5" }
- * ```
- */
-
-import path from "node:path";
-import { getLogger } from "../../logger";
-import { countStories } from "../../prd";
-import { logTestOutput } from "../../utils/log-test-output";
-import type { PipelineContext, PipelineStage, StageResult } from "../types";
-
-/**
- * Parse bun test output to extract failed test names.
- *
- * Looks for lines containing "AC-N:" to identify which acceptance criteria failed.
- *
- * @param output - stdout/stderr from bun test
- * @returns Array of failed AC IDs (e.g., ["AC-2", "AC-5"])
- *
- * @example
- * ```ts
- * const output = `
- *   ✓ AC-1: TTL expiry
- *   ✗ AC-2: handles empty input
- *   ✓ AC-3: validates format
- * `;
- * const failed = parseTestFailures(output);
- * // Returns: ["AC-2"]
- * ```
- */
-function parseTestFailures(output: string): string[] {
-  const failedACs: string[] = [];
-  const lines = output.split("\n");
-
-  for (const line of lines) {
-    // Look for Bun's (fail) marker followed by AC-N pattern
-    // Pattern: (fail) ... > AC-N: description
-    if (line.includes("(fail)")) {
-      const acMatch = line.match(/(AC-\d+):/i);
-      if (acMatch) {
-        const acId = acMatch[1].toUpperCase();
-        if (!failedACs.includes(acId)) {
-          failedACs.push(acId);
-        }
-      }
-    }
-  }
-
-  return failedACs;
-}
-
-/**
- * Check if all stories in the PRD are complete.
- *
- * Stories are complete if their status is passed, failed, or skipped.
- * Pending or in-progress stories are not complete.
- *
- * @param ctx - Pipeline context
- * @returns true if all stories complete, false otherwise
- */
-function areAllStoriesComplete(ctx: PipelineContext): boolean {
-  const counts = countStories(ctx.prd);
-  const totalComplete = counts.passed + counts.failed + counts.skipped;
-  return totalComplete === counts.total;
-}
-
-export const acceptanceStage: PipelineStage = {
-  name: "acceptance",
-
-  enabled(ctx: PipelineContext): boolean {
-    // Only run when:
-    // 1. Acceptance validation is enabled
-    // 2. All stories are complete
-    const effectiveConfig = ctx.effectiveConfig ?? ctx.config;
-    if (!effectiveConfig.acceptance.enabled) {
-      return false;
-    }
-
-    if (!areAllStoriesComplete(ctx)) {
-      return false;
-    }
-
-    return true;
-  },
-
-  async execute(ctx: PipelineContext): Promise<StageResult> {
-    const logger = getLogger();
-
-    // PKG-004: use centrally resolved effective config
-    const effectiveConfig = ctx.effectiveConfig ?? ctx.config;
-
-    logger.info("acceptance", "Running acceptance tests");
-
-    // Build path to acceptance test file
-    if (!ctx.featureDir) {
-      logger.warn("acceptance", "No feature directory — skipping acceptance tests");
-      return { action: "continue" };
-    }
-
-    const testPath = path.join(ctx.featureDir, effectiveConfig.acceptance.testPath);
-
-    // Check if test file exists
-    const testFile = Bun.file(testPath);
-    const exists = await testFile.exists();
-
-    if (!exists) {
-      logger.warn("acceptance", "Acceptance test file not found — skipping", {
-        testPath,
-      });
-      return { action: "continue" };
-    }
-
-    // Run bun test on the acceptance test file
-    const proc = Bun.spawn(["bun", "test", testPath], {
-      cwd: ctx.workdir,
-      stdout: "pipe",
-      stderr: "pipe",
-    });
-
-    const [exitCode, stdout, stderr] = await Promise.all([
-      proc.exited,
-      new Response(proc.stdout).text(),
-      new Response(proc.stderr).text(),
-    ]);
-
-    // Combine stdout and stderr for parsing
-    const output = `${stdout}\n${stderr}`;
-
-    // Parse test results
-    const failedACs = parseTestFailures(output);
-
-    // Check for overridden ACs (skip those)
-    const overrides = ctx.prd.acceptanceOverrides || {};
-    const actualFailures = failedACs.filter((acId) => !overrides[acId]);
-
-    // If all tests passed cleanly
-    if (actualFailures.length === 0 && exitCode === 0) {
-      logger.info("acceptance", "All acceptance tests passed");
-      return { action: "continue" };
-    }
-
-    // All parsed AC failures are overridden — treat as success even with non-zero exit
-    if (failedACs.length > 0 && actualFailures.length === 0) {
-      logger.info("acceptance", "All failed ACs are overridden — treating as pass");
-      return { action: "continue" };
-    }
-
-    // Non-zero exit but no AC failures parsed at all — test crashed (syntax error, import failure, etc.)
-    if (failedACs.length === 0 && exitCode !== 0) {
-      logger.error("acceptance", "Tests errored with no AC failures parsed", { exitCode });
-      logTestOutput(logger, "acceptance", output);
-
-      ctx.acceptanceFailures = {
-        failedACs: ["AC-ERROR"],
-        testOutput: output,
-      };
-
-      return {
-        action: "fail",
-        reason: `Acceptance tests errored (exit code ${exitCode}): syntax error, import failure, or unhandled exception`,
-      };
-    }
-
-    // If we have actual failures, report them
-    if (actualFailures.length > 0) {
-      // Log overridden failures (if any)
-      const overriddenFailures = failedACs.filter((acId) => overrides[acId]);
-      if (overriddenFailures.length > 0) {
-        logger.warn("acceptance", "Skipped failures (overridden)", {
-          overriddenFailures,
-          overrides: overriddenFailures.map((acId) => ({ acId, reason: overrides[acId] })),
-        });
-      }
-
-      logger.error("acceptance", "Acceptance tests failed", { failedACs: actualFailures });
-      logTestOutput(logger, "acceptance", output);
-
-      // Store failed ACs and test output in context for fix generation
-      ctx.acceptanceFailures = {
-        failedACs: actualFailures,
-        testOutput: output,
-      };
-
-      return {
-        action: "fail",
-        reason: `Acceptance tests failed: ${actualFailures.join(", ")}`,
-      };
-    }
-
-    // All tests passed
-    logger.info("acceptance", "All acceptance tests passed");
-    return { action: "continue" };
-  },
-};

package/src/pipeline/stages/autofix.ts

@@ -1,262 +0,0 @@
-// RE-ARCH: keep
-/**
- * Autofix Stage (ADR-005, Phase 2)
- *
- * Runs after a failed review stage. Attempts to fix quality issues
- * automatically before escalating:
- *
- * Phase 1 — Mechanical fix: runs lintFix / formatFix commands (if configured)
- * Phase 2 — Agent rectification: spawns an agent session with the review error
- *            output as context (reuses the pattern from rectification-loop.ts)
- *
- * Language-agnostic: uses quality.commands.lintFix / formatFix from config.
- * No hardcoded tool names.
- *
- * Enabled only when ctx.reviewResult?.passed === false AND autofix is enabled.
- *
- * Returns:
- * - `retry` fromStage:"review" — autofix resolved the failures
- * - `escalate`                 — max attempts exhausted or agent unavailable
- */
-
-import { join } from "node:path";
-import { getAgent } from "../../agents";
-import { resolveModel } from "../../config";
-import { loadConfigForWorkdir } from "../../config/loader";
-import { resolvePermissions } from "../../config/permissions";
-import { getLogger } from "../../logger";
-import type { UserStory } from "../../prd";
-import type { ReviewCheckResult } from "../../review/types";
-import { pipelineEventBus } from "../event-bus";
-import type { PipelineContext, PipelineStage, StageResult } from "../types";
-
-export const autofixStage: PipelineStage = {
-  name: "autofix",
-
-  enabled(ctx: PipelineContext): boolean {
-    if (!ctx.reviewResult) return false;
-    if (ctx.reviewResult.success) return false;
-    const autofixEnabled = (ctx.effectiveConfig ?? ctx.config).quality.autofix?.enabled ?? true;
-    return autofixEnabled;
-  },
-
-  skipReason(ctx: PipelineContext): string {
-    if (!ctx.reviewResult || ctx.reviewResult.success) return "not needed (review passed)";
-    return "disabled (autofix not enabled in config)";
-  },
-
-  async execute(ctx: PipelineContext): Promise<StageResult> {
-    const logger = getLogger();
-    const { reviewResult } = ctx;
-
-    if (!reviewResult || reviewResult.success) {
-      return { action: "continue" };
-    }
-
-    // PKG-004: use centrally resolved effective config (ctx.effectiveConfig set once per story)
-    const effectiveConfig = ctx.effectiveConfig ?? ctx.config;
-    const lintFixCmd = effectiveConfig.quality.commands.lintFix;
-    const formatFixCmd = effectiveConfig.quality.commands.formatFix;
-
-    // Effective workdir for running commands (scoped to package if monorepo)
-    const effectiveWorkdir = ctx.story.workdir ? join(ctx.workdir, ctx.story.workdir) : ctx.workdir;
-
-    // Identify which checks failed
-    const failedCheckNames = new Set((reviewResult.checks ?? []).filter((c) => !c.success).map((c) => c.check));
-    const hasLintFailure = failedCheckNames.has("lint");
-
-    logger.info("autofix", "Starting autofix", {
-      storyId: ctx.story.id,
-      failedChecks: [...failedCheckNames],
-      workdir: effectiveWorkdir,
-    });
-
-    // Phase 1: Mechanical fix — only for lint failures (lintFix/formatFix cannot fix typecheck errors)
-    if (hasLintFailure && (lintFixCmd || formatFixCmd)) {
-      if (lintFixCmd) {
-        pipelineEventBus.emit({ type: "autofix:started", storyId: ctx.story.id, command: lintFixCmd });
-        const lintResult = await _autofixDeps.runCommand(lintFixCmd, effectiveWorkdir);
-        logger.debug("autofix", `lintFix exit=${lintResult.exitCode}`, { storyId: ctx.story.id, command: lintFixCmd });
-        if (lintResult.exitCode !== 0) {
-          logger.warn("autofix", "lintFix command failed — may not have fixed all issues", {
-            storyId: ctx.story.id,
-            exitCode: lintResult.exitCode,
-          });
-        }
-      }
-
-      if (formatFixCmd) {
-        pipelineEventBus.emit({ type: "autofix:started", storyId: ctx.story.id, command: formatFixCmd });
-        const fmtResult = await _autofixDeps.runCommand(formatFixCmd, effectiveWorkdir);
-        logger.debug("autofix", `formatFix exit=${fmtResult.exitCode}`, {
-          storyId: ctx.story.id,
-          command: formatFixCmd,
-        });
-        if (fmtResult.exitCode !== 0) {
-          logger.warn("autofix", "formatFix command failed — may not have fixed all issues", {
-            storyId: ctx.story.id,
-            exitCode: fmtResult.exitCode,
-          });
-        }
-      }
-
-      const recheckPassed = await _autofixDeps.recheckReview(ctx);
-      pipelineEventBus.emit({ type: "autofix:completed", storyId: ctx.story.id, fixed: recheckPassed });
-
-      if (recheckPassed) {
-        logger.info("autofix", "Mechanical autofix succeeded — retrying review", { storyId: ctx.story.id });
-        return { action: "retry", fromStage: "review" };
-      }
-
-      logger.info("autofix", "Mechanical autofix did not resolve all failures — proceeding to agent rectification", {
-        storyId: ctx.story.id,
-      });
-    }
-
-    // Phase 2: Agent rectification — spawn agent with review error context
-    const agentFixed = await _autofixDeps.runAgentRectification(ctx);
-    if (agentFixed) {
-      if (ctx.reviewResult) ctx.reviewResult = { ...ctx.reviewResult, success: true };
-      logger.info("autofix", "Agent rectification succeeded — retrying review", { storyId: ctx.story.id });
-      return { action: "retry", fromStage: "review" };
-    }
-
-    logger.warn("autofix", "Autofix exhausted — escalating", { storyId: ctx.story.id });
-    return { action: "escalate", reason: "Autofix exhausted: review still failing after fix attempts" };
-  },
-};
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-interface CommandResult {
-  exitCode: number;
-  output: string;
-}
-
-async function runCommand(cmd: string, cwd: string): Promise<CommandResult> {
-  const parts = cmd.split(/\s+/);
-  const proc = Bun.spawn(parts, { cwd, stdout: "pipe", stderr: "pipe" });
-  const [exitCode, stdout, stderr] = await Promise.all([
-    proc.exited,
-    new Response(proc.stdout).text(),
-    new Response(proc.stderr).text(),
-  ]);
-  return { exitCode, output: `${stdout}\n${stderr}` };
-}
-
-async function recheckReview(ctx: PipelineContext): Promise<boolean> {
-  // Import reviewStage lazily to avoid circular deps
-  const { reviewStage } = await import("./review");
-  if (!reviewStage.enabled(ctx)) return true;
-  // reviewStage.execute updates ctx.reviewResult in place.
-  // We cannot use result.action here because review returns "continue" for BOTH
-  // pass and built-in-check-failure (to hand off to autofix). Check success directly.
-  await reviewStage.execute(ctx);
-  return ctx.reviewResult?.success === true;
-}
-
-function collectFailedChecks(ctx: PipelineContext): ReviewCheckResult[] {
-  return (ctx.reviewResult?.checks ?? []).filter((c) => !c.success);
-}
-
-export function buildReviewRectificationPrompt(failedChecks: ReviewCheckResult[], story: UserStory): string {
-  const errors = failedChecks
-    .map((c) => `## ${c.check} errors (exit code ${c.exitCode})\n\`\`\`\n${c.output}\n\`\`\``)
-    .join("\n\n");
-
-  // ENH-008: Scope constraint for monorepo stories — prevent out-of-package changes
-  const scopeConstraint = story.workdir
-    ? `\n\nIMPORTANT: Only modify files within \`${story.workdir}/\`. Do NOT touch files outside this directory.`
-    : "";
-
-  return `You are fixing lint/typecheck errors from a code review.
-
-Story: ${story.title} (${story.id})
-
-The following quality checks failed after implementation:
-
-${errors}
-
-Fix ALL errors listed above. Do NOT change test files or test behavior.
-Do NOT add new features — only fix the quality check errors.
-Commit your fixes when done.${scopeConstraint}`;
-}
-
-async function runAgentRectification(ctx: PipelineContext): Promise<boolean> {
-  const logger = getLogger();
-  const effectiveConfig = ctx.effectiveConfig ?? ctx.config;
-  const maxAttempts = effectiveConfig.quality.autofix?.maxAttempts ?? 2;
-  const failedChecks = collectFailedChecks(ctx);
-
-  if (failedChecks.length === 0) {
-    logger.debug("autofix", "No failed checks found — skipping agent rectification", { storyId: ctx.story.id });
-    return false;
-  }
-
-  logger.info("autofix", "Starting agent rectification for review failures", {
-    storyId: ctx.story.id,
-    failedChecks: failedChecks.map((c) => c.check),
-    maxAttempts,
-  });
-
-  const agentGetFn = ctx.agentGetFn ?? getAgent;
-
-  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-    logger.info("autofix", `Agent rectification attempt ${attempt}/${maxAttempts}`, { storyId: ctx.story.id });
-
-    const agent = agentGetFn(ctx.config.autoMode.defaultAgent);
-    if (!agent) {
-      logger.error("autofix", "Agent not found — cannot run agent rectification", { storyId: ctx.story.id });
-      return false;
-    }
-
-    const prompt = buildReviewRectificationPrompt(failedChecks, ctx.story);
-    const modelTier = ctx.story.routing?.modelTier ?? ctx.config.autoMode.escalation.tierOrder[0]?.tier ?? "balanced";
-    const modelDef = resolveModel(ctx.config.models[modelTier]);
-
-    // ENH-008: Scope agent to story.workdir for monorepo — prevents out-of-package changes
-    const rectificationWorkdir = ctx.story.workdir ? join(ctx.workdir, ctx.story.workdir) : ctx.workdir;
-
-    await agent.run({
-      prompt,
-      workdir: rectificationWorkdir,
-      modelTier,
-      modelDef,
-      timeoutSeconds: ctx.config.execution.sessionTimeoutSeconds,
-      dangerouslySkipPermissions: resolvePermissions(ctx.config, "rectification").skipPermissions,
-      pipelineStage: "rectification",
-      config: ctx.config,
-      maxInteractionTurns: ctx.config.agent?.maxInteractionTurns,
-      storyId: ctx.story.id,
-      sessionRole: "implementer",
-    });
-
-    const passed = await _autofixDeps.recheckReview(ctx);
-    if (passed) {
-      logger.info("autofix", `[OK] Agent rectification succeeded on attempt ${attempt}`, {
-        storyId: ctx.story.id,
-      });
-      return true;
-    }
-
-    // Refresh failed checks for next attempt
-    const updatedFailed = collectFailedChecks(ctx);
-    if (updatedFailed.length > 0) {
-      failedChecks.splice(0, failedChecks.length, ...updatedFailed);
-    }
-
-    logger.warn("autofix", `Agent rectification still failing after attempt ${attempt}`, {
-      storyId: ctx.story.id,
-    });
-  }
-
-  logger.warn("autofix", "Agent rectification exhausted", { storyId: ctx.story.id });
-  return false;
-}
-
-/**
- * Injectable deps for testing.
- */
-export const _autofixDeps = { runCommand, recheckReview, runAgentRectification, loadConfigForWorkdir };