@shipispec/tsfix 0.5.0 → 0.6.1

package/dist/index.js

@@ -189,7 +189,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");
@@ -276,15 +276,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];
@@ -295,6 +317,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(
@@ -475,8 +512,8 @@ function resetLSPFixerCache() {
 }
 
 // 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";
@@ -554,9 +591,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;
@@ -789,10 +837,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.
@@ -813,16 +930,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)";
   }
@@ -832,10 +976,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;
@@ -846,22 +995,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");
 }
@@ -878,10 +1026,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 }]
   });
@@ -903,6 +1065,7 @@ async function mendSingleFile(opts) {
   const llmResult = await _callLLM({
     systemBlock,
     userBlock,
+    provider: llm.provider,
     model: llm.model,
     apiKey: llm.apiKey
   });
@@ -925,8 +1088,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: () => {
@@ -943,17 +1106,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;
@@ -1012,7 +1175,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);
@@ -1054,10 +1217,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)}`);
       }
     }
   }
@@ -1107,9 +1270,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 {
@@ -1158,6 +1349,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";
@@ -1188,6 +1386,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";
@@ -1222,7 +1434,7 @@ function discoverTsFiles(workspaceRoot) {
   const walk = (dir) => {
     let entries;
     try {
-      entries = fs7.readdirSync(dir, { withFileTypes: true });
+      entries = fs8.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -1231,10 +1443,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)));
         }
       }
     }
@@ -1245,10 +1457,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);
@@ -1264,7 +1476,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,
@@ -1295,10 +1513,108 @@ function runValidationLoop(opts) {
     elapsedMs: Date.now() - startMs
   };
 }
+var PRICING = {
+  anthropic: {
+    "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: {
+    "gpt-5-nano": { input: 0.05, output: 0.4 },
+    "gpt-5-mini": { input: 0.25, output: 2 },
+    "gpt-5": { input: 1.25, output: 10 },
+    "gpt-5.1": { input: 1.25, output: 10 },
+    "gpt-5.2": { input: 1.75, output: 14 },
+    "o3-mini": { input: 1.1, output: 4.4 },
+    "o4-mini": { input: 1.1, output: 4.4 },
+    "o3": { input: 2, output: 8 }
+  },
+  google: {
+    "gemini-2.5-flash-lite": { input: 0.1, output: 0.4 },
+    "gemini-2.5-flash": { input: 0.3, output: 2.5 },
+    "gemini-2.5-pro": { input: 1.25, output: 10 }
+  }
+};
+function costUsd(provider, model, inputTokens, outputTokens) {
+  const p = PRICING[provider]?.[model];
+  if (!p) return 0;
+  return (inputTokens * p.input + outputTokens * p.output) / 1e6;
+}
+async function runFullStack(opts) {
+  const startMs = Date.now();
+  const { workspaceRoot, llm, stubOnFailure = false, dryRun = false, onLayerEvent } = opts;
+  const layer1 = runValidationLoop({
+    workspaceRoot,
+    targetFiles: opts.targetFiles,
+    skipLSPFixer: opts.skipLSPFixer,
+    dryRun,
+    logger: opts.logger,
+    onLayerEvent
+  });
+  let layer2 = null;
+  let layer4 = null;
+  let totalCostUsd = 0;
+  let finalDiagnostics = layer1.diagnostics;
+  const shouldRunLayer2 = llm && !dryRun && layer1.errorsAfter > 0;
+  if (shouldRunLayer2) {
+    const errorDiags = layer1.diagnostics.filter((d) => d.category === "error");
+    layer2 = await runMendLoop({
+      context: {
+        workspaceRoot,
+        diagnostics: errorDiags,
+        erroredFiles: Array.from(new Set(errorDiags.map((d) => d.file)))
+      },
+      llm: { provider: llm.provider, model: llm.model, apiKey: llm.apiKey },
+      maxIterations: llm.maxIterations,
+      stubOnFailure,
+      onLayerEvent,
+      _callLLM: opts._callLLM
+    });
+    totalCostUsd = costUsd(llm.provider, llm.model, layer2.totalInputTokens, layer2.totalOutputTokens);
+    if (layer2.stubs && layer2.stubs.length > 0) {
+      layer4 = { stubsApplied: layer2.stubs };
+    }
+    resetInProcessTscCache();
+    const post = runInProcessTsc({
+      workspaceRoot,
+      generatedFiles: opts.targetFiles ?? discoverTsFiles(workspaceRoot),
+      logger: opts.logger ?? noopLogger3
+    });
+    finalDiagnostics = post.diagnostics;
+  }
+  const finalErrorDiags = finalDiagnostics.filter((d) => d.category === "error");
+  const remainingByCode = {};
+  const remainingByFile = {};
+  for (const d of finalErrorDiags) {
+    remainingByCode[d.code] = (remainingByCode[d.code] ?? 0) + 1;
+    remainingByFile[d.file] = (remainingByFile[d.file] ?? 0) + 1;
+  }
+  return {
+    passed: finalErrorDiags.length === 0,
+    errorsBefore: layer1.errorsBefore,
+    errorsAfterLayer1: layer1.errorsAfter,
+    errorsAfterAllLayers: finalErrorDiags.length,
+    layer1: layer1.lspFixer,
+    layer2,
+    layer4,
+    totalCostUsd,
+    totalLatencyMs: Date.now() - startMs,
+    remainingByCode,
+    remainingByFile
+  };
+}
 export {
+  BUILT_IN_LIBRARY_MIGRATIONS,
   applyEditBlocks,
   applySingleBlock,
+  detectLibraryMigrations,
   discoverTsFiles,
+  formatLibraryMigrationsBlock,
+  formatLibraryMigrationsTaskDescription,
   getTypeContext,
   isInProcessTscEnabled,
   isLSPFixerEnabled,
@@ -1307,6 +1623,7 @@ export {
   resetInProcessTscCache,
   resetLSPFixerCache,
   resetTypeContextCache,
+  runFullStack,
   runInProcessTsc,
   runLSPFixerPass,
   runMendLoop,