@nathapp/nax 0.69.4 → 0.69.6

package/dist/nax.js

@@ -34389,17 +34389,18 @@ function acSentinelToFinding(sentinel, _output) {
 }
 
 // src/findings/adapters/typecheck.ts
-function tscDiagnosticToFinding(d, workdir) {
+function genericTypecheckDiagnosticToFinding(d, workdir, tool) {
   return {
     source: "typecheck",
-    tool: "tsc",
+    tool,
     severity: "error",
     category: "type-error",
     rule: d.code ? `TS${d.code}` : undefined,
     file: rebaseToWorkdir(d.file, workdir, workdir),
     line: d.line,
     column: d.column,
-    message: d.message
+    message: d.message,
+    fixTarget: "source"
   };
 }
 var init_typecheck = __esm(() => {
@@ -38911,7 +38912,7 @@ function makeAutofixImplementerStrategy(story, config2, sink, opts = {}) {
   const claimsAdversarial = opts.includeAdversarialReview === true;
   return {
     name: "autofix-implementer",
-    appliesTo: (f) => f.fixTarget === "source" && IMPLEMENTER_SOURCES.has(f.source) || claimsAdversarial && f.source === "adversarial-review",
+    appliesTo: (f) => (f.fixTarget === "source" || f.fixTarget == null) && IMPLEMENTER_SOURCES.has(f.source) || claimsAdversarial && f.source === "adversarial-review",
     fixOp: implementerRectifyOp,
     buildInput: (findings, _prior, _cycleCtx) => ({
       failedChecks: findingsToFailedChecks(findings),
@@ -39392,7 +39393,15 @@ var init_lint_check = __esm(() => {
         return { success: true, status: "passed", findings: [], durationMs: Date.now() - start };
       }
       const parsed = deps.parseLintOutput(result.output, "auto", { workdir: input.workdir });
-      return { success: false, findings: parsed?.findings ?? [], durationMs: Date.now() - start };
+      const parsedFindings = parsed?.findings ?? [];
+      const sentinel = {
+        source: "lint",
+        severity: "error",
+        category: "lint-failure",
+        message: `lint failed (no structured findings parsed), please run the lint check command: ${command}`
+      };
+      const findings = parsedFindings.length > 0 ? parsedFindings : [sentinel];
+      return { success: false, findings, durationMs: Date.now() - start };
     }
   };
 });
@@ -39583,6 +39592,11 @@ function strategiesFor(format) {
     return [];
   return [tscStrategy, typecheckTextBlockStrategy];
 }
+function toolForFormat(format) {
+  if (format === "tsc")
+    return "tsc";
+  return;
+}
 function parseTypecheckOutput(output, format = "auto", opts) {
   if (!output.trim())
     return null;
@@ -39590,7 +39604,8 @@ function parseTypecheckOutput(output, format = "auto", opts) {
     const parsed = strategy.parse(output);
     if (parsed && parsed.diagnostics.length > 0) {
       if (opts) {
-        const findings = parsed.diagnostics.map((d) => tscDiagnosticToFinding(d, opts.workdir));
+        const tool = toolForFormat(parsed.format);
+        const findings = parsed.diagnostics.map((d) => genericTypecheckDiagnosticToFinding(d, opts.workdir, tool));
         return { ...parsed, findings };
       }
       return parsed;
@@ -39648,7 +39663,16 @@ var init_typecheck_check = __esm(() => {
         return { success: true, status: "passed", findings: [], durationMs: Date.now() - start };
       }
       const parsed = deps.parseTypecheckOutput(result.output, "auto", { workdir: input.workdir });
-      return { success: false, findings: parsed?.findings ?? [], durationMs: Date.now() - start };
+      const parsedFindings = parsed?.findings ?? [];
+      const sentinel = {
+        source: "typecheck",
+        severity: "error",
+        category: "typecheck-failure",
+        fixTarget: "source",
+        message: `typecheck failed (no structured findings parsed), please run the typecheck command: ${command}`
+      };
+      const findings = parsedFindings.length > 0 ? parsedFindings : [sentinel];
+      return { success: false, findings, durationMs: Date.now() - start };
     }
   };
 });
@@ -39949,26 +39973,23 @@ async function runFixCycle(cycle, ctx, cycleName, _deps = {}) {
         costUsd: totalCostUsd
       };
     }
-    for (const strategy of active) {
-      const attempts = countStrategyAttempts(cycle.iterations, strategy.name);
-      if (attempts >= strategy.maxAttempts) {
-        logger?.info("findings.cycle", "cycle exited \u2014 strategy attempt cap reached", {
-          storyId,
-          packageDir,
-          cycleName,
-          reason: "max-attempts-per-strategy",
-          exhaustedStrategy: strategy.name,
-          attempts,
-          maxAttempts: strategy.maxAttempts
-        });
-        return {
-          iterations: cycle.iterations,
-          finalFindings: cycle.findings,
-          exitReason: "max-attempts-per-strategy",
-          exhaustedStrategy: strategy.name,
-          costUsd: totalCostUsd
-        };
-      }
+    const uncappedActive = active.filter((s) => countStrategyAttempts(cycle.iterations, s.name) < s.maxAttempts);
+    if (uncappedActive.length === 0) {
+      const exhaustedStrategy = active.find((s) => countStrategyAttempts(cycle.iterations, s.name) >= s.maxAttempts);
+      logger?.info("findings.cycle", "cycle exited \u2014 all active strategies exhausted", {
+        storyId,
+        packageDir,
+        cycleName,
+        reason: "max-attempts-per-strategy",
+        exhaustedStrategy: exhaustedStrategy?.name
+      });
+      return {
+        iterations: cycle.iterations,
+        finalFindings: cycle.findings,
+        exitReason: "max-attempts-per-strategy",
+        exhaustedStrategy: exhaustedStrategy?.name,
+        costUsd: totalCostUsd
+      };
     }
     const totalAttempts = countTotalAttempts(cycle.iterations);
     if (totalAttempts >= cycle.config.maxAttemptsTotal) {
@@ -39987,7 +40008,7 @@ async function runFixCycle(cycle, ctx, cycleName, _deps = {}) {
         costUsd: totalCostUsd
       };
     }
-    for (const strategy of active) {
+    for (const strategy of uncappedActive) {
       const bailReason = strategy.bailWhen?.(cycle.iterations) ?? null;
       if (bailReason !== null) {
         logger?.info("findings.cycle", "cycle exited \u2014 bail predicate fired", {
@@ -40007,7 +40028,7 @@ async function runFixCycle(cycle, ctx, cycleName, _deps = {}) {
         };
       }
     }
-    const group = selectExecutionGroup(active);
+    const group = selectExecutionGroup(uncappedActive);
     const startedAt = now();
     const findingsBefore = [...cycle.findings];
     const fixesApplied = [];
@@ -40118,6 +40139,19 @@ async function runFixCycle(cycle, ctx, cycleName, _deps = {}) {
         };
       }
       if (liteShortCircuited) {
+        const companions = uncappedActive.filter((s) => !group.includes(s));
+        if (companions.length > 0) {
+          const iterCostUsd = fixesApplied.reduce((sum, fa) => sum + (fa.costUsd ?? 0), 0);
+          totalCostUsd += iterCostUsd;
+          logger?.info("findings.cycle", "exclusive strategy exhausted \u2014 continuing to companion strategies", {
+            storyId,
+            packageDir,
+            cycleName,
+            exhaustedStrategies: group.map((s) => s.name),
+            remainingStrategies: companions.map((s) => s.name)
+          });
+          continue;
+        }
         logger?.info("findings.cycle", "cycle exited \u2014 validate short-circuited", {
           storyId,
           packageDir,
@@ -40467,6 +40501,67 @@ var init_text_block2 = __esm(() => {
   };
 });
 
+// src/review/lint-parsing/strategies/ruff-annotated.ts
+function parseRuffAnnotated(output) {
+  if (!output.trim())
+    return null;
+  const lines = output.split(/\r?\n/);
+  let hasArrow = false;
+  for (const line of lines) {
+    if (ARROW_RE.test(line)) {
+      hasArrow = true;
+      break;
+    }
+  }
+  if (!hasArrow)
+    return null;
+  const diagnostics = [];
+  let i = 0;
+  while (i < lines.length) {
+    const arrowMatch = ARROW_RE.exec(lines[i]);
+    if (!arrowMatch || !SOURCE_EXT_RE2.test(arrowMatch[1])) {
+      i++;
+      continue;
+    }
+    const file3 = arrowMatch[1];
+    const line = Number.parseInt(arrowMatch[2], 10);
+    const col = arrowMatch[3] ? Number.parseInt(arrowMatch[3], 10) : undefined;
+    const messageLines = [];
+    let j = i - 1;
+    while (j >= 0) {
+      const l = lines[j]?.trim() ?? "";
+      if (!l || ARROW_RE.test(lines[j] ?? "") || CONTEXT_LINE_RE.test(lines[j] ?? ""))
+        break;
+      messageLines.unshift(lines[j] ?? "");
+      j--;
+    }
+    const contextLines = [lines[i]];
+    let k = i + 1;
+    while (k < lines.length && CONTEXT_LINE_RE.test(lines[k])) {
+      contextLines.push(lines[k]);
+      k++;
+    }
+    const raw = [...messageLines, ...contextLines].join(`
+`);
+    const message = (messageLines[messageLines.length - 1] ?? file3).trim();
+    diagnostics.push({ file: file3, line, column: col, message, raw });
+    i = k;
+  }
+  if (diagnostics.length === 0)
+    return null;
+  return { diagnostics, format: "ruff-annotated" };
+}
+var ARROW_RE, CONTEXT_LINE_RE, ruffAnnotatedStrategy;
+var init_ruff_annotated = __esm(() => {
+  init_text_block2();
+  ARROW_RE = /^\s+-->\s+(.+?):(\d+)(?::(\d+))?$/;
+  CONTEXT_LINE_RE = /^\s*\d*\s*\|/;
+  ruffAnnotatedStrategy = {
+    name: "ruff-annotated",
+    parse: parseRuffAnnotated
+  };
+});
+
 // src/review/lint-parsing/parse.ts
 function strategiesFor2(format) {
   if (format === "eslint-json")
@@ -40474,12 +40569,12 @@ function strategiesFor2(format) {
   if (format === "biome-json")
     return [biomeJsonStrategy];
   if (format === "text")
-    return [textBlockStrategy];
+    return [ruffAnnotatedStrategy, textBlockStrategy];
   if (format === "none")
     return [];
-  return [eslintJsonStrategy, biomeJsonStrategy, textBlockStrategy];
+  return [eslintJsonStrategy, biomeJsonStrategy, ruffAnnotatedStrategy, textBlockStrategy];
 }
-function toolForFormat(format) {
+function toolForFormat2(format) {
   if (format === "biome-json")
     return "biome";
   if (format === "eslint-json")
@@ -40493,7 +40588,7 @@ function parseLintOutput(output, format = "auto", opts) {
     const parsed = strategy.parse(output);
     if (parsed && parsed.diagnostics.length > 0) {
       if (opts) {
-        const tool = toolForFormat(parsed.format);
+        const tool = toolForFormat2(parsed.format);
         const findings = parsed.diagnostics.map((d) => lintDiagnosticToFinding(d, opts.workdir, tool));
         return { ...parsed, findings };
       }
@@ -40513,6 +40608,7 @@ var init_parse4 = __esm(() => {
   init_findings();
   init_biome_json();
   init_eslint_json();
+  init_ruff_annotated();
   init_text_block2();
 });
 
@@ -54717,6 +54813,33 @@ class ExecutionPlan {
         }
       }
     }
+    if (this.state.rectification && rectResult.rectificationExhausted) {
+      const mechanicalOnly = !!rectResult.unfixedFindings?.length && rectResult.unfixedFindings.every((f) => f.source === "lint" || f.source === "typecheck");
+      if (mechanicalOnly) {
+        for (const phase of collectOrderedPhases(this.state)) {
+          const name = phase.slot.op.name;
+          if (name in phaseOutputs)
+            continue;
+          try {
+            await runPhase(this.ctx, phase.slot, phaseCosts, phaseOutputs, this.isThreeSession);
+          } catch (error48) {
+            logger?.error("story-orchestrator", "Phase threw unexpected error (mechanical-only resume)", {
+              storyId: this.ctx.storyId,
+              phase: name,
+              error: errorMessage(error48)
+            });
+            throw error48;
+          }
+          if (!phasePassed(name, phaseOutputs[name], this.ctx.storyId)) {
+            logger?.warn("story-orchestrator", "Phase failed in mechanical-only resume", {
+              storyId: this.ctx.storyId,
+              phase: name
+            });
+            break;
+          }
+        }
+      }
+    }
     const advCfg = this.state.adversarialReview ? this.state.nonBlockingFix : undefined;
     const advisoryOut = phaseOutputs["adversarial-review"];
     const advisoryFindings = advisoryOut?.advisoryFindings ?? [];
@@ -55577,7 +55700,7 @@ async function decideStageAction(ctx, planResult, inspection, opts) {
     const sources = new Set(planResult.unfixedFindings.map((f) => f.source));
     const allMechanical = [...sources].every((s) => s === "lint" || s === "typecheck");
     if (allMechanical) {
-      logger.warn("execution", "Mechanical-only failure unfixable \u2014 proceeding (LLM review passed)", {
+      logger.warn("execution", "Mechanical-only failure unfixable \u2014 proceeding (style-only errors remain)", {
         storyId: ctx.story.id
       });
       return { action: "continue" };
@@ -59572,7 +59695,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.69.4",
+    version: "0.69.6",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -59667,8 +59790,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("fb1560dd"))
-        return "fb1560dd";
+      if (/^[0-9a-f]{6,10}$/.test("97a1e367"))
+        return "97a1e367";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {

package/package.json

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