@shipispec/tsfix 0.5.0 → 0.6.1

package/dist/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>;