@shipispec/tsfix 0.5.0 → 0.6.1

package/dist/types/index.d.ts

@@ -82,6 +82,12 @@ export interface ValidationLoopOptions {
     dryRun?: boolean;
     /** Default: a no-op logger. Pass your own to capture layer events. */
     logger?: Logger;
+    /**
+     * Per-error telemetry callback for Layer 1 (LSP fixer). Fires once per
+     * fixable error with `{layer: 1, errorCode, fixed, latencyMs, ts}`. Optional;
+     * undefined callback costs nothing. See `LayerEvent`.
+     */
+    onLayerEvent?: (event: LayerEvent) => void;
 }
 export interface ValidationLoopResult {
     passed: boolean;
@@ -156,6 +162,20 @@ export interface MendContext {
     priorTaskExports?: string;
     /** Compact type signatures of installed npm dependencies (helps prevent API hallucination). */
     installedTypes?: string;
+    /**
+     * Library-migration hints for installed deps whose breaking changes are
+     * known to mislead tsc's quick-fix. When non-empty, the Layer 2 prompt
+     * leads with these and the `taskDescription` is overridden to name them.
+     *
+     * Auto-populated by `runMendLoop` from `<workspaceRoot>/package.json` if
+     * the caller doesn't set it. Pass `[]` explicitly to opt out.
+     *
+     * See `libraryMigrations.ts` for the built-in registry.
+     */
+    libraryMigrations?: Array<{
+        name: string;
+        hint: string;
+    }>;
 }
 /**
  * Per-layer event for streaming telemetry across the validate → fix → mend
@@ -189,8 +209,88 @@ export type { TypeContextOptions, TypeContext } from "./typeContext.js";
 export { parseEditBlocks, applySingleBlock, applyEditBlocks } from "./applyEditBlock.js";
 export type { EditBlock, ApplyEditBlocksOptions, ApplyResult, SingleBlockResult, } from "./applyEditBlock.js";
 export { mendSingleFile } from "./mendAgent.js";
-export type { MendSingleFileOptions, MendSingleFileResult, LLMCall } from "./mendAgent.js";
+export type { MendSingleFileOptions, MendSingleFileResult, LLMCall, LLMProvider, } from "./mendAgent.js";
 export { runMendLoop } from "./runMendLoop.js";
 export type { RunMendLoopOptions, RunMendLoopResult, MendLoopIteration, StopReason, } from "./runMendLoop.js";
 export { stubAndContinue } from "./stubAndContinue.js";
 export type { StubAndContinueOptions, StubAndContinueResult, AppliedStub, SkippedStub, } from "./stubAndContinue.js";
+export { BUILT_IN_LIBRARY_MIGRATIONS, detectLibraryMigrations, formatLibraryMigrationsBlock, formatLibraryMigrationsTaskDescription, } from "./libraryMigrations.js";
+export type { LibraryMigrationHint } from "./libraryMigrations.js";
+import { type RunMendLoopResult } from "./runMendLoop.js";
+import type { AppliedStub } from "./stubAndContinue.js";
+import type { LLMProvider } from "./mendAgent.js";
+export interface RunFullStackOptions {
+    /** Absolute path to the workspace (must contain `tsconfig.json`). */
+    workspaceRoot: string;
+    /** Files to scope to. If omitted, all `.ts`/`.tsx` files under workspaceRoot. */
+    targetFiles?: string[];
+    /** Skip Layer 0/1 LSP auto-fixer. Default false. */
+    skipLSPFixer?: boolean;
+    /**
+     * Layer 2 config. If omitted, the loop stops after Layer 0/1 (matches
+     * `runValidationLoop` behavior — no LLM calls).
+     */
+    llm?: {
+        provider: LLMProvider;
+        model: string;
+        apiKey: string;
+        maxIterations?: number;
+    };
+    /**
+     * After Layer 2 (if any), insert `// @ts-expect-error - tsfix: …` above
+     * each unresolved error site so tsc exits 0. Opt-in. Default false.
+     */
+    stubOnFailure?: boolean;
+    /**
+     * Run all layers in memory; report counts but don't write. Default false.
+     * Layer 2 is auto-skipped under dryRun (it writes patches; would be a
+     * no-op).
+     */
+    dryRun?: boolean;
+    /** Logger. Default no-op. */
+    logger?: Logger;
+    /** Per-layer telemetry stream. Forwarded to Layer 1, 2, 4. */
+    onLayerEvent?: (event: LayerEvent) => void;
+    /** @internal — LLM call override. Tests inject a fake; real callers leave it. */
+    _callLLM?: import("./mendAgent.js").LLMCall;
+}
+export interface RunFullStackResult {
+    /** True if `errorsAfterAllLayers === 0`. */
+    passed: boolean;
+    /** Errors detected before any fix attempt. */
+    errorsBefore: number;
+    /** Errors remaining after Layer 0/1 (before Layer 2 + 4). */
+    errorsAfterLayer1: number;
+    /** Errors remaining after every layer that ran. */
+    errorsAfterAllLayers: number;
+    /** Per-layer sub-results. `layer2` is null when `llm` was omitted; `layer4` is null when `stubOnFailure` was false (or had no candidates). */
+    layer1: ValidationLoopResult["lspFixer"];
+    layer2: RunMendLoopResult | null;
+    layer4: {
+        stubsApplied: AppliedStub[];
+    } | null;
+    /** USD spent on Layer 2. 0 when Layer 2 didn't run. */
+    totalCostUsd: number;
+    /** Wall-clock total across all layers. */
+    totalLatencyMs: number;
+    /** Remaining diagnostics, grouped by TS code (e.g. `{TS2339: 3}`). */
+    remainingByCode: Record<string, number>;
+    /** Remaining diagnostics, grouped by file path (relative to workspaceRoot). */
+    remainingByFile: Record<string, number>;
+}
+/**
+ * Run the full tsfix stack (Layer 0/1 → Layer 2 → Layer 4) end-to-end.
+ *
+ * @example
+ * ```ts
+ * const result = await runFullStack({
+ *   workspaceRoot: "/path/to/project",
+ *   llm: { provider: "anthropic", model: "claude-haiku-4-5", apiKey: KEY },
+ *   stubOnFailure: true,
+ *   onLayerEvent: (e) => console.log(e),
+ * });
+ * if (!result.passed) { ... }
+ * console.log(`Spent $${result.totalCostUsd.toFixed(4)}`);
+ * ```
+ */
+export declare function runFullStack(opts: RunFullStackOptions): Promise<RunFullStackResult>;

package/dist/types/libraryMigrations.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Library breaking-change registry for Layer 2.
+ *
+ * When an installed dependency has a known migration whose correct fix
+ * differs from tsc's own quick-fix suggestion, this module injects a hint
+ * into the mend prompt so the LLM doesn't blindly follow tsc.
+ *
+ * Empirically grounded — each entry corresponds to a concrete bench case
+ * where, without the hint, both haiku-4-5 and sonnet-4-5 score 0/3
+ * functional+secure and follow tsc's misleading quick-fix; with the hint,
+ * both score 3/3 functional+secure on the same fixture.
+ *
+ * Scope: library MIGRATIONS where tsc's quick-fix is misleading or where
+ * the correct fix requires syntax not present in the source. NOT for
+ * general TS errors — those are tsfix's deterministic Layer 0/1 surface.
+ */
+export interface LibraryMigrationHint {
+    /** Display name, e.g., `"vite-plugin-svgr@^4.0.0"`. Populated by detect. */
+    name: string;
+    /** Instructional text injected into the Layer 2 system prompt. */
+    hint: string;
+}
+interface RegistryEntry {
+    match: {
+        name: string;
+        minMajor?: number;
+        maxMajor?: number;
+    };
+    hint: string;
+}
+/**
+ * Built-in registry. Keep entries SMALL — only patterns where we have
+ * empirical evidence that the model picks the wrong fix without the hint.
+ * Don't lard this up with general advice; that belongs in the system prompt.
+ */
+export declare const BUILT_IN_LIBRARY_MIGRATIONS: RegistryEntry[];
+/**
+ * Read the workspace's package.json, walk dependencies + devDependencies,
+ * return the registry entries whose match rule fires.
+ *
+ * Best-effort: returns `[]` on any failure (missing package.json, parse
+ * error, etc.). Never throws.
+ */
+export declare function detectLibraryMigrations(workspaceRoot: string, registry?: RegistryEntry[]): LibraryMigrationHint[];
+/**
+ * Format an array of hints into a prompt block. Empty input → empty string,
+ * caller can short-circuit.
+ */
+export declare function formatLibraryMigrationsBlock(hints: LibraryMigrationHint[]): string;
+/**
+ * Build the one-line task description from a list of hints. Empty input
+ * → undefined. We've found that putting library names in the
+ * `taskDescription` (the prompt's headline framing) is dramatically more
+ * effective than burying the same content in the body.
+ */
+export declare function formatLibraryMigrationsTaskDescription(hints: LibraryMigrationHint[]): string | undefined;
+export {};

package/dist/types/mendAgent.d.ts

@@ -16,10 +16,17 @@
  */
 import type { MendContext } from "./index.js";
 import { type ApplyResult, type EditBlock } from "./applyEditBlock.js";
+/**
+ * Provider identifier. Each corresponds to one `@ai-sdk/<provider>` adapter
+ * in the Vercel AI SDK. Adding a provider requires (1) the corresponding
+ * `@ai-sdk/X` dep in package.json, (2) a case in `buildLanguageModel`, and
+ * (3) the appropriate API-key env-var name documented in the CLI.
+ */
+export type LLMProvider = "anthropic" | "openai" | "google";
 export interface MendSingleFileOptions {
     context: MendContext;
     llm: {
-        provider: "anthropic";
+        provider: LLMProvider;
         model: string;
         apiKey: string;
     };
@@ -39,6 +46,12 @@ export interface MendSingleFileResult {
 export type LLMCall = (params: {
     systemBlock: string;
     userBlock: string;
+    /**
+     * Provider name. Optional for backward compatibility — when omitted,
+     * the default impl treats it as "anthropic" (matches v0.5.0 behavior).
+     * Test injection points can ignore this field.
+     */
+    provider?: LLMProvider;
     model: string;
     apiKey: string;
 }) => Promise<{

package/dist/types/runMendLoop.d.ts

@@ -22,13 +22,13 @@
  * returns. We can't iterate without writing to disk because re-validation
  * needs the actual file changes.
  */
-import type { Diagnostic, MendContext } from "./index.js";
-import { type LLMCall } from "./mendAgent.js";
+import type { Diagnostic, LayerEvent, MendContext } from "./index.js";
+import { type LLMCall, type LLMProvider } from "./mendAgent.js";
 import { type AppliedStub } from "./stubAndContinue.js";
 export interface RunMendLoopOptions {
     context: MendContext;
     llm: {
-        provider: "anthropic";
+        provider: LLMProvider;
         model: string;
         apiKey: string;
     };
@@ -43,6 +43,13 @@ export interface RunMendLoopOptions {
      * Default false. Ignored when `dryRun: true`.
      */
     stubOnFailure?: boolean;
+    /**
+     * Per-iteration / per-stub telemetry callback. Layer 2 emits one event per
+     * iteration with the dominant error code (`fixed: true` if the iteration
+     * cleared all errors); Layer 4 emits one event per stubbed `(line, code)`
+     * pair. Both forwarded to the same callback. Optional.
+     */
+    onLayerEvent?: (event: LayerEvent) => void;
     /** @internal — LLM call override for tests. */
     _callLLM?: LLMCall;
 }

package/dist/types/tsLanguageServiceFixer.d.ts

@@ -51,6 +51,13 @@ export interface LSPFixerOptions {
      * before letting it modify a workspace.
      */
     dryRun?: boolean;
+    /**
+     * Per-error telemetry callback. One event per `(errorCode, fix-attempt)`
+     * with `fixed: true` when the fix landed and `fixed: false` when the LSP
+     * abstained (no safe candidate). Events fire even on dry runs.
+     * Optional — undefined callback costs nothing.
+     */
+    onLayerEvent?: (event: import("./index.js").LayerEvent) => void;
 }
 export interface LSPFixerResult {
     /** Number of fixes successfully applied across all iterations. */

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@shipispec/tsfix",
-	"version": "0.5.0",
+	"version": "0.6.1",
 	"description": "TypeScript error-recovery for LLM-generated code. Layer 0/1 deterministic auto-fix via the TS Language Service + Layer 2 LLM mend (Vercel AI SDK + Anthropic) in one package.",
 	"keywords": [
 		"typescript",
@@ -65,6 +65,8 @@
 	},
 	"dependencies": {
 		"@ai-sdk/anthropic": "^3.0.44",
+		"@ai-sdk/google": "^3.0.75",
+		"@ai-sdk/openai": "^3.0.64",
 		"ai": "^6.0.86"
 	},
 	"devDependencies": {