@shipispec/tsfix 0.4.0 → 0.6.0

package/dist/cli.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // cli/run-stack.ts
-import * as path4 from "node:path";
-import * as fs4 from "node:fs";
+import * as path9 from "node:path";
+import * as fs9 from "node:fs";
 
 // src/validatorInProcess.ts
 import * as fs from "node:fs";
@@ -473,14 +473,847 @@ function applyFixToSnapshots(fix, snapshots) {
 }
 
 // src/index.ts
-import * as fs3 from "node:fs";
-import * as path3 from "node:path";
+import * as fs8 from "node:fs";
+import * as path8 from "node:path";
 
 // src/typeContext.ts
+import * as fs3 from "node:fs";
+import * as path3 from "node:path";
 import * as ts3 from "typescript";
+var programCache2 = /* @__PURE__ */ new Map();
+function buildProgram(workspaceRoot) {
+  const tsconfigPath = path3.join(workspaceRoot, "tsconfig.json");
+  if (!fs3.existsSync(tsconfigPath)) return null;
+  let configMtime = 0;
+  try {
+    configMtime = fs3.statSync(tsconfigPath).mtimeMs;
+  } catch {
+    return null;
+  }
+  const cached = programCache2.get(workspaceRoot);
+  if (cached && cached.configMtime === configMtime) return cached.program;
+  const configFile = ts3.readConfigFile(tsconfigPath, ts3.sys.readFile);
+  if (configFile.error) return null;
+  const parsed = ts3.parseJsonConfigFileContent(
+    configFile.config,
+    ts3.sys,
+    path3.dirname(tsconfigPath)
+  );
+  const host = ts3.createCompilerHost(parsed.options);
+  const workspaceLibDir = path3.join(workspaceRoot, "node_modules", "typescript", "lib");
+  if (fs3.existsSync(workspaceLibDir)) {
+    const origGetDefaultLibFileName = host.getDefaultLibFileName.bind(host);
+    host.getDefaultLibLocation = () => workspaceLibDir;
+    host.getDefaultLibFileName = (options) => {
+      const fileName = path3.basename(origGetDefaultLibFileName(options));
+      return path3.join(workspaceLibDir, fileName);
+    };
+  }
+  let program;
+  try {
+    program = ts3.createProgram({
+      rootNames: parsed.fileNames,
+      options: parsed.options,
+      host
+    });
+  } catch {
+    return null;
+  }
+  programCache2.set(workspaceRoot, { program, configMtime });
+  return program;
+}
+function sliceLines(content, oneIndexedLine, padding) {
+  const allLines = content.split("\n");
+  const start = Math.max(0, oneIndexedLine - 1 - padding);
+  const end = Math.min(allLines.length, oneIndexedLine + padding);
+  const width = String(end).length;
+  return allLines.slice(start, end).map((l, i) => `${String(start + i + 1).padStart(width, " ")} | ${l}`).join("\n");
+}
+function getNodeAtPosition(sourceFile, position) {
+  let result = sourceFile;
+  function walk(node) {
+    ts3.forEachChild(node, (child) => {
+      if (position >= child.getStart(sourceFile) && position < child.getEnd()) {
+        result = child;
+        walk(child);
+        return true;
+      }
+      return false;
+    });
+  }
+  walk(sourceFile);
+  return result;
+}
+function isLibFile(fileName) {
+  return /lib\.[a-z0-9.]+\.d\.ts$/.test(fileName);
+}
+function findTypeDeclaration(checker, startNode, maxWalkUp = 4) {
+  const tryResolve = (n) => {
+    let type;
+    try {
+      type = checker.getTypeAtLocation(n);
+    } catch {
+      return void 0;
+    }
+    let symbol;
+    let declarations;
+    try {
+      symbol = type.getSymbol() ?? type.aliasSymbol;
+      declarations = symbol?.getDeclarations();
+    } catch {
+      return void 0;
+    }
+    if (!declarations || declarations.length === 0) return void 0;
+    const nonLib = declarations.find((d) => !isLibFile(d.getSourceFile().fileName));
+    if (!nonLib) return void 0;
+    return { decl: nonLib, symbolName: symbol?.getName() ?? "(unnamed)" };
+  };
+  let node = startNode;
+  for (let i = 0; i < maxWalkUp && node; i++) {
+    const direct = tryResolve(node);
+    if (direct) return direct;
+    if (ts3.isPropertyAccessExpression(node) || ts3.isElementAccessExpression(node)) {
+      const sibling = tryResolve(node.expression);
+      if (sibling) return sibling;
+    }
+    node = node.parent;
+  }
+  return void 0;
+}
+function getTypeContext(opts) {
+  const { workspaceRoot, diagnostic } = opts;
+  const errorPadding = opts.errorPadding ?? 3;
+  const declarationPadding = opts.declarationPadding ?? 20;
+  const filePath = path3.isAbsolute(diagnostic.file) ? diagnostic.file : path3.join(workspaceRoot, diagnostic.file);
+  const fileContent = fs3.existsSync(filePath) ? fs3.readFileSync(filePath, "utf-8") : "";
+  const errorSite = {
+    file: diagnostic.file,
+    lines: sliceLines(fileContent, diagnostic.line, errorPadding)
+  };
+  const program = buildProgram(workspaceRoot);
+  if (!program) return { errorSite };
+  const sourceFile = program.getSourceFile(filePath);
+  if (!sourceFile) return { errorSite };
+  let position;
+  try {
+    position = ts3.getPositionOfLineAndCharacter(
+      sourceFile,
+      diagnostic.line - 1,
+      diagnostic.column - 1
+    );
+  } catch {
+    return { errorSite };
+  }
+  const errorNode = getNodeAtPosition(sourceFile, position);
+  const checker = program.getTypeChecker();
+  const found = findTypeDeclaration(checker, errorNode);
+  if (!found) return { errorSite };
+  const declSourceFile = found.decl.getSourceFile();
+  const declStart = found.decl.getStart(declSourceFile);
+  const { line: declLine0 } = ts3.getLineAndCharacterOfPosition(declSourceFile, declStart);
+  return {
+    errorSite,
+    typeDeclaration: {
+      file: path3.relative(workspaceRoot, declSourceFile.fileName) || declSourceFile.fileName,
+      lines: sliceLines(declSourceFile.text, declLine0 + 1, declarationPadding),
+      symbol: found.symbolName
+    }
+  };
+}
+
+// src/applyEditBlock.ts
+import * as fs4 from "node:fs";
+import * as path4 from "node:path";
+var SEARCH_MARKER = "<<<<<<< SEARCH";
+var SEPARATOR = "=======";
+var REPLACE_MARKER = ">>>>>>> REPLACE";
+function extractFilePath(line) {
+  const trimmed = line.trim();
+  const attrMatch = trimmed.match(/<\s*file\s+path\s*=\s*["']([^"']+)["']\s*\/?>/i);
+  if (attrMatch) return attrMatch[1];
+  return trimmed.replace(/^[`'"]+|[`'"]+$/g, "");
+}
+function parseEditBlocks(llmOutput) {
+  const blocks = [];
+  const lines = llmOutput.split("\n");
+  let i = 0;
+  while (i < lines.length) {
+    while (i < lines.length && lines[i].trim() !== SEARCH_MARKER) {
+      i++;
+    }
+    if (i >= lines.length) {
+      break;
+    }
+    let fileIdx = i - 1;
+    while (fileIdx >= 0) {
+      const trimmed = lines[fileIdx].trim();
+      if (trimmed === "" || trimmed.startsWith("```") || trimmed.startsWith("</")) {
+        fileIdx--;
+        continue;
+      }
+      break;
+    }
+    const filePath = fileIdx >= 0 ? extractFilePath(lines[fileIdx]) : "";
+    i++;
+    const searchLines = [];
+    while (i < lines.length && lines[i].trim() !== SEPARATOR) {
+      searchLines.push(lines[i]);
+      i++;
+    }
+    if (i >= lines.length) {
+      break;
+    }
+    i++;
+    const replaceLines = [];
+    while (i < lines.length && lines[i].trim() !== REPLACE_MARKER) {
+      replaceLines.push(lines[i]);
+      i++;
+    }
+    if (i >= lines.length) {
+      break;
+    }
+    blocks.push({
+      file: filePath,
+      search: searchLines.join("\n"),
+      replace: replaceLines.join("\n")
+    });
+    i++;
+  }
+  return blocks;
+}
+function countOccurrences(haystack, needle) {
+  if (needle.length === 0) return 0;
+  let count = 0;
+  let pos = 0;
+  while (true) {
+    const idx = haystack.indexOf(needle, pos);
+    if (idx < 0) return count;
+    count++;
+    pos = idx + needle.length;
+  }
+}
+function rstripPerLine(text) {
+  return text.split("\n").map((l) => l.replace(/\s+$/, "")).join("\n");
+}
+function stripPerLine(text) {
+  return text.split("\n").map((l) => l.trim()).join("\n");
+}
+function spliceLines(originalContent, normalizedContent, normalizedSearch, replace) {
+  const idx = normalizedContent.indexOf(normalizedSearch);
+  if (idx < 0) return void 0;
+  const linesBefore = normalizedContent.slice(0, idx).split("\n").length - 1;
+  const matchLineCount = normalizedSearch.split("\n").length;
+  const origLines = originalContent.split("\n");
+  const before = origLines.slice(0, linesBefore);
+  const after = origLines.slice(linesBefore + matchLineCount);
+  return [...before, replace, ...after].join("\n");
+}
+function applySingleBlock(fileContent, search, replace) {
+  if (search === "") {
+    return { error: "empty search block" };
+  }
+  const exactCount = countOccurrences(fileContent, search);
+  if (exactCount === 1) {
+    return { newContent: fileContent.replace(search, replace), matchedTier: "exact" };
+  }
+  if (exactCount > 1) {
+    return { error: `ambiguous: ${exactCount} exact matches` };
+  }
+  const rstripContent = rstripPerLine(fileContent);
+  const rstripSearch = rstripPerLine(search);
+  const rstripCount = countOccurrences(rstripContent, rstripSearch);
+  if (rstripCount === 1) {
+    const out = spliceLines(fileContent, rstripContent, rstripSearch, replace);
+    if (out !== void 0) {
+      return { newContent: out, matchedTier: "rstrip" };
+    }
+  }
+  if (rstripCount > 1) {
+    return { error: `ambiguous: ${rstripCount} rstrip matches` };
+  }
+  const stripContent = stripPerLine(fileContent);
+  const stripSearch = stripPerLine(search);
+  const stripCount = countOccurrences(stripContent, stripSearch);
+  if (stripCount === 1) {
+    const out = spliceLines(fileContent, stripContent, stripSearch, replace);
+    if (out !== void 0) {
+      return { newContent: out, matchedTier: "strip" };
+    }
+  }
+  if (stripCount > 1) {
+    return { error: `ambiguous: ${stripCount} strip matches` };
+  }
+  return { error: "no match" };
+}
+function applyEditBlocks(opts) {
+  const { workspaceRoot, blocks, dryRun = false } = opts;
+  const fileSnapshots = /* @__PURE__ */ new Map();
+  const failures = [];
+  const filesEdited = /* @__PURE__ */ new Set();
+  let applied = 0;
+  for (const block of blocks) {
+    const filePath = path4.isAbsolute(block.file) ? block.file : path4.join(workspaceRoot, block.file);
+    let content = fileSnapshots.get(filePath);
+    if (content === void 0) {
+      try {
+        content = fs4.readFileSync(filePath, "utf-8");
+      } catch (err) {
+        failures.push({
+          block,
+          reason: `cannot read file: ${err instanceof Error ? err.message : String(err)}`
+        });
+        continue;
+      }
+    }
+    const result = applySingleBlock(content, block.search, block.replace);
+    if ("error" in result) {
+      failures.push({ block, reason: result.error });
+      continue;
+    }
+    fileSnapshots.set(filePath, result.newContent);
+    filesEdited.add(filePath);
+    applied++;
+  }
+  if (!dryRun) {
+    for (const [filePath, content] of fileSnapshots) {
+      try {
+        fs4.writeFileSync(filePath, content);
+      } catch (err) {
+        failures.push({
+          block: { file: filePath, search: "", replace: "" },
+          reason: `write failed: ${err instanceof Error ? err.message : String(err)}`
+        });
+      }
+    }
+  }
+  return {
+    blocks,
+    applied,
+    filesEdited: Array.from(filesEdited),
+    failures
+  };
+}
+
+// src/mendAgent.ts
+import * as fs6 from "node:fs";
+import * as path6 from "node:path";
+import { generateText } from "ai";
+import { createAnthropic } from "@ai-sdk/anthropic";
+
+// src/libraryMigrations.ts
+import * as fs5 from "node:fs";
+import * as path5 from "node:path";
+var BUILT_IN_LIBRARY_MIGRATIONS = [
+  {
+    match: { name: "vite-plugin-svgr", minMajor: 4 },
+    hint: "vite-plugin-svgr v4+ (released 2023-09-20) changed how SVG imports work. The PREVIOUS form `import { ReactComponent as X } from './x.svg'` no longer works \u2014 the ambient module declaration now only matches `*.svg?react`. Correct fix: `import X from './x.svg?react'` (default import + ?react query suffix). DO NOT use tsc's quick-fix `import X from './x.svg'` (no query) \u2014 that type-checks but resolves to the asset URL string at runtime, not a component."
+  },
+  {
+    match: { name: "next", minMajor: 15 },
+    hint: "Next.js 15 changed dynamic-route page props: `params` and `searchParams` are now `Promise<...>` instead of plain objects. The fix shape is: change the page's `params` type to `Promise<{...}>`, mark the page component `async`, and `await params` inside. See https://nextjs.org/docs/app/api-reference/file-conventions/page."
+  },
+  {
+    match: { name: "ai", minMajor: 3, maxMajor: 4 },
+    hint: "Vercel AI SDK v3.x has overload-narrowing issues with `generateObject`. If passing a schema through an object widened with `satisfies Record<K, z.ZodTypeAny>`, the typed overload silently falls back to `output: 'no-schema'` (which forbids the `schema` property). Fix: drop the `satisfies Record<...>` widener, or cast the schema at the call site."
+  },
+  {
+    match: { name: "drizzle-orm" },
+    hint: "Drizzle ORM table access has two distinct surfaces. `db.<table>` is for `select/insert/update/delete` builders. `db.query.<table>` is the Relational Queries API for `findFirst`/`findMany` with relation loading. If you see `Property '<table>' does not exist on type 'PostgresJsDatabase<...>'` when trying to call `.findFirst`/`.findMany`, use `db.query.<table>` instead."
+  }
+];
+function parseMajor(spec) {
+  const m = spec.match(/(\d+)(?:\.\d+)*/);
+  return m ? parseInt(m[1], 10) : null;
+}
+function detectLibraryMigrations(workspaceRoot, registry = BUILT_IN_LIBRARY_MIGRATIONS) {
+  let pkg;
+  try {
+    const pkgPath = path5.join(workspaceRoot, "package.json");
+    if (!fs5.existsSync(pkgPath)) return [];
+    pkg = JSON.parse(fs5.readFileSync(pkgPath, "utf-8"));
+  } catch {
+    return [];
+  }
+  const allDeps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
+  const hints = [];
+  for (const entry of registry) {
+    const { match, hint } = entry;
+    const versionSpec = allDeps[match.name];
+    if (!versionSpec) continue;
+    const major = parseMajor(versionSpec);
+    if (match.minMajor != null && (major == null || major < match.minMajor)) continue;
+    if (match.maxMajor != null && (major == null || major > match.maxMajor)) continue;
+    hints.push({ name: `${match.name}@${versionSpec}`, hint });
+  }
+  return hints;
+}
+function formatLibraryMigrationsBlock(hints) {
+  if (hints.length === 0) return "";
+  const lines = ["### library-migrations", ""];
+  lines.push(
+    "These migrations apply to your workspace's installed deps. When tsc's quick-fix conflicts with the migration target below, PREFER the migration target. tsc only checks types, not runtime semantics \u2014 these hints encode runtime constraints tsc cannot see."
+  );
+  lines.push("");
+  for (const h of hints) {
+    lines.push(`- [${h.name}] ${h.hint}`);
+  }
+  return lines.join("\n");
+}
+function formatLibraryMigrationsTaskDescription(hints) {
+  if (hints.length === 0) return void 0;
+  const names = hints.map((h) => h.name).join(", ");
+  return `Library migration: ${names}`;
+}
+
+// src/mendAgent.ts
+var SYSTEM_INSTRUCTIONS = `You are a TypeScript code-repair tool. You receive a TypeScript file with one or more compiler errors and resolve them.
+
+Output ONLY SEARCH/REPLACE blocks. No prose, no explanations, no XML wrappers.
+
+The first line of each block is the workspace-relative file path on its own line. Then the SEARCH/REPLACE markers around the change. Concrete example:
+
+src/api.ts
+<<<<<<< SEARCH
+const x = 1;
+=======
+const x: number = 1;
+>>>>>>> REPLACE
+
+Rules:
+- The file path is a plain line. Do not wrap it in tags, fences, or quotes.
+- SEARCH text must match the file VERBATIM. Whitespace, indentation, line endings: copy exactly.
+- Make SEARCH unique. If a one-line search would match multiple places in the file, include 1-2 lines of surrounding context.
+- REPLACE must be valid TypeScript that resolves the diagnostic.
+- Do not invent imports, types, properties, or values. Use only what the type-context section shows.
+- One SEARCH/REPLACE block per logical change.
+- If you cannot resolve a diagnostic with the information given, omit a block for it.
+
+Anti-patterns \u2014 these silence the type error but break runtime semantics, lose type safety, or introduce security regressions. Do NOT emit a patch that does any of the following:
+
+1. Type-assertion escape-hatches that hide the error rather than fix it:
+   - \`x as any\` / \`x as unknown as T\` to dodge a real mismatch.
+   - \`key as keyof T\` to silence a TS7053 index-signature error when \`key\` is a runtime \`string\` (not a statically-known literal). Narrow the parameter type to \`keyof T\` at the function signature instead, OR widen the object type to include an index signature, OR perform a runtime \`if (key in obj)\` guard. \`as keyof T\` keeps the call site type-passing while losing all the runtime safety the index signature gave.
+   - \`!\` non-null assertions to dodge TS18047/TS2532 \u2014 narrow with a truthiness check or optional-chaining + nullish-coalesce that actually preserves the narrow on the true branch.
+
+2. Removing or substituting a declared dependency to dodge a missing-import error. If \`package.json\` lists the package and the source uses it, RESTORE the import. Do not substitute a different library (e.g. \`bcrypt\` \u2192 \`crypto.subtle.digest\`) \u2014 that is a security regression even when tsc accepts it.
+
+3. SQL / NoSQL / shell injection patterns:
+   - String concatenation of user-controlled values into raw query strings (\`db.execute("WHERE id = " + userId)\`). Use the library's tagged-template / parameterized form (\`db.execute(sql\\\`WHERE id = \\\${userId}\\\`)\` for Drizzle; placeholders for Prisma / mysql2; etc).
+   - Never use template literals to interpolate user input into a raw SQL string unless the literal is itself a parameterizing tagged template.
+
+4. React XSS escape-hatches:
+   - \`dangerouslySetInnerHTML\` to dodge a children-type error. If a component expects \`children: string\` and you have arbitrary HTML, render it as text (JSX \`{value}\` auto-escapes) or sanitize via a library (DOMPurify) and document the assumption.
+   - Setting \`innerHTML\` directly on a DOM element from user input.
+
+These anti-patterns apply only to the listed shapes. For other diagnostics, follow the regular Rules above and pick the smallest valid fix \u2014 including legitimate uses of \`as unknown as T\`, \`keyof typeof T\` (as a type annotation, not a cast), or restructuring a type union. Do not omit a block just because the fix involves an \`as\` cast or a structural change \u2014 only omit when the fix would match one of the four anti-patterns above.
+
+When a type, union variant, or interface property has been removed or renamed, consumer code that referenced the old shape needs FULL cleanup, not partial cleanup:
+
+- TS2322 / TS2353 (excess property in object literal): REMOVE the excess property from the literal. Do not retain it. Example: if a \`{ type: 'archived', userId, reason, at }\` object now needs \`type: 'created'\` and the \`created\` variant has no \`reason\` field, the fix is to drop \`reason\` from the object \u2014 keeping it produces a fresh TS2353. This is field deletion, not "silencing an error" \u2014 there is no error to silence; the property genuinely no longer belongs.
+- Function parameters and return types that exist solely to support the removed variant (e.g. a \`reason: string\` parameter on a function that no longer needs reasons) should be dropped along with their use sites in the same SEARCH/REPLACE block.
+- TS2367 (comparison with no overlap): if comparing against a removed literal, EITHER pick a still-valid literal that preserves the function's spirit, OR delete the comparison and its branch if neither makes sense. Don't leave a comparison against a now-invalid literal.
+
+The goal is internal consistency: if you change one reference to a removed variant/property, sweep ALL references in this file in the same patch. A half-cleanup leaves new tsc errors and is worse than the original state.`;
+function workspaceRelative(workspaceRoot, p) {
+  return path6.isAbsolute(p) ? path6.relative(workspaceRoot, p) : p;
+}
+function buildSystemBlock(context, erroredFile) {
+  const wsRel = workspaceRelative(context.workspaceRoot, erroredFile);
+  const absPath = path6.isAbsolute(erroredFile) ? erroredFile : path6.join(context.workspaceRoot, erroredFile);
+  let fileContent;
+  try {
+    fileContent = fs6.readFileSync(absPath, "utf-8");
+  } catch {
+    fileContent = "(file unreadable)";
+  }
+  const fileDiags = context.diagnostics.filter(
+    (d) => d.category === "error" && workspaceRelative(context.workspaceRoot, d.file) === wsRel
+  );
+  const typeContexts = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const diag of fileDiags) {
+    let ctx;
+    try {
+      ctx = getTypeContext({
+        workspaceRoot: context.workspaceRoot,
+        diagnostic: diag
+      });
+    } catch {
+      continue;
+    }
+    if (!ctx.typeDeclaration) continue;
+    const key = `${ctx.typeDeclaration.file}:${ctx.typeDeclaration.symbol}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    typeContexts.push(
+      `// type: ${ctx.typeDeclaration.symbol}
+// file: ${ctx.typeDeclaration.file}
+` + ctx.typeDeclaration.lines
+    );
+  }
+  const parts = [SYSTEM_INSTRUCTIONS, ""];
+  const libMigrations = context.libraryMigrations ?? [];
+  if (libMigrations.length > 0) {
+    parts.push(formatLibraryMigrationsBlock(libMigrations), "");
+  }
+  parts.push(`### file: ${wsRel}`, "```ts", fileContent.replace(/\n$/, ""), "```");
+  if (typeContexts.length > 0) {
+    parts.push("", "### type-context");
+    for (const tc of typeContexts) {
+      parts.push("```ts", tc, "```");
+    }
+  }
+  const taskHeadline = formatLibraryMigrationsTaskDescription(libMigrations) ?? context.taskDescription;
+  if (taskHeadline) {
+    parts.push("", `### task`, taskHeadline);
+  }
+  return parts.join("\n");
+}
+function buildUserBlock(context, erroredFile) {
+  const wsRel = workspaceRelative(context.workspaceRoot, erroredFile);
+  const fileDiags = context.diagnostics.filter(
+    (d) => d.category === "error" && workspaceRelative(context.workspaceRoot, d.file) === wsRel
+  );
+  const lines = fileDiags.map(
+    (d) => `${d.file}(${d.line},${d.column}): ${d.code}: ${d.message}`
+  );
+  return `tsc reports:
+${lines.join("\n")}
+
+Emit SEARCH/REPLACE blocks to resolve.`;
+}
+var defaultLLMCall = async ({ systemBlock, userBlock, model, apiKey }) => {
+  const anthropic = createAnthropic({ apiKey });
+  const result = await generateText({
+    model: anthropic(model),
+    system: systemBlock,
+    messages: [{ role: "user", content: userBlock }]
+  });
+  return {
+    text: result.text,
+    inputTokens: result.usage?.inputTokens ?? 0,
+    outputTokens: result.usage?.outputTokens ?? 0
+  };
+};
+async function mendSingleFile(opts) {
+  const { context, llm, dryRun = false, _callLLM = defaultLLMCall } = opts;
+  const erroredFile = context.erroredFiles[0];
+  if (!erroredFile) {
+    throw new Error("mendSingleFile: no errored files in context");
+  }
+  const systemBlock = buildSystemBlock(context, erroredFile);
+  const userBlock = buildUserBlock(context, erroredFile);
+  const startMs = Date.now();
+  const llmResult = await _callLLM({
+    systemBlock,
+    userBlock,
+    model: llm.model,
+    apiKey: llm.apiKey
+  });
+  const latencyMs = Date.now() - startMs;
+  const rawResponse = llmResult.text;
+  const blocks = parseEditBlocks(rawResponse);
+  const apply = applyEditBlocks({
+    workspaceRoot: context.workspaceRoot,
+    blocks,
+    dryRun
+  });
+  return {
+    rawResponse,
+    blocks,
+    apply,
+    inputTokens: llmResult.inputTokens,
+    outputTokens: llmResult.outputTokens,
+    latencyMs
+  };
+}
+
+// src/stubAndContinue.ts
+import * as fs7 from "node:fs";
+import * as path7 from "node:path";
+var noopLogger = { info: () => {
+}, warn: () => {
+}, error: () => {
+} };
+function groupByLine(diagnostics) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const d of diagnostics) {
+    if (d.category !== "error") continue;
+    const key = `${d.file}::${d.line}`;
+    const list = groups.get(key);
+    if (list) list.push(d);
+    else groups.set(key, [d]);
+  }
+  return groups;
+}
+function resolveFile(diagnosticFile, workspaceRoot) {
+  return path7.isAbsolute(diagnosticFile) ? diagnosticFile : path7.resolve(workspaceRoot, diagnosticFile);
+}
+function shouldSkipFile(file, workspaceRoot) {
+  const rel = path7.relative(workspaceRoot, file);
+  if (rel.startsWith("node_modules") || rel.includes(`${path7.sep}node_modules${path7.sep}`)) {
+    return "node_modules";
+  }
+  if (file.endsWith(".d.ts")) {
+    return "declaration_file";
+  }
+  if (!fs7.existsSync(file)) {
+    return "file_not_found";
+  }
+  return null;
+}
+function lineIsTsSuppression(line) {
+  return /^\s*\/\/\s*@ts-(?:expect-error|ignore)\b/.test(line);
+}
+function leadingWhitespace(line) {
+  const match = line.match(/^(\s*)/);
+  return match ? match[1] : "";
+}
+function truncate(s, max) {
+  if (s.length <= max) return s;
+  return s.slice(0, max - 1) + "\u2026";
+}
+function buildStubComment(group, marker, maxMessageLength) {
+  const codes = Array.from(new Set(group.map((d) => d.code))).sort();
+  const messages = Array.from(new Set(group.map((d) => d.message.replace(/\s+/g, " ").trim()))).join(" | ");
+  const truncated = truncate(messages, maxMessageLength);
+  return `// @ts-expect-error - ${marker}: ${codes.join(", ")} \u2014 ${truncated}`;
+}
+function stubAndContinue(opts) {
+  const {
+    workspaceRoot,
+    diagnostics,
+    dryRun = false,
+    logger = noopLogger,
+    stubMarker = "tsfix",
+    maxMessageLength = 120
+  } = opts;
+  const errorOnly = diagnostics.filter((d) => d.category === "error");
+  const grouped = groupByLine(errorOnly);
+  const stubsApplied = [];
+  const skipped = [];
+  const filesEditedSet = /* @__PURE__ */ new Set();
+  const byFile = /* @__PURE__ */ new Map();
+  for (const [key, group] of grouped) {
+    const sepIdx = key.lastIndexOf("::");
+    const rawFile = key.slice(0, sepIdx);
+    const file = resolveFile(rawFile, workspaceRoot);
+    const line = parseInt(key.slice(sepIdx + 2), 10);
+    const list = byFile.get(file) ?? [];
+    list.push({ line, group });
+    byFile.set(file, list);
+  }
+  for (const [file, entries] of byFile) {
+    const skipReason = shouldSkipFile(file, workspaceRoot);
+    if (skipReason !== null) {
+      for (const entry of entries) {
+        skipped.push({
+          file,
+          line: entry.line,
+          codes: Array.from(new Set(entry.group.map((d) => d.code))).sort(),
+          reason: skipReason
+        });
+      }
+      continue;
+    }
+    const source = fs7.readFileSync(file, "utf-8");
+    const eol = source.includes("\r\n") ? "\r\n" : "\n";
+    const lines = source.split(/\r?\n/);
+    entries.sort((a, b) => b.line - a.line);
+    let edited = false;
+    for (const { line: errorLine, group } of entries) {
+      const errorIdx = errorLine - 1;
+      if (errorIdx < 0 || errorIdx >= lines.length) {
+        skipped.push({
+          file,
+          line: errorLine,
+          codes: Array.from(new Set(group.map((d) => d.code))).sort(),
+          reason: "file_too_short"
+        });
+        continue;
+      }
+      const lineAbove = errorIdx > 0 ? lines[errorIdx - 1] : "";
+      if (lineIsTsSuppression(lineAbove)) {
+        skipped.push({
+          file,
+          line: errorLine,
+          codes: Array.from(new Set(group.map((d) => d.code))).sort(),
+          reason: "already_stubbed"
+        });
+        continue;
+      }
+      const indent = leadingWhitespace(lines[errorIdx]);
+      const commentText = buildStubComment(group, stubMarker, maxMessageLength);
+      const commentLineWithIndent = `${indent}${commentText}`;
+      lines.splice(errorIdx, 0, commentLineWithIndent);
+      edited = true;
+      stubsApplied.push({
+        file,
+        errorLine,
+        // original line as reported by tsc; in the file post-stub, the comment is here and the code is at errorLine+1
+        codes: Array.from(new Set(group.map((d) => d.code))).sort(),
+        commentText
+      });
+    }
+    if (edited) {
+      filesEditedSet.add(file);
+      if (!dryRun) {
+        fs7.writeFileSync(file, lines.join(eol), "utf-8");
+        logger.info(`[stub-and-continue] stubbed ${entries.length} site(s) in ${path7.relative(workspaceRoot, file)}`);
+      } else {
+        logger.info(`[stub-and-continue] (dry-run) would stub ${entries.length} site(s) in ${path7.relative(workspaceRoot, file)}`);
+      }
+    }
+  }
+  return {
+    stubsApplied,
+    skipped,
+    filesEdited: Array.from(filesEditedSet),
+    diagnosticsBefore: errorOnly.length,
+    // Each applied stub suppresses every diagnostic on its line. Compare
+    // after resolving raw diagnostic paths to absolute, since stubsApplied
+    // stores absolute paths but the input diagnostics may be relative.
+    diagnosticsAfter: errorOnly.length - stubsApplied.reduce((acc, s) => {
+      const onLine = errorOnly.filter(
+        (d) => resolveFile(d.file, workspaceRoot) === s.file && d.line === s.errorLine
+      ).length;
+      return acc + onLine;
+    }, 0)
+  };
+}
+
+// src/runMendLoop.ts
+var noopLogger2 = { info: () => {
+}, warn: () => {
+}, error: () => {
+} };
+function errorSignature(d) {
+  return `${d.file}:${d.line}:${d.column}:${d.code}`;
+}
+function signatureSet(diags) {
+  const out = /* @__PURE__ */ new Set();
+  for (const d of diags) {
+    if (d.category === "error") out.add(errorSignature(d));
+  }
+  return out;
+}
+function setsEqual(a, b) {
+  if (a.size !== b.size) return false;
+  for (const x of a) if (!b.has(x)) return false;
+  return true;
+}
+function refreshDiagnostics(workspaceRoot, files) {
+  resetInProcessTscCache();
+  const result = runInProcessTsc({
+    workspaceRoot,
+    generatedFiles: files,
+    logger: noopLogger2
+  });
+  return result.diagnostics.filter((d) => d.category === "error");
+}
+async function runMendLoop(opts) {
+  const { context: rawContext, llm, maxIterations = 3, dryRun = false, stubOnFailure = false, _callLLM } = opts;
+  const startMs = Date.now();
+  const context = rawContext.libraryMigrations === void 0 ? { ...rawContext, libraryMigrations: detectLibraryMigrations(rawContext.workspaceRoot) } : rawContext;
+  const diagnosticsBefore = context.diagnostics.filter((d) => d.category === "error");
+  if (diagnosticsBefore.length === 0) {
+    return {
+      iterations: [],
+      diagnosticsBefore,
+      diagnosticsAfter: [],
+      passed: true,
+      stopReason: "noErrors",
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalLatencyMs: Date.now() - startMs
+    };
+  }
+  const filesInScope = Array.from(new Set(context.diagnostics.map((d) => d.file)));
+  const iterations = [];
+  let currentDiags = diagnosticsBefore;
+  let prevSig = signatureSet(currentDiags);
+  let stopReason = "maxIterations";
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+  for (let i = 0; i < maxIterations; i++) {
+    const erroredFiles = Array.from(new Set(currentDiags.map((d) => d.file)));
+    const iterContext = {
+      ...context,
+      diagnostics: currentDiags,
+      erroredFiles
+    };
+    const mend = await mendSingleFile({
+      context: iterContext,
+      llm,
+      dryRun,
+      _callLLM
+    });
+    totalInputTokens += mend.inputTokens;
+    totalOutputTokens += mend.outputTokens;
+    const newDiags = dryRun ? currentDiags : refreshDiagnostics(context.workspaceRoot, filesInScope);
+    const newSig = signatureSet(newDiags);
+    iterations.push({
+      index: i,
+      diagnosticsBefore: currentDiags.length,
+      diagnosticsAfter: newDiags.length,
+      patchesApplied: mend.apply.applied,
+      patchesFailed: mend.apply.failures.length,
+      inputTokens: mend.inputTokens,
+      outputTokens: mend.outputTokens,
+      latencyMs: mend.latencyMs,
+      rawResponse: mend.rawResponse
+    });
+    if (dryRun) {
+      currentDiags = newDiags;
+      stopReason = "maxIterations";
+      break;
+    }
+    if (newDiags.length === 0) {
+      stopReason = "fixed";
+      currentDiags = newDiags;
+      break;
+    }
+    if (newSig.size > prevSig.size) {
+      stopReason = "regressed";
+      currentDiags = newDiags;
+      break;
+    }
+    if (setsEqual(newSig, prevSig)) {
+      stopReason = "noProgress";
+      currentDiags = newDiags;
+      break;
+    }
+    currentDiags = newDiags;
+    prevSig = newSig;
+  }
+  let stubs;
+  if (stubOnFailure && !dryRun && currentDiags.length > 0) {
+    const stubResult = stubAndContinue({
+      workspaceRoot: context.workspaceRoot,
+      diagnostics: currentDiags
+    });
+    stubs = stubResult.stubsApplied;
+    const postStubDiags = refreshDiagnostics(context.workspaceRoot, filesInScope);
+    if (postStubDiags.length === 0) {
+      stopReason = "stubbed";
+    }
+    currentDiags = postStubDiags;
+  }
+  return {
+    iterations,
+    diagnosticsBefore,
+    diagnosticsAfter: currentDiags,
+    passed: currentDiags.length === 0,
+    stopReason,
+    totalInputTokens,
+    totalOutputTokens,
+    totalLatencyMs: Date.now() - startMs,
+    ...stubs !== void 0 ? { stubs } : {}
+  };
+}
 
 // src/index.ts
-var noopLogger = {
+var noopLogger3 = {
   info: () => {
   },
   warn: () => {
@@ -494,7 +1327,7 @@ function discoverTsFiles(workspaceRoot) {
   const walk = (dir) => {
     let entries;
     try {
-      entries = fs3.readdirSync(dir, { withFileTypes: true });
+      entries = fs8.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -503,10 +1336,10 @@ function discoverTsFiles(workspaceRoot) {
         if (skip.has(e.name)) {
           continue;
         }
-        walk(path3.join(dir, e.name));
+        walk(path8.join(dir, e.name));
       } else if (e.isFile() && !e.name.endsWith(".d.ts")) {
         if (e.name.endsWith(".ts") || e.name.endsWith(".tsx")) {
-          out.push(path3.relative(workspaceRoot, path3.join(dir, e.name)));
+          out.push(path8.relative(workspaceRoot, path8.join(dir, e.name)));
         }
       }
     }
@@ -516,11 +1349,11 @@ function discoverTsFiles(workspaceRoot) {
 }
 function runValidationLoop(opts) {
   const { workspaceRoot, skipLSPFixer = false, dryRun = false } = opts;
-  const logger = opts.logger ?? noopLogger;
-  if (!fs3.existsSync(workspaceRoot)) {
+  const logger = opts.logger ?? noopLogger3;
+  if (!fs8.existsSync(workspaceRoot)) {
     throw new Error(`workspace not found: ${workspaceRoot}`);
   }
-  if (!fs3.existsSync(path3.join(workspaceRoot, "tsconfig.json"))) {
+  if (!fs8.existsSync(path8.join(workspaceRoot, "tsconfig.json"))) {
     throw new Error(`no tsconfig.json in ${workspaceRoot}`);
   }
   const targetFiles = opts.targetFiles ?? discoverTsFiles(workspaceRoot);
@@ -569,6 +1402,16 @@ function runValidationLoop(opts) {
 }
 
 // cli/run-stack.ts
+var ANTHROPIC_PRICING = {
+  "claude-haiku-4-5": { input: 0.8, output: 4 },
+  "claude-sonnet-4-5": { input: 3, output: 15 },
+  "claude-opus-4-7": { input: 15, output: 75 }
+};
+function estimateCostUsd(model, inputTokens, outputTokens) {
+  const p = ANTHROPIC_PRICING[model];
+  if (!p) return 0;
+  return (inputTokens * p.input + outputTokens * p.output) / 1e6;
+}
 function parseArgs(argv) {
   const args = {
     workspace: "",
@@ -576,7 +1419,12 @@ function parseArgs(argv) {
     noLsp: false,
     dryRun: false,
     files: void 0,
-    verbose: false
+    verbose: false,
+    llm: false,
+    llmModel: "claude-haiku-4-5",
+    llmMaxIterations: 3,
+    llmBudgetUsd: void 0,
+    noLibraryHints: false
   };
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
@@ -592,6 +1440,26 @@ function parseArgs(argv) {
       args.files = (argv[++i] ?? "").split(",").map((s) => s.trim()).filter(Boolean);
     } else if (a === "--verbose" || a === "-v") {
       args.verbose = true;
+    } else if (a === "--llm") {
+      args.llm = true;
+    } else if (a === "--llm-model") {
+      args.llmModel = argv[++i] ?? args.llmModel;
+    } else if (a === "--llm-max-iterations") {
+      const n = parseInt(argv[++i] ?? "", 10);
+      if (Number.isNaN(n) || n < 1) {
+        console.error(`error: --llm-max-iterations expects a positive integer, got '${argv[i]}'`);
+        process.exit(2);
+      }
+      args.llmMaxIterations = n;
+    } else if (a === "--llm-budget-usd") {
+      const v = parseFloat(argv[++i] ?? "");
+      if (Number.isNaN(v) || v < 0) {
+        console.error(`error: --llm-budget-usd expects a positive number, got '${argv[i]}'`);
+        process.exit(2);
+      }
+      args.llmBudgetUsd = v;
+    } else if (a === "--no-library-hints") {
+      args.noLibraryHints = true;
     } else if (a === "--help" || a === "-h") {
       printHelp();
       process.exit(0);
@@ -606,22 +1474,39 @@ function parseArgs(argv) {
 }
 function printHelp() {
   console.error(`
-Usage: run-stack --workspace <path> [options]
-
-Options:
-  --workspace, -w <path>   Workspace root (required)
-  --files <list>           Comma-separated file paths to scope tsc/lsp to (default: all .ts/.tsx)
-  --no-lsp                 Skip Layer 0 LSP auto-fixer
-  --dry-run                Run the LSP fixer in memory; do NOT write changes
-                           to disk. Lists files that would be edited.
-  --json                   Emit JSON report on stdout
-  --verbose, -v            Stream layer logs to stderr
-  --help, -h               Show this help
+Usage: tsfix --workspace <path> [options]
+
+Layer 0/1 (default \u2014 deterministic, no network):
+  --workspace, -w <path>      Workspace root (required)
+  --files <a.ts,b.ts>         Scope tsc/lsp to this comma-separated list
+  --no-lsp                    Skip Layer 0 LSP auto-fixer (validate only)
+  --dry-run                   Run fixer in memory; list edits but don't write
+  --json                      Emit JSON report on stdout
+  --verbose, -v               Stream layer logs to stderr
+  --help, -h                  Show this help
+
+Layer 2 (opt-in \u2014 single-file LLM mend via Anthropic):
+  --llm                       Enable Layer 2 on errors that survive Layer 0/1
+  --llm-model <name>          Anthropic model (default: claude-haiku-4-5)
+                              Known-priced models: claude-haiku-4-5,
+                              claude-sonnet-4-5, claude-opus-4-7.
+                              Cost estimate is 0 for unknown models.
+  --llm-max-iterations <N>    Cap on LLM retries (default: 3)
+  --llm-budget-usd <amount>   Soft cost cap. Exits with code 3 if exceeded.
+  --no-library-hints          Disable auto-detection of library breaking-change
+                              hints (vite-plugin-svgr v4 ?react migration,
+                              Next.js 15 async params, etc.). When workspace
+                              package.json contains a known migration target,
+                              tsfix injects hints into Layer 2's prompt + skips
+                              Layer 0/1 (whose quick-fix would conflict).
+
+Layer 2 requires ANTHROPIC_API_KEY in the environment.
 
 Exit codes:
   0  no errors after stack
   1  errors remain after stack
   2  bad arguments / harness error
+  3  Layer 2 budget exceeded (errors may still remain; partial work persisted)
 `.trim());
 }
 function makeLogger(captureLines, verbose) {
@@ -658,6 +1543,15 @@ TSC Defense Stack \u2014 ${r.workspace}${r.dryRun ? " (dry-run)" : ""}
     }
   } else {
     w.write(`  LSP fixer:     skipped
+`);
+  }
+  if (r.layer2) {
+    const l2 = r.layer2;
+    w.write(
+      `  Layer 2 (LLM): ${l2.errorsBefore} \u2192 ${l2.errorsAfter} errors  ${l2.iterations}\xD7 iter  ${l2.totalInputTokens}\u2192${l2.totalOutputTokens} tokens  $${l2.totalCostUsd.toFixed(4)} ${l2.budgetExceeded ? "\u26A0\uFE0F  budget exceeded" : ""}
+`
+    );
+    w.write(`                 model=${l2.model} \xB7 stopReason=${l2.stopReason}
 `);
   }
   w.write(`  errors after:  ${r.errorsAfter}
@@ -679,12 +1573,12 @@ TSC Defense Stack \u2014 ${r.workspace}${r.dryRun ? " (dry-run)" : ""}
 }
 async function main() {
   const args = parseArgs(process.argv.slice(2));
-  const workspaceRoot = path4.resolve(args.workspace);
-  if (!fs4.existsSync(workspaceRoot)) {
+  const workspaceRoot = path9.resolve(args.workspace);
+  if (!fs9.existsSync(workspaceRoot)) {
     console.error(`error: workspace not found: ${workspaceRoot}`);
     return 2;
   }
-  if (!fs4.existsSync(path4.join(workspaceRoot, "tsconfig.json"))) {
+  if (!fs9.existsSync(path9.join(workspaceRoot, "tsconfig.json"))) {
     console.error(`error: no tsconfig.json in ${workspaceRoot}`);
     return 2;
   }
@@ -695,17 +1589,26 @@ async function main() {
     console.error("error: no .ts/.tsx files found in workspace");
     return 2;
   }
+  const libraryMigrations = args.noLibraryHints ? [] : detectLibraryMigrations(workspaceRoot);
+  const migrationApplies = args.llm && libraryMigrations.length > 0;
+  if (migrationApplies && !args.noLsp) {
+    logger.info(
+      `Library migrations detected (${libraryMigrations.map((h) => h.name).join(", ")}) \u2014 skipping Layer 0/1 to let Layer 2 apply the migration target. Use --no-library-hints to disable.`
+    );
+  }
+  const effectiveNoLsp = args.noLsp || migrationApplies;
   const loop = runValidationLoop({
     workspaceRoot,
     targetFiles,
-    skipLSPFixer: args.noLsp,
+    skipLSPFixer: effectiveNoLsp,
     dryRun: args.dryRun,
     logger
   });
   const report = {
-    workspace: path4.relative(process.cwd(), workspaceRoot) || workspaceRoot,
+    workspace: path9.relative(process.cwd(), workspaceRoot) || workspaceRoot,
     errorsBefore: loop.errorsBefore,
     lspFixer: args.noLsp ? { ran: false, fixesApplied: 0, filesEdited: [], iterations: 0 } : loop.lspFixer,
+    layer2: null,
     errorsAfter: loop.errorsAfter,
     remainingByCode: loop.remainingByCode,
     remainingByFile: loop.remainingByFile,
@@ -713,11 +1616,79 @@ async function main() {
     elapsedMs: loop.elapsedMs,
     dryRun: args.dryRun
   };
+  let budgetExceeded = false;
+  if (args.llm && loop.errorsAfter > 0) {
+    if (args.dryRun) {
+      console.error("error: --llm and --dry-run are mutually exclusive (Layer 2 writes patches to disk)");
+      return 2;
+    }
+    const apiKey = process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) {
+      console.error("error: --llm requires ANTHROPIC_API_KEY in the environment");
+      return 2;
+    }
+    if (!ANTHROPIC_PRICING[args.llmModel]) {
+      logger.warn(
+        `unknown model '${args.llmModel}' \u2014 cost estimates will be 0; budget cap will not trigger`
+      );
+    }
+    const errorDiags = loop.diagnostics.filter((d) => d.category === "error");
+    const context = {
+      workspaceRoot,
+      diagnostics: errorDiags,
+      erroredFiles: Array.from(new Set(errorDiags.map((d) => d.file))),
+      // Explicitly pass migrations so `runMendLoop` doesn't re-detect.
+      // `[]` is meaningful — it means "we know there are none" — vs
+      // `undefined` which would trigger auto-detect.
+      libraryMigrations
+    };
+    const layer2Start = Date.now();
+    const mend = await runMendLoop({
+      context,
+      llm: { provider: "anthropic", model: args.llmModel, apiKey },
+      maxIterations: args.llmMaxIterations
+    });
+    void layer2Start;
+    const totalCostUsd = estimateCostUsd(
+      args.llmModel,
+      mend.totalInputTokens,
+      mend.totalOutputTokens
+    );
+    budgetExceeded = args.llmBudgetUsd !== void 0 && totalCostUsd > args.llmBudgetUsd;
+    report.layer2 = {
+      ran: true,
+      stopReason: mend.stopReason,
+      errorsBefore: errorDiags.length,
+      errorsAfter: mend.diagnosticsAfter.length,
+      iterations: mend.iterations.length,
+      totalInputTokens: mend.totalInputTokens,
+      totalOutputTokens: mend.totalOutputTokens,
+      totalCostUsd,
+      budgetExceeded,
+      model: args.llmModel
+    };
+    const post = runInProcessTsc({
+      workspaceRoot,
+      generatedFiles: targetFiles,
+      logger
+    });
+    const postErrorDiags = post.diagnostics.filter((d) => d.category === "error");
+    report.errorsAfter = postErrorDiags.length;
+    report.remainingByCode = {};
+    report.remainingByFile = {};
+    for (const d of postErrorDiags) {
+      report.remainingByCode[d.code] = (report.remainingByCode[d.code] ?? 0) + 1;
+      report.remainingByFile[d.file] = (report.remainingByFile[d.file] ?? 0) + 1;
+    }
+    report.passed = report.errorsAfter === 0;
+    report.elapsedMs = loop.elapsedMs + (Date.now() - layer2Start);
+  }
   if (args.json) {
     process.stdout.write(JSON.stringify(report, null, 2) + "\n");
   } else {
     printHumanReport(report);
   }
+  if (budgetExceeded) return 3;
   return report.passed ? 0 : 1;
 }
 main().then(