universal-ast-mapper 1.28.0 → 2.0.1

package/dist/ai-refactor.js

@@ -0,0 +1,185 @@
+import https from "node:https";
+import fs from "node:fs";
+// ─── Anthropic API ────────────────────────────────────────────────────────────
+export 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 model = opts.model ?? "claude-sonnet-4-6";
+    const body = JSON.stringify({
+        model,
+        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: ${raw.slice(0, 300)}`));
+                }
+            });
+        });
+        req.on("error", reject);
+        req.write(body);
+        req.end();
+    });
+}
+// ─── Prompt builders ──────────────────────────────────────────────────────────
+function smellPrompt(smell, sourceCode, language) {
+    const langFence = language === "typescript" ? "ts" : language === "javascript" ? "js" : language;
+    const symbol = smell.symbol ? ` for \`${smell.symbol}\`` : "";
+    return `You are an expert ${language} developer performing a refactoring.
+
+## Problem
+Smell type: **${smell.smell}**${symbol}
+Message: ${smell.message}
+File: ${smell.file}${smell.line ? `, line ${smell.line}` : ""}
+
+## Source file
+\`\`\`${langFence}
+${sourceCode}
+\`\`\`
+
+## Your task
+Refactor the code to eliminate the smell. Provide:
+1. The **minimal refactored code** — just the changed function/class (not the whole file unless necessary)
+2. A one-paragraph **explanation** of what you changed and why
+
+Format your response EXACTLY as:
+<before>
+// paste the original problematic code block here
+</before>
+<after>
+// paste the refactored code here
+</after>
+<explanation>
+Your explanation here.
+</explanation>`;
+}
+function securityPrompt(issue, sourceCode, language) {
+    const langFence = language === "typescript" ? "ts" : language === "javascript" ? "js" : language;
+    return `You are a security expert performing a code fix.
+
+## Security Issue
+Rule: **${issue.rule}** (${issue.severity})
+Message: ${issue.message}
+File: ${issue.file}, line ${issue.line}
+Snippet: \`${issue.snippet}\`
+
+## Source file
+\`\`\`${langFence}
+${sourceCode}
+\`\`\`
+
+## Your task
+Fix the security vulnerability. Provide:
+1. The **minimal fixed code** — just the changed lines/block
+2. A one-paragraph **explanation** of the vulnerability and how the fix addresses it
+
+Format your response EXACTLY as:
+<before>
+${issue.snippet}
+</before>
+<after>
+// fixed code here
+</after>
+<explanation>
+Your explanation here.
+</explanation>`;
+}
+// ─── Response parser ──────────────────────────────────────────────────────────
+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"),
+    };
+}
+// ─── Public API ───────────────────────────────────────────────────────────────
+/** Send one refactor target to Claude and return a structured RefactorResult. */
+export async function aiRefactor(target, opts = {}) {
+    const model = opts.model ?? "claude-sonnet-4-6";
+    let prompt;
+    let issue;
+    let symbol;
+    if (target.kind === "smell" && target.smell) {
+        prompt = smellPrompt(target.smell, target.sourceCode, target.language);
+        issue = `${target.smell.smell}${target.smell.symbol ? `: ${target.smell.symbol}` : ""}`;
+        symbol = target.smell.symbol;
+    }
+    else if (target.kind === "security" && target.security) {
+        prompt = securityPrompt(target.security, target.sourceCode, target.language);
+        issue = `${target.security.rule} (${target.security.severity})`;
+    }
+    else {
+        throw new Error("Invalid refactor target: must have smell or security");
+    }
+    const raw = await callClaude(prompt, opts);
+    const { before, after, explanation } = parseResponse(raw);
+    return {
+        filePath: target.filePath,
+        symbol,
+        issue,
+        before: before || "(see source)",
+        after: after || raw,
+        explanation: explanation || "(no explanation provided)",
+        model,
+    };
+}
+/**
+ * Batch-refactor: takes a list of targets and calls Claude once per target.
+ * Returns results in the same order; errors produce a result with `error` set.
+ */
+export async function aiRefactorBatch(targets, opts = {}) {
+    const results = [];
+    for (const target of targets) {
+        try {
+            results.push(await aiRefactor(target, opts));
+        }
+        catch (e) {
+            results.push({
+                filePath: target.filePath,
+                issue: target.kind === "smell" ? target.smell?.smell ?? "smell" : target.security?.rule ?? "security",
+                before: "",
+                after: "",
+                explanation: "",
+                model: opts.model ?? "claude-sonnet-4-6",
+                error: e instanceof Error ? e.message : String(e),
+            });
+        }
+    }
+    return results;
+}
+/** Read source code for a file, returning empty string on error. */
+export function readSource(filePath) {
+    try {
+        return fs.readFileSync(filePath, "utf8");
+    }
+    catch {
+        return "";
+    }
+}

package/dist/ai-testgen.js

@@ -0,0 +1,105 @@
+import https from "node:https";
+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: ${raw.slice(0, 300)}`));
+                }
+            });
+        });
+        req.on("error", reject);
+        req.write(body);
+        req.end();
+    });
+}
+// ─── Prompt builder ───────────────────────────────────────────────────────────
+function buildPrompt(sourceFile, sourceCode, stubContent, framework, language) {
+    const langFence = language === "typescript" ? "ts" : language === "javascript" ? "js" : language;
+    return `You are an expert ${language} developer and TDD practitioner.
+
+Your task: given a source file and its auto-generated test stubs, replace all TODO placeholders with real, meaningful assertions.
+
+## Source file: ${sourceFile}
+\`\`\`${langFence}
+${sourceCode}
+\`\`\`
+
+## Generated stubs to fill in:
+\`\`\`${langFence}
+${stubContent}
+\`\`\`
+
+## Rules:
+- Test framework: **${framework}**
+- Keep every test name and describe block from the stubs exactly as-is
+- Replace "// TODO: arrange" with real setup code using the source implementation
+- Replace generic assertions (toBeDefined, is not None, assertNotNull) with precise assertions that verify actual return values, side effects, or thrown errors
+- For functions with clear deterministic behavior, use concrete expected values
+- Cover happy path AND at least one edge case (empty/null/zero input) for each test
+- For async functions, always use async/await
+- Do NOT import anything extra beyond what the stubs already import
+- Do NOT add tests beyond what is in the stubs
+- Return ONLY the complete test file — no markdown fences, no explanation`;
+}
+// ─── Stripper ─────────────────────────────────────────────────────────────────
+/** Remove leading/trailing markdown code fences if Claude adds them anyway. */
+function stripFences(text) {
+    return text
+        .replace(/^```[\w]*\r?\n/m, "")
+        .replace(/\r?\n```$/m, "")
+        .trim();
+}
+// ─── Public API ───────────────────────────────────────────────────────────────
+/**
+ * Enhance a stub-only TestGenResult by asking Claude to fill in real assertions.
+ * Falls back to the original stubs if the API is unavailable or `opts.apiKey` / the
+ * ANTHROPIC_API_KEY env var is not set.
+ */
+export async function aiEnhanceTests(result, sourceCode, language, opts = {}) {
+    const enhanced = await callClaude(buildPrompt(result.sourceFile, sourceCode, result.content, result.framework, language), opts);
+    const cleaned = stripFences(enhanced);
+    return { ...result, content: cleaned, aiEnhanced: true };
+}
+/**
+ * Like `aiEnhanceTests` but never throws — returns original stubs if the API call
+ * fails, and sets `aiEnhanced: false` along with an `error` field for diagnostics.
+ */
+export async function tryAiEnhanceTests(result, sourceCode, language, opts = {}) {
+    try {
+        return await aiEnhanceTests(result, sourceCode, language, opts);
+    }
+    catch (e) {
+        return { ...result, aiEnhanced: false, error: e instanceof Error ? e.message : String(e) };
+    }
+}

package/dist/arch-rules.js

@@ -0,0 +1,82 @@
+function globToRegex(pattern) {
+    let result = "";
+    for (let i = 0; i < pattern.length; i++) {
+        const c = pattern[i];
+        if (c === "*" && pattern[i + 1] === "*") {
+            result += ".*";
+            i++;
+        }
+        else if (c === "*") {
+            result += "[^/]*";
+        }
+        else if (c === "?") {
+            result += "[^/]";
+        }
+        else if (/[.+^${}()|[\]\\]/.test(c)) {
+            result += "\\" + c;
+        }
+        else {
+            result += c;
+        }
+    }
+    return new RegExp("^" + result + "$");
+}
+function matchGlob(pattern, str) {
+    try {
+        return globToRegex(pattern).test(str);
+    }
+    catch {
+        return false;
+    }
+}
+export function loadArchRules(projectConfig) {
+    const arch = projectConfig.arch;
+    return arch?.rules ?? [];
+}
+export function checkArchRules(graph, rules) {
+    if (rules.length === 0)
+        return [];
+    const violations = [];
+    const fileImports = new Map();
+    for (const edge of graph.edges) {
+        if (edge.edgeType === "imports") {
+            const fromFile = edge.from.split("::")[0];
+            const toFile = edge.to.split("::")[0];
+            if (!fileImports.has(fromFile))
+                fileImports.set(fromFile, new Set());
+            fileImports.get(fromFile).add(toFile);
+        }
+    }
+    const allFiles = [...fileImports.keys()];
+    for (const rule of rules) {
+        const severity = rule.severity ?? "error";
+        const fromFiles = allFiles.filter(f => matchGlob(rule.from, f));
+        for (const file of fromFiles) {
+            const imports = fileImports.get(file) ?? new Set();
+            if (rule.forbidImport) {
+                for (const imp of imports) {
+                    if (matchGlob(rule.forbidImport, imp)) {
+                        violations.push({
+                            rule: rule.name ?? `forbid: ${rule.from} → ${rule.forbidImport}`,
+                            severity,
+                            file,
+                            message: rule.message ?? `"${file}" must not import "${imp}" (matches ${rule.forbidImport})`,
+                        });
+                    }
+                }
+            }
+            if (rule.requireImport) {
+                const hasRequired = [...imports].some(imp => matchGlob(rule.requireImport, imp));
+                if (!hasRequired) {
+                    violations.push({
+                        rule: rule.name ?? `require: ${rule.from} → ${rule.requireImport}`,
+                        severity,
+                        file,
+                        message: rule.message ?? `"${file}" must import something matching "${rule.requireImport}"`,
+                    });
+                }
+            }
+        }
+    }
+    return violations;
+}