@shipispec/tsfix 0.5.0 → 0.6.1

package/dist/cli.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // cli/run-stack.ts
-import * as path8 from "node:path";
-import * as fs8 from "node:fs";
+import * as path9 from "node:path";
+import * as fs9 from "node:fs";
 
 // src/validatorInProcess.ts
 import * as fs from "node:fs";
@@ -192,7 +192,7 @@ var SAFE_FIX_NAMES = /* @__PURE__ */ new Set([
   // alternate spelling-fix name some TS versions emit
 ]);
 function runLSPFixerPass(opts) {
-  const { workspaceRoot, targetFiles, logger } = opts;
+  const { workspaceRoot, targetFiles, logger, onLayerEvent } = opts;
   const maxIterations = opts.maxIterations ?? 5;
   const dryRun = opts.dryRun ?? false;
   const tsconfigPath = path2.join(workspaceRoot, "tsconfig.json");
@@ -279,15 +279,37 @@ function runLSPFixerPass(opts) {
     lastErrorSignatures = signatures;
     let appliedThisIter = 0;
     for (const err of fixableErrors) {
+      const errStartMs = Date.now();
       const fixes = safeGetCodeFixes(service, err);
       if (!fixes || fixes.length === 0) {
+        onLayerEvent?.({
+          layer: 1,
+          errorCode: err.code,
+          fixed: false,
+          latencyMs: Date.now() - errStartMs,
+          ts: Date.now()
+        });
         continue;
       }
       const safeFixes = fixes.filter((f) => SAFE_FIX_NAMES.has(f.fixName));
       if (safeFixes.length === 0) {
+        onLayerEvent?.({
+          layer: 1,
+          errorCode: err.code,
+          fixed: false,
+          latencyMs: Date.now() - errStartMs,
+          ts: Date.now()
+        });
         continue;
       }
       if (safeFixes.length > 1 && !fixesAreEquivalent(safeFixes)) {
+        onLayerEvent?.({
+          layer: 1,
+          errorCode: err.code,
+          fixed: false,
+          latencyMs: Date.now() - errStartMs,
+          ts: Date.now()
+        });
         continue;
       }
       const fix = safeFixes[0];
@@ -298,6 +320,21 @@ function runLSPFixerPass(opts) {
         for (const change of fix.changes) {
           filesEdited.add(change.fileName);
         }
+        onLayerEvent?.({
+          layer: 1,
+          errorCode: err.code,
+          fixed: true,
+          latencyMs: Date.now() - errStartMs,
+          ts: Date.now()
+        });
+      } else {
+        onLayerEvent?.({
+          layer: 1,
+          errorCode: err.code,
+          fixed: false,
+          latencyMs: Date.now() - errStartMs,
+          ts: Date.now()
+        });
       }
     }
     logger.info(
@@ -473,8 +510,8 @@ function applyFixToSnapshots(fix, snapshots) {
 }
 
 // src/index.ts
-import * as fs7 from "node:fs";
-import * as path7 from "node:path";
+import * as fs8 from "node:fs";
+import * as path8 from "node:path";
 
 // src/typeContext.ts
 import * as fs3 from "node:fs";
@@ -549,9 +586,20 @@ function isLibFile(fileName) {
 }
 function findTypeDeclaration(checker, startNode, maxWalkUp = 4) {
   const tryResolve = (n) => {
-    const type = checker.getTypeAtLocation(n);
-    const symbol = type.getSymbol() ?? type.aliasSymbol;
-    const declarations = symbol?.getDeclarations();
+    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;
@@ -784,10 +832,79 @@ function applyEditBlocks(opts) {
 }
 
 // src/mendAgent.ts
-import * as fs5 from "node:fs";
-import * as path5 from "node:path";
+import * as fs6 from "node:fs";
+import * as path6 from "node:path";
 import { generateText } from "ai";
 import { createAnthropic } from "@ai-sdk/anthropic";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+
+// 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.
@@ -808,16 +925,43 @@ Rules:
 - 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.`;
+- 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 path5.isAbsolute(p) ? path5.relative(workspaceRoot, p) : p;
+  return path6.isAbsolute(p) ? path6.relative(workspaceRoot, p) : p;
 }
 function buildSystemBlock(context, erroredFile) {
   const wsRel = workspaceRelative(context.workspaceRoot, erroredFile);
-  const absPath = path5.isAbsolute(erroredFile) ? erroredFile : path5.join(context.workspaceRoot, erroredFile);
+  const absPath = path6.isAbsolute(erroredFile) ? erroredFile : path6.join(context.workspaceRoot, erroredFile);
   let fileContent;
   try {
-    fileContent = fs5.readFileSync(absPath, "utf-8");
+    fileContent = fs6.readFileSync(absPath, "utf-8");
   } catch {
     fileContent = "(file unreadable)";
   }
@@ -827,10 +971,15 @@ function buildSystemBlock(context, erroredFile) {
   const typeContexts = [];
   const seen = /* @__PURE__ */ new Set();
   for (const diag of fileDiags) {
-    const ctx = getTypeContext({
-      workspaceRoot: context.workspaceRoot,
-      diagnostic: diag
-    });
+    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;
@@ -841,22 +990,21 @@ function buildSystemBlock(context, erroredFile) {
 ` + ctx.typeDeclaration.lines
     );
   }
-  const parts = [
-    SYSTEM_INSTRUCTIONS,
-    "",
-    `### file: ${wsRel}`,
-    "```ts",
-    fileContent.replace(/\n$/, ""),
-    "```"
-  ];
+  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, "```");
     }
   }
-  if (context.taskDescription) {
-    parts.push("", `### task`, context.taskDescription);
+  const taskHeadline = formatLibraryMigrationsTaskDescription(libMigrations) ?? context.taskDescription;
+  if (taskHeadline) {
+    parts.push("", `### task`, taskHeadline);
   }
   return parts.join("\n");
 }
@@ -873,10 +1021,24 @@ ${lines.join("\n")}
 
 Emit SEARCH/REPLACE blocks to resolve.`;
 }
-var defaultLLMCall = async ({ systemBlock, userBlock, model, apiKey }) => {
-  const anthropic = createAnthropic({ apiKey });
+function buildLanguageModel(provider, model, apiKey) {
+  switch (provider) {
+    case "anthropic":
+      return createAnthropic({ apiKey })(model);
+    case "openai":
+      return createOpenAI({ apiKey })(model);
+    case "google":
+      return createGoogleGenerativeAI({ apiKey })(model);
+    default: {
+      const _exhaustive = provider;
+      throw new Error(`unknown provider: ${_exhaustive}`);
+    }
+  }
+}
+var defaultLLMCall = async ({ systemBlock, userBlock, provider = "anthropic", model, apiKey }) => {
+  const llmModel = buildLanguageModel(provider, model, apiKey);
   const result = await generateText({
-    model: anthropic(model),
+    model: llmModel,
     system: systemBlock,
     messages: [{ role: "user", content: userBlock }]
   });
@@ -898,6 +1060,7 @@ async function mendSingleFile(opts) {
   const llmResult = await _callLLM({
     systemBlock,
     userBlock,
+    provider: llm.provider,
     model: llm.model,
     apiKey: llm.apiKey
   });
@@ -920,8 +1083,8 @@ async function mendSingleFile(opts) {
 }
 
 // src/stubAndContinue.ts
-import * as fs6 from "node:fs";
-import * as path6 from "node:path";
+import * as fs7 from "node:fs";
+import * as path7 from "node:path";
 var noopLogger = { info: () => {
 }, warn: () => {
 }, error: () => {
@@ -938,17 +1101,17 @@ function groupByLine(diagnostics) {
   return groups;
 }
 function resolveFile(diagnosticFile, workspaceRoot) {
-  return path6.isAbsolute(diagnosticFile) ? diagnosticFile : path6.resolve(workspaceRoot, diagnosticFile);
+  return path7.isAbsolute(diagnosticFile) ? diagnosticFile : path7.resolve(workspaceRoot, diagnosticFile);
 }
 function shouldSkipFile(file, workspaceRoot) {
-  const rel = path6.relative(workspaceRoot, file);
-  if (rel.startsWith("node_modules") || rel.includes(`${path6.sep}node_modules${path6.sep}`)) {
+  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 (!fs6.existsSync(file)) {
+  if (!fs7.existsSync(file)) {
     return "file_not_found";
   }
   return null;
@@ -1007,7 +1170,7 @@ function stubAndContinue(opts) {
       }
       continue;
     }
-    const source = fs6.readFileSync(file, "utf-8");
+    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);
@@ -1049,10 +1212,10 @@ function stubAndContinue(opts) {
     if (edited) {
       filesEditedSet.add(file);
       if (!dryRun) {
-        fs6.writeFileSync(file, lines.join(eol), "utf-8");
-        logger.info(`[stub-and-continue] stubbed ${entries.length} site(s) in ${path6.relative(workspaceRoot, file)}`);
+        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 ${path6.relative(workspaceRoot, file)}`);
+        logger.info(`[stub-and-continue] (dry-run) would stub ${entries.length} site(s) in ${path7.relative(workspaceRoot, file)}`);
       }
     }
   }
@@ -1102,9 +1265,37 @@ function refreshDiagnostics(workspaceRoot, files) {
   });
   return result.diagnostics.filter((d) => d.category === "error");
 }
+function parseTsCode(code) {
+  const m = /^TS(\d+)$/.exec(code);
+  return m ? parseInt(m[1], 10) : 0;
+}
+function dominantErrorCode(diags) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const d of diags) {
+    counts.set(d.code, (counts.get(d.code) ?? 0) + 1);
+  }
+  let bestCode = "";
+  let bestCount = 0;
+  for (const [code, count] of counts) {
+    if (count > bestCount) {
+      bestCount = count;
+      bestCode = code;
+    }
+  }
+  return parseTsCode(bestCode);
+}
 async function runMendLoop(opts) {
-  const { context, llm, maxIterations = 3, dryRun = false, stubOnFailure = false, _callLLM } = opts;
+  const {
+    context: rawContext,
+    llm,
+    maxIterations = 3,
+    dryRun = false,
+    stubOnFailure = false,
+    onLayerEvent,
+    _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 {
@@ -1153,6 +1344,13 @@ async function runMendLoop(opts) {
       latencyMs: mend.latencyMs,
       rawResponse: mend.rawResponse
     });
+    onLayerEvent?.({
+      layer: 2,
+      errorCode: dominantErrorCode(currentDiags),
+      fixed: newDiags.length === 0,
+      latencyMs: mend.latencyMs,
+      ts: Date.now()
+    });
     if (dryRun) {
       currentDiags = newDiags;
       stopReason = "maxIterations";
@@ -1183,6 +1381,20 @@ async function runMendLoop(opts) {
       diagnostics: currentDiags
     });
     stubs = stubResult.stubsApplied;
+    if (onLayerEvent) {
+      const stubTs = Date.now();
+      for (const stub of stubResult.stubsApplied) {
+        for (const code of stub.codes) {
+          onLayerEvent({
+            layer: 4,
+            errorCode: parseTsCode(code),
+            fixed: true,
+            latencyMs: 0,
+            ts: stubTs
+          });
+        }
+      }
+    }
     const postStubDiags = refreshDiagnostics(context.workspaceRoot, filesInScope);
     if (postStubDiags.length === 0) {
       stopReason = "stubbed";
@@ -1217,7 +1429,7 @@ function discoverTsFiles(workspaceRoot) {
   const walk = (dir) => {
     let entries;
     try {
-      entries = fs7.readdirSync(dir, { withFileTypes: true });
+      entries = fs8.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -1226,10 +1438,10 @@ function discoverTsFiles(workspaceRoot) {
         if (skip.has(e.name)) {
           continue;
         }
-        walk(path7.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(path7.relative(workspaceRoot, path7.join(dir, e.name)));
+          out.push(path8.relative(workspaceRoot, path8.join(dir, e.name)));
         }
       }
     }
@@ -1240,10 +1452,10 @@ function discoverTsFiles(workspaceRoot) {
 function runValidationLoop(opts) {
   const { workspaceRoot, skipLSPFixer = false, dryRun = false } = opts;
   const logger = opts.logger ?? noopLogger3;
-  if (!fs7.existsSync(workspaceRoot)) {
+  if (!fs8.existsSync(workspaceRoot)) {
     throw new Error(`workspace not found: ${workspaceRoot}`);
   }
-  if (!fs7.existsSync(path7.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);
@@ -1259,7 +1471,13 @@ function runValidationLoop(opts) {
     iterations: 0
   };
   if (errorsBefore > 0 && !skipLSPFixer) {
-    const lsp = runLSPFixerPass({ workspaceRoot, targetFiles, logger, dryRun });
+    const lsp = runLSPFixerPass({
+      workspaceRoot,
+      targetFiles,
+      logger,
+      dryRun,
+      onLayerEvent: opts.onLayerEvent
+    });
     lspFixer = {
       ran: true,
       fixesApplied: lsp.fixesApplied,
@@ -1292,16 +1510,59 @@ 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 }
+var PRICING = {
+  anthropic: {
+    // All 4.5+ models share the same tier (the 4.5 release brought a
+    // significant price drop on Opus). 4.1 retains the older Opus tier.
+    "claude-haiku-4-5": { input: 1, output: 5 },
+    "claude-sonnet-4-5": { input: 3, output: 15 },
+    "claude-sonnet-4-6": { input: 3, output: 15 },
+    "claude-opus-4-5": { input: 5, output: 25 },
+    "claude-opus-4-6": { input: 5, output: 25 },
+    "claude-opus-4-7": { input: 5, output: 25 },
+    "claude-opus-4-1": { input: 15, output: 75 }
+  },
+  openai: {
+    // Mini / nano tiers — well-matched to TypeScript repair (small
+    // context, structured output). Default model uses one of these.
+    "gpt-5-nano": { input: 0.05, output: 0.4 },
+    "gpt-5-mini": { input: 0.25, output: 2 },
+    // gpt-5 flagship + recent point releases (all $1.25 / $10).
+    "gpt-5": { input: 1.25, output: 10 },
+    "gpt-5.1": { input: 1.25, output: 10 },
+    "gpt-5.2": { input: 1.75, output: 14 },
+    // Reasoning models — sometimes better at semantic repair, more expensive.
+    "o3-mini": { input: 1.1, output: 4.4 },
+    "o4-mini": { input: 1.1, output: 4.4 },
+    "o3": { input: 2, output: 8 }
+  },
+  google: {
+    // Lite < flash < pro, matching the haiku/sonnet/opus mental model.
+    "gemini-2.5-flash-lite": { input: 0.1, output: 0.4 },
+    "gemini-2.5-flash": { input: 0.3, output: 2.5 },
+    // Standard tier (≤200k tokens). 2.5-pro doubles to $2.50/$15.00 above
+    // 200k — not modeled here since our prompts are well below that.
+    "gemini-2.5-pro": { input: 1.25, output: 10 }
+  }
 };
-function estimateCostUsd(model, inputTokens, outputTokens) {
-  const p = ANTHROPIC_PRICING[model];
+function estimateCostUsd(provider, model, inputTokens, outputTokens) {
+  const p = PRICING[provider]?.[model];
   if (!p) return 0;
   return (inputTokens * p.input + outputTokens * p.output) / 1e6;
 }
+var ENV_KEY_BY_PROVIDER = {
+  anthropic: "ANTHROPIC_API_KEY",
+  openai: "OPENAI_API_KEY",
+  google: "GOOGLE_GENERATIVE_AI_API_KEY"
+};
+var DEFAULT_MODEL_BY_PROVIDER = {
+  anthropic: "claude-haiku-4-5",
+  openai: "gpt-5-mini",
+  google: "gemini-2.5-flash"
+};
+function isLLMProvider(s) {
+  return s === "anthropic" || s === "openai" || s === "google";
+}
 function parseArgs(argv) {
   const args = {
     workspace: "",
@@ -1311,9 +1572,14 @@ function parseArgs(argv) {
     files: void 0,
     verbose: false,
     llm: false,
-    llmModel: "claude-haiku-4-5",
+    llmProvider: "anthropic",
+    // llmModel default depends on provider — we set it AFTER parsing so
+    // `--llm-provider openai` without `--llm-model` picks gpt-4o-mini, etc.
+    // An empty string here means "use the provider's default".
+    llmModel: "",
     llmMaxIterations: 3,
-    llmBudgetUsd: void 0
+    llmBudgetUsd: void 0,
+    noLibraryHints: false
   };
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
@@ -1331,6 +1597,13 @@ function parseArgs(argv) {
       args.verbose = true;
     } else if (a === "--llm") {
       args.llm = true;
+    } else if (a === "--llm-provider") {
+      const p = argv[++i] ?? "";
+      if (!isLLMProvider(p)) {
+        console.error(`error: --llm-provider expects one of: anthropic, openai, google. Got '${p}'`);
+        process.exit(2);
+      }
+      args.llmProvider = p;
     } else if (a === "--llm-model") {
       args.llmModel = argv[++i] ?? args.llmModel;
     } else if (a === "--llm-max-iterations") {
@@ -1347,6 +1620,8 @@ function parseArgs(argv) {
         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);
@@ -1357,6 +1632,9 @@ function parseArgs(argv) {
     printHelp();
     process.exit(2);
   }
+  if (args.llmModel === "") {
+    args.llmModel = DEFAULT_MODEL_BY_PROVIDER[args.llmProvider];
+  }
   return args;
 }
 function printHelp() {
@@ -1372,16 +1650,36 @@ Layer 0/1 (default \u2014 deterministic, no network):
   --verbose, -v               Stream layer logs to stderr
   --help, -h                  Show this help
 
-Layer 2 (opt-in \u2014 single-file LLM mend via Anthropic):
+Layer 2 (opt-in \u2014 single-file LLM mend):
   --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-provider <name>       anthropic | openai | google   (default: anthropic)
+  --llm-model <name>          Model name. Defaults per provider:
+                                anthropic \u2192 claude-haiku-4-5
+                                openai    \u2192 gpt-5-mini
+                                google    \u2192 gemini-2.5-flash
+                              Known-priced models per provider:
+                                anthropic: claude-haiku-4-5, -sonnet-4-5,
+                                           -sonnet-4-6, -opus-4-5, -opus-4-6,
+                                           -opus-4-7, -opus-4-1
+                                openai:    gpt-5-nano, gpt-5-mini, gpt-5,
+                                           gpt-5.1, gpt-5.2, o3-mini, o4-mini, o3
+                                google:    gemini-2.5-flash-lite, gemini-2.5-flash,
+                                           gemini-2.5-pro
+                              Cost estimate is 0 for unlisted models (the
+                              warning suggests pinning a listed one).
   --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.
+Layer 2 requires the provider's API key in env:
+  anthropic \u2192 ANTHROPIC_API_KEY
+  openai    \u2192 OPENAI_API_KEY
+  google    \u2192 GOOGLE_GENERATIVE_AI_API_KEY
 
 Exit codes:
   0  no errors after stack
@@ -1432,7 +1730,7 @@ TSC Defense Stack \u2014 ${r.workspace}${r.dryRun ? " (dry-run)" : ""}
       `  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(`                 ${l2.provider}/${l2.model} \xB7 stopReason=${l2.stopReason}
 `);
   }
   w.write(`  errors after:  ${r.errorsAfter}
@@ -1454,12 +1752,12 @@ TSC Defense Stack \u2014 ${r.workspace}${r.dryRun ? " (dry-run)" : ""}
 }
 async function main() {
   const args = parseArgs(process.argv.slice(2));
-  const workspaceRoot = path8.resolve(args.workspace);
-  if (!fs8.existsSync(workspaceRoot)) {
+  const workspaceRoot = path9.resolve(args.workspace);
+  if (!fs9.existsSync(workspaceRoot)) {
     console.error(`error: workspace not found: ${workspaceRoot}`);
     return 2;
   }
-  if (!fs8.existsSync(path8.join(workspaceRoot, "tsconfig.json"))) {
+  if (!fs9.existsSync(path9.join(workspaceRoot, "tsconfig.json"))) {
     console.error(`error: no tsconfig.json in ${workspaceRoot}`);
     return 2;
   }
@@ -1470,15 +1768,23 @@ 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: path8.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,
@@ -1495,30 +1801,36 @@ async function main() {
       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;
+    const envKeyName = ENV_KEY_BY_PROVIDER[args.llmProvider];
+    const apiKey = process.env[envKeyName];
     if (!apiKey) {
-      console.error("error: --llm requires ANTHROPIC_API_KEY in the environment");
+      console.error(`error: --llm with provider '${args.llmProvider}' requires ${envKeyName} in the environment`);
       return 2;
     }
-    if (!ANTHROPIC_PRICING[args.llmModel]) {
+    if (!PRICING[args.llmProvider]?.[args.llmModel]) {
       logger.warn(
-        `unknown model '${args.llmModel}' \u2014 cost estimates will be 0; budget cap will not trigger`
+        `unknown model '${args.llmProvider}/${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)))
+      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 },
+      llm: { provider: args.llmProvider, model: args.llmModel, apiKey },
       maxIterations: args.llmMaxIterations
     });
     void layer2Start;
     const totalCostUsd = estimateCostUsd(
+      args.llmProvider,
       args.llmModel,
       mend.totalInputTokens,
       mend.totalOutputTokens
@@ -1534,6 +1846,7 @@ async function main() {
       totalOutputTokens: mend.totalOutputTokens,
       totalCostUsd,
       budgetExceeded,
+      provider: args.llmProvider,
       model: args.llmModel
     };
     const post = runInProcessTsc({