universal-ast-mapper 2.0.0 → 2.0.2

package/dist/indexstore.js

@@ -0,0 +1,105 @@
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+import { buildSkeletonsBulk } from "./pool.js";
+import { collectSourceFiles } from "./skeleton.js";
+import { resolveOptions } from "./config.js";
+const INDEX_VERSION = "2";
+const INDEX_FILE = ".ast-map/index.json";
+function indexPath(root) {
+    return path.join(root, INDEX_FILE);
+}
+export function loadIndex(root) {
+    try {
+        const raw = fs.readFileSync(indexPath(root), "utf8");
+        const store = JSON.parse(raw);
+        if (store.version !== INDEX_VERSION)
+            return null;
+        return store;
+    }
+    catch {
+        return null;
+    }
+}
+export function saveIndex(root, store) {
+    const p = indexPath(root);
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, JSON.stringify(store, null, 2), "utf8");
+}
+export function hashFile(filePath) {
+    try {
+        const content = fs.readFileSync(filePath);
+        return crypto.createHash("sha1").update(content).digest("hex").slice(0, 16);
+    }
+    catch {
+        return "";
+    }
+}
+export function isIndexFresh(store) {
+    for (const [, entry] of Object.entries(store.entries)) {
+        const abs = path.join(store.root, entry.rel);
+        if (hashFile(abs) !== entry.hash)
+            return false;
+    }
+    return true;
+}
+export function getSkeletons(store, filterPrefix) {
+    const entries = Object.values(store.entries);
+    if (filterPrefix) {
+        const norm = filterPrefix.split(path.sep).join("/");
+        return entries.filter(e => e.rel.startsWith(norm)).map(e => e.skel);
+    }
+    return entries.map(e => e.skel);
+}
+export async function buildIndex(root, scanDir, opts) {
+    const skOpts = resolveOptions({ ...opts, detail: "outline", emitHtml: false });
+    const files = collectSourceFiles(scanDir, skOpts);
+    const items = files.map(f => ({
+        abs: f,
+        rel: path.relative(root, f).split(path.sep).join("/"),
+    }));
+    const existing = loadIndex(root);
+    const existingEntries = existing?.entries ?? {};
+    const toRebuild = [];
+    const reused = [];
+    for (const item of items) {
+        const h = hashFile(item.abs);
+        const cached = existingEntries[item.rel];
+        if (cached && cached.hash === h) {
+            reused.push(cached);
+        }
+        else {
+            toRebuild.push(item);
+        }
+    }
+    const built = await buildSkeletonsBulk(toRebuild, skOpts);
+    const entries = {};
+    for (const e of reused) {
+        entries[e.rel] = e;
+    }
+    for (let i = 0; i < toRebuild.length; i++) {
+        const r = built[i];
+        if (!r)
+            continue;
+        const rel = toRebuild[i].rel;
+        entries[rel] = {
+            rel,
+            hash: hashFile(toRebuild[i].abs),
+            builtAt: new Date().toISOString(),
+            skel: r.skel,
+        };
+    }
+    const store = {
+        version: INDEX_VERSION,
+        root,
+        scanDir,
+        builtAt: new Date().toISOString(),
+        fileCount: Object.keys(entries).length,
+        entries,
+    };
+    saveIndex(root, store);
+    return store;
+}
+export async function refreshIndex(root, scanDir) {
+    return buildIndex(root, scanDir);
+}

package/dist/layers.js

@@ -0,0 +1,36 @@
+import { computeCoupling } from "./coupling.js";
+/**
+ * Detect violations of Robert C. Martin's Stable Dependencies Principle (SDP):
+ * a module should depend only on modules at least as stable as itself. A "stable"
+ * file (low instability) that imports a "volatile" file (high instability) is a
+ * violation — volatile code changes often and will keep dragging the stable code
+ * with it. Severity is the instability gap the dependency crosses.
+ */
+export function findLayerViolations(graph, minGap = 0) {
+    const inst = new Map(computeCoupling(graph).map((m) => [m.file, m.instability]));
+    const nodeMap = new Map(graph.nodes.map((n) => [n.id, n]));
+    const seen = new Set();
+    const violations = [];
+    for (const e of graph.edges) {
+        if (e.edgeType !== "imports")
+            continue;
+        const to = nodeMap.get(e.to);
+        const toFile = to ? (to.nodeType === "file" ? to.id : to.file) : null;
+        const fromFile = e.from;
+        if (!toFile || fromFile === toFile)
+            continue;
+        const fi = inst.get(fromFile);
+        const ti = inst.get(toFile);
+        if (fi === undefined || ti === undefined)
+            continue;
+        const severity = Math.round((ti - fi) * 100) / 100;
+        if (severity <= minGap)
+            continue; // only "uphill" dependencies (stable -> volatile)
+        const key = fromFile + " " + toFile;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        violations.push({ from: fromFile, to: toFile, fromInstability: fi, toInstability: ti, severity });
+    }
+    return violations.sort((a, b) => b.severity - a.severity || a.from.localeCompare(b.from));
+}

package/dist/lsp.js

@@ -0,0 +1,238 @@
+#!/usr/bin/env node
+/**
+ * Minimal Language Server Protocol (LSP) server for ast-map.
+ * Implements JSON-RPC 2.0 over stdio without any external library.
+ *
+ * Capabilities:
+ *   - textDocument/publishDiagnostics (dead exports + security issues)
+ *   - textDocument/codeLens (cyclomatic complexity per function/class)
+ *   - textDocument/hover (symbol kind, complexity, line count)
+ *
+ * Invocation: node dist/lsp.js
+ * The VS Code extension (or any LSP client) starts this as a child process.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { buildSkeleton, collectSourceFiles } from "./skeleton.js";
+import { resolveOptions, loadProjectConfig } from "./config.js";
+import { initDiskCache, defaultCacheDir } from "./diskcache.js";
+import { buildSymbolGraph } from "./graph.js";
+import { findDeadExports } from "./graph-analysis.js";
+import { computeFileComplexity } from "./complexity.js";
+import { scanFileForSecurityIssues } from "./security.js";
+import { detectSmells } from "./smells.js";
+import { parseRootsFromEnv } from "./roots.js";
+const ROOTS = parseRootsFromEnv();
+const ROOT = ROOTS.roots[0];
+if (process.env.AST_MAP_NO_CACHE !== "1" && loadProjectConfig(ROOT).cache !== false) {
+    initDiskCache(defaultCacheDir(ROOT));
+}
+function sendRaw(obj) {
+    const body = JSON.stringify(obj);
+    process.stdout.write(`Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n\r\n${body}`);
+}
+function respond(id, result) {
+    sendRaw({ jsonrpc: "2.0", id, result });
+}
+function notify(method, params) {
+    sendRaw({ jsonrpc: "2.0", method, params });
+}
+function respondError(id, code, message) {
+    sendRaw({ jsonrpc: "2.0", id: id ?? null, error: { code, message } });
+}
+// ─── LSP message reader ───────────────────────────────────────────────────────
+let buffer = Buffer.alloc(0);
+process.stdin.on("data", (chunk) => {
+    buffer = Buffer.concat([buffer, chunk]);
+    processBuffer();
+});
+function processBuffer() {
+    while (true) {
+        const headerEnd = buffer.indexOf("\r\n\r\n");
+        if (headerEnd === -1)
+            break;
+        const headerStr = buffer.slice(0, headerEnd).toString("utf8");
+        const match = /Content-Length:\s*(\d+)/i.exec(headerStr);
+        if (!match) {
+            buffer = buffer.slice(headerEnd + 4);
+            continue;
+        }
+        const contentLength = parseInt(match[1], 10);
+        const start = headerEnd + 4;
+        if (buffer.length < start + contentLength)
+            break;
+        const body = buffer.slice(start, start + contentLength).toString("utf8");
+        buffer = buffer.slice(start + contentLength);
+        try {
+            const msg = JSON.parse(body);
+            void handleMessage(msg);
+        }
+        catch { /* malformed JSON */ }
+    }
+}
+async function computeDiagnostics(fileUri) {
+    const filePath = uriToPath(fileUri);
+    const rel = path.relative(ROOT, filePath).split(path.sep).join("/");
+    const diags = [];
+    try {
+        const source = fs.readFileSync(filePath, "utf8");
+        // Security issues
+        const issues = scanFileForSecurityIssues(source, rel);
+        for (const issue of issues) {
+            const line = Math.max(0, issue.line - 1);
+            diags.push({
+                range: { start: { line, character: 0 }, end: { line, character: 999 } },
+                severity: ["critical", "high"].includes(issue.severity) ? 1 : 2,
+                source: "ast-map",
+                message: `[${issue.severity.toUpperCase()}] ${issue.message}`,
+                code: issue.rule,
+            });
+        }
+        // Smells
+        const opts = resolveOptions({ detail: "full", emitHtml: false });
+        const skel = await buildSkeleton(filePath, rel, opts);
+        const lineCount = source.split("\n").length;
+        const smells = detectSmells(skel, lineCount);
+        for (const smell of smells) {
+            const line = Math.max(0, (smell.line ?? 1) - 1);
+            diags.push({
+                range: { start: { line, character: 0 }, end: { line, character: 999 } },
+                severity: smell.severity === "warning" ? 2 : 3,
+                source: "ast-map",
+                message: smell.symbol ? `[${smell.smell}] ${smell.symbol}: ${smell.message}` : `[${smell.smell}] ${smell.message}`,
+                code: smell.smell,
+            });
+        }
+        // Dead exports (scan directory containing the file)
+        try {
+            const dir = path.dirname(filePath);
+            const skOpts = resolveOptions({ detail: "outline", emitHtml: false });
+            const files = collectSourceFiles(dir, skOpts);
+            const skels = await Promise.all(files.map(async (f) => {
+                const r = path.relative(ROOT, f).split(path.sep).join("/");
+                try {
+                    return await buildSkeleton(f, r, skOpts);
+                }
+                catch {
+                    return null;
+                }
+            }));
+            const graph = buildSymbolGraph(skels.filter(Boolean), ROOT);
+            const dead = findDeadExports(graph).filter((d) => d.file === rel && d.confidence === "high");
+            for (const d of dead) {
+                const line = 0; // DeadExport has no line number; mark at file start
+                diags.push({
+                    range: { start: { line, character: 0 }, end: { line, character: 999 } },
+                    severity: 2,
+                    source: "ast-map",
+                    message: `Dead export: "${d.symbol}" (${d.kind}) is never imported within the scanned directory.`,
+                    code: "dead-export",
+                });
+            }
+        }
+        catch { /* dead export scan optional */ }
+    }
+    catch { /* file unreadable */ }
+    return diags;
+}
+async function computeCodeLenses(fileUri) {
+    const filePath = uriToPath(fileUri);
+    const rel = path.relative(ROOT, filePath).split(path.sep).join("/");
+    try {
+        const cx = await computeFileComplexity(filePath, rel);
+        if (!cx)
+            return [];
+        return cx.functions.map((fn) => {
+            const line = Math.max(0, fn.startLine - 1);
+            const icon = fn.complexity >= 20 ? "🔴" : fn.complexity >= 10 ? "🟡" : "✦";
+            return {
+                range: { start: { line, character: 0 }, end: { line, character: 0 } },
+                command: {
+                    title: `${icon} Complexity: ${fn.complexity} (${fn.rating})`,
+                    command: "",
+                },
+            };
+        });
+    }
+    catch {
+        return [];
+    }
+}
+// ─── URI helpers ─────────────────────────────────────────────────────────────
+function uriToPath(uri) {
+    return decodeURIComponent(uri.replace(/^file:\/\//, "").replace(/^\/([A-Za-z]):/, "$1:"));
+}
+function pathToUri(p) {
+    return "file://" + p.split(path.sep).join("/");
+}
+// ─── Supported languages ─────────────────────────────────────────────────────
+const SUPPORTED_EXTS = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py", ".go", ".java", ".rb"]);
+function isSupported(uri) {
+    return SUPPORTED_EXTS.has(path.extname(uriToPath(uri)));
+}
+// ─── Message router ───────────────────────────────────────────────────────────
+const CAPABILITIES = {
+    textDocumentSync: 2, // incremental
+    codeLensProvider: { resolveProvider: false },
+    hoverProvider: false,
+    diagnosticProvider: { interFileDependencies: false, workspaceDiagnostics: false },
+};
+async function handleMessage(msg) {
+    const { method, id, params } = msg;
+    if (method === "initialize") {
+        respond(id ?? null, {
+            capabilities: CAPABILITIES,
+            serverInfo: { name: "ast-map-lsp", version: "1.33.0" },
+        });
+        return;
+    }
+    if (method === "initialized") {
+        // Push diagnostics for already-open files (none tracked yet at startup)
+        return;
+    }
+    if (method === "shutdown") {
+        respond(id ?? null, null);
+        return;
+    }
+    if (method === "exit") {
+        process.exit(0);
+    }
+    if (method === "textDocument/didOpen") {
+        const p = params;
+        if (isSupported(p.textDocument.uri)) {
+            const diags = await computeDiagnostics(p.textDocument.uri);
+            notify("textDocument/publishDiagnostics", { uri: p.textDocument.uri, diagnostics: diags });
+        }
+        return;
+    }
+    if (method === "textDocument/didSave") {
+        const p = params;
+        if (isSupported(p.textDocument.uri)) {
+            const diags = await computeDiagnostics(p.textDocument.uri);
+            notify("textDocument/publishDiagnostics", { uri: p.textDocument.uri, diagnostics: diags });
+        }
+        return;
+    }
+    if (method === "textDocument/didClose") {
+        const p = params;
+        notify("textDocument/publishDiagnostics", { uri: p.textDocument.uri, diagnostics: [] });
+        return;
+    }
+    if (method === "textDocument/codeLens") {
+        const p = params;
+        if (!isSupported(p.textDocument.uri)) {
+            respond(id ?? null, []);
+            return;
+        }
+        const lenses = await computeCodeLenses(p.textDocument.uri);
+        respond(id ?? null, lenses);
+        return;
+    }
+    // Unknown method — return null for requests, ignore notifications
+    if (id !== undefined && id !== null) {
+        respondError(id, -32601, `Method not found: ${method}`);
+    }
+}
+process.on("SIGTERM", () => process.exit(0));
+process.on("SIGINT", () => process.exit(0));
+process.stderr.write(`ast-map LSP server started. root=${ROOT}\n`);

package/dist/parser.js

@@ -0,0 +1,84 @@
+import Parser from "web-tree-sitter";
+import { createRequire } from "node:module";
+import path from "node:path";
+const require = createRequire(import.meta.url);
+// `web-tree-sitter` 0.20.x ships a CommonJS class with static members that are
+// only populated after `init()`. We treat the static surface loosely.
+const P = Parser;
+let initPromise = null;
+const languageCache = new Map();
+const parserCache = new Map();
+function pkgDir(spec) {
+    return path.dirname(require.resolve(spec));
+}
+function grammarWasmPath(grammar) {
+    return path.join(pkgDir("tree-sitter-wasms/package.json"), "out", `tree-sitter-${grammar}.wasm`);
+}
+export async function initParser() {
+    if (!initPromise) {
+        const coreDir = pkgDir("web-tree-sitter/package.json");
+        initPromise = P.init({
+            locateFile(name) {
+                // The runtime requests "tree-sitter.wasm"; serve it from the package dir.
+                return path.join(coreDir, name);
+            },
+        });
+    }
+    return initPromise;
+}
+async function loadLanguage(grammar) {
+    await initParser();
+    const cached = languageCache.get(grammar);
+    if (cached)
+        return cached;
+    const lang = await P.Language.load(grammarWasmPath(grammar));
+    languageCache.set(grammar, lang);
+    return lang;
+}
+/** Parse source code with the given grammar and return the root node. */
+export async function parseSource(grammar, source) {
+    const lang = await loadLanguage(grammar);
+    let parser = parserCache.get(grammar);
+    if (!parser) {
+        parser = new P();
+        parser.setLanguage(lang);
+        parserCache.set(grammar, parser);
+    }
+    return parser.parse(source).rootNode;
+}
+/* ----------------------------- node helpers ----------------------------- */
+export function namedChildren(node) {
+    const out = [];
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const c = node.namedChild(i);
+        if (c)
+            out.push(c);
+    }
+    return out;
+}
+export function nameOf(node) {
+    const n = node.childForFieldName("name");
+    return n ? n.text : null;
+}
+/**
+ * Build a one-line "header" signature: text from the node start up to the
+ * start of its body (or the whole node if there is no body), whitespace
+ * collapsed. Works uniformly across languages.
+ */
+export function headerSignature(node, body) {
+    const src = node.text;
+    const slice = body ? src.slice(0, body.startIndex - node.startIndex) : src;
+    return slice.replace(/\s+/g, " ").trim();
+}
+/** Collect consecutive leading line/block comments immediately above a node. */
+export function leadingComment(node) {
+    const lines = [];
+    let prev = node.previousNamedSibling;
+    while (prev && prev.type === "comment") {
+        lines.unshift(prev.text);
+        prev = prev.previousNamedSibling;
+    }
+    if (lines.length === 0)
+        return null;
+    return lines.join("\n").slice(0, 500);
+}

package/dist/patch.js

@@ -0,0 +1,199 @@
+import https from "node:https";
+import readline from "node:readline";
+import fs from "node:fs";
+// ─── ANSI ─────────────────────────────────────────────────────────────────────
+const tty = process.stdout.isTTY ?? false;
+const esc = (code) => (s) => tty ? `\x1b[${code}m${s}\x1b[0m` : s;
+const red = esc("31");
+const green = esc("32");
+const dim = esc("2");
+// ─── Colored unified diff ─────────────────────────────────────────────────────
+function coloredDiff(before, after) {
+    const beforeLines = before.split("\n");
+    const afterLines = after.split("\n");
+    const lines = [dim("--- before"), dim("+++ after")];
+    const max = Math.max(beforeLines.length, afterLines.length);
+    for (let i = 0; i < max; i++) {
+        if (i < beforeLines.length && i < afterLines.length) {
+            if (beforeLines[i] !== afterLines[i]) {
+                lines.push(red("- " + beforeLines[i]));
+                lines.push(green("+ " + afterLines[i]));
+            }
+            else {
+                lines.push(dim("  " + beforeLines[i]));
+            }
+        }
+        else if (i < beforeLines.length) {
+            lines.push(red("- " + beforeLines[i]));
+        }
+        else {
+            lines.push(green("+ " + afterLines[i]));
+        }
+    }
+    return lines.join("\n");
+}
+// ─── Claude API ───────────────────────────────────────────────────────────────
+async function callClaude(prompt, opts) {
+    const apiKey = opts.apiKey ?? process.env.ANTHROPIC_API_KEY;
+    if (!apiKey)
+        throw new Error("No Anthropic API key — set ANTHROPIC_API_KEY or pass --api-key");
+    const body = JSON.stringify({
+        model: opts.model ?? "claude-sonnet-4-6",
+        max_tokens: opts.maxTokens ?? 4096,
+        messages: [{ role: "user", content: prompt }],
+    });
+    return new Promise((resolve, reject) => {
+        const req = https.request({
+            hostname: "api.anthropic.com",
+            path: "/v1/messages",
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                "x-api-key": apiKey,
+                "anthropic-version": "2023-06-01",
+                "content-length": Buffer.byteLength(body),
+            },
+        }, (res) => {
+            const chunks = [];
+            res.on("data", (c) => chunks.push(c));
+            res.on("end", () => {
+                const raw = Buffer.concat(chunks).toString("utf8");
+                try {
+                    const parsed = JSON.parse(raw);
+                    if (parsed.error)
+                        reject(new Error(`Anthropic API: ${parsed.error.message}`));
+                    else
+                        resolve(parsed.content?.[0]?.text ?? "");
+                }
+                catch {
+                    reject(new Error("Unexpected API response"));
+                }
+            });
+        });
+        req.on("error", reject);
+        req.write(body);
+        req.end();
+    });
+}
+// ─── Prompt ───────────────────────────────────────────────────────────────────
+function buildPatchPrompt(issue) {
+    const langFence = issue.language === "typescript" ? "ts" : issue.language === "javascript" ? "js" : issue.language;
+    let issueDesc;
+    if (issue.kind === "smell" && issue.smell) {
+        issueDesc = `Code smell: **${issue.smell.smell}**\nMessage: ${issue.smell.message}\nFile: ${issue.filePath}${issue.smell.line ? `, line ${issue.smell.line}` : ""}`;
+    }
+    else if (issue.kind === "security" && issue.security) {
+        issueDesc = `Security issue: **${issue.security.rule}** (${issue.security.severity})\nMessage: ${issue.security.message}\nFile: ${issue.filePath}, line ${issue.security.line}\nSnippet: \`${issue.security.snippet}\``;
+    }
+    else {
+        issueDesc = "Unknown issue";
+    }
+    return `You are an expert ${issue.language} developer fixing a code issue.
+
+## Issue
+${issueDesc}
+
+## Source file
+\`\`\`${langFence}
+${issue.sourceCode}
+\`\`\`
+
+## Your task
+Fix the issue with the minimal change needed (not the whole file unless necessary).
+
+Format your response EXACTLY as:
+<before>
+// original code block
+</before>
+<after>
+// fixed code block
+</after>
+<explanation>
+One paragraph explanation of the fix.
+</explanation>`;
+}
+function parseResponse(raw) {
+    const extract = (tag) => {
+        const m = raw.match(new RegExp(`<${tag}>([\\s\\S]*?)<\\/${tag}>`));
+        return m ? m[1].trim() : "";
+    };
+    return { before: extract("before"), after: extract("after"), explanation: extract("explanation") };
+}
+function issueLabel(issue) {
+    if (issue.kind === "smell" && issue.smell) {
+        return issue.smell.smell + (issue.smell.symbol ? `: ${issue.smell.symbol}` : "");
+    }
+    if (issue.kind === "security" && issue.security) {
+        return `${issue.security.rule} (${issue.security.severity})`;
+    }
+    return "issue";
+}
+// ─── Interactive y/n ──────────────────────────────────────────────────────────
+async function askYesNo(question) {
+    if (!process.stdin.isTTY)
+        return false;
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(question + " [y/N] ", (ans) => {
+            rl.close();
+            resolve(ans.trim().toLowerCase() === "y");
+        });
+    });
+}
+// ─── Public API ───────────────────────────────────────────────────────────────
+export async function generatePatch(issue, opts = {}) {
+    const label = issueLabel(issue);
+    try {
+        const raw = await callClaude(buildPatchPrompt(issue), opts);
+        const { before, after, explanation } = parseResponse(raw);
+        return { filePath: issue.filePath, issue: label, before, after, explanation, applied: false };
+    }
+    catch (e) {
+        return { filePath: issue.filePath, issue: label, before: "", after: "", explanation: "", applied: false, error: e instanceof Error ? e.message : String(e) };
+    }
+}
+export async function interactivePatch(issues, opts = {}) {
+    const results = [];
+    for (const issue of issues) {
+        console.log(`\n${dim("─────────────────────────────────────────────")}`);
+        console.log(`${dim(issue.filePath)}  ${issueLabel(issue)}`);
+        console.log(dim("Generating patch…"));
+        const result = await generatePatch(issue, opts);
+        if (result.error) {
+            console.error(`  Error: ${result.error}`);
+            results.push(result);
+            continue;
+        }
+        if (!result.before || !result.after) {
+            console.log(dim("  (no diff produced)"));
+            results.push(result);
+            continue;
+        }
+        console.log(coloredDiff(result.before, result.after));
+        console.log(dim(`\n  ${result.explanation}`));
+        let apply = opts.yes ?? false;
+        if (!apply) {
+            apply = await askYesNo(`  Apply this patch to ${issue.filePath}?`);
+        }
+        if (apply) {
+            try {
+                const src = fs.readFileSync(issue.filePath, "utf8");
+                const patched = src.replace(result.before, result.after);
+                if (patched === src) {
+                    console.log(dim("  (patch did not change file — before block not found verbatim)"));
+                }
+                else {
+                    fs.writeFileSync(issue.filePath, patched, "utf8");
+                    console.log(`${green("✓")} Applied patch to ${issue.filePath}`);
+                    results.push({ ...result, applied: true });
+                    continue;
+                }
+            }
+            catch (e) {
+                console.error(`  Failed to apply: ${e instanceof Error ? e.message : String(e)}`);
+            }
+        }
+        results.push(result);
+    }
+    return results;
+}