@nathapp/nax 0.38.0 → 0.38.2

package/src/execution/parallel-executor.ts

@@ -19,139 +19,14 @@ import type { StoryMetrics } from "../metrics";
 import type { PipelineEventEmitter } from "../pipeline/events";
 import type { PluginRegistry } from "../plugins/registry";
 import type { PRD } from "../prd";
-import { countStories, isComplete, markStoryPassed } from "../prd";
+import { countStories, isComplete } from "../prd";
+import { errorMessage } from "../utils/errors";
 import { getAllReadyStories, hookCtx } from "./helpers";
 import { executeParallel } from "./parallel";
+import { type ParallelStoryMetrics, runRectificationPass } from "./parallel-executor-rectification-pass";
+import { type ConflictedStoryInfo, rectifyConflictedStory } from "./parallel-executor-rectify";
 import type { StatusWriter } from "./status-writer";
 
-/** StoryMetrics extended with execution-path source */
-export type ParallelStoryMetrics = StoryMetrics & {
-  source: "parallel" | "sequential" | "rectification";
-  rectifiedFromConflict?: boolean;
-  originalCost?: number;
-  rectificationCost?: number;
-};
-
-/** A story that conflicted during the initial parallel merge pass */
-export interface ConflictedStoryInfo {
-  storyId: string;
-  conflictFiles: string[];
-  originalCost: number;
-}
-
-/** Result from attempting to rectify a single conflicted story */
-export type RectificationResult =
-  | { success: true; storyId: string; cost: number }
-  | {
-      success: false;
-      storyId: string;
-      cost: number;
-      finalConflict: boolean;
-      pipelineFailure?: boolean;
-      conflictFiles?: string[];
-    };
-
-/** Options passed to rectifyConflictedStory */
-export interface RectifyConflictedStoryOptions extends ConflictedStoryInfo {
-  workdir: string;
-  config: NaxConfig;
-  hooks: LoadedHooksConfig;
-  pluginRegistry: PluginRegistry;
-  prd: PRD;
-  eventEmitter?: PipelineEventEmitter;
-}
-
-/**
- * Actual implementation of rectifyConflictedStory.
- *
- * Steps:
- * 1. Remove the old worktree
- * 2. Create a fresh worktree from current HEAD (post-merge state)
- * 3. Re-run the full story pipeline
- * 4. Attempt merge on the updated base
- * 5. Return success/finalConflict
- */
-async function rectifyConflictedStory(options: RectifyConflictedStoryOptions): Promise<RectificationResult> {
-  const { storyId, workdir, config, hooks, pluginRegistry, prd, eventEmitter } = options;
-  const logger = getSafeLogger();
-
-  logger?.info("parallel", "Rectifying story on updated base", { storyId, attempt: "rectification" });
-
-  try {
-    const { WorktreeManager } = await import("../worktree/manager");
-    const { MergeEngine } = await import("../worktree/merge");
-    const { runPipeline } = await import("../pipeline/runner");
-    const { defaultPipeline } = await import("../pipeline/stages");
-    const { routeTask } = await import("../routing");
-
-    const worktreeManager = new WorktreeManager();
-    const mergeEngine = new MergeEngine(worktreeManager);
-
-    // Step 1: Remove old worktree
-    try {
-      await worktreeManager.remove(workdir, storyId);
-    } catch {
-      // Ignore — worktree may have already been removed
-    }
-
-    // Step 2: Create fresh worktree from current HEAD
-    await worktreeManager.create(workdir, storyId);
-    const worktreePath = path.join(workdir, ".nax-wt", storyId);
-
-    // Step 3: Re-run the story pipeline
-    const story = prd.userStories.find((s) => s.id === storyId);
-    if (!story) {
-      return { success: false, storyId, cost: 0, finalConflict: false, pipelineFailure: true };
-    }
-
-    const routing = routeTask(story.title, story.description, story.acceptanceCriteria, story.tags, config);
-
-    const pipelineContext = {
-      config,
-      prd,
-      story,
-      stories: [story],
-      workdir: worktreePath,
-      featureDir: undefined,
-      hooks,
-      plugins: pluginRegistry,
-      storyStartTime: new Date().toISOString(),
-      routing: routing as import("../pipeline/types").RoutingResult,
-    };
-
-    const pipelineResult = await runPipeline(defaultPipeline, pipelineContext, eventEmitter);
-    const cost = pipelineResult.context.agentResult?.estimatedCost ?? 0;
-
-    if (!pipelineResult.success) {
-      logger?.info("parallel", "Rectification failed - preserving worktree", { storyId });
-      return { success: false, storyId, cost, finalConflict: false, pipelineFailure: true };
-    }
-
-    // Step 4: Attempt merge on updated base
-    const mergeResults = await mergeEngine.mergeAll(workdir, [storyId], { [storyId]: [] });
-    const mergeResult = mergeResults[0];
-
-    if (!mergeResult || !mergeResult.success) {
-      const conflictFiles = mergeResult?.conflictFiles ?? [];
-      logger?.info("parallel", "Rectification failed - preserving worktree", { storyId });
-      return { success: false, storyId, cost, finalConflict: true, conflictFiles };
-    }
-
-    logger?.info("parallel", "Rectification succeeded - story merged", {
-      storyId,
-      originalCost: options.originalCost,
-      rectificationCost: cost,
-    });
-    return { success: true, storyId, cost };
-  } catch (error) {
-    logger?.error("parallel", "Rectification failed - preserving worktree", {
-      storyId,
-      error: error instanceof Error ? error.message : String(error),
-    });
-    return { success: false, storyId, cost: 0, finalConflict: false, pipelineFailure: true };
-  }
-}
-
 /**
  * Injectable dependencies for testing (avoids mock.module() which leaks in Bun 1.x).
  * @internal - test use only.
@@ -201,86 +76,6 @@ export interface ParallelExecutorResult {
   rectificationStats: RectificationStats;
 }
 
-/**
- * Run the rectification pass: sequentially re-run each conflicted story on
- * the updated base (which already includes all clean merges from the first pass).
- */
-async function runRectificationPass(
-  conflictedStories: ConflictedStoryInfo[],
-  options: ParallelExecutorOptions,
-  prd: PRD,
-): Promise<{
-  rectifiedCount: number;
-  stillConflictingCount: number;
-  additionalCost: number;
-  updatedPrd: PRD;
-  rectificationMetrics: ParallelStoryMetrics[];
-}> {
-  const logger = getSafeLogger();
-  const { workdir, config, hooks, pluginRegistry, eventEmitter } = options;
-  const rectificationMetrics: ParallelStoryMetrics[] = [];
-  let rectifiedCount = 0;
-  let stillConflictingCount = 0;
-  let additionalCost = 0;
-
-  logger?.info("parallel", "Starting merge conflict rectification", {
-    stories: conflictedStories.map((s) => s.storyId),
-    totalConflicts: conflictedStories.length,
-  });
-
-  // Sequential — each story sees all previously rectified stories in the base
-  for (const conflictInfo of conflictedStories) {
-    const result = await _parallelExecutorDeps.rectifyConflictedStory({
-      ...conflictInfo,
-      workdir,
-      config,
-      hooks,
-      pluginRegistry,
-      prd,
-      eventEmitter,
-    });
-
-    additionalCost += result.cost;
-
-    if (result.success) {
-      markStoryPassed(prd, result.storyId);
-      rectifiedCount++;
-
-      rectificationMetrics.push({
-        storyId: result.storyId,
-        complexity: "unknown",
-        modelTier: "parallel",
-        modelUsed: "parallel",
-        attempts: 1,
-        finalTier: "parallel",
-        success: true,
-        cost: result.cost,
-        durationMs: 0,
-        firstPassSuccess: false,
-        startedAt: new Date().toISOString(),
-        completedAt: new Date().toISOString(),
-        source: "rectification" as const,
-        rectifiedFromConflict: true,
-        originalCost: conflictInfo.originalCost,
-        rectificationCost: result.cost,
-      });
-    } else {
-      const isFinalConflict = result.finalConflict === true;
-      if (isFinalConflict) {
-        stillConflictingCount++;
-      }
-      // pipelineFailure — not counted as structural conflict, story remains failed
-    }
-  }
-
-  logger?.info("parallel", "Rectification complete", {
-    rectified: rectifiedCount,
-    stillConflicting: stillConflictingCount,
-  });
-
-  return { rectifiedCount, stillConflictingCount, additionalCost, updatedPrd: prd, rectificationMetrics };
-}
-
 /**
  * Execute parallel stories if --parallel is set
  */
@@ -415,7 +210,7 @@ export async function runParallelExecution(
     });
   } catch (error) {
     logger?.error("parallel", "Parallel execution failed", {
-      error: error instanceof Error ? error.message : String(error),
+      error: errorMessage(error),
     });
 
     // Clear parallel status on error
@@ -430,7 +225,12 @@ export async function runParallelExecution(
   let rectificationStats: RectificationStats = { rectified: 0, stillConflicting: 0 };
 
   if (conflictedStories.length > 0) {
-    const rectResult = await runRectificationPass(conflictedStories, options, prd);
+    const rectResult = await runRectificationPass(
+      conflictedStories,
+      options,
+      prd,
+      _parallelExecutorDeps.rectifyConflictedStory,
+    );
     prd = rectResult.updatedPrd;
     storiesCompleted += rectResult.rectifiedCount;
     totalCost += rectResult.additionalCost;
@@ -517,3 +317,11 @@ export async function runParallelExecution(
 
   return { prd, totalCost, storiesCompleted, completed: false, storyMetrics: batchStoryMetrics, rectificationStats };
 }
+
+// Re-export types for backward compatibility
+export type {
+  ConflictedStoryInfo,
+  RectificationResult,
+  RectifyConflictedStoryOptions,
+} from "./parallel-executor-rectify";
+export type { ParallelStoryMetrics } from "./parallel-executor-rectification-pass";

package/src/execution/parallel-worker.ts

@@ -0,0 +1,148 @@
+/**
+ * Parallel worker — Story execution in worktrees
+ */
+
+import { join } from "node:path";
+import type { NaxConfig } from "../config";
+import { getSafeLogger } from "../logger";
+import type { PipelineEventEmitter } from "../pipeline/events";
+import { runPipeline } from "../pipeline/runner";
+import { defaultPipeline } from "../pipeline/stages";
+import type { PipelineContext, RoutingResult } from "../pipeline/types";
+import type { UserStory } from "../prd";
+import { routeTask } from "../routing";
+import { errorMessage } from "../utils/errors";
+
+/**
+ * Execute a single story in its worktree
+ */
+export async function executeStoryInWorktree(
+  story: UserStory,
+  worktreePath: string,
+  context: Omit<PipelineContext, "story" | "stories" | "workdir" | "routing">,
+  routing: RoutingResult,
+  eventEmitter?: PipelineEventEmitter,
+): Promise<{ success: boolean; cost: number; error?: string }> {
+  const logger = getSafeLogger();
+
+  try {
+    const pipelineContext: PipelineContext = {
+      ...context,
+      story,
+      stories: [story],
+      workdir: worktreePath,
+      routing,
+    };
+
+    logger?.debug("parallel", "Executing story in worktree", {
+      storyId: story.id,
+      worktreePath,
+    });
+
+    const result = await runPipeline(defaultPipeline, pipelineContext, eventEmitter);
+
+    return {
+      success: result.success,
+      cost: result.context.agentResult?.estimatedCost || 0,
+      error: result.success ? undefined : result.reason,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      cost: 0,
+      error: errorMessage(error),
+    };
+  }
+}
+
+/**
+ * Batch execution result
+ */
+export interface ParallelBatchResult {
+  /** Stories that passed the TDD pipeline (pre-merge) */
+  pipelinePassed: UserStory[];
+  /** Stories that were actually merged to the base branch */
+  merged: UserStory[];
+  /** Stories that failed the pipeline */
+  failed: Array<{ story: UserStory; error: string }>;
+  /** Total cost accumulated */
+  totalCost: number;
+  /** Stories with merge conflicts (includes per-story original cost for rectification) */
+  mergeConflicts: Array<{ storyId: string; conflictFiles: string[]; originalCost: number }>;
+  /** Per-story execution costs for successful stories */
+  storyCosts: Map<string, number>;
+}
+
+/**
+ * Execute a batch of independent stories in parallel (worktree setup must be done separately)
+ */
+export async function executeParallelBatch(
+  stories: UserStory[],
+  projectRoot: string,
+  config: NaxConfig,
+  context: Omit<PipelineContext, "story" | "stories" | "workdir" | "routing">,
+  worktreePaths: Map<string, string>,
+  maxConcurrency: number,
+  eventEmitter?: PipelineEventEmitter,
+): Promise<ParallelBatchResult> {
+  const logger = getSafeLogger();
+  const results: ParallelBatchResult = {
+    pipelinePassed: [],
+    merged: [],
+    failed: [],
+    totalCost: 0,
+    mergeConflicts: [],
+    storyCosts: new Map(),
+  };
+
+  // Execute stories in parallel with concurrency limit
+  const executing = new Set<Promise<void>>();
+
+  for (const story of stories) {
+    const worktreePath = worktreePaths.get(story.id);
+    if (!worktreePath) {
+      results.failed.push({
+        story,
+        error: "Worktree not created",
+      });
+      continue;
+    }
+
+    const routing = routeTask(story.title, story.description, story.acceptanceCriteria, story.tags, config);
+
+    const executePromise = executeStoryInWorktree(story, worktreePath, context, routing as RoutingResult, eventEmitter)
+      .then((result) => {
+        results.totalCost += result.cost;
+        results.storyCosts.set(story.id, result.cost);
+
+        if (result.success) {
+          results.pipelinePassed.push(story);
+          logger?.info("parallel", "Story execution succeeded", {
+            storyId: story.id,
+            cost: result.cost,
+          });
+        } else {
+          results.failed.push({ story, error: result.error || "Unknown error" });
+          logger?.error("parallel", "Story execution failed", {
+            storyId: story.id,
+            error: result.error,
+          });
+        }
+      })
+      .finally(() => {
+        executing.delete(executePromise);
+      });
+
+    executing.add(executePromise);
+
+    // Wait if we've hit the concurrency limit
+    if (executing.size >= maxConcurrency) {
+      await Promise.race(executing);
+    }
+  }
+
+  // Wait for all remaining executions
+  await Promise.all(executing);
+
+  return results;
+}