@nathapp/nax 0.50.3 → 0.51.0

package/src/verification/types.ts

@@ -1,117 +0,0 @@
-/**
- * Unified Verification Types
- *
- * Shared type definitions for test execution, parsing, and verification.
- */
-
-/** Verification scope: what tests to run */
-export type VerificationScope = "scoped" | "full" | "regression";
-
-/** Verification status outcomes */
-export type VerificationStatus =
-  | "SUCCESS"
-  | "TEST_FAILURE"
-  | "ENVIRONMENTAL_FAILURE"
-  | "ASSET_CHECK_FAILED"
-  | "TIMEOUT";
-
-/** Test execution result (raw) */
-export interface TestExecutionResult {
-  success: boolean;
-  timeout: boolean;
-  exitCode?: number;
-  output?: string;
-  error?: string;
-  killed?: boolean;
-  childProcessesKilled?: boolean;
-  countsTowardEscalation: boolean;
-}
-
-/** Test output analysis (parsed) */
-export interface TestOutputAnalysis {
-  allTestsPassed: boolean;
-  passCount: number;
-  failCount: number;
-  isEnvironmentalFailure: boolean;
-  error?: string;
-}
-
-/** Asset verification result */
-export interface AssetVerificationResult {
-  success: boolean;
-  missingFiles: string[];
-  error?: string;
-}
-
-/** Structured test failure information */
-export interface TestFailure {
-  /** File path where the test failed */
-  file: string;
-  /** Full test name (including nested describe blocks) */
-  testName: string;
-  /** Error message */
-  error: string;
-  /** Stack trace lines (truncated to first 5 lines) */
-  stackTrace: string[];
-}
-
-/** Test run summary */
-export interface TestSummary {
-  /** Number of tests that passed */
-  passed: number;
-  /** Number of tests that failed */
-  failed: number;
-  /** Structured failure details */
-  failures: TestFailure[];
-}
-
-/** Complete verification result */
-export interface VerificationResult {
-  status: VerificationStatus;
-  success: boolean;
-  countsTowardEscalation: boolean;
-  output?: string;
-  error?: string;
-  missingFiles?: string[];
-  passCount?: number;
-  failCount?: number;
-}
-
-/** Rectification state tracking per story execution */
-export interface RectificationState {
-  /** Current attempt number (0 = initial run, 1+ = retries) */
-  attempt: number;
-  /** Number of test failures on initial run */
-  initialFailures: number;
-  /** Number of test failures on current run */
-  currentFailures: number;
-}
-
-/** Verification gate options */
-export interface VerificationGateOptions {
-  /** Working directory */
-  workdir: string;
-  /** Test command to execute */
-  command: string;
-  /** Timeout in seconds */
-  timeoutSeconds: number;
-  /** Expected files (for asset verification) */
-  expectedFiles?: string[];
-  /** Quality config for open handle / force exit behavior */
-  forceExit?: boolean;
-  detectOpenHandles?: boolean;
-  detectOpenHandlesRetries?: number;
-  /** How many times this story has timed out (tracks across retries) */
-  timeoutRetryCount?: number;
-  /** Process management config */
-  gracePeriodMs?: number;
-  drainTimeoutMs?: number;
-  shell?: string;
-  stripEnvVars?: string[];
-  /** Whether to accept story as passed on timeout (BUG-026) */
-  acceptOnTimeout?: boolean;
-  /** Scoped test paths (for scoped verification) */
-  scopedTestPaths?: string[];
-  /** Scoped test command template with {{files}} placeholder — overrides buildSmartTestCommand heuristic */
-  testScopedTemplate?: string;
-}

package/src/version.ts

@@ -1,40 +0,0 @@
-/**
- * Version and build info for nax.
- *
- * GIT_COMMIT is injected at build time via --define in the bun build script.
- * When running from source (bin/nax.ts), falls back to runtime git rev-parse.
- */
-
-import pkg from "../package.json";
-
-declare const GIT_COMMIT: string;
-
-export const NAX_VERSION: string = pkg.version;
-
-/** Short git commit hash — injected at build time, or resolved at runtime from git. */
-export const NAX_COMMIT: string = (() => {
-  // Build-time injection (bun build --define GIT_COMMIT=...)
-  // Guard: must be a non-empty string that looks like a real commit hash
-  try {
-    if (typeof GIT_COMMIT === "string" && /^[0-9a-f]{6,10}$/.test(GIT_COMMIT)) return GIT_COMMIT;
-  } catch {
-    // not injected — fall through to runtime resolution
-  }
-  // Runtime fallback: resolve from the source file's git repo (Bun-native)
-  try {
-    const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
-      cwd: import.meta.dir,
-      stderr: "ignore",
-    });
-    if (result.exitCode === 0) {
-      const hash = result.stdout.toString().trim();
-      if (/^[0-9a-f]{6,10}$/.test(hash)) return hash;
-    }
-  } catch {
-    // git not available
-  }
-  return "dev";
-})();
-
-/** Human-readable build info string — omits commit when unavailable. */
-export const NAX_BUILD_INFO: string = NAX_COMMIT === "dev" ? `v${NAX_VERSION}` : `v${NAX_VERSION} (${NAX_COMMIT})`;

package/src/worktree/dispatcher.ts

@@ -1,6 +0,0 @@
-export interface DispatchResult {
-  storyId: string;
-  success: boolean;
-  worktreePath: string;
-  error?: string;
-}

package/src/worktree/index.ts

@@ -1,2 +0,0 @@
-export { WorktreeManager } from "./manager";
-export type { WorktreeInfo } from "./types";

package/src/worktree/manager.ts

@@ -1,193 +0,0 @@
-import { existsSync, symlinkSync } from "node:fs";
-import { join } from "node:path";
-import { getSafeLogger } from "../logger";
-import { validateStoryId } from "../prd/validate";
-import { errorMessage } from "../utils/errors";
-import type { WorktreeInfo } from "./types";
-
-export class WorktreeManager {
-  /**
-   * Creates a git worktree at .nax-wt/<storyId>/ with branch nax/<storyId>
-   * and symlinks node_modules and .env from project root
-   */
-  async create(projectRoot: string, storyId: string): Promise<void> {
-    validateStoryId(storyId);
-
-    const worktreePath = join(projectRoot, ".nax-wt", storyId);
-    const branchName = `nax/${storyId}`;
-
-    try {
-      // Create worktree with new branch
-      const proc = Bun.spawn(["git", "worktree", "add", worktreePath, "-b", branchName], {
-        cwd: projectRoot,
-        stdout: "pipe",
-        stderr: "pipe",
-      });
-
-      const exitCode = await proc.exited;
-      if (exitCode !== 0) {
-        const stderr = await new Response(proc.stderr).text();
-        throw new Error(`Failed to create worktree: ${stderr || "unknown error"}`);
-      }
-    } catch (error) {
-      if (error instanceof Error) {
-        // Enhance error messages for common scenarios
-        if (error.message.includes("not a git repository")) {
-          throw new Error(`Not a git repository: ${projectRoot}`);
-        }
-        if (error.message.includes("already exists")) {
-          throw new Error(`Worktree for story ${storyId} already exists at ${worktreePath}`);
-        }
-        throw error;
-      }
-      throw new Error(`Failed to create worktree: ${String(error)}`);
-    }
-
-    // Symlink node_modules if it exists
-    const nodeModulesSource = join(projectRoot, "node_modules");
-    if (existsSync(nodeModulesSource)) {
-      const nodeModulesTarget = join(worktreePath, "node_modules");
-      try {
-        symlinkSync(nodeModulesSource, nodeModulesTarget, "dir");
-      } catch (error) {
-        // Clean up worktree if symlinking fails
-        await this.remove(projectRoot, storyId);
-        throw new Error(`Failed to symlink node_modules: ${errorMessage(error)}`);
-      }
-    }
-
-    // Symlink .env if it exists
-    const envSource = join(projectRoot, ".env");
-    if (existsSync(envSource)) {
-      const envTarget = join(worktreePath, ".env");
-      try {
-        symlinkSync(envSource, envTarget, "file");
-      } catch (error) {
-        // Clean up worktree if symlinking fails
-        await this.remove(projectRoot, storyId);
-        throw new Error(`Failed to symlink .env: ${errorMessage(error)}`);
-      }
-    }
-  }
-
-  /**
-   * Removes worktree and deletes branch
-   */
-  async remove(projectRoot: string, storyId: string): Promise<void> {
-    validateStoryId(storyId);
-
-    const worktreePath = join(projectRoot, ".nax-wt", storyId);
-    const branchName = `nax/${storyId}`;
-
-    // Remove worktree
-    try {
-      const proc = Bun.spawn(["git", "worktree", "remove", worktreePath, "--force"], {
-        cwd: projectRoot,
-        stdout: "pipe",
-        stderr: "pipe",
-      });
-
-      const exitCode = await proc.exited;
-      if (exitCode !== 0) {
-        const stderr = await new Response(proc.stderr).text();
-        if (
-          stderr.includes("not found") ||
-          stderr.includes("does not exist") ||
-          stderr.includes("no such worktree") ||
-          stderr.includes("is not a working tree")
-        ) {
-          throw new Error(`Worktree not found: ${worktreePath}`);
-        }
-        throw new Error(`Failed to remove worktree: ${stderr || "unknown error"}`);
-      }
-    } catch (error) {
-      if (error instanceof Error) {
-        throw error;
-      }
-      throw new Error(`Failed to remove worktree: ${String(error)}`);
-    }
-
-    // Delete branch
-    try {
-      const proc = Bun.spawn(["git", "branch", "-D", branchName], {
-        cwd: projectRoot,
-        stdout: "pipe",
-        stderr: "pipe",
-      });
-
-      const exitCode = await proc.exited;
-      if (exitCode !== 0) {
-        const stderr = await new Response(proc.stderr).text();
-        // Don't fail if branch doesn't exist
-        if (!stderr.includes("not found")) {
-          const logger = getSafeLogger();
-          logger?.warn("worktree", `Failed to delete branch ${branchName}`, { stderr });
-        }
-      }
-    } catch (error) {
-      // Log warning but don't fail - worktree is already removed
-      const logger = getSafeLogger();
-      logger?.warn("worktree", `Failed to delete branch ${branchName}`, {
-        error: errorMessage(error),
-      });
-    }
-  }
-
-  /**
-   * Returns active worktrees
-   */
-  async list(projectRoot: string): Promise<WorktreeInfo[]> {
-    try {
-      const proc = Bun.spawn(["git", "worktree", "list", "--porcelain"], {
-        cwd: projectRoot,
-        stdout: "pipe",
-        stderr: "pipe",
-      });
-
-      const exitCode = await proc.exited;
-      if (exitCode !== 0) {
-        const stderr = await new Response(proc.stderr).text();
-        throw new Error(`Failed to list worktrees: ${stderr || "unknown error"}`);
-      }
-
-      const stdout = await new Response(proc.stdout).text();
-      return this.parseWorktreeList(stdout);
-    } catch (error) {
-      if (error instanceof Error) {
-        throw error;
-      }
-      throw new Error(`Failed to list worktrees: ${String(error)}`);
-    }
-  }
-
-  /**
-   * Parses git worktree list --porcelain output
-   */
-  private parseWorktreeList(output: string): WorktreeInfo[] {
-    const worktrees: WorktreeInfo[] = [];
-    const lines = output.trim().split("\n");
-
-    let currentWorktree: Partial<WorktreeInfo> = {};
-
-    for (const line of lines) {
-      if (line.startsWith("worktree ")) {
-        currentWorktree.path = line.substring("worktree ".length);
-      } else if (line.startsWith("branch ")) {
-        currentWorktree.branch = line.substring("branch ".length).replace("refs/heads/", "");
-      } else if (line === "") {
-        // Empty line indicates end of worktree entry
-        if (currentWorktree.path && currentWorktree.branch) {
-          worktrees.push(currentWorktree as WorktreeInfo);
-        }
-        currentWorktree = {};
-      }
-    }
-
-    // Handle last entry if no trailing newline
-    if (currentWorktree.path && currentWorktree.branch) {
-      worktrees.push(currentWorktree as WorktreeInfo);
-    }
-
-    return worktrees;
-  }
-}

package/src/worktree/merge.ts

@@ -1,302 +0,0 @@
-import { getSafeLogger } from "../logger";
-import { errorMessage } from "../utils/errors";
-import type { WorktreeManager } from "./manager";
-
-export interface MergeResult {
-  success: boolean;
-  storyId: string;
-  conflictFiles?: string[];
-  retryCount?: number;
-}
-
-export interface StoryDependencies {
-  [storyId: string]: string[];
-}
-
-export class MergeEngine {
-  constructor(private worktreeManager: WorktreeManager) {}
-
-  /**
-   * Merges branch nax/<storyId> into current branch with --no-ff
-   * Returns { success: true } on clean merge
-   * Returns { success: false, conflictFiles: [...] } on conflict
-   * Cleans up worktree after successful merge
-   */
-  async merge(projectRoot: string, storyId: string): Promise<Omit<MergeResult, "storyId">> {
-    const branchName = `nax/${storyId}`;
-
-    try {
-      // Perform merge with --no-ff
-      const mergeProc = Bun.spawn(["git", "merge", "--no-ff", branchName, "-m", `Merge branch '${branchName}'`], {
-        cwd: projectRoot,
-        stdout: "pipe",
-        stderr: "pipe",
-      });
-
-      const exitCode = await mergeProc.exited;
-      const stderr = await new Response(mergeProc.stderr).text();
-      const stdout = await new Response(mergeProc.stdout).text();
-
-      if (exitCode === 0) {
-        // Clean merge - cleanup worktree
-        try {
-          await this.worktreeManager.remove(projectRoot, storyId);
-        } catch (error) {
-          // Log warning but don't fail the merge
-          const logger = getSafeLogger();
-          logger?.warn("worktree", `Failed to cleanup worktree for ${storyId}`, {
-            error: errorMessage(error),
-          });
-        }
-
-        return { success: true };
-      }
-
-      // Merge failed - check for conflicts
-      const output = `${stdout}\n${stderr}`;
-      if (output.includes("CONFLICT") || output.includes("conflict") || output.includes("Automatic merge failed")) {
-        // Extract conflict files
-        const conflictFiles = await this.getConflictFiles(projectRoot);
-
-        // Abort the merge
-        await this.abortMerge(projectRoot);
-
-        return {
-          success: false,
-          conflictFiles,
-        };
-      }
-
-      // Other error
-      throw new Error(`Merge failed: ${stderr || stdout || "unknown error"}`);
-    } catch (error) {
-      if (error instanceof Error) {
-        throw error;
-      }
-      throw new Error(`Failed to merge branch ${branchName}: ${String(error)}`);
-    }
-  }
-
-  /**
-   * Merges stories in topological order based on dependencies
-   * On conflict: retries once after rebasing worktree on updated base
-   * On 2nd conflict: marks story as failed, continues with remaining stories
-   */
-  async mergeAll(projectRoot: string, storyIds: string[], dependencies: StoryDependencies): Promise<MergeResult[]> {
-    // Sort stories in topological order
-    const orderedStories = this.topologicalSort(storyIds, dependencies);
-    const results: MergeResult[] = [];
-    const failedStories = new Set<string>();
-
-    for (const storyId of orderedStories) {
-      // Check if any dependencies failed
-      const deps = dependencies[storyId] || [];
-      const hasFailedDeps = deps.some((dep) => failedStories.has(dep));
-
-      if (hasFailedDeps) {
-        results.push({
-          success: false,
-          storyId,
-          conflictFiles: [],
-        });
-        failedStories.add(storyId);
-        continue;
-      }
-
-      // Try to merge
-      let result = await this.merge(projectRoot, storyId);
-
-      // If conflict, retry once after rebasing
-      if (!result.success && result.conflictFiles) {
-        try {
-          // Rebase worktree on updated base
-          await this.rebaseWorktree(projectRoot, storyId);
-
-          // Retry merge
-          result = await this.merge(projectRoot, storyId);
-
-          // If still fails, mark as failed
-          if (!result.success) {
-            results.push({
-              success: false,
-              storyId,
-              conflictFiles: result.conflictFiles,
-              retryCount: 1,
-            });
-            failedStories.add(storyId);
-            continue;
-          }
-
-          // Success after retry
-          results.push({
-            success: true,
-            storyId,
-            retryCount: 1,
-          });
-        } catch (error) {
-          // Rebase failed, mark as failed
-          results.push({
-            success: false,
-            storyId,
-            conflictFiles: result.conflictFiles,
-            retryCount: 1,
-          });
-          failedStories.add(storyId);
-        }
-      } else if (result.success) {
-        // First attempt succeeded
-        results.push({
-          success: true,
-          storyId,
-          retryCount: 0,
-        });
-      } else {
-        // Failed without conflicts (shouldn't happen normally)
-        results.push({
-          success: false,
-          storyId,
-          retryCount: 0,
-        });
-        failedStories.add(storyId);
-      }
-    }
-
-    return results;
-  }
-
-  /**
-   * Topological sort of stories based on dependencies
-   * Returns stories in order where dependencies come before dependents
-   */
-  private topologicalSort(storyIds: string[], dependencies: StoryDependencies): string[] {
-    const visited = new Set<string>();
-    const sorted: string[] = [];
-    const visiting = new Set<string>();
-
-    const visit = (storyId: string) => {
-      if (visited.has(storyId)) {
-        return;
-      }
-
-      if (visiting.has(storyId)) {
-        throw new Error(`Circular dependency detected involving ${storyId}`);
-      }
-
-      visiting.add(storyId);
-
-      // Visit dependencies first
-      const deps = dependencies[storyId] || [];
-      for (const dep of deps) {
-        if (storyIds.includes(dep)) {
-          visit(dep);
-        }
-      }
-
-      visiting.delete(storyId);
-      visited.add(storyId);
-      sorted.push(storyId);
-    };
-
-    for (const storyId of storyIds) {
-      visit(storyId);
-    }
-
-    return sorted;
-  }
-
-  /**
-   * Rebases worktree on current base branch
-   */
-  private async rebaseWorktree(projectRoot: string, storyId: string): Promise<void> {
-    const worktreePath = `${projectRoot}/.nax-wt/${storyId}`;
-
-    try {
-      // Get current branch name from main repo
-      const currentBranchProc = Bun.spawn(["git", "rev-parse", "--abbrev-ref", "HEAD"], {
-        cwd: projectRoot,
-        stdout: "pipe",
-        stderr: "pipe",
-      });
-
-      const exitCode = await currentBranchProc.exited;
-      if (exitCode !== 0) {
-        throw new Error("Failed to get current branch");
-      }
-
-      const currentBranch = (await new Response(currentBranchProc.stdout).text()).trim();
-
-      // Rebase worktree branch onto current branch
-      const rebaseProc = Bun.spawn(["git", "rebase", currentBranch], {
-        cwd: worktreePath,
-        stdout: "pipe",
-        stderr: "pipe",
-      });
-
-      const rebaseExitCode = await rebaseProc.exited;
-      if (rebaseExitCode !== 0) {
-        const stderr = await new Response(rebaseProc.stderr).text();
-
-        // Abort rebase on failure
-        await Bun.spawn(["git", "rebase", "--abort"], {
-          cwd: worktreePath,
-          stdout: "pipe",
-          stderr: "pipe",
-        }).exited;
-
-        throw new Error(`Rebase failed: ${stderr || "unknown error"}`);
-      }
-    } catch (error) {
-      if (error instanceof Error) {
-        throw error;
-      }
-      throw new Error(`Failed to rebase worktree ${storyId}: ${String(error)}`);
-    }
-  }
-
-  /**
-   * Gets list of conflicted files
-   */
-  private async getConflictFiles(projectRoot: string): Promise<string[]> {
-    try {
-      const proc = Bun.spawn(["git", "diff", "--name-only", "--diff-filter=U"], {
-        cwd: projectRoot,
-        stdout: "pipe",
-        stderr: "pipe",
-      });
-
-      const exitCode = await proc.exited;
-      if (exitCode !== 0) {
-        return [];
-      }
-
-      const stdout = await new Response(proc.stdout).text();
-      return stdout
-        .trim()
-        .split("\n")
-        .filter((line) => line.length > 0);
-    } catch {
-      return [];
-    }
-  }
-
-  /**
-   * Aborts an in-progress merge
-   */
-  private async abortMerge(projectRoot: string): Promise<void> {
-    try {
-      const proc = Bun.spawn(["git", "merge", "--abort"], {
-        cwd: projectRoot,
-        stdout: "pipe",
-        stderr: "pipe",
-      });
-
-      await proc.exited;
-    } catch (error) {
-      // Log warning but don't throw - merge might already be aborted
-      const logger = getSafeLogger();
-      logger?.warn("worktree", "Failed to abort merge", {
-        error: errorMessage(error),
-      });
-    }
-  }
-}

package/src/worktree/types.ts

@@ -1,4 +0,0 @@
-export interface WorktreeInfo {
-  path: string;
-  branch: string;
-}