@untestutils/ai 0.5.0

package/dist/tools/browser.mjs

@@ -0,0 +1,146 @@
+
+export function createBrowserTools(opts = {}) {
+	let browser;
+	let page;
+	async function ensurePage() {
+		if (page) return page;
+		const { chromium } = await import("playwright-core");
+		browser = await chromium.launch({ headless: opts.headless ?? true });
+		const context = await browser.newContext(opts.baseURL ? { baseURL: opts.baseURL } : undefined);
+		page = await context.newPage();
+		return page;
+	}
+	async function dispose() {
+		await page?.context().close().catch(() => {});
+		await browser?.close().catch(() => {});
+		page = undefined;
+		browser = undefined;
+	}
+	return {
+		readPaths: () => [],
+		dispose,
+		tools: [
+			{
+				name: "browser_goto",
+				description: "Navigate the Playwright page to a path or absolute URL. Uses baseURL when path is relative.",
+				inputSchema: {
+					type: "object",
+					properties: { url: {
+						type: "string",
+						description: "Path or absolute URL"
+					} },
+					required: ["url"]
+				},
+				execute: async (args) => {
+					const p = await ensurePage();
+					const res = await p.goto(String(args.url), { waitUntil: "domcontentloaded" });
+					return {
+						ok: Boolean(res && res.ok()),
+						status: res?.status() ?? null,
+						url: p.url(),
+						title: await p.title()
+					};
+				}
+			},
+			{
+				name: "browser_snapshot",
+				description: "Accessibility snapshot of the current page (roles, names, text) — preferred over raw HTML for test authoring.",
+				inputSchema: {
+					type: "object",
+					properties: {}
+				},
+				execute: async () => {
+					const p = await ensurePage();
+					const snapshot = await p.locator("body").ariaSnapshot().catch(async () => {
+						const text = await p.innerText("body").catch(() => "");
+						return text.slice(0, 8e3);
+					});
+					return {
+						url: p.url(),
+						title: await p.title(),
+						snapshot
+					};
+				}
+			},
+			{
+				name: "browser_content",
+				description: "Return truncated HTML or visible text of the current page.",
+				inputSchema: {
+					type: "object",
+					properties: {
+						mode: {
+							type: "string",
+							description: "\"text\" (default) or \"html\""
+						},
+						maxChars: {
+							type: "string",
+							description: "Max characters (default 12000)"
+						}
+					}
+				},
+				execute: async (args) => {
+					const p = await ensurePage();
+					const max = Number(args.maxChars ?? 12e3);
+					const mode = String(args.mode ?? "text");
+					const raw = mode === "html" ? await p.content() : await p.innerText("body").catch(() => "");
+					return {
+						url: p.url(),
+						content: raw.slice(0, max)
+					};
+				}
+			},
+			{
+				name: "browser_click",
+				description: "Click an element by CSS selector or role=name (e.g. role=button[name=Save]).",
+				inputSchema: {
+					type: "object",
+					properties: {
+						selector: {
+							type: "string",
+							description: "CSS selector"
+						},
+						role: {
+							type: "string",
+							description: "ARIA role"
+						},
+						name: {
+							type: "string",
+							description: "Accessible name when using role"
+						}
+					}
+				},
+				execute: async (args) => {
+					const p = await ensurePage();
+					if (args.role) {
+						await p.getByRole(String(args.role), { name: args.name ? String(args.name) : undefined }).click();
+					} else if (args.selector) {
+						await p.locator(String(args.selector)).click();
+					} else {
+						throw new Error("Provide selector or role");
+					}
+					return {
+						ok: true,
+						url: p.url()
+					};
+				}
+			},
+			{
+				name: "browser_eval",
+				description: "Evaluate a small JS expression in the page (return JSON-serializable value).",
+				inputSchema: {
+					type: "object",
+					properties: { expression: {
+						type: "string",
+						description: "JS expression"
+					} },
+					required: ["expression"]
+				},
+				execute: async (args) => {
+					const p = await ensurePage();
+					const value = await p.evaluate(String(args.expression));
+					return { value };
+				}
+			}
+		]
+	};
+}

package/dist/tools/fs.d.ts

@@ -0,0 +1,16 @@
+import type { AgentToolBag } from '../agent/types';
+export declare function createFsTools(root: string, limits: {
+    maxFilesRead: number;
+    maxBytesTotal: number;
+}): AgentToolBag;
+/** Back-compat wrapper used by older call sites */
+export declare function createAiTools(root: string, limits: {
+    maxFilesRead: number;
+    maxBytesTotal: number;
+}): {
+    readPaths: () => string[];
+    list_dir: (path?: string) => Promise<unknown>;
+    read_file: (path: string) => Promise<unknown>;
+    grep: (pattern: string, path?: string) => Promise<unknown>;
+};
+//# sourceMappingURL=fs.d.ts.map

package/dist/tools/fs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs.d.ts","sourceRoot":"","sources":["../../src/tools/fs.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAQnD,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,GACtD,YAAY,CAmGd;AAED,mDAAmD;AACnD,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE;;sBAMnC,MAAM;sBACN,MAAM;oBACR,MAAM,SAAS,MAAM;EAExC"}

package/dist/tools/fs.mjs

@@ -0,0 +1,132 @@
+import { readdir, readFile } from "node:fs/promises";
+import { join, relative, resolve, sep } from "pathe";
+import { IGNORE } from "../tree.mjs";
+function redact(content) {
+	return content.replace(/(api[_-]?key|token|password|secret)\s*[:=]\s*['"][^'"]+['"]/gi, "$1: \"***\"").replace(/Bearer\s+[A-Za-z0-9._-]+/g, "Bearer ***");
+}
+export function createFsTools(root, limits) {
+	const absRoot = resolve(root);
+	let filesRead = 0;
+	let bytes = 0;
+	const readPaths = [];
+	function assertInside(rel) {
+		const full = resolve(absRoot, rel);
+		if (!full.startsWith(absRoot + sep) && full !== absRoot) {
+			throw new Error(`path escapes root: ${rel}`);
+		}
+		return full;
+	}
+	const list_dir = async (path = ".") => {
+		const full = assertInside(path);
+		const entries = await readdir(full, { withFileTypes: true });
+		return entries.filter((e) => !IGNORE.has(e.name)).map((e) => ({
+			name: e.name,
+			type: e.isDirectory() ? "dir" : "file"
+		}));
+	};
+	const read_file = async (path) => {
+		if (filesRead >= limits.maxFilesRead) throw new Error("maxFilesRead exceeded");
+		const full = assertInside(path);
+		if (full.includes(`${sep}.env`) || /secret|credential/i.test(full)) {
+			throw new Error("denied path");
+		}
+		const content = await readFile(full, "utf8");
+		if (bytes + content.length > limits.maxBytesTotal) throw new Error("maxBytesTotal exceeded");
+		filesRead++;
+		bytes += content.length;
+		readPaths.push(path);
+		return redact(content);
+	};
+	const grep = async (pattern, path = ".") => {
+		const full = assertInside(path);
+		const re = new RegExp(pattern);
+		const hits = [];
+		async function walk(dir) {
+			if (hits.length >= 50) return;
+			const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+			for (const e of entries) {
+				if (IGNORE.has(e.name)) continue;
+				const p = join(dir, e.name);
+				if (e.isDirectory()) await walk(p);
+				else if (e.isFile()) {
+					const text = await readFile(p, "utf8").catch(() => "");
+					const lines = text.split("\n");
+					lines.forEach((line, i) => {
+						if (hits.length < 50 && re.test(line)) {
+							hits.push({
+								file: relative(absRoot, p),
+								line: i + 1,
+								text: line.slice(0, 200)
+							});
+						}
+					});
+				}
+			}
+		}
+		await walk(full);
+		return hits;
+	};
+	return {
+		readPaths: () => readPaths,
+		tools: [
+			{
+				name: "list_dir",
+				description: "List directory under project root",
+				inputSchema: {
+					type: "object",
+					properties: { path: {
+						type: "string",
+						description: "Relative directory"
+					} }
+				},
+				execute: async (args) => list_dir(String(args.path ?? "."))
+			},
+			{
+				name: "read_file",
+				description: "Read a file under project root",
+				inputSchema: {
+					type: "object",
+					properties: { path: {
+						type: "string",
+						description: "Relative file path"
+					} },
+					required: ["path"]
+				},
+				execute: async (args) => read_file(String(args.path))
+			},
+			{
+				name: "grep",
+				description: "Search files for a regex pattern",
+				inputSchema: {
+					type: "object",
+					properties: {
+						pattern: {
+							type: "string",
+							description: "Regex"
+						},
+						path: {
+							type: "string",
+							description: "Relative start path"
+						}
+					},
+					required: ["pattern"]
+				},
+				execute: async (args) => grep(String(args.pattern), args.path ? String(args.path) : ".")
+			}
+		]
+	};
+}
+
+export function createAiTools(root, limits) {
+	const bag = createFsTools(root, limits);
+	const byName = Object.fromEntries(bag.tools.map((t) => [t.name, t]));
+	return {
+		readPaths: bag.readPaths,
+		list_dir: (path) => byName.list_dir.execute({ path }),
+		read_file: (path) => byName.read_file.execute({ path }),
+		grep: (pattern, path) => byName.grep.execute({
+			pattern,
+			path
+		})
+	};
+}

package/dist/tools/registry.d.mts

@@ -0,0 +1,15 @@
+import type { AgentToolBag } from "../agent/types.mjs";
+export interface CreateAgentToolkitOptions {
+	root: string;
+	maxFilesRead?: number;
+	maxBytesTotal?: number;
+	/** Enable Playwright page tools */
+	browser?: boolean | {
+		baseURL?: string;
+		headless?: boolean;
+	};
+}
+/**
+* Shared toolkit used by AI workflows (generate / convert / fix / cover).
+*/
+export declare function createAgentToolkit(opts: CreateAgentToolkitOptions): AgentToolBag;

package/dist/tools/registry.d.ts

@@ -0,0 +1,16 @@
+import type { AgentToolBag } from '../agent/types';
+export interface CreateAgentToolkitOptions {
+    root: string;
+    maxFilesRead?: number;
+    maxBytesTotal?: number;
+    /** Enable Playwright page tools */
+    browser?: boolean | {
+        baseURL?: string;
+        headless?: boolean;
+    };
+}
+/**
+ * Shared toolkit used by AI workflows (generate / convert / fix / cover).
+ */
+export declare function createAgentToolkit(opts: CreateAgentToolkitOptions): AgentToolBag;
+//# sourceMappingURL=registry.d.ts.map

package/dist/tools/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/tools/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAa,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAI9D,MAAM,WAAW,yBAAyB;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,mCAAmC;IACnC,OAAO,CAAC,EAAE,OAAO,GAAG;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;CAC9D;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,yBAAyB,GAAG,YAAY,CAoBhF"}

package/dist/tools/registry.mjs

@@ -0,0 +1,22 @@
+import { createFsTools } from "./fs.mjs";
+import { createBrowserTools } from "./browser.mjs";
+
+export function createAgentToolkit(opts) {
+	const fsBag = createFsTools(opts.root, {
+		maxFilesRead: opts.maxFilesRead ?? 30,
+		maxBytesTotal: opts.maxBytesTotal ?? 3e5
+	});
+	const bags = [fsBag];
+	if (opts.browser) {
+		const browserOpts = typeof opts.browser === "object" ? opts.browser : {};
+		bags.push(createBrowserTools(browserOpts));
+	}
+	const tools = bags.flatMap((b) => b.tools);
+	return {
+		tools,
+		readPaths: () => bags.flatMap((b) => b.readPaths()),
+		dispose: async () => {
+			for (const b of bags) await b.dispose?.();
+		}
+	};
+}

package/dist/tree.d.ts

@@ -0,0 +1,18 @@
+import { readdir } from 'node:fs/promises';
+export declare const IGNORE: Set<string>;
+export interface FileTreeEntry {
+    path: string;
+    size: number;
+}
+export declare function buildFileTree(root: string, maxEntries?: number): Promise<FileTreeEntry[]>;
+export declare function treeSignature(tree: FileTreeEntry[]): string;
+export declare function fingerprint(partsOrOpts: string[] | {
+    prompt: string;
+    root: string;
+    recipes: string[];
+    focus: string[];
+    treeSig: string;
+}): string;
+export declare function listTestFiles(root: string): Promise<string[]>;
+export { readdir };
+//# sourceMappingURL=tree.d.ts.map

package/dist/tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree.d.ts","sourceRoot":"","sources":["../src/tree.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAQ,MAAM,kBAAkB,CAAC;AAIjD,eAAO,MAAM,MAAM,aAUjB,CAAC;AAEH,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED,wBAAsB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,SAAO,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC,CAwB7F;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,aAAa,EAAE,GAAG,MAAM,CAI3D;AAED,wBAAgB,WAAW,CACzB,WAAW,EACP,MAAM,EAAE,GACR;IACE,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB,GACJ,MAAM,CAiBR;AAED,wBAAsB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAQnE;AAED,OAAO,EAAE,OAAO,EAAE,CAAC"}

package/dist/tree.mjs

@@ -0,0 +1,70 @@
+import { createHash } from "node:crypto";
+import { readdir, stat } from "node:fs/promises";
+import { join, resolve } from "pathe";
+import { glob } from "tinyglobby";
+export const IGNORE = new Set([
+	"node_modules",
+	".git",
+	"dist",
+	".output",
+	".nuxt",
+	".untestutils",
+	"coverage",
+	".next",
+	".turbo"
+]);
+export async function buildFileTree(root, maxEntries = 2e3) {
+	const abs = resolve(root);
+	if (maxEntries <= 0) return [];
+	let paths = [];
+	try {
+		paths = await glob(["**/*"], {
+			cwd: abs,
+			onlyFiles: true,
+			ignore: [...IGNORE].map((d) => `**/${d}/**`).concat(["**/.env*", "**/.env"]),
+			absolute: false
+		});
+	} catch {
+		return [];
+	}
+	const out = [];
+	for (const rel of paths) {
+		if (out.length >= maxEntries) break;
+		if (rel.split(/[/\\]/).some((p) => IGNORE.has(p) || p.startsWith(".env"))) continue;
+		const full = join(abs, rel);
+		const s = await stat(full).catch(() => null);
+		if (!s?.isFile()) continue;
+		out.push({
+			path: rel.replace(/\\/g, "/"),
+			size: s.size
+		});
+	}
+	return out.sort((a, b) => a.path.localeCompare(b.path));
+}
+export function treeSignature(tree) {
+	return createHash("sha1").update(tree.map((t) => `${t.path}|${t.size}`).join("\n")).digest("hex");
+}
+export function fingerprint(partsOrOpts) {
+	if (Array.isArray(partsOrOpts)) {
+		return createHash("sha1").update(partsOrOpts.join("|")).digest("hex");
+	}
+	const opts = partsOrOpts;
+	return createHash("sha1").update([
+		"v1",
+		opts.prompt.trim(),
+		resolve(opts.root),
+		opts.recipes.join(","),
+		opts.focus.join(","),
+		opts.treeSig
+	].join("|")).digest("hex");
+}
+export async function listTestFiles(root) {
+	const abs = resolve(root);
+	const paths = await glob(["**/*.{test,spec}.{ts,tsx,js,mjs,cjs}", "**/e2e/**/*.{ts,js}"], {
+		cwd: abs,
+		onlyFiles: true,
+		ignore: [...IGNORE].map((d) => `**/${d}/**`)
+	});
+	return paths.map((p) => p.replace(/\\/g, "/")).sort();
+}
+export { readdir };

package/dist/workflows/cover.d.mts

@@ -0,0 +1,23 @@
+export interface CoverTestsOptions {
+	root: string;
+	recipes?: string[];
+	baseURL?: string;
+	browser?: boolean;
+	/** Directory to write new tests into */
+	outDir?: string;
+	focus?: string[];
+	maxExploreSteps?: number;
+	maxFilesRead?: number;
+	maxBytesTotal?: number;
+	write?: boolean;
+}
+export interface CoverResult {
+	files: {
+		path: string;
+		code: string;
+	}[];
+	fingerprint: string;
+	readPaths: string[];
+	genDir: string;
+}
+export declare function coverMissingTests(opts: CoverTestsOptions): Promise<CoverResult>;

package/dist/workflows/cover.d.ts

@@ -0,0 +1,24 @@
+export interface CoverTestsOptions {
+    root: string;
+    recipes?: string[];
+    baseURL?: string;
+    browser?: boolean;
+    /** Directory to write new tests into */
+    outDir?: string;
+    focus?: string[];
+    maxExploreSteps?: number;
+    maxFilesRead?: number;
+    maxBytesTotal?: number;
+    write?: boolean;
+}
+export interface CoverResult {
+    files: {
+        path: string;
+        code: string;
+    }[];
+    fingerprint: string;
+    readPaths: string[];
+    genDir: string;
+}
+export declare function coverMissingTests(opts: CoverTestsOptions): Promise<CoverResult>;
+//# sourceMappingURL=cover.d.ts.map

package/dist/workflows/cover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cover.d.ts","sourceRoot":"","sources":["../../src/workflows/cover.ts"],"names":[],"mappings":"AAWA,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,wCAAwC;IACxC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IACxC,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAAC,WAAW,CAAC,CAsGrF"}

package/dist/workflows/cover.mjs

@@ -0,0 +1,95 @@
+import { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join, relative, resolve } from "pathe";
+import { resolveArtifactsRoot, debug, envFlag, log } from "@untestutils/core";
+import { extractLabeledTsFiles } from "../agent/types.mjs";
+import { runAgentRaw } from "../agent/run.mjs";
+import { loadCoverPrompt } from "../prompts.mjs";
+import { createAgentToolkit } from "../tools/registry.mjs";
+import { buildFileTree, fingerprint, listTestFiles, treeSignature } from "../tree.mjs";
+export async function coverMissingTests(opts) {
+	const root = resolve(opts.root);
+	const existing = await listTestFiles(root);
+	const tree = await buildFileTree(root);
+	const treeSig = treeSignature(tree);
+	const id = `cover-${createHash("sha1").update(root + existing.join(",")).digest("hex").slice(0, 10)}`;
+	const fp = fingerprint([
+		"cover-v1",
+		resolve(root),
+		(opts.recipes ?? []).join(","),
+		(opts.focus ?? []).join(","),
+		existing.join("\n"),
+		treeSig
+	]);
+	const artifactsRoot = resolveArtifactsRoot();
+	const genDir = join(artifactsRoot, "ai", id);
+	await mkdir(genDir, { recursive: true });
+	const metaPath = join(genDir, `${fp.slice(0, 8)}.meta.json`);
+	if (existsSync(metaPath) && !opts.write) {
+		const meta = JSON.parse(await readFile(metaPath, "utf8"));
+		debug("ai", `cover cache hit ${id}`);
+		return meta;
+	}
+	if (!envFlag("UNTESTUTILS_AI", false) && process.env.UNTESTUTILS_AI_MOCK !== "1") {
+		throw new Error(`[untestutils/ai] no cached cover for "${root}". Run with UNTESTUTILS_AI=1 (genDir would be ${genDir}).`);
+	}
+	const toolkit = createAgentToolkit({
+		root,
+		maxFilesRead: opts.maxFilesRead ?? 40,
+		maxBytesTotal: opts.maxBytesTotal ?? 4e5,
+		browser: opts.browser || opts.baseURL ? {
+			baseURL: opts.baseURL,
+			headless: true
+		} : false
+	});
+	try {
+		const system = await loadCoverPrompt();
+		const raw = await runAgentRaw({
+			system,
+			mockKind: "cover",
+			mockRecipe: opts.recipes?.[0] ?? "basic",
+			maxSteps: opts.maxExploreSteps ?? 20,
+			tools: toolkit.tools,
+			prompt: [
+				`Project root: ${root}`,
+				`Recipes: ${(opts.recipes ?? []).join(", ") || "(none)"}`,
+				`Focus: ${(opts.focus ?? []).join(", ") || "(none)"}`,
+				opts.baseURL ? `Base URL: ${opts.baseURL}` : "Base URL: (none)",
+				`Existing test files:\n${existing.slice(0, 200).join("\n") || "(none)"}`,
+				`File tree (truncated):\n${tree.slice(0, 500).map((t) => t.path).join("\n")}`,
+				`Write missing high-value e2e tests. Prefer outDir ${opts.outDir ?? "tests/e2e"}.`
+			].join("\n\n")
+		});
+		const blocks = extractLabeledTsFiles(raw);
+		const outDir = resolve(root, opts.outDir ?? "tests/e2e");
+		const files = [];
+		for (let i = 0; i < blocks.length; i++) {
+			const b = blocks[i];
+			const rel = b.path || relative(root, join(outDir, blocks.length === 1 ? "generated-cover.test.ts" : `generated-cover-${i + 1}.test.ts`));
+			const abs = resolve(root, rel);
+			files.push({
+				path: abs,
+				code: b.code
+			});
+			await mkdir(dirname(abs), { recursive: true });
+			const cacheCopy = join(genDir, rel.replace(/[\\/]/g, "__"));
+			await mkdir(dirname(cacheCopy), { recursive: true });
+			await writeFile(cacheCopy, b.code, "utf8");
+			if (opts.write) {
+				await writeFile(abs, b.code, "utf8");
+				log("ai", `cover wrote ${abs}`);
+			}
+		}
+		const result = {
+			files,
+			fingerprint: fp,
+			readPaths: toolkit.readPaths(),
+			genDir
+		};
+		await writeFile(metaPath, JSON.stringify(result, null, 2), "utf8");
+		return result;
+	} finally {
+		await toolkit.dispose?.();
+	}
+}

package/dist/workflows/fix.d.mts

@@ -0,0 +1,17 @@
+import type { GenerateResult } from "./types.mjs";
+export interface FixTestsOptions {
+	/** Failing test file */
+	path: string;
+	root: string;
+	/** Vitest/Playwright failure log */
+	failureLog: string;
+	recipes?: string[];
+	baseURL?: string;
+	browser?: boolean;
+	maxExploreSteps?: number;
+	maxFilesRead?: number;
+	maxBytesTotal?: number;
+	/** Write fixed content back to path */
+	write?: boolean;
+}
+export declare function fixBrokenTests(opts: FixTestsOptions): Promise<GenerateResult>;

package/dist/workflows/fix.d.ts

@@ -0,0 +1,18 @@
+import type { GenerateResult } from '../workflows/types';
+export interface FixTestsOptions {
+    /** Failing test file */
+    path: string;
+    root: string;
+    /** Vitest/Playwright failure log */
+    failureLog: string;
+    recipes?: string[];
+    baseURL?: string;
+    browser?: boolean;
+    maxExploreSteps?: number;
+    maxFilesRead?: number;
+    maxBytesTotal?: number;
+    /** Write fixed content back to path */
+    write?: boolean;
+}
+export declare function fixBrokenTests(opts: FixTestsOptions): Promise<GenerateResult>;
+//# sourceMappingURL=fix.d.ts.map

package/dist/workflows/fix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fix.d.ts","sourceRoot":"","sources":["../../src/workflows/fix.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEzD,MAAM,WAAW,eAAe;IAC9B,wBAAwB;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,oCAAoC;IACpC,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,uCAAuC;IACvC,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,wBAAsB,cAAc,CAAC,IAAI,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC,CAgFnF"}