@nathapp/nax 0.50.2 → 0.51.0

package/src/execution/parallel-executor.ts

@@ -1,330 +0,0 @@
-/**
- * Parallel Execution Wrapper
- *
- * Handles the full parallel execution flow:
- * - Status updates with parallel info
- * - Execute parallel stories
- * - Rectify merge conflicts (MFX-005): re-run conflicted stories sequentially
- *   on the updated base branch so each sees all previously merged stories
- * - Handle completion or continue to sequential
- */
-
-import * as os from "node:os";
-import path from "node:path";
-import type { NaxConfig } from "../config";
-import type { LoadedHooksConfig } from "../hooks";
-import { fireHook } from "../hooks";
-import { getSafeLogger } from "../logger";
-import type { StoryMetrics } from "../metrics";
-import type { PipelineEventEmitter } from "../pipeline/events";
-import type { AgentGetFn } from "../pipeline/types";
-import type { PluginRegistry } from "../plugins/registry";
-import type { PRD } 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";
-
-/**
- * Injectable dependencies for testing (avoids mock.module() which leaks in Bun 1.x).
- * @internal - test use only.
- */
-export const _parallelExecutorDeps = {
-  fireHook,
-  executeParallel,
-  rectifyConflictedStory,
-};
-
-export interface ParallelExecutorOptions {
-  prdPath: string;
-  workdir: string;
-  config: NaxConfig;
-  hooks: LoadedHooksConfig;
-  feature: string;
-  featureDir?: string;
-  parallelCount: number;
-  eventEmitter?: PipelineEventEmitter;
-  statusWriter: StatusWriter;
-  runId: string;
-  startedAt: string;
-  startTime: number;
-  totalCost: number;
-  iterations: number;
-  storiesCompleted: number;
-  allStoryMetrics: StoryMetrics[];
-  pluginRegistry: PluginRegistry;
-  formatterMode: "quiet" | "normal" | "verbose" | "json";
-  headless: boolean;
-  agentGetFn?: AgentGetFn;
-}
-
-export interface RectificationStats {
-  rectified: number;
-  stillConflicting: number;
-}
-
-export interface ParallelExecutorResult {
-  prd: PRD;
-  totalCost: number;
-  storiesCompleted: number;
-  completed: boolean;
-  durationMs?: number;
-  /** Per-story metrics for stories completed via the parallel path */
-  storyMetrics: ParallelStoryMetrics[];
-  /** Stats from the merge-conflict rectification pass (MFX-005) */
-  rectificationStats: RectificationStats;
-}
-
-/**
- * Execute parallel stories if --parallel is set
- */
-export async function runParallelExecution(
-  options: ParallelExecutorOptions,
-  initialPrd: PRD,
-): Promise<ParallelExecutorResult> {
-  const logger = getSafeLogger();
-  const {
-    prdPath,
-    workdir,
-    config,
-    hooks,
-    feature,
-    featureDir,
-    parallelCount,
-    eventEmitter,
-    statusWriter,
-    runId,
-    startedAt,
-    startTime,
-    pluginRegistry,
-    formatterMode,
-    headless,
-  } = options;
-
-  let { totalCost, iterations, storiesCompleted, allStoryMetrics } = options;
-  let prd = initialPrd;
-
-  const readyStories = getAllReadyStories(prd);
-  if (readyStories.length === 0) {
-    logger?.info("parallel", "No stories ready for parallel execution");
-    return {
-      prd,
-      totalCost,
-      storiesCompleted,
-      completed: false,
-      storyMetrics: [],
-      rectificationStats: { rectified: 0, stillConflicting: 0 },
-    };
-  }
-
-  const maxConcurrency = parallelCount === 0 ? os.cpus().length : Math.max(1, parallelCount);
-
-  logger?.info("parallel", "Starting parallel execution mode", {
-    totalStories: readyStories.length,
-    maxConcurrency,
-  });
-
-  // Update status with parallel info
-  statusWriter.setPrd(prd);
-  await statusWriter.update(totalCost, iterations, {
-    parallel: {
-      enabled: true,
-      maxConcurrency,
-      activeStories: readyStories.map((s) => ({
-        storyId: s.id,
-        worktreePath: path.join(workdir, ".nax-wt", s.id),
-      })),
-    },
-  });
-
-  // Track which stories were already passed before this batch
-  const initialPassedIds = new Set(initialPrd.userStories.filter((s) => s.status === "passed").map((s) => s.id));
-  const batchStartedAt = new Date().toISOString();
-  const batchStartMs = Date.now();
-  const batchStoryMetrics: ParallelStoryMetrics[] = [];
-
-  let conflictedStories: ConflictedStoryInfo[] = [];
-
-  try {
-    const parallelResult = await _parallelExecutorDeps.executeParallel(
-      readyStories,
-      prdPath,
-      workdir,
-      config,
-      hooks,
-      pluginRegistry,
-      prd,
-      featureDir,
-      parallelCount,
-      eventEmitter,
-      options.agentGetFn,
-    );
-
-    const batchDurationMs = Date.now() - batchStartMs;
-    const batchCompletedAt = new Date().toISOString();
-
-    prd = parallelResult.updatedPrd;
-    storiesCompleted += parallelResult.storiesCompleted;
-    totalCost += parallelResult.totalCost;
-    conflictedStories = parallelResult.mergeConflicts ?? [];
-
-    // BUG-066: Build per-story metrics for stories newly completed by this parallel batch
-    const newlyPassedStories = prd.userStories.filter((s) => s.status === "passed" && !initialPassedIds.has(s.id));
-    const costPerStory = newlyPassedStories.length > 0 ? parallelResult.totalCost / newlyPassedStories.length : 0;
-    for (const story of newlyPassedStories) {
-      batchStoryMetrics.push({
-        storyId: story.id,
-        complexity: "unknown",
-        modelTier: "parallel",
-        modelUsed: "parallel",
-        attempts: 1,
-        finalTier: "parallel",
-        success: true,
-        cost: costPerStory,
-        durationMs: batchDurationMs,
-        firstPassSuccess: true,
-        startedAt: batchStartedAt,
-        completedAt: batchCompletedAt,
-        source: "parallel" as const,
-      });
-    }
-
-    allStoryMetrics.push(...batchStoryMetrics);
-
-    // Log each conflict before scheduling rectification
-    for (const conflict of conflictedStories) {
-      logger?.info("parallel", "Merge conflict detected - scheduling for rectification", {
-        storyId: conflict.storyId,
-        conflictFiles: conflict.conflictFiles,
-      });
-    }
-
-    // Clear parallel status
-    statusWriter.setPrd(prd);
-    await statusWriter.update(totalCost, iterations, {
-      parallel: {
-        enabled: true,
-        maxConcurrency,
-        activeStories: [],
-      },
-    });
-  } catch (error) {
-    logger?.error("parallel", "Parallel execution failed", {
-      error: errorMessage(error),
-    });
-
-    // Clear parallel status on error
-    await statusWriter.update(totalCost, iterations, {
-      parallel: undefined,
-    });
-
-    throw error;
-  }
-
-  // ── MFX-005: Rectification pass ────────────────────────────────────────────
-  let rectificationStats: RectificationStats = { rectified: 0, stillConflicting: 0 };
-
-  if (conflictedStories.length > 0) {
-    const rectResult = await runRectificationPass(
-      conflictedStories,
-      options,
-      prd,
-      _parallelExecutorDeps.rectifyConflictedStory,
-    );
-    prd = rectResult.updatedPrd;
-    storiesCompleted += rectResult.rectifiedCount;
-    totalCost += rectResult.additionalCost;
-    rectificationStats = {
-      rectified: rectResult.rectifiedCount,
-      stillConflicting: rectResult.stillConflictingCount,
-    };
-    batchStoryMetrics.push(...rectResult.rectificationMetrics);
-    allStoryMetrics.push(...rectResult.rectificationMetrics);
-  }
-
-  // Check if all stories are complete after parallel execution + rectification
-  if (isComplete(prd)) {
-    logger?.info("execution", "All stories complete!", {
-      feature,
-      totalCost,
-    });
-    await _parallelExecutorDeps.fireHook(
-      hooks,
-      "on-all-stories-complete",
-      hookCtx(feature, { status: "passed", cost: totalCost }),
-      workdir,
-    );
-    await _parallelExecutorDeps.fireHook(
-      hooks,
-      "on-complete",
-      hookCtx(feature, { status: "complete", cost: totalCost }),
-      workdir,
-    );
-
-    // Skip to metrics and cleanup
-    const durationMs = Date.now() - startTime;
-    const runCompletedAt = new Date().toISOString();
-
-    const { handleParallelCompletion } = await import("./lifecycle/parallel-lifecycle");
-    await handleParallelCompletion({
-      runId,
-      feature,
-      startedAt,
-      completedAt: runCompletedAt,
-      prd,
-      allStoryMetrics,
-      totalCost,
-      storiesCompleted,
-      durationMs,
-      workdir,
-      pluginRegistry,
-    });
-
-    const finalCounts = countStories(prd);
-    statusWriter.setPrd(prd);
-    statusWriter.setCurrentStory(null);
-    statusWriter.setRunStatus("completed");
-    await statusWriter.update(totalCost, iterations);
-
-    // ── Output run footer in headless mode (parallel path) ──────────────
-    if (headless && formatterMode !== "json") {
-      const { outputRunFooter } = await import("./lifecycle/headless-formatter");
-      outputRunFooter({
-        finalCounts: {
-          total: finalCounts.total,
-          passed: finalCounts.passed,
-          failed: finalCounts.failed,
-          skipped: finalCounts.skipped,
-        },
-        durationMs,
-        totalCost,
-        startedAt,
-        completedAt: runCompletedAt,
-        formatterMode,
-      });
-    }
-
-    return {
-      prd,
-      totalCost,
-      storiesCompleted,
-      completed: true,
-      durationMs,
-      storyMetrics: batchStoryMetrics,
-      rectificationStats,
-    };
-  }
-
-  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

@@ -1,149 +0,0 @@
-/**
- * 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,
-      effectiveConfig: context.effectiveConfig ?? context.config,
-      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;
-}

package/src/execution/parallel.ts

@@ -1,13 +0,0 @@
-/**
- * Parallel Execution — Hub file
- *
- * Orchestrates parallel story execution using git worktrees: groups stories
- * by dependencies, creates worktrees, dispatches concurrent pipelines,
- * merges in dependency order, and cleans up worktrees.
- *
- * Re-exports coordinator and worker modules for backward compatibility.
- */
-
-// Re-export for backward compatibility
-export { executeParallel } from "./parallel-coordinator";
-export type { ParallelBatchResult } from "./parallel-worker";