assertloom 0.0.0-stage → 0.2.0

package/dist/ai/openaiCompatible.js

@@ -0,0 +1,62 @@
+import OpenAI from "openai";
+import { zodResponseFormat } from "openai/helpers/zod";
+import { ProviderError } from "./provider.js";
+/**
+ * Any server that speaks the OpenAI Chat Completions API with JSON-schema response formats:
+ * Ollama, LM Studio, vLLM, llama.cpp, OpenRouter, and others.
+ */
+export class OpenAICompatibleProvider {
+    model;
+    baseURL;
+    name = "openai-compatible";
+    client;
+    constructor(model, baseURL, apiKey = process.env.ASSERTLOOM_API_KEY) {
+        this.model = model;
+        this.baseURL = baseURL;
+        if (!model)
+            throw new ProviderError("--provider openai-compatible needs a model: pass --model or set ASSERTLOOM_MODEL.");
+        if (!baseURL) {
+            throw new ProviderError("--provider openai-compatible needs a server URL: pass --base-url or set ASSERTLOOM_BASE_URL (for example http://localhost:11434/v1).");
+        }
+        // Local servers usually ignore the key, but the SDK requires one.
+        this.client = new OpenAI({ apiKey: apiKey || "not-needed", baseURL, timeout: 300_000, maxRetries: 0 });
+    }
+    async generateStructured(request) {
+        let completion;
+        try {
+            completion = await this.client.chat.completions.create({
+                model: this.model,
+                messages: [
+                    { role: "system", content: request.system },
+                    { role: "user", content: request.prompt },
+                ],
+                response_format: zodResponseFormat(request.schema, request.schemaName),
+                max_tokens: request.maxOutputTokens,
+            });
+        }
+        catch (error) {
+            const status = error instanceof OpenAI.APIError ? ` (${error.status ?? "no status"})` : "";
+            throw new ProviderError(`Request to ${this.baseURL} failed${status}: ${error.message}`);
+        }
+        const choice = completion.choices[0];
+        if (choice?.finish_reason === "length")
+            throw new ProviderError("The model's response was cut off (max_tokens).");
+        let json;
+        try {
+            json = JSON.parse(choice?.message.content ?? "");
+        }
+        catch {
+            throw new ProviderError(`${this.model} returned no JSON output. Check that the server supports JSON-schema response formats.`);
+        }
+        const parsed = request.schema.safeParse(json);
+        if (!parsed.success) {
+            throw new ProviderError(`${this.model} returned output that does not match the ${request.schemaName} schema: ${parsed.error.message}`);
+        }
+        return {
+            data: parsed.data,
+            model: completion.model || this.model,
+            usage: { inputTokens: completion.usage?.prompt_tokens ?? 0, outputTokens: completion.usage?.completion_tokens ?? 0 },
+        };
+    }
+}
+//# sourceMappingURL=openaiCompatible.js.map

package/dist/ai/openaiCompatible.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"openaiCompatible.js","sourceRoot":"","sources":["../../src/ai/openaiCompatible.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,QAAQ,CAAC;AAC5B,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAAE,aAAa,EAAqE,MAAM,eAAe,CAAC;AAEjH;;;GAGG;AACH,MAAM,OAAO,wBAAwB;IAKxB,KAAK;IACL,OAAO;IALT,IAAI,GAAG,mBAAmB,CAAC;IACnB,MAAM,CAAS;IAEhC,YACW,KAAa,EACb,OAAe,EACxB,MAAM,GAAuB,OAAO,CAAC,GAAG,CAAC,kBAAkB;qBAFlD,KAAK;uBACL,OAAO;QAGhB,IAAI,CAAC,KAAK;YAAE,MAAM,IAAI,aAAa,CAAC,mFAAmF,CAAC,CAAC;QACzH,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,MAAM,IAAI,aAAa,CAAC,sIAAsI,CAAC,CAAC;QAClK,CAAC;QACD,kEAAkE;QAClE,IAAI,CAAC,MAAM,GAAG,IAAI,MAAM,CAAC,EAAE,MAAM,EAAE,MAAM,IAAI,YAAY,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,CAAC,EAAE,CAAC,CAAC;IACzG,CAAC;IAED,KAAK,CAAC,kBAAkB,CAAI,OAA6B;QACvD,IAAI,UAAU,CAAC;QACf,IAAI,CAAC;YACH,UAAU,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC;gBACrD,KAAK,EAAE,IAAI,CAAC,KAAK;gBACjB,QAAQ,EAAE;oBACR,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,CAAC,MAAM,EAAE;oBAC3C,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,MAAM,EAAE;iBAC1C;gBACD,eAAe,EAAE,iBAAiB,CAAC,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,UAAU,CAAC;gBACtE,UAAU,EAAE,OAAO,CAAC,eAAe;aACpC,CAAC,CAAC;QACL,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,MAAM,GAAG,KAAK,YAAY,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,MAAM,IAAI,WAAW,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;YAC3F,MAAM,IAAI,aAAa,CAAC,cAAc,IAAI,CAAC,OAAO,UAAU,MAAM,KAAM,KAAe,CAAC,OAAO,EAAE,CAAC,CAAC;QACrG,CAAC;QAED,MAAM,MAAM,GAAG,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;QACrC,IAAI,MAAM,EAAE,aAAa,KAAK,QAAQ;YAAE,MAAM,IAAI,aAAa,CAAC,gDAAgD,CAAC,CAAC;QAClH,IAAI,IAAa,CAAC;QAClB,IAAI,CAAC;YACH,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,OAAO,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC;QACnD,CAAC;QAAC,MAAM,CAAC;YACP,MAAM,IAAI,aAAa,CAAC,GAAG,IAAI,CAAC,KAAK,wFAAwF,CAAC,CAAC;QACjI,CAAC;QACD,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;QAC9C,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;YACpB,MAAM,IAAI,aAAa,CAAC,GAAG,IAAI,CAAC,KAAK,4CAA4C,OAAO,CAAC,UAAU,YAAY,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;QACzI,CAAC;QAED,OAAO;YACL,IAAI,EAAE,MAAM,CAAC,IAAI;YACjB,KAAK,EAAE,UAAU,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK;YACrC,KAAK,EAAE,EAAE,WAAW,EAAE,UAAU,CAAC,KAAK,EAAE,aAAa,IAAI,CAAC,EAAE,YAAY,EAAE,UAAU,CAAC,KAAK,EAAE,iBAAiB,IAAI,CAAC,EAAE;SACrH,CAAC;IACJ,CAAC;CACF"}

package/dist/ai/pricing.d.ts

@@ -0,0 +1,38 @@
+import type { TokenUsage } from "./provider.js";
+/**
+ * Standard prices in USD per 1M tokens, checked on 2026-10-31 at https://platform.openai.com/docs/pricing and
+ * https://platform.claude.com/docs/en/about-claude/pricing. Claude Haiku 5.5 is priced for prompts up to 100K tokens.
+ */
+export declare const PRICES_CHECKED = "2026-10-31";
+/** Prices for a model name, including dated snapshots such as `gpt-5.4-mini-2026-03-17` or `claude-haiku-4-5-20251001`. */
+export declare function priceFor(model: string): {
+    input: number;
+    output: number;
+} | undefined;
+export declare function estimateCost(model: string, usage: TokenUsage): number | undefined;
+export declare function formatUsd(amount: number): string;
+/** Without known prices, spending is capped by tokens instead. */
+export declare const UNPRICED_TOKEN_LIMIT = 500000;
+/**
+ * A hard spending limit for one command. Each model call is checked against its worst case
+ * (full prompt plus the maximum output) before it is made. Share one instance to share the limit
+ * across several files.
+ */
+export declare class Budget {
+    readonly model: string;
+    readonly maxUsd: number;
+    /** Token cap used when the model has no known price. */
+    readonly maxTokens: number;
+    readonly usage: TokenUsage;
+    constructor(model: string, maxUsd: number, 
+    /** Token cap used when the model has no known price. */
+    maxTokens?: number);
+    get priced(): boolean;
+    get spentUsd(): number | undefined;
+    /** The limit that applies to this model, for messages. */
+    describeLimit(): string;
+    allows(worstCase: TokenUsage): boolean;
+    add(usage: TokenUsage): void;
+}
+/** Rough upper bound on tokens for a prompt: about 3 characters per token for code. */
+export declare function promptTokens(...parts: string[]): number;

package/dist/ai/pricing.js

@@ -0,0 +1,105 @@
+/**
+ * Standard prices in USD per 1M tokens, checked on 2026-10-31 at https://platform.openai.com/docs/pricing and
+ * https://platform.claude.com/docs/en/about-claude/pricing. Claude Haiku 5.5 is priced for prompts up to 100K tokens.
+ */
+export const PRICES_CHECKED = "2026-10-31";
+const PRICES = {
+    "claude-fable-5-1": { input: 10, output: 50 },
+    "claude-fable-5": { input: 10, output: 50 },
+    "claude-opus-5-5": { input: 4, output: 20 },
+    "claude-opus-5": { input: 5, output: 25 },
+    "claude-opus-4-8": { input: 5, output: 25 },
+    "claude-opus-4-7": { input: 5, output: 25 },
+    "claude-opus-4-6": { input: 5, output: 25 },
+    "claude-opus-4-5": { input: 5, output: 25 },
+    "claude-sonnet-5-5": { input: 2, output: 10 },
+    "claude-sonnet-5": { input: 2, output: 10 },
+    "claude-sonnet-4-6": { input: 3, output: 15 },
+    "claude-sonnet-4-5": { input: 3, output: 15 },
+    "claude-haiku-5-5": { input: 0.1, output: 0.5 },
+    "claude-haiku-4-5": { input: 1, output: 5 },
+    "gpt-6-astra": { input: 10, output: 50 },
+    "gpt-6.1-sol": { input: 2, output: 10 },
+    "gpt-6.1-terra": { input: 1, output: 5 },
+    "gpt-6-luna": { input: 0.1, output: 0.5 },
+    "gpt-6-sol": { input: 2, output: 10 },
+    "gpt-5.6-sol": { input: 4, output: 20 },
+    "gpt-5.6-terra": { input: 2, output: 12 },
+    "gpt-5.6-luna": { input: 0.2, output: 1.2 },
+    "gpt-5.5": { input: 5, output: 30 },
+    "gpt-5.4": { input: 2.5, output: 15 },
+    "gpt-5.4-mini": { input: 0.75, output: 4.5 },
+    "gpt-5.4-nano": { input: 0.2, output: 1.25 },
+    "gpt-5.2": { input: 1.75, output: 14 },
+    "gpt-5.1": { input: 1.25, output: 10 },
+    "gpt-5": { input: 1.25, output: 10 },
+    "gpt-5-mini": { input: 0.25, output: 2 },
+    "gpt-5-nano": { input: 0.05, output: 0.4 },
+    "gpt-4.1": { input: 2, output: 8 },
+    "gpt-4.1-mini": { input: 0.4, output: 1.6 },
+    "gpt-4.1-nano": { input: 0.1, output: 0.4 },
+    "gpt-4o": { input: 2.5, output: 10 },
+    "gpt-4o-mini": { input: 0.15, output: 0.6 },
+};
+/** Prices for a model name, including dated snapshots such as `gpt-5.4-mini-2026-03-17` or `claude-haiku-4-5-20251001`. */
+export function priceFor(model) {
+    if (PRICES[model])
+        return PRICES[model];
+    const snapshot = /^(.*)-(?:\d{4}-\d{2}-\d{2}|\d{8})$/.exec(model);
+    return snapshot ? PRICES[snapshot[1]] : undefined;
+}
+export function estimateCost(model, usage) {
+    const price = priceFor(model);
+    if (!price)
+        return undefined;
+    return (usage.inputTokens * price.input + usage.outputTokens * price.output) / 1_000_000;
+}
+export function formatUsd(amount) {
+    return amount >= 0.01 ? `$${amount.toFixed(2)}` : `$${amount.toFixed(4)}`;
+}
+/** Without known prices, spending is capped by tokens instead. */
+export const UNPRICED_TOKEN_LIMIT = 500_000;
+/**
+ * A hard spending limit for one command. Each model call is checked against its worst case
+ * (full prompt plus the maximum output) before it is made. Share one instance to share the limit
+ * across several files.
+ */
+export class Budget {
+    model;
+    maxUsd;
+    maxTokens;
+    usage = { inputTokens: 0, outputTokens: 0 };
+    constructor(model, maxUsd, 
+    /** Token cap used when the model has no known price. */
+    maxTokens = UNPRICED_TOKEN_LIMIT) {
+        this.model = model;
+        this.maxUsd = maxUsd;
+        this.maxTokens = maxTokens;
+    }
+    get priced() {
+        return priceFor(this.model) !== undefined;
+    }
+    get spentUsd() {
+        return estimateCost(this.model, this.usage);
+    }
+    /** The limit that applies to this model, for messages. */
+    describeLimit() {
+        return this.priced ? formatUsd(this.maxUsd) : `${this.maxTokens.toLocaleString("en-US")} tokens (no known price for ${this.model})`;
+    }
+    allows(worstCase) {
+        const projected = { inputTokens: this.usage.inputTokens + worstCase.inputTokens, outputTokens: this.usage.outputTokens + worstCase.outputTokens };
+        const cost = estimateCost(this.model, projected);
+        if (cost === undefined)
+            return projected.inputTokens + projected.outputTokens <= this.maxTokens;
+        return cost <= this.maxUsd;
+    }
+    add(usage) {
+        this.usage.inputTokens += usage.inputTokens;
+        this.usage.outputTokens += usage.outputTokens;
+    }
+}
+/** Rough upper bound on tokens for a prompt: about 3 characters per token for code. */
+export function promptTokens(...parts) {
+    return Math.ceil(parts.reduce((n, p) => n + p.length, 0) / 3);
+}
+//# sourceMappingURL=pricing.js.map

package/dist/ai/pricing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pricing.js","sourceRoot":"","sources":["../../src/ai/pricing.ts"],"names":[],"mappings":"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"}

package/dist/ai/prompts.d.ts

@@ -0,0 +1,27 @@
+import type { Binding } from "../generator/importPlan.js";
+import type { FileAnalysis } from "../types/index.js";
+export declare const GENERATION_SYSTEM_PROMPT = "You are Assertloom, a tool that writes Jest unit tests for JavaScript and TypeScript code.\n\nFor each target function you are given, return test cases. Each case has a short name (the `it` title), a category, and a body: the statements that go inside the test callback.\n\nRules:\n- Call target functions only through the binding names listed. They are already imported; Assertloom writes the imports, describe blocks, and it() wrappers.\n- Do not write import or require statements, describe/it/test wrappers, or jest.mock calls.\n- Assert the behavior of the source as written. Work out expected values by reading the code; never guess. If you cannot be sure of an exact value, assert something you can verify (type, length, ordering, a relationship between outputs).\n- Tests must be deterministic: no real network or file system access, real timers, Date.now(), or Math.random().\n- Dependencies listed under \"Mocks\" are already mocked by Assertloom and reset before every test, so every jest.fn() returns undefined until the test configures it. In each test, set up exactly what the code path needs with mockResolvedValue, mockRejectedValue, mockReturnValue, mockReturnValueOnce, or mockImplementation. In TypeScript, wrap mocks with jest.mocked(...) and cast fake values with `as any` when they are partial.\n- Shape fake values like the real API the source expects (for example, fetch responses need `ok`, `status`, and `json: async () => data`).\n- Where it matters, assert how dependencies were called with toHaveBeenCalledWith or toHaveBeenCalledTimes.\n- Functions in the source call each other directly, so spying on them has no effect, and `module.exports`/`exports` in a test refer to the test file itself. Control behavior through the mocked dependencies and real inputs instead.\n- Tests must pass on every operating system. Never hardcode path separators in expected values; build expected paths with the same functions the source uses (such as path.join, when it is imported in the test file) or use expect.stringContaining.\n- For async functions, use await, or await expect(...).rejects for rejections.\n- Use toBeCloseTo for floating-point results and toEqual for objects and arrays.\n- For generators, collect values with Array.from() or spread syntax.\n- In TypeScript, arguments must match the declared parameter types. If an error case needs an invalid argument, cast it with `as any`.\n- Cover each function with normal cases (typical input) and edge cases (empty values, zero, negative numbers, boundaries, unicode where relevant). Add error cases when the source throws or rejects, using toThrow / rejects.toThrow and matching the message when the source shows it.\n- For functions that use mocked dependencies, also cover failure paths: make the dependency reject or return an error result, then assert what the source does (rejects with its own message, rethrows, or falls back to a default).\n- Write 3 to 6 cases per function. Each case should check one behavior with a few focused expect() calls.";
+export declare const REPAIR_SYSTEM_PROMPT = "You are Assertloom, a tool that repairs failing Jest tests it generated. You cannot change the source code; only the tests.\n\nFor each failing test you are given, return exactly one repair with one of these actions:\n- fix: the test is wrong (a miscalculated expected value, a wrong assumption about behavior, a missing await, a mock that was not configured or returns the wrong shape \u2014 \"Cannot read properties of undefined\" often means a mock still returns undefined). Return a corrected body that keeps testing the same behavior, with expected values derived from the source.\n- skip: the test's expectation matches what the function clearly intends (its name, documentation, or error messages), but the source does something else. This is likely a bug in the source; do not rewrite the test to match buggy behavior. Explain the suspected bug in the reason.\n- remove: the test cannot be made deterministic or tests something outside the function.\n\nPrefer fix. Use the failure message: \"Expected\"/\"Received\" lines show what the code actually returned.\n\nBody rules for fix:\n- Call target functions only through the binding names listed. They are already imported; Assertloom writes the imports, describe blocks, and it() wrappers.\n- Do not write import or require statements, describe/it/test wrappers, or jest.mock calls.\n- Assert the behavior of the source as written. Work out expected values by reading the code; never guess. If you cannot be sure of an exact value, assert something you can verify (type, length, ordering, a relationship between outputs).\n- Tests must be deterministic: no real network or file system access, real timers, Date.now(), or Math.random().\n- Dependencies listed under \"Mocks\" are already mocked by Assertloom and reset before every test, so every jest.fn() returns undefined until the test configures it. In each test, set up exactly what the code path needs with mockResolvedValue, mockRejectedValue, mockReturnValue, mockReturnValueOnce, or mockImplementation. In TypeScript, wrap mocks with jest.mocked(...) and cast fake values with `as any` when they are partial.\n- Shape fake values like the real API the source expects (for example, fetch responses need `ok`, `status`, and `json: async () => data`).\n- Where it matters, assert how dependencies were called with toHaveBeenCalledWith or toHaveBeenCalledTimes.\n- Functions in the source call each other directly, so spying on them has no effect, and `module.exports`/`exports` in a test refer to the test file itself. Control behavior through the mocked dependencies and real inputs instead.\n- Tests must pass on every operating system. Never hardcode path separators in expected values; build expected paths with the same functions the source uses (such as path.join, when it is imported in the test file) or use expect.stringContaining.\n- For async functions, use await, or await expect(...).rejects for rejections.\n- Use toBeCloseTo for floating-point results and toEqual for objects and arrays.\n- For generators, collect values with Array.from() or spread syntax.\n- In TypeScript, arguments must match the declared parameter types. If an error case needs an invalid argument, cast it with `as any`.";
+export interface GenerationPromptInput {
+    analysis: FileAnalysis;
+    code: string;
+    bindings: Binding[];
+    testFileName: string;
+    mockSummary?: string;
+}
+export declare function buildGenerationPrompt({ analysis, code, bindings, testFileName, mockSummary }: GenerationPromptInput): string;
+export declare const MAX_FAILURE_MESSAGE_CHARS = 1200;
+export interface RepairTarget {
+    binding: Binding;
+    testName: string;
+    body: string;
+    failureCategory: string;
+    message: string;
+}
+export declare function buildRepairPrompt(input: {
+    analysis: FileAnalysis;
+    code: string;
+    targets: RepairTarget[];
+    attempt: number;
+    mockSummary?: string;
+}): string;

package/dist/ai/prompts.js

@@ -0,0 +1,89 @@
+import { formatSignature } from "../analyzer/format.js";
+const BODY_RULES = `- Call target functions only through the binding names listed. They are already imported; Assertloom writes the imports, describe blocks, and it() wrappers.
+- Do not write import or require statements, describe/it/test wrappers, or jest.mock calls.
+- Assert the behavior of the source as written. Work out expected values by reading the code; never guess. If you cannot be sure of an exact value, assert something you can verify (type, length, ordering, a relationship between outputs).
+- Tests must be deterministic: no real network or file system access, real timers, Date.now(), or Math.random().
+- Dependencies listed under "Mocks" are already mocked by Assertloom and reset before every test, so every jest.fn() returns undefined until the test configures it. In each test, set up exactly what the code path needs with mockResolvedValue, mockRejectedValue, mockReturnValue, mockReturnValueOnce, or mockImplementation. In TypeScript, wrap mocks with jest.mocked(...) and cast fake values with \`as any\` when they are partial.
+- Shape fake values like the real API the source expects (for example, fetch responses need \`ok\`, \`status\`, and \`json: async () => data\`).
+- Where it matters, assert how dependencies were called with toHaveBeenCalledWith or toHaveBeenCalledTimes.
+- Functions in the source call each other directly, so spying on them has no effect, and \`module.exports\`/\`exports\` in a test refer to the test file itself. Control behavior through the mocked dependencies and real inputs instead.
+- Tests must pass on every operating system. Never hardcode path separators in expected values; build expected paths with the same functions the source uses (such as path.join, when it is imported in the test file) or use expect.stringContaining.
+- For async functions, use await, or await expect(...).rejects for rejections.
+- Use toBeCloseTo for floating-point results and toEqual for objects and arrays.
+- For generators, collect values with Array.from() or spread syntax.
+- In TypeScript, arguments must match the declared parameter types. If an error case needs an invalid argument, cast it with \`as any\`.`;
+export const GENERATION_SYSTEM_PROMPT = `You are Assertloom, a tool that writes Jest unit tests for JavaScript and TypeScript code.
+
+For each target function you are given, return test cases. Each case has a short name (the \`it\` title), a category, and a body: the statements that go inside the test callback.
+
+Rules:
+${BODY_RULES}
+- Cover each function with normal cases (typical input) and edge cases (empty values, zero, negative numbers, boundaries, unicode where relevant). Add error cases when the source throws or rejects, using toThrow / rejects.toThrow and matching the message when the source shows it.
+- For functions that use mocked dependencies, also cover failure paths: make the dependency reject or return an error result, then assert what the source does (rejects with its own message, rethrows, or falls back to a default).
+- Write 3 to 6 cases per function. Each case should check one behavior with a few focused expect() calls.`;
+export const REPAIR_SYSTEM_PROMPT = `You are Assertloom, a tool that repairs failing Jest tests it generated. You cannot change the source code; only the tests.
+
+For each failing test you are given, return exactly one repair with one of these actions:
+- fix: the test is wrong (a miscalculated expected value, a wrong assumption about behavior, a missing await, a mock that was not configured or returns the wrong shape — "Cannot read properties of undefined" often means a mock still returns undefined). Return a corrected body that keeps testing the same behavior, with expected values derived from the source.
+- skip: the test's expectation matches what the function clearly intends (its name, documentation, or error messages), but the source does something else. This is likely a bug in the source; do not rewrite the test to match buggy behavior. Explain the suspected bug in the reason.
+- remove: the test cannot be made deterministic or tests something outside the function.
+
+Prefer fix. Use the failure message: "Expected"/"Received" lines show what the code actually returned.
+
+Body rules for fix:
+${BODY_RULES}`;
+function mocksSection(mockSummary) {
+    return mockSummary ? `\nMocks (already set up in the test file):\n${mockSummary}\n` : "\nMocks: none. The source has no dependencies that need mocking.\n";
+}
+export function buildGenerationPrompt({ analysis, code, bindings, testFileName, mockSummary }) {
+    const language = analysis.language === "typescript" ? "typescript" : "javascript";
+    const targets = bindings
+        .map(({ binding, fn }) => {
+        const notes = [
+            binding !== fn.name ? `declared as \`${fn.name}\` in the source` : "",
+            fn.throws ? "throws in its own body" : "",
+            `defined at line ${fn.line}`,
+        ].filter(Boolean);
+        return `- \`${binding}\`: \`${formatSignature(fn, binding)}\` (${notes.join("; ")})`;
+    })
+        .join("\n");
+    return `Write Jest tests for the target functions in \`${analysis.file}\`.
+
+Test file: \`${testFileName}\` (${language}, Jest globals available)
+
+Target functions (use these binding names exactly):
+${targets}
+${mocksSection(mockSummary)}
+Source of \`${analysis.file}\`:
+\`\`\`${language}
+${code}
+\`\`\``;
+}
+export const MAX_FAILURE_MESSAGE_CHARS = 1200;
+export function buildRepairPrompt(input) {
+    const language = input.analysis.language === "typescript" ? "typescript" : "javascript";
+    const failures = input.targets
+        .map((t, i) => {
+        const message = t.message.length > MAX_FAILURE_MESSAGE_CHARS ? `${t.message.slice(0, MAX_FAILURE_MESSAGE_CHARS)}\n…(truncated)` : t.message;
+        return `### ${i + 1}. \`${t.binding.binding}\` › ${JSON.stringify(t.testName)}
+Signature: \`${formatSignature(t.binding.fn, t.binding.binding)}\`
+Failure (${t.failureCategory}):
+\`\`\`
+${message}
+\`\`\`
+Current body:
+\`\`\`${language}
+${t.body}
+\`\`\``;
+    })
+        .join("\n\n");
+    return `Repair attempt ${input.attempt}: ${input.targets.length} generated test${input.targets.length === 1 ? "" : "s"} in the tests for \`${input.analysis.file}\` failed.
+
+${failures}
+${mocksSection(input.mockSummary)}
+Source of \`${input.analysis.file}\` (read-only):
+\`\`\`${language}
+${input.code}
+\`\`\``;
+}
+//# sourceMappingURL=prompts.js.map

package/dist/ai/prompts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompts.js","sourceRoot":"","sources":["../../src/ai/prompts.ts"],"names":[],"mappings":"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"}

package/dist/ai/provider.d.ts

@@ -0,0 +1,26 @@
+import type { z } from "zod";
+import { UserError } from "../errors.js";
+export declare class ProviderError extends UserError {
+}
+export interface StructuredRequest<T> {
+    system: string;
+    prompt: string;
+    schema: z.ZodType<T>;
+    schemaName: string;
+    maxOutputTokens: number;
+}
+export interface TokenUsage {
+    inputTokens: number;
+    outputTokens: number;
+}
+export interface StructuredResponse<T> {
+    data: T;
+    model: string;
+    usage: TokenUsage;
+}
+/** A model that returns JSON validated against a Zod schema. Implement this to add a provider. */
+export interface LLMProvider {
+    readonly name: string;
+    readonly model: string;
+    generateStructured<T>(request: StructuredRequest<T>): Promise<StructuredResponse<T>>;
+}

package/dist/ai/provider.js

@@ -0,0 +1,4 @@
+import { UserError } from "../errors.js";
+export class ProviderError extends UserError {
+}
+//# sourceMappingURL=provider.js.map

package/dist/ai/provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.js","sourceRoot":"","sources":["../../src/ai/provider.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzC,MAAM,OAAO,aAAc,SAAQ,SAAS;CAAG"}

package/dist/ai/redact.d.ts

@@ -0,0 +1,5 @@
+/** Replaces likely credentials with a placeholder before code leaves the machine. */
+export declare function redactSecrets(code: string): {
+    code: string;
+    redactions: number;
+};

package/dist/ai/redact.js

@@ -0,0 +1,31 @@
+const SECRET_PATTERNS = [
+    /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g,
+    /\bsk-(?:proj-|ant-)?[A-Za-z0-9_-]{20,}/g,
+    /\b(?:sk|rk|pk)_(?:live|test)_[A-Za-z0-9]{16,}/g,
+    /\bBearer\s+[A-Za-z0-9._~+/-]{16,}=*/g,
+    /\b(?:AKIA|ASIA)[A-Z0-9]{16}\b/g,
+    /\bgh[pousr]_[A-Za-z0-9]{36,}\b/g,
+    /\bxox[abprs]-[A-Za-z0-9-]{10,}/g,
+    /\bAIza[0-9A-Za-z_-]{35}\b/g,
+    /\b[a-z][a-z0-9+.-]*:\/\/[^\s:/@'"`]+:[^\s@'"`]+@/gi,
+];
+const ASSIGNED_SECRET = /\b([A-Za-z0-9_]*(?:secret|password|passwd|api_?key|token|credential|authorization)[A-Za-z0-9_]*["']?\s*(?:[:=]|===?|!==?)\s*)(["'`])((?:(?!\2)[^\n\\]|\\.){8,})\2/gi;
+/** Replaces likely credentials with a placeholder before code leaves the machine. */
+export function redactSecrets(code) {
+    let redactions = 0;
+    let result = code;
+    for (const pattern of SECRET_PATTERNS) {
+        result = result.replace(pattern, () => {
+            redactions++;
+            return "<redacted>";
+        });
+    }
+    result = result.replace(ASSIGNED_SECRET, (match, prefix, quote, value) => {
+        if (value.includes("<redacted>"))
+            return match;
+        redactions++;
+        return `${prefix}${quote}<redacted>${quote}`;
+    });
+    return { code: result, redactions };
+}
+//# sourceMappingURL=redact.js.map

package/dist/ai/redact.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"redact.js","sourceRoot":"","sources":["../../src/ai/redact.ts"],"names":[],"mappings":"AAAA,MAAM,eAAe,GAAa;IAChC,6EAA6E;IAC7E,yCAAyC;IACzC,gDAAgD;IAChD,sCAAsC;IACtC,gCAAgC;IAChC,iCAAiC;IACjC,iCAAiC;IACjC,4BAA4B;IAC5B,oDAAoD;CACrD,CAAC;AAEF,MAAM,eAAe,GACnB,qKAAqK,CAAC;AAExK,qFAAqF;AACrF,MAAM,UAAU,aAAa,CAAC,IAAY;IACxC,IAAI,UAAU,GAAG,CAAC,CAAC;IACnB,IAAI,MAAM,GAAG,IAAI,CAAC;IAElB,KAAK,MAAM,OAAO,IAAI,eAAe,EAAE,CAAC;QACtC,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,GAAG,EAAE;YACpC,UAAU,EAAE,CAAC;YACb,OAAO,YAAY,CAAC;QACtB,CAAC,CAAC,CAAC;IACL,CAAC;IAED,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,eAAe,EAAE,CAAC,KAAK,EAAE,MAAc,EAAE,KAAa,EAAE,KAAa,EAAE,EAAE;QAC/F,IAAI,KAAK,CAAC,QAAQ,CAAC,YAAY,CAAC;YAAE,OAAO,KAAK,CAAC;QAC/C,UAAU,EAAE,CAAC;QACb,OAAO,GAAG,MAAM,GAAG,KAAK,aAAa,KAAK,EAAE,CAAC;IAC/C,CAAC,CAAC,CAAC;IAEH,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC;AACtC,CAAC"}

package/dist/analyzer/dependencies.d.ts

@@ -0,0 +1,16 @@
+import type { File, Node } from "@babel/types";
+import type { DependencySummary, ImportCategory, ImportInfo } from "../types/index.js";
+export interface ImportScan {
+    imports: ImportInfo[];
+    /** Top-level runtime bindings created by imports, keyed by local name. */
+    bindings: Map<string, string>;
+    /** `require()` and `import()` call nodes, mapped to the module they load. */
+    callSites: Map<Node, string>;
+    usesCommonJsExports: boolean;
+}
+export declare function classifySource(source: string): {
+    category: ImportCategory;
+    packageName?: string;
+};
+export declare function scanImports(ast: File): ImportScan;
+export declare function summarizeDependencies(imports: ImportInfo[]): DependencySummary;

package/dist/analyzer/dependencies.js

@@ -0,0 +1,168 @@
+import { builtinModules } from "node:module";
+import traverse from "@babel/traverse";
+export function classifySource(source) {
+    if (source.startsWith(".") || source.startsWith("/") || source.startsWith("#")) {
+        return { category: "local" };
+    }
+    if (source.startsWith("node:") || builtinModules.includes(source)) {
+        return { category: "builtin" };
+    }
+    const segments = source.split("/");
+    const packageName = source.startsWith("@") ? segments.slice(0, 2).join("/") : segments[0];
+    return { category: "external", packageName };
+}
+function stringValue(node) {
+    if (node?.type === "StringLiteral")
+        return node.value;
+    if (node?.type === "TemplateLiteral" && node.expressions.length === 0)
+        return node.quasis[0].value.cooked ?? undefined;
+    return undefined;
+}
+function moduleName(node) {
+    return node.type === "StringLiteral" ? node.value : node.type === "Identifier" ? node.name : "";
+}
+function isRequireCall(path) {
+    const callee = path.node.callee;
+    return callee.type === "Identifier" && callee.name === "require" && !path.scope.hasBinding("require");
+}
+function isCommonJsExportTarget(node) {
+    if (node.type !== "MemberExpression")
+        return false;
+    if (node.object.type === "Identifier") {
+        return (node.object.name === "exports" ||
+            (node.object.name === "module" && node.property.type === "Identifier" && node.property.name === "exports"));
+    }
+    return isCommonJsExportTarget(node.object);
+}
+export function scanImports(ast) {
+    const imports = [];
+    const bindings = new Map();
+    const callSites = new Map();
+    let usesCommonJsExports = false;
+    const add = (source, info) => {
+        imports.push({ source, ...classifySource(source), ...info });
+    };
+    traverse(ast, {
+        ImportDeclaration(path) {
+            const node = path.node;
+            const source = node.source.value;
+            const typeOnly = node.importKind === "type" ||
+                (node.specifiers.length > 0 && node.specifiers.every((s) => s.type === "ImportSpecifier" && s.importKind === "type"));
+            const specifiers = node.specifiers.map((s) => {
+                if (s.type === "ImportDefaultSpecifier")
+                    return { kind: "default", imported: "default", local: s.local.name };
+                if (s.type === "ImportNamespaceSpecifier")
+                    return { kind: "namespace", imported: "*", local: s.local.name };
+                return { kind: "named", imported: moduleName(s.imported), local: s.local.name };
+            });
+            if (!typeOnly) {
+                for (const s of node.specifiers) {
+                    if (s.type === "ImportSpecifier" && s.importKind === "type")
+                        continue;
+                    bindings.set(s.local.name, source);
+                }
+            }
+            add(source, { kind: "import", typeOnly, specifiers, line: node.loc?.start.line ?? 0 });
+        },
+        ExportNamedDeclaration(path) {
+            const node = path.node;
+            if (!node.source)
+                return;
+            const specifiers = node.specifiers.map((s) => s.type === "ExportNamespaceSpecifier"
+                ? { kind: "namespace", imported: "*", local: moduleName(s.exported) }
+                : { kind: "named", imported: moduleName(s.type === "ExportSpecifier" ? s.local : s.exported), local: moduleName(s.exported) });
+            add(node.source.value, {
+                kind: "re-export",
+                typeOnly: node.exportKind === "type",
+                specifiers,
+                line: node.loc?.start.line ?? 0,
+            });
+        },
+        ExportAllDeclaration(path) {
+            const node = path.node;
+            add(node.source.value, {
+                kind: "re-export",
+                typeOnly: node.exportKind === "type",
+                specifiers: [{ kind: "namespace", imported: "*", local: "*" }],
+                line: node.loc?.start.line ?? 0,
+            });
+        },
+        ImportExpression(path) {
+            const source = stringValue(path.node.source);
+            if (!source)
+                return;
+            callSites.set(path.node, source);
+            add(source, { kind: "dynamic-import", typeOnly: false, specifiers: [], line: path.node.loc?.start.line ?? 0 });
+        },
+        CallExpression(path) {
+            if (!isRequireCall(path))
+                return;
+            const source = stringValue(path.node.arguments[0]);
+            if (!source)
+                return;
+            callSites.set(path.node, source);
+            const specifiers = [];
+            const declarator = path.parentPath;
+            if (declarator.isVariableDeclarator() && declarator.node.init === path.node) {
+                const id = declarator.node.id;
+                if (id.type === "Identifier") {
+                    specifiers.push({ kind: "namespace", imported: "*", local: id.name });
+                }
+                else if (id.type === "ObjectPattern") {
+                    for (const prop of id.properties) {
+                        if (prop.type === "ObjectProperty" && prop.value.type === "Identifier") {
+                            specifiers.push({ kind: "named", imported: moduleName(prop.key), local: prop.value.name });
+                        }
+                    }
+                }
+                if (path.scope.getProgramParent() === path.scope) {
+                    for (const s of specifiers)
+                        bindings.set(s.local, source);
+                }
+            }
+            add(source, { kind: "require", typeOnly: false, specifiers, line: path.node.loc?.start.line ?? 0 });
+        },
+        AssignmentExpression(path) {
+            if (isCommonJsExportTarget(path.node.left))
+                usesCommonJsExports = true;
+        },
+        // `const client = new PrismaClient()` makes `client` a stand-in for "@prisma/client".
+        VariableDeclarator(path) {
+            const { id, init } = path.node;
+            if (id.type !== "Identifier" || !init || path.scope !== path.scope.getProgramParent())
+                return;
+            if (init.type === "ArrowFunctionExpression" || init.type === "FunctionExpression")
+                return;
+            const programScope = path.scope;
+            path.traverse({
+                Identifier(idPath) {
+                    if (bindings.has(id.name) || !idPath.isReferencedIdentifier())
+                        return;
+                    const source = bindings.get(idPath.node.name);
+                    if (source && idPath.scope.getBinding(idPath.node.name) === programScope.getBinding(idPath.node.name)) {
+                        bindings.set(id.name, source);
+                    }
+                },
+            });
+        },
+    });
+    imports.sort((a, b) => a.line - b.line);
+    return { imports, bindings, callSites, usesCommonJsExports };
+}
+export function summarizeDependencies(imports) {
+    const local = new Set();
+    const external = new Set();
+    const builtin = new Set();
+    for (const entry of imports) {
+        if (entry.typeOnly)
+            continue;
+        if (entry.category === "local")
+            local.add(entry.source);
+        else if (entry.category === "builtin")
+            builtin.add(entry.source.replace(/^node:/, ""));
+        else if (entry.packageName)
+            external.add(entry.packageName);
+    }
+    return { local: [...local].sort(), external: [...external].sort(), builtin: [...builtin].sort() };
+}
+//# sourceMappingURL=dependencies.js.map