@nathapp/nax 0.73.2 → 0.73.3

package/dist/nax.js

@@ -24524,16 +24524,24 @@ function buildTestFrameworkHint(testCommand) {
     return "Use Jest (describe/test/expect)";
   return "Use your project's test framework";
 }
+function stripAnsi(output) {
+  return output.replace(/\x1b\[[0-9;?]*[A-Za-z]/g, "");
+}
 function detectFramework(output) {
-  if (/^\s*Test Files\s+\d+/m.test(output))
+  const clean = stripAnsi(output);
+  if (/^\s*Test Files\s+\d+/m.test(clean))
     return "vitest";
-  if (/^\s*Tests:\s+\d+/m.test(output))
+  if (/^\s*Tests:\s+\d+/m.test(clean))
     return "jest";
-  if (/={3,}\s+\d+\s+(?:failed|passed).*in\s+[\d.]+s\s*={3,}/m.test(output))
+  if (/={3,}\s+\d+\s+(?:failed|passed).*in\s+[\d.]+s\s*={3,}/m.test(clean))
     return "pytest";
-  if (/^--- (?:FAIL|PASS):/m.test(output) || /^(?:ok|FAIL)\s+\t/m.test(output))
+  if (/^--- (?:FAIL|PASS):/m.test(clean) || /^(?:ok|FAIL)\s+\t/m.test(clean))
     return "go";
-  if (/^\(fail\)\s/m.test(output) || /^bun test/m.test(output) || /[\u2713\u2714\u2717\u2718]/m.test(output))
+  if (/^test result:\s+(?:ok|FAILED)\./m.test(clean) || /panicked at /.test(clean))
+    return "rust";
+  if (/^\s*\d+\s+passing\b/m.test(clean))
+    return "mocha";
+  if (/^\(fail\)\s/m.test(clean) || /^bun test/m.test(clean) || /[\u2713\u2714\u2717\u2718]/m.test(clean))
     return "bun";
   return "unknown";
 }
@@ -24670,21 +24678,125 @@ var init_resolver = __esm(() => {
   };
 });
 
+// src/test-runners/parse-mocha.ts
+function parseMochaOutput(output) {
+  return {
+    passed: matchCount(output, /(\d+)\s+passing\b/),
+    failed: matchCount(output, /(\d+)\s+failing\b/),
+    failures: extractMochaFailures(output)
+  };
+}
+function matchCount(output, re) {
+  const m = output.match(re);
+  return m ? Number.parseInt(m[1], 10) : 0;
+}
+function extractMochaFailures(output) {
+  const failingIdx = output.search(/^\s*\d+\s+failing\b/m);
+  if (failingIdx === -1)
+    return [];
+  const lines = output.slice(failingIdx).split(`
+`);
+  const failures = [];
+  for (let i = 1;i < lines.length; i++) {
+    const header = lines[i].match(/^\s*(\d+)\)\s+(.+)$/);
+    if (!header)
+      continue;
+    const testName = header[2].replace(/:\s*$/, "").trim();
+    let file3 = "unknown";
+    let error48 = "";
+    const stackTrace = [];
+    for (let j = i + 1;j < lines.length; j++) {
+      const line = lines[j];
+      if (/^\s*\d+\)\s+/.test(line))
+        break;
+      const at = line.match(/at\s+.*\(([^)]+):(\d+):(\d+)\)/);
+      if (at) {
+        if (file3 === "unknown")
+          file3 = at[1];
+        if (stackTrace.length < MAX_STACK_LINES)
+          stackTrace.push(`${at[1]}:${at[2]}`);
+        continue;
+      }
+      if (!error48 && line.trim())
+        error48 = line.trim();
+    }
+    failures.push({ file: file3, testName, error: error48 || "Unknown error", stackTrace });
+  }
+  return failures;
+}
+var MAX_STACK_LINES = 5;
+
+// src/test-runners/parse-rust.ts
+function parseRustTestOutput(output) {
+  let passed = 0;
+  let failed = 0;
+  for (const m of output.matchAll(RESULT_LINE_RE)) {
+    passed += Number.parseInt(m[1], 10);
+    failed += Number.parseInt(m[2], 10);
+  }
+  return { passed, failed, failures: extractRustFailures(output) };
+}
+function extractRustFailures(output) {
+  const lines = output.split(`
+`);
+  const failures = [];
+  for (let i = 0;i < lines.length; i++) {
+    const header = lines[i].match(/^---- (\S+) stdout ----$/);
+    if (!header)
+      continue;
+    const testName = header[1];
+    let file3 = "unknown";
+    let error48 = "";
+    const stackTrace = [];
+    for (let j = i + 1;j < lines.length; j++) {
+      const line = lines[j];
+      if (/^---- \S+ stdout ----$/.test(line) || /^test result:/.test(line))
+        break;
+      const panic = line.match(/panicked at ([^:\n]+):(\d+):(?:\d+):/);
+      if (panic) {
+        file3 = panic[1];
+        if (stackTrace.length < MAX_STACK_LINES2)
+          stackTrace.push(`${panic[1]}:${panic[2]}`);
+        continue;
+      }
+      if (!error48 && line.trim() && !line.startsWith("note:"))
+        error48 = line.trim();
+    }
+    failures.push({ file: file3, testName, error: error48 || "Unknown error", stackTrace });
+  }
+  if (failures.length > 0)
+    return failures;
+  for (const m of output.matchAll(FAILED_TEST_LINE_RE)) {
+    failures.push({ file: "unknown", testName: m[1], error: "Unknown error", stackTrace: [] });
+  }
+  return failures;
+}
+var RESULT_LINE_RE, FAILED_TEST_LINE_RE, MAX_STACK_LINES2 = 5;
+var init_parse_rust = __esm(() => {
+  RESULT_LINE_RE = /^test result:\s+(?:ok|FAILED)\.\s+(\d+)\s+passed;\s+(\d+)\s+failed;/gm;
+  FAILED_TEST_LINE_RE = /^test (\S+) \.\.\. FAILED$/gm;
+});
+
 // src/test-runners/parser.ts
 function parseTestOutput(output) {
-  const framework = detectFramework(output);
+  const clean = stripAnsi(output);
+  const framework = detectFramework(clean);
   switch (framework) {
     case "bun":
-      return parseBunOutput(output);
+      return parseBunOutput(clean);
     case "jest":
     case "vitest":
-      return parseJestOutput(output);
+      return parseJestOutput(clean);
     case "pytest":
-      return parsePytestOutput(output);
+      return parsePytestOutput(clean);
     case "go":
-      return parseGoTestOutput(output);
+      return parseGoTestOutput(clean);
+    case "rust":
+      return parseRustTestOutput(clean);
+    case "mocha":
+      return parseMochaOutput(clean);
     default:
-      return parseCommonOutput(output);
+      return parseCommonOutput(clean);
   }
 }
 function parseBunTestOutput(output) {
@@ -25014,11 +25126,12 @@ function analyzeTestExitCode(output, exitCode) {
 }
 var init_parser = __esm(() => {
   init_detector2();
+  init_parse_rust();
 });
 
 // src/test-runners/ac-parser.ts
 function parseTestFailures(output) {
-  const clean = output.replace(ANSI_ESCAPE_PATTERN, "");
+  const clean = stripAnsi(output);
   const framework = detectFramework(clean);
   const failedACs = [];
   const lines = clean.split(`
@@ -25072,10 +25185,8 @@ function parseTestFailures(output) {
   }
   return failedACs;
 }
-var ANSI_ESCAPE_PATTERN;
 var init_ac_parser = __esm(() => {
   init_detector2();
-  ANSI_ESCAPE_PATTERN = new RegExp(`${String.fromCharCode(27)}\\[[0-9;?]*[A-Za-z]`, "g");
 });
 
 // src/utils/git.ts
@@ -25756,6 +25867,8 @@ __export(exports_test_runners, {
   resolveReviewExcludePatterns: () => resolveReviewExcludePatterns,
   parseTestOutput: () => parseTestOutput,
   parseTestFailures: () => parseTestFailures,
+  parseRustTestOutput: () => parseRustTestOutput,
+  parseMochaOutput: () => parseMochaOutput,
   parseBunTestOutput: () => parseBunTestOutput,
   isTestFileByPatterns: () => isTestFileByPatterns,
   isTestFile: () => isTestFile,
@@ -25787,6 +25900,7 @@ var init_test_runners = __esm(() => {
   init_detector2();
   init_resolver();
   init_parser();
+  init_parse_rust();
   init_workspace();
   init_ac_parser();
   init_scoped_selection();
@@ -35651,7 +35765,7 @@ var init_semantic_review = __esm(() => {
       const substantiated = await substantiateSemanticEvidence(sanitized, input.mode, input.workdir, input.story.id, threshold, input.repoRoot);
       const { accepted, dropped } = filterByAcGroundingMinimal(substantiated, input.story.acceptanceCriteria);
       const blocking = accepted.filter((f) => isBlockingSeverity(f.severity, threshold));
-      const passed = parsed.passed && blocking.length === 0;
+      const passed = blocking.length === 0 && (parsed.passed || accepted.length > 0);
       return {
         ...parsed,
         passed,
@@ -40454,27 +40568,37 @@ function flipWithPairs(pairs, snippet) {
   }
   return results;
 }
-function applyBooleanFlip(snippet) {
-  const seen = new Set;
-  const results = [];
-  if (/\btrue\b/.test(snippet)) {
-    const produced = snippet.replace(/\btrue\b/g, "false");
-    seen.add(produced);
-    results.push(produced);
-  }
-  if (/\bfalse\b/.test(snippet)) {
-    const produced = snippet.replace(/\bfalse\b/g, "true");
-    if (!seen.has(produced))
+function makeBooleanFlip(trueLit, falseLit) {
+  return (snippet) => {
+    const seen = new Set;
+    const results = [];
+    if (new RegExp(`\\b${trueLit}\\b`).test(snippet)) {
+      const produced = snippet.replace(new RegExp(`\\b${trueLit}\\b`, "g"), falseLit);
+      seen.add(produced);
       results.push(produced);
-  }
-  return results;
+    }
+    if (new RegExp(`\\b${falseLit}\\b`).test(snippet)) {
+      const produced = snippet.replace(new RegExp(`\\b${falseLit}\\b`, "g"), trueLit);
+      if (!seen.has(produced))
+        results.push(produced);
+    }
+    return results;
+  };
+}
+function makeOperators(prefix, trueLit, falseLit) {
+  return [
+    { id: `${prefix}:cmp-flip`, apply: (snippet) => flipWithPairs(UNIVERSAL_COMPARISON_PAIRS, snippet) },
+    { id: `${prefix}:cmp-bracket-flip`, apply: applyComparisonBracketFlip },
+    { id: `${prefix}:bool-flip`, apply: makeBooleanFlip(trueLit, falseLit) },
+    { id: `${prefix}:arith-flip`, apply: (snippet) => flipWithPairs(ARITHMETIC_PAIRS, snippet) }
+  ];
 }
 function getOperatorsForLanguage(language) {
   if (!language)
     return [];
   return SUPPORTED_LANGUAGES.get(language) ?? [];
 }
-var TS_COMPARISON_PAIRS, COMPARISON_GT, COMPARISON_LT, TS_COMPARISON_BRACKET_FLIP_ID = "ts:cmp-bracket-flip", TS_COMPARISON_FLIP_ID = "ts:cmp-flip", TS_BOOLEAN_FLIP_ID = "ts:bool-flip", TS_ARITHMETIC_PAIRS, TS_ARITHMETIC_FLIP_ID = "ts:arith-flip", TYPESCRIPT_OPERATORS, PYTHON_OPERATORS, GO_OPERATORS, SUPPORTED_LANGUAGES;
+var TS_COMPARISON_PAIRS, UNIVERSAL_COMPARISON_PAIRS, COMPARISON_GT, COMPARISON_LT, ARITHMETIC_PAIRS, TYPESCRIPT_OPERATORS, PYTHON_OPERATORS, GO_OPERATORS, RUST_OPERATORS, SUPPORTED_LANGUAGES;
 var init_operators = __esm(() => {
   TS_COMPARISON_PAIRS = [
     [/==/g, "!="],
@@ -40484,27 +40608,35 @@ var init_operators = __esm(() => {
     [/>=/g, "<="],
     [/<=/g, ">="]
   ];
+  UNIVERSAL_COMPARISON_PAIRS = [
+    [/==/g, "!="],
+    [/!=/g, "=="],
+    [/>=/g, "<="],
+    [/<=/g, ">="]
+  ];
   COMPARISON_GT = /(?<=\s)>(?!=)(?=\s|$)/g;
   COMPARISON_LT = /(?<=\s)<(?!=)(?=\s)/g;
-  TS_ARITHMETIC_PAIRS = [
+  ARITHMETIC_PAIRS = [
     [/\+/g, "-"],
     [/-/g, "+"],
     [/\*/g, "/"],
     [/\//g, "*"]
   ];
   TYPESCRIPT_OPERATORS = [
-    { id: TS_COMPARISON_FLIP_ID, apply: (snippet) => flipWithPairs(TS_COMPARISON_PAIRS, snippet) },
-    { id: TS_COMPARISON_BRACKET_FLIP_ID, apply: applyComparisonBracketFlip },
-    { id: TS_BOOLEAN_FLIP_ID, apply: applyBooleanFlip },
-    { id: TS_ARITHMETIC_FLIP_ID, apply: (snippet) => flipWithPairs(TS_ARITHMETIC_PAIRS, snippet) }
+    { id: "ts:cmp-flip", apply: (snippet) => flipWithPairs(TS_COMPARISON_PAIRS, snippet) },
+    { id: "ts:cmp-bracket-flip", apply: applyComparisonBracketFlip },
+    { id: "ts:bool-flip", apply: makeBooleanFlip("true", "false") },
+    { id: "ts:arith-flip", apply: (snippet) => flipWithPairs(ARITHMETIC_PAIRS, snippet) }
   ];
-  PYTHON_OPERATORS = [];
-  GO_OPERATORS = [];
+  PYTHON_OPERATORS = makeOperators("py", "True", "False");
+  GO_OPERATORS = makeOperators("go", "true", "false");
+  RUST_OPERATORS = makeOperators("rust", "true", "false");
   SUPPORTED_LANGUAGES = new Map([
     ["typescript", TYPESCRIPT_OPERATORS],
     ["javascript", TYPESCRIPT_OPERATORS],
     ["python", PYTHON_OPERATORS],
-    ["go", GO_OPERATORS]
+    ["go", GO_OPERATORS],
+    ["rust", RUST_OPERATORS]
   ]);
 });
 
@@ -40526,7 +40658,8 @@ function generateMutants(input) {
       const line = lines[i];
       const lineNumber = i + 1;
       const trimmed = line.trim();
-      if (trimmed.startsWith("//") || trimmed.startsWith("/*") || trimmed.startsWith("*"))
+      const commentPrefixes = language === "python" ? ["#"] : ["//", "/*", "*"];
+      if (commentPrefixes.some((prefix) => trimmed.startsWith(prefix)))
         continue;
       for (const operator of operators) {
         for (const replacement of applyOperator(operator, line)) {
@@ -41632,7 +41765,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.73.2",
+    version: "0.73.3",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -41733,8 +41866,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("18a1906c"))
-        return "18a1906c";
+      if (/^[0-9a-f]{6,10}$/.test("a98a211e"))
+        return "a98a211e";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -64582,44 +64715,210 @@ var init_crash_recovery = __esm(() => {
   init_crash_heartbeat();
 });
 
-// src/acceptance/fix-diagnosis.ts
-function parseImportStatements(content) {
-  const importRegex = /import\s+(?:{[^}]+}|[^;]+)\s+from\s+["']([^"']+)["']/g;
-  const imports = [];
-  const regexMatch = content.matchAll(importRegex);
-  for (const match of regexMatch) {
-    imports.push(match[1]);
+// src/acceptance/import-resolution.ts
+import { resolve as resolve16, sep as sep5 } from "path";
+function languageFromExtension(testFilePath) {
+  if (!testFilePath)
+    return;
+  const dot = testFilePath.lastIndexOf(".");
+  if (dot < 0)
+    return;
+  return EXT_LANGUAGE.get(testFilePath.slice(dot).toLowerCase());
+}
+function isResolvedLanguage(lang) {
+  return lang !== undefined && SUPPORTED.has(lang);
+}
+async function resolveLanguage(opts) {
+  const explicit = opts.language ?? languageFromExtension(opts.testFilePath);
+  if (isResolvedLanguage(explicit))
+    return explicit;
+  const detected = await detectLanguage(opts.packageDir);
+  if (isResolvedLanguage(detected))
+    return detected;
+  return "typescript";
+}
+async function readCapped(relPath, packageDir) {
+  const resolvedPackageDir = resolve16(packageDir);
+  const fullPath = resolve16(resolvedPackageDir, relPath);
+  if (fullPath !== resolvedPackageDir && !fullPath.startsWith(resolvedPackageDir + sep5)) {
+    return null;
+  }
+  try {
+    const text = await Bun.file(fullPath).text();
+    const content = text.split(`
+`).slice(0, MAX_FILE_LINES2).join(`
+`);
+    return { path: relPath, content };
+  } catch {
+    return null;
   }
-  return imports;
 }
-function resolveImportPaths(imports, _workdir) {
-  const resolved = [];
-  for (const imp of imports) {
-    if (imp.startsWith(".")) {
-      resolved.push(imp);
-    }
+function parseTsImports(content) {
+  const specs = [];
+  for (const m of content.matchAll(TS_IMPORT_RE)) {
+    if (m[1].startsWith("."))
+      specs.push(m[1]);
+  }
+  return specs;
+}
+function tsCandidates(spec) {
+  if (TS_EXTS.some((e) => spec.endsWith(e)))
+    return [spec];
+  const out = [];
+  for (const e of TS_EXTS)
+    out.push(`${spec}${e}`);
+  for (const e of TS_EXTS)
+    out.push(`${spec}/index${e}`);
+  return out;
+}
+function parsePythonImports(content) {
+  const modules = [];
+  for (const m of content.matchAll(PY_IMPORT_LINE_RE)) {
+    const fromModule = m[1];
+    const importList = m[2];
+    if (fromModule !== undefined) {
+      if (fromModule)
+        modules.push(fromModule);
+    } else if (importList) {
+      for (const part of importList.split(",")) {
+        const mod = part.trim().split(/\s+as\s+/)[0].trim();
+        if (mod)
+          modules.push(mod);
+      }
+    }
+  }
+  return modules;
+}
+function pythonCandidates(module) {
+  const base = module.replace(/\./g, "/");
+  return [`${base}.py`, `${base}/__init__.py`];
+}
+function parseRustUses(content) {
+  const paths = [];
+  for (const m of content.matchAll(RUST_USE_RE))
+    paths.push(m[1]);
+  return paths;
+}
+function rustCandidates(usePath) {
+  const rest = usePath.split("::").slice(1);
+  if (rest.length === 0)
+    return [];
+  const base = `src/${rest.join("/")}`;
+  const candidates = [`${base}.rs`, `${base}/mod.rs`];
+  if (rest.length > 1) {
+    const parent = `src/${rest.slice(0, -1).join("/")}`;
+    candidates.push(`${parent}.rs`, `${parent}/mod.rs`);
+  } else {
+    candidates.push("src/lib.rs");
   }
-  return resolved.slice(0, MAX_SOURCE_FILES);
+  return candidates;
 }
-async function loadSourceFilesForDiagnosis(testFileContent, workdir) {
-  const imports = parseImportStatements(testFileContent);
-  const relativeImports = resolveImportPaths(imports, workdir);
-  const results = await Promise.all(relativeImports.map((imp) => readSourceFileContent(imp, workdir)));
-  return results.filter((f) => f !== null);
+function parseGoImports(content) {
+  const paths = [];
+  for (const m of content.matchAll(GO_SINGLE_IMPORT_RE))
+    paths.push(m[1]);
+  for (const block of content.matchAll(GO_IMPORT_BLOCK_RE)) {
+    for (const line of block[1].matchAll(GO_BLOCK_LINE_RE))
+      paths.push(line[1]);
+  }
+  return paths;
 }
-async function readSourceFileContent(filePath, workdir) {
+async function readGoModulePrefix(packageDir) {
   try {
-    const fullPath = `${workdir}/${filePath}`;
-    const file3 = await Bun.file(fullPath).text();
-    const lines = file3.split(`
-`).slice(0, MAX_FILE_LINES2);
-    return { path: filePath, content: lines.join(`
-`) };
+    const text = await Bun.file(`${packageDir}/go.mod`).text();
+    const m = text.match(/^\s*module\s+(\S+)/m);
+    return m ? m[1] : null;
   } catch {
     return null;
   }
 }
-var MAX_SOURCE_FILES = 5, MAX_FILE_LINES2 = 500;
+async function resolveGoCandidates(content, packageDir) {
+  const prefix = await readGoModulePrefix(packageDir);
+  if (!prefix)
+    return [];
+  const candidates = [];
+  for (const imp of parseGoImports(content)) {
+    if (imp !== prefix && !imp.startsWith(`${prefix}/`))
+      continue;
+    const relDir = imp === prefix ? "." : imp.slice(prefix.length + 1);
+    try {
+      for (const file3 of new Bun.Glob("*.go").scanSync({ cwd: `${packageDir}/${relDir}`, absolute: false })) {
+        if (file3.endsWith("_test.go"))
+          continue;
+        candidates.push(relDir === "." ? file3 : `${relDir}/${file3}`);
+      }
+    } catch {}
+  }
+  return candidates;
+}
+async function collectCandidates(lang, opts) {
+  switch (lang) {
+    case "typescript":
+    case "javascript":
+      return parseTsImports(opts.testFileContent).flatMap(tsCandidates);
+    case "python":
+      return parsePythonImports(opts.testFileContent).flatMap(pythonCandidates);
+    case "rust":
+      return parseRustUses(opts.testFileContent).flatMap(rustCandidates);
+    case "go":
+      return resolveGoCandidates(opts.testFileContent, opts.packageDir);
+    default:
+      return [];
+  }
+}
+async function readCandidates(candidates, packageDir) {
+  const seen = new Set;
+  const results = [];
+  for (const rel of candidates) {
+    if (results.length >= MAX_SOURCE_FILES)
+      break;
+    if (seen.has(rel))
+      continue;
+    seen.add(rel);
+    const file3 = await readCapped(rel, packageDir);
+    if (file3)
+      results.push(file3);
+  }
+  return results;
+}
+async function resolveSourceFiles(opts) {
+  const lang = await resolveLanguage(opts);
+  const candidates = await collectCandidates(lang, opts);
+  return readCandidates(candidates, opts.packageDir);
+}
+var MAX_SOURCE_FILES = 5, MAX_FILE_LINES2 = 500, SUPPORTED, EXT_LANGUAGE, TS_IMPORT_RE, TS_EXTS, PY_IMPORT_LINE_RE, RUST_USE_RE, GO_SINGLE_IMPORT_RE, GO_IMPORT_BLOCK_RE, GO_BLOCK_LINE_RE;
+var init_import_resolution = __esm(() => {
+  init_project();
+  SUPPORTED = new Set(["typescript", "javascript", "python", "go", "rust"]);
+  EXT_LANGUAGE = new Map([
+    [".ts", "typescript"],
+    [".tsx", "typescript"],
+    [".mts", "typescript"],
+    [".cts", "typescript"],
+    [".js", "javascript"],
+    [".jsx", "javascript"],
+    [".mjs", "javascript"],
+    [".cjs", "javascript"],
+    [".py", "python"],
+    [".go", "go"],
+    [".rs", "rust"]
+  ]);
+  TS_IMPORT_RE = /import\s+(?:{[^}]+}|[^;'"]+)\s+from\s+["']([^"']+)["']/g;
+  TS_EXTS = [".ts", ".tsx", ".js", ".jsx", ".mts", ".cts", ".mjs", ".cjs"];
+  PY_IMPORT_LINE_RE = /^\s*(?:from\s+\.*([\w.]*)\s+import\s+|import\s+([\w.]+(?:\s*,\s*[\w.]+)*))/gm;
+  RUST_USE_RE = /^\s*use\s+(crate(?:::\w+)*|(?:super|self)(?:::\w+)?)/gm;
+  GO_SINGLE_IMPORT_RE = /^\s*import\s+"([^"]+)"/gm;
+  GO_IMPORT_BLOCK_RE = /import\s*\(([\s\S]*?)\)/g;
+  GO_BLOCK_LINE_RE = /"([^"]+)"/g;
+});
+
+// src/acceptance/fix-diagnosis.ts
+async function loadSourceFilesForDiagnosis(opts) {
+  return resolveSourceFiles(opts);
+}
+var init_fix_diagnosis = __esm(() => {
+  init_import_resolution();
+});
 
 // src/execution/lifecycle/acceptance-helpers.ts
 import path23 from "path";
@@ -64800,7 +65099,11 @@ async function resolveAcceptanceDiagnosis(opts) {
       confidence: 0.9
     };
   }
-  const sourceFiles = await loadSourceFilesForDiagnosis(diagnosisOpts.testFileContent, diagnosisOpts.workdir);
+  const sourceFiles = await loadSourceFilesForDiagnosis({
+    testFileContent: diagnosisOpts.testFileContent,
+    packageDir: diagnosisOpts.workdir,
+    testFilePath: diagnosisOpts.acceptanceTestPath
+  });
   return await _diagnosisDeps.callOp(fixCallCtx(ctx), acceptanceDiagnoseOp, {
     testOutput: diagnosisOpts.testOutput,
     testFileContent: diagnosisOpts.testFileContent,
@@ -64811,6 +65114,7 @@ async function resolveAcceptanceDiagnosis(opts) {
 }
 var _diagnosisDeps;
 var init_acceptance_fix2 = __esm(() => {
+  init_fix_diagnosis();
   init_errors();
   init_logger2();
   init_operations();
@@ -69317,7 +69621,7 @@ var init_runner_execution = __esm(() => {
 
 // src/execution/status-file.ts
 import { rename as rename2, unlink as unlink3 } from "fs/promises";
-import { resolve as resolve16 } from "path";
+import { resolve as resolve17 } from "path";
 function countProgress(prd) {
   const stories = prd.userStories;
   const passed = stories.filter((s) => s.status === "passed").length;
@@ -69362,7 +69666,7 @@ function buildStatusSnapshot(state) {
   return snapshot;
 }
 async function writeStatusFile(filePath, status) {
-  const resolvedPath = resolve16(filePath);
+  const resolvedPath = resolve17(filePath);
   if (filePath.includes("../") || filePath.includes("..\\")) {
     throw new Error("Invalid status file path: path traversal detected");
   }
@@ -71300,14 +71604,14 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
       prevActScopeDepth !== actScopeDepth - 1 && console.error("You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. ");
       actScopeDepth = prevActScopeDepth;
     }
-    function recursivelyFlushAsyncActWork(returnValue, resolve17, reject) {
+    function recursivelyFlushAsyncActWork(returnValue, resolve18, reject) {
       var queue = ReactSharedInternals.actQueue;
       if (queue !== null)
         if (queue.length !== 0)
           try {
             flushActQueue(queue);
             enqueueTask(function() {
-              return recursivelyFlushAsyncActWork(returnValue, resolve17, reject);
+              return recursivelyFlushAsyncActWork(returnValue, resolve18, reject);
             });
             return;
           } catch (error48) {
@@ -71315,7 +71619,7 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
           }
         else
           ReactSharedInternals.actQueue = null;
-      0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve17(returnValue);
+      0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve18(returnValue);
     }
     function flushActQueue(queue) {
       if (!isFlushing) {
@@ -71491,14 +71795,14 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
           didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = true, console.error("You called act(async () => ...) without await. This could lead to unexpected testing behaviour, interleaving multiple act calls and mixing their scopes. You should - await act(async () => ...);"));
         });
         return {
-          then: function(resolve17, reject) {
+          then: function(resolve18, reject) {
             didAwaitActCall = true;
             thenable.then(function(returnValue) {
               popActScope(prevActQueue, prevActScopeDepth);
               if (prevActScopeDepth === 0) {
                 try {
                   flushActQueue(queue), enqueueTask(function() {
-                    return recursivelyFlushAsyncActWork(returnValue, resolve17, reject);
+                    return recursivelyFlushAsyncActWork(returnValue, resolve18, reject);
                   });
                 } catch (error$0) {
                   ReactSharedInternals.thrownErrors.push(error$0);
@@ -71509,7 +71813,7 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
                   reject(_thrownError);
                 }
               } else
-                resolve17(returnValue);
+                resolve18(returnValue);
             }, function(error48) {
               popActScope(prevActQueue, prevActScopeDepth);
               0 < ReactSharedInternals.thrownErrors.length ? (error48 = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(error48)) : reject(error48);
@@ -71525,11 +71829,11 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
       if (0 < ReactSharedInternals.thrownErrors.length)
         throw callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback;
       return {
-        then: function(resolve17, reject) {
+        then: function(resolve18, reject) {
           didAwaitActCall = true;
           prevActScopeDepth === 0 ? (ReactSharedInternals.actQueue = queue, enqueueTask(function() {
-            return recursivelyFlushAsyncActWork(returnValue$jscomp$0, resolve17, reject);
-          })) : resolve17(returnValue$jscomp$0);
+            return recursivelyFlushAsyncActWork(returnValue$jscomp$0, resolve18, reject);
+          })) : resolve18(returnValue$jscomp$0);
         }
       };
     };
@@ -74371,8 +74675,8 @@ It can also happen if the client has a browser extension installed which messes
         currentEntangledActionThenable = {
           status: "pending",
           value: undefined,
-          then: function(resolve17) {
-            entangledListeners.push(resolve17);
+          then: function(resolve18) {
+            entangledListeners.push(resolve18);
           }
         };
       }
@@ -74396,8 +74700,8 @@ It can also happen if the client has a browser extension installed which messes
         status: "pending",
         value: null,
         reason: null,
-        then: function(resolve17) {
-          listeners.push(resolve17);
+        then: function(resolve18) {
+          listeners.push(resolve18);
         }
       };
       thenable.then(function() {
@@ -106460,7 +106764,7 @@ function ansiRegex({ onlyFirst = false } = {}) {
 
 // node_modules/strip-ansi/index.js
 var regex = ansiRegex();
-function stripAnsi(string4) {
+function stripAnsi2(string4) {
   if (typeof string4 !== "string") {
     throw new TypeError(`Expected a \`string\`, got \`${typeof string4}\``);
   }
@@ -106509,7 +106813,7 @@ function stringWidth(string4, options = {}) {
     countAnsiEscapeCodes = false
   } = options;
   if (!countAnsiEscapeCodes) {
-    string4 = stripAnsi(string4);
+    string4 = stripAnsi2(string4);
   }
   if (string4.length === 0) {
     return 0;
@@ -106740,7 +107044,7 @@ var wrapWord = (rows, word, columns) => {
   const characters = [...word];
   let isInsideEscape = false;
   let isInsideLinkEscape = false;
-  let visible = stringWidth(stripAnsi(rows.at(-1)));
+  let visible = stringWidth(stripAnsi2(rows.at(-1)));
   for (const [index, character] of characters.entries()) {
     const characterLength = stringWidth(character);
     if (visible + characterLength <= columns) {
@@ -107026,7 +107330,7 @@ function stringWidth2(input, options = {}) {
   } = options;
   let string4 = input;
   if (!countAnsiEscapeCodes) {
-    string4 = stripAnsi(string4);
+    string4 = stripAnsi2(string4);
   }
   if (string4.length === 0) {
     return 0;
@@ -109906,8 +110210,8 @@ class Ink {
     }
   }
   async waitUntilExit() {
-    this.exitPromise ||= new Promise((resolve17, reject2) => {
-      this.resolveExitPromise = resolve17;
+    this.exitPromise ||= new Promise((resolve18, reject2) => {
+      this.resolveExitPromise = resolve18;
       this.rejectExitPromise = reject2;
     });
     if (!this.beforeExitHandler) {
@@ -112161,7 +112465,7 @@ async function promptForConfirmation(question) {
   if (!process.stdin.isTTY) {
     return true;
   }
-  return new Promise((resolve17) => {
+  return new Promise((resolve18) => {
     process.stdout.write(source_default.bold(`${question} [Y/n] `));
     process.stdin.setRawMode(true);
     process.stdin.resume();
@@ -112174,9 +112478,9 @@ async function promptForConfirmation(question) {
       process.stdout.write(`
 `);
       if (answer === "n") {
-        resolve17(false);
+        resolve18(false);
       } else {
-        resolve17(true);
+        resolve18(true);
       }
     };
     process.stdin.on("data", handler);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nathapp/nax",
-  "version": "0.73.2",
+  "version": "0.73.3",
   "description": "AI Coding Agent Orchestrator — loops until done",
   "type": "module",
   "bin": {