universal-ast-mapper 1.28.0 → 2.0.1

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/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;
+}

package/dist/plugins.js

@@ -0,0 +1,88 @@
+import fs from "node:fs";
+import path from "node:path";
+// ─── Loader ───────────────────────────────────────────────────────────────────
+const PLUGINS_DIR = ".ast-map/plugins";
+/** Load all `.mjs` / `.js` plugin files from `<root>/.ast-map/plugins/`. */
+export async function loadPlugins(root) {
+    const dir = path.join(root, PLUGINS_DIR);
+    if (!fs.existsSync(dir))
+        return [];
+    const files = fs.readdirSync(dir).filter((f) => f.endsWith(".mjs") || f.endsWith(".js"));
+    const plugins = [];
+    for (const file of files) {
+        const abs = path.resolve(dir, file);
+        try {
+            const mod = await import(abs);
+            const plugin = "default" in mod && isPlugin(mod.default) ? mod.default
+                : "plugin" in mod && isPlugin(mod.plugin) ? mod.plugin
+                    : isPlugin(mod) ? mod
+                        : undefined;
+            if (plugin)
+                plugins.push(plugin);
+            else
+                process.stderr.write(`[ast-map plugins] ${file}: no valid default/plugin export\n`);
+        }
+        catch (e) {
+            process.stderr.write(`[ast-map plugins] failed to load ${file}: ${e instanceof Error ? e.message : String(e)}\n`);
+        }
+    }
+    return plugins;
+}
+function isPlugin(v) {
+    return typeof v === "object" && v !== null && "id" in v && "run" in v && typeof v.run === "function";
+}
+/** Run all loaded plugins against the given skeletons. */
+export async function runPlugins(plugins, ctx) {
+    const results = [];
+    for (const plugin of plugins) {
+        try {
+            const violations = await plugin.run(ctx);
+            results.push({ pluginId: plugin.id, description: plugin.description, violations });
+        }
+        catch (e) {
+            results.push({
+                pluginId: plugin.id,
+                description: plugin.description,
+                violations: [],
+                error: e instanceof Error ? e.message : String(e),
+            });
+        }
+    }
+    return results;
+}
+// ─── Example plugin scaffolding (written to disk by ast-map init) ─────────────
+export const EXAMPLE_PLUGIN = `/**
+ * Example ast-map plugin: no-console-in-lib
+ *
+ * Reports any "console.log/warn/error" usage in library source files.
+ * Adapt the logic to define your own custom rules.
+ *
+ * Export your plugin as the default export.
+ * @type {import('universal-ast-mapper').AstMapPlugin}
+ */
+export default {
+  id: "no-console-in-lib",
+  description: "Disallow console.* calls in library code",
+
+  run({ skeletons }) {
+    const violations = [];
+    for (const skel of skeletons) {
+      // Only apply to files under src/ (adjust as needed)
+      if (!skel.file.startsWith("src/")) continue;
+      for (const sym of skel.symbols) {
+        if (sym.name.startsWith("console")) {
+          violations.push({
+            rule: "no-console-in-lib",
+            file: skel.file,
+            line: sym.range?.startLine,
+            symbol: sym.name,
+            severity: "warning",
+            message: \`console.\${sym.name} should not be used in library code\`,
+          });
+        }
+      }
+    }
+    return violations;
+  },
+};
+`;