@nathapp/nax 0.46.3 → 0.47.0

package/src/pipeline/stages/verify.ts

@@ -9,6 +9,8 @@
  * - `escalate`: Tests failed (retry with escalation)
  */
 
+import { join } from "node:path";
+import { loadConfigForWorkdir } from "../../config/loader";
 import type { SmartTestRunnerConfig } from "../../config/types";
 import { getLogger } from "../../logger";
 import { logTestOutput } from "../../utils/log-test-output";
@@ -53,15 +55,20 @@ export const verifyStage: PipelineStage = {
   async execute(ctx: PipelineContext): Promise<StageResult> {
     const logger = getLogger();
 
+    // MW-009: resolve effective config for per-package test commands
+    const effectiveConfig = ctx.story.workdir
+      ? await _verifyDeps.loadConfigForWorkdir(join(ctx.workdir, "nax", "config.json"), ctx.story.workdir)
+      : ctx.config;
+
     // Skip verification if tests are not required
-    if (!ctx.config.quality.requireTests) {
+    if (!effectiveConfig.quality.requireTests) {
       logger.debug("verify", "Skipping verification (quality.requireTests = false)", { storyId: ctx.story.id });
       return { action: "continue" };
     }
 
     // Skip verification if no test command is configured
-    const testCommand = ctx.config.review?.commands?.test ?? ctx.config.quality.commands.test;
-    const testScopedTemplate = ctx.config.quality.commands.testScoped;
+    const testCommand = effectiveConfig.review?.commands?.test ?? effectiveConfig.quality.commands.test;
+    const testScopedTemplate = effectiveConfig.quality.commands.testScoped;
     if (!testCommand) {
       logger.debug("verify", "Skipping verification (no test command configured)", { storyId: ctx.story.id });
       return { action: "continue" };
@@ -69,6 +76,9 @@ export const verifyStage: PipelineStage = {
 
     logger.info("verify", "Running verification", { storyId: ctx.story.id });
 
+    // MW-006: resolve effective workdir for test execution
+    const effectiveWorkdir = ctx.story.workdir ? join(ctx.workdir, ctx.story.workdir) : ctx.workdir;
+
     // Determine effective test command (smart runner or full suite)
     let effectiveCommand = testCommand;
     let isFullSuite = true;
@@ -76,10 +86,15 @@ export const verifyStage: PipelineStage = {
     const regressionMode = ctx.config.execution.regressionGate?.mode ?? "deferred";
 
     if (smartRunnerConfig.enabled) {
-      const sourceFiles = await _smartRunnerDeps.getChangedSourceFiles(ctx.workdir, ctx.storyGitRef);
+      // MW-006: pass packagePrefix so git diff is scoped to the package in monorepos
+      const sourceFiles = await _smartRunnerDeps.getChangedSourceFiles(
+        effectiveWorkdir,
+        ctx.storyGitRef,
+        ctx.story.workdir,
+      );
 
       // Pass 1: path convention mapping
-      const pass1Files = await _smartRunnerDeps.mapSourceToTests(sourceFiles, ctx.workdir);
+      const pass1Files = await _smartRunnerDeps.mapSourceToTests(sourceFiles, effectiveWorkdir);
       if (pass1Files.length > 0) {
         logger.info("verify", `[smart-runner] Pass 1: path convention matched ${pass1Files.length} test files`, {
           storyId: ctx.story.id,
@@ -90,7 +105,7 @@ export const verifyStage: PipelineStage = {
         // Pass 2: import-grep fallback
         const pass2Files = await _smartRunnerDeps.importGrepFallback(
           sourceFiles,
-          ctx.workdir,
+          effectiveWorkdir,
           smartRunnerConfig.testFilePatterns,
         );
         if (pass2Files.length > 0) {
@@ -126,7 +141,7 @@ export const verifyStage: PipelineStage = {
 
     // Use unified regression gate (includes 2s wait for agent process cleanup)
     const result = await _verifyDeps.regression({
-      workdir: ctx.workdir,
+      workdir: effectiveWorkdir,
       command: effectiveCommand,
       timeoutSeconds: ctx.config.execution.verificationTimeoutSeconds,
       acceptOnTimeout: ctx.config.execution.regressionGate?.acceptOnTimeout ?? true,
@@ -199,4 +214,5 @@ export const verifyStage: PipelineStage = {
  */
 export const _verifyDeps = {
   regression,
+  loadConfigForWorkdir,
 };

package/src/prd/schema.ts

@@ -155,6 +155,22 @@ function validateStory(raw: unknown, index: number, allIds: Set<string>): UserSt
   const rawTags = s.tags;
   const tags: string[] = Array.isArray(rawTags) ? (rawTags as string[]) : [];
 
+  // workdir — optional, relative path only, no traversal
+  const rawWorkdir = s.workdir;
+  let workdir: string | undefined;
+  if (rawWorkdir !== undefined && rawWorkdir !== null) {
+    if (typeof rawWorkdir !== "string") {
+      throw new Error(`[schema] story[${index}].workdir must be a string`);
+    }
+    if (rawWorkdir.startsWith("/")) {
+      throw new Error(`[schema] story[${index}].workdir must be relative (no leading /): "${rawWorkdir}"`);
+    }
+    if (rawWorkdir.includes("..")) {
+      throw new Error(`[schema] story[${index}].workdir must not contain '..': "${rawWorkdir}"`);
+    }
+    workdir = rawWorkdir;
+  }
+
   return {
     id,
     title: title.trim(),
@@ -172,6 +188,7 @@ function validateStory(raw: unknown, index: number, allIds: Set<string>): UserSt
       testStrategy,
       reasoning: "validated from LLM output",
     },
+    ...(workdir !== undefined ? { workdir } : {}),
   };
 }
 

package/src/prd/types.ts

@@ -127,6 +127,12 @@ export interface UserStory {
   failureCategory?: FailureCategory;
   /** Worktree path for parallel execution (set when --parallel is used) */
   worktreePath?: string;
+  /**
+   * Working directory for this story, relative to repo root.
+   * Overrides the global workdir for pipeline execution.
+   * @example "packages/api"
+   */
+  workdir?: string;
 }
 
 // ============================================================================

package/src/precheck/checks-system.ts

@@ -37,127 +37,65 @@ export async function checkDependenciesInstalled(workdir: string): Promise<Check
   };
 }
 
-/** Check if test command works. Skips silently if command is null/false. */
+/** Check if test command is configured. Downgraded to warning since the verify stage will catch actual failures. */
 export async function checkTestCommand(config: NaxConfig): Promise<Check> {
   const testCommand = config.execution.testCommand || (config.quality?.commands?.test as string | undefined);
 
   if (!testCommand || testCommand === null) {
     return {
       name: "test-command-works",
-      tier: "blocker",
+      tier: "warning",
       passed: true,
-      message: "Test command not configured (skipped)",
+      message: "Test command not configured (will use default: bun test)",
     };
   }
 
-  const parts = testCommand.split(" ");
-  const [cmd, ...args] = parts;
-
-  try {
-    const proc = Bun.spawn([cmd, ...args, "--help"], {
-      stdout: "pipe",
-      stderr: "pipe",
-    });
-
-    const exitCode = await proc.exited;
-    const passed = exitCode === 0;
-
-    return {
-      name: "test-command-works",
-      tier: "blocker",
-      passed,
-      message: passed ? "Test command is available" : `Test command failed: ${testCommand}`,
-    };
-  } catch {
-    return {
-      name: "test-command-works",
-      tier: "blocker",
-      passed: false,
-      message: `Test command failed: ${testCommand}`,
-    };
-  }
+  return {
+    name: "test-command-works",
+    tier: "warning",
+    passed: true,
+    message: `Test command configured: ${testCommand}`,
+  };
 }
 
-/** Check if lint command works. Skips silently if command is null/false. */
+/** Check if lint command is configured. Downgraded to warning since the verify stage will catch actual failures. */
 export async function checkLintCommand(config: NaxConfig): Promise<Check> {
   const lintCommand = config.execution.lintCommand;
 
   if (!lintCommand || lintCommand === null) {
     return {
       name: "lint-command-works",
-      tier: "blocker",
+      tier: "warning",
       passed: true,
       message: "Lint command not configured (skipped)",
     };
   }
 
-  const parts = lintCommand.split(" ");
-  const [cmd, ...args] = parts;
-
-  try {
-    const proc = Bun.spawn([cmd, ...args, "--help"], {
-      stdout: "pipe",
-      stderr: "pipe",
-    });
-
-    const exitCode = await proc.exited;
-    const passed = exitCode === 0;
-
-    return {
-      name: "lint-command-works",
-      tier: "blocker",
-      passed,
-      message: passed ? "Lint command is available" : `Lint command failed: ${lintCommand}`,
-    };
-  } catch {
-    return {
-      name: "lint-command-works",
-      tier: "blocker",
-      passed: false,
-      message: `Lint command failed: ${lintCommand}`,
-    };
-  }
+  return {
+    name: "lint-command-works",
+    tier: "warning",
+    passed: true,
+    message: `Lint command configured: ${lintCommand}`,
+  };
 }
 
-/** Check if typecheck command works. Skips silently if command is null/false. */
+/** Check if typecheck command is configured. Downgraded to warning since the verify stage will catch actual failures. */
 export async function checkTypecheckCommand(config: NaxConfig): Promise<Check> {
   const typecheckCommand = config.execution.typecheckCommand;
 
   if (!typecheckCommand || typecheckCommand === null) {
     return {
       name: "typecheck-command-works",
-      tier: "blocker",
+      tier: "warning",
       passed: true,
       message: "Typecheck command not configured (skipped)",
     };
   }
 
-  const parts = typecheckCommand.split(" ");
-  const [cmd, ...args] = parts;
-
-  try {
-    const proc = Bun.spawn([cmd, ...args, "--help"], {
-      stdout: "pipe",
-      stderr: "pipe",
-    });
-
-    const exitCode = await proc.exited;
-    const passed = exitCode === 0;
-
-    return {
-      name: "typecheck-command-works",
-      tier: "blocker",
-      passed,
-      message: passed
-        ? `Typecheck command is available: ${typecheckCommand}`
-        : `Typecheck command failed: ${typecheckCommand}`,
-    };
-  } catch {
-    return {
-      name: "typecheck-command-works",
-      tier: "blocker",
-      passed: false,
-      message: `Typecheck command failed: ${typecheckCommand}`,
-    };
-  }
+  return {
+    name: "typecheck-command-works",
+    tier: "warning",
+    passed: true,
+    message: `Typecheck command configured: ${typecheckCommand}`,
+  };
 }

package/src/review/orchestrator.ts

@@ -75,6 +75,7 @@ export class ReviewOrchestrator {
     executionConfig: NaxConfig["execution"],
     plugins?: PluginRegistry,
     storyGitRef?: string,
+    scopePrefix?: string,
   ): Promise<OrchestratorReviewResult> {
     const logger = getSafeLogger();
 
@@ -95,14 +96,17 @@ export class ReviewOrchestrator {
         // Use the story's start ref if available to capture auto-committed changes
         const baseRef = storyGitRef ?? executionConfig?.storyGitRef;
         const changedFiles = await getChangedFiles(workdir, baseRef);
+        const scopedFiles = scopePrefix
+          ? changedFiles.filter((f) => f === scopePrefix || f.startsWith(`${scopePrefix}/`))
+          : changedFiles;
         const pluginResults: ReviewResult["pluginReviewers"] = [];
 
         for (const reviewer of reviewers) {
           logger?.info("review", `Running plugin reviewer: ${reviewer.name}`, {
-            changedFiles: changedFiles.length,
+            changedFiles: scopedFiles.length,
           });
           try {
-            const result = await reviewer.check(workdir, changedFiles);
+            const result = await reviewer.check(workdir, scopedFiles);
             // Always log the result so skips/passes are visible in the log
             logger?.info("review", `Plugin reviewer result: ${reviewer.name}`, {
               passed: result.passed,

package/src/verification/smart-runner.ts

@@ -194,7 +194,27 @@ export function buildSmartTestCommand(testFiles: string[], baseCommand: string):
   return newParts.join(" ");
 }
 
-export async function getChangedSourceFiles(workdir: string, baseRef?: string): Promise<string[]> {
+/**
+ * Get TypeScript source files changed since the previous commit.
+ *
+ * Runs `git diff --name-only <ref>` in the given workdir and filters
+ * results to only `.ts` files under the relevant source prefix.
+ *
+ * In a monorepo, git returns paths relative to the git root (e.g.
+ * `packages/api/src/foo.ts`). When `packagePrefix` is set to the
+ * story's workdir (e.g. `"packages/api"`), the filter is scoped to
+ * `<packagePrefix>/src/` instead of just `src/`.
+ *
+ * @param workdir       - Working directory to run git command in
+ * @param baseRef       - Git ref for diff base (default: HEAD~1)
+ * @param packagePrefix - Story workdir relative to repo root (e.g. "packages/api")
+ * @returns Array of changed .ts file paths relative to the git root
+ */
+export async function getChangedSourceFiles(
+  workdir: string,
+  baseRef?: string,
+  packagePrefix?: string,
+): Promise<string[]> {
   try {
     // FEAT-010: Use per-attempt baseRef for precise diff; fall back to HEAD~1 if not provided
     const ref = baseRef ?? "HEAD~1";
@@ -204,7 +224,9 @@ export async function getChangedSourceFiles(workdir: string, baseRef?: string):
 
     const lines = stdout.trim().split("\n").filter(Boolean);
 
-    return lines.filter((f) => f.startsWith("src/") && f.endsWith(".ts"));
+    // MW-006: scope filter to package prefix in monorepo
+    const srcPrefix = packagePrefix ? `${packagePrefix}/src/` : "src/";
+    return lines.filter((f) => f.startsWith(srcPrefix) && f.endsWith(".ts"));
   } catch {
     return [];
   }