coderoast 0.1.0

package/dist/agents/roast-narrator-agent.js

@@ -0,0 +1,256 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runRoastNarratorAgent = runRoastNarratorAgent;
+const gemini_client_1 = require("./gemini-client");
+function formatEvidenceItem(item) {
+    const metrics = item.metrics
+        .map((metric) => `${metric.type}=${metric.value}`)
+        .join(", ");
+    return `${item.file}:${item.startLine}-${item.endLine} (${metrics})`;
+}
+function getMetricValue(metrics, type) {
+    return metrics.find((metric) => metric.type === type)?.value;
+}
+function formatEvidenceExample(item) {
+    const loc = getMetricValue(item.metrics, "loc");
+    const locText = typeof loc === "number" ? ` (${loc} lines)` : "";
+    return `${item.file} lines ${item.startLine}-${item.endLine}${locText}`;
+}
+function buildLongFunctionMessage(issue) {
+    const example = issue.evidence[0];
+    if (!example) {
+        return "Long functions detected, but the evidence list is empty.";
+    }
+    const extraCount = issue.evidence.length - 1;
+    const extraText = extraCount > 0 ? ` (+${extraCount} more)` : "";
+    return `Very long functions can be hard to maintain, for example ${formatEvidenceExample(example)}${extraText}.`;
+}
+function buildDuplicateMessage(issue) {
+    const byHash = new Map();
+    for (const item of issue.evidence) {
+        const hash = String(getMetricValue(item.metrics, "hash") ?? "unknown");
+        const count = getMetricValue(item.metrics, "count");
+        const loc = getMetricValue(item.metrics, "loc");
+        const entry = byHash.get(hash) ?? {
+            count: typeof count === "number" ? count : undefined,
+            loc: typeof loc === "number" ? loc : undefined,
+            examples: [],
+        };
+        entry.examples.push(item);
+        if (typeof count === "number") {
+            entry.count = count;
+        }
+        if (typeof loc === "number") {
+            entry.loc = loc;
+        }
+        byHash.set(hash, entry);
+    }
+    const firstBlock = [...byHash.values()].sort((a, b) => {
+        const countA = a.count ?? 0;
+        const countB = b.count ?? 0;
+        return countB - countA;
+    })[0];
+    if (!firstBlock || firstBlock.examples.length === 0) {
+        return "Repeated code detected, but the evidence list is empty.";
+    }
+    const example = firstBlock.examples[0];
+    const countText = typeof firstBlock.count === "number"
+        ? ` (${firstBlock.count} total copies)`
+        : "";
+    const locText = typeof firstBlock.loc === "number" ? ` (~${firstBlock.loc} lines)` : "";
+    if (!example) {
+        return `Repeated code${locText} appears in multiple places${countText}.`;
+    }
+    return `Repeated code${locText} appears in multiple places${countText}, for example ${formatEvidenceExample(example)}.`;
+}
+function buildCircularMessage(issue) {
+    const unique = Array.from(new Map(issue.evidence.map((item) => [item.file, item])).values());
+    if (unique.length === 0) {
+        return "Possible circular dependency detected, but the evidence list is empty.";
+    }
+    const examples = unique.slice(0, 2).map(formatEvidenceExample);
+    if (examples.length === 1) {
+        return `Possible circular dependency involving ${examples[0]}.`;
+    }
+    return `Possible circular dependency between ${examples[0]} and ${examples[1]}.`;
+}
+function buildLaymanMessage(issue) {
+    if (!issue.evidenceComplete) {
+        return "not enough data";
+    }
+    switch (issue.signal) {
+        case "longFunctions":
+            return buildLongFunctionMessage(issue);
+        case "duplicateBlocks":
+            return buildDuplicateMessage(issue);
+        case "circularDependencies":
+            return buildCircularMessage(issue);
+        case "testPresence":
+            return "not enough data";
+        default: {
+            const example = issue.evidence[0];
+            if (!example) {
+                return "Issue detected, but the evidence list is empty.";
+            }
+            return `Potential issue spotted around ${formatEvidenceExample(example)}.`;
+        }
+    }
+}
+function buildActionItem(issue) {
+    if (!issue.evidenceComplete) {
+        if (issue.signal === "testPresence") {
+            return "Add at least one test file to cover critical paths.";
+        }
+        return null;
+    }
+    const example = issue.evidence[0];
+    switch (issue.signal) {
+        case "longFunctions": {
+            if (!example) {
+                return "Split long functions into smaller helpers.";
+            }
+            return `Split ${example.file} around lines ${example.startLine}-${example.endLine} into smaller helpers.`;
+        }
+        case "duplicateBlocks": {
+            if (!example) {
+                return "Extract repeated logic into a shared helper.";
+            }
+            return `Extract repeated logic around ${example.file} lines ${example.startLine}-${example.endLine} into a shared helper.`;
+        }
+        case "circularDependencies": {
+            if (!example) {
+                return "Break circular dependencies by moving shared code into a lower-level module.";
+            }
+            return `Break the dependency loop involving ${example.file} (lines ${example.startLine}-${example.endLine}).`;
+        }
+        case "testPresence":
+            return "Add at least one test file to cover critical paths.";
+        default:
+            if (!example) {
+                return "Create a focused refactor for the flagged area.";
+            }
+            return `Review ${example.file} lines ${example.startLine}-${example.endLine} for a focused refactor.`;
+    }
+}
+function formatEvidenceList(issue, limit) {
+    if (issue.evidence.length === 0) {
+        return "   Evidence: none";
+    }
+    const maxItems = limit === undefined ? 3 : limit <= 0 ? issue.evidence.length : limit;
+    const shown = issue.evidence.slice(0, maxItems);
+    const lines = shown.map((item) => `   - ${formatEvidenceItem(item)}`);
+    const remaining = issue.evidence.length - shown.length;
+    if (remaining > 0) {
+        lines.push(`   - ... +${remaining} more`);
+    }
+    return ["   Evidence:", ...lines].join("\n");
+}
+function formatIssueLine(index, issue, message, showDetails, detailsLimit) {
+    const base = `${index + 1}. [${issue.type}] ${message}`;
+    if (!showDetails) {
+        return base;
+    }
+    return `${base}\n${formatEvidenceList(issue, detailsLimit)}`;
+}
+function buildGeminiPrompt(config, issues) {
+    const payload = issues.map((issue) => ({
+        id: issue.id,
+        type: issue.type,
+        signal: issue.signal,
+        confidence: issue.confidence,
+        evidenceComplete: issue.evidenceComplete,
+        evidence: issue.evidence,
+    }));
+    return [
+        "You are CodeRoast, a strict evidence-only code review narrator.",
+        "Use plain, non-technical language that a non-engineer can understand.",
+        "Use only the evidence provided in the JSON below.",
+        "Do not invent details or add new issues.",
+        "If evidenceComplete is false or evidence is empty, output \"not enough data\".",
+        `Tone: ${config.severity}. Focus: ${config.focus}.`,
+        "Return ONLY valid JSON, no markdown or extra text.",
+        "Output format: [{\"id\":1,\"text\":\"...\"}].",
+        "Each text must be one sentence and should reference file paths and line ranges.",
+        "",
+        "Issues JSON:",
+        JSON.stringify(payload, null, 2),
+    ].join("\n");
+}
+function extractJsonArray(raw) {
+    const start = raw.indexOf("[");
+    const end = raw.lastIndexOf("]");
+    if (start === -1 || end === -1 || end <= start) {
+        throw new Error("Gemini response missing JSON array");
+    }
+    const jsonText = raw.slice(start, end + 1);
+    const parsed = JSON.parse(jsonText);
+    if (!Array.isArray(parsed)) {
+        throw new Error("Gemini response JSON is not an array");
+    }
+    return parsed;
+}
+function normalizeGeminiText(value) {
+    return value.replace(/\s+/g, " ").trim();
+}
+async function runRoastNarratorAgent(config, insights) {
+    if (insights.issues.length === 0) {
+        return {
+            content: `No issues detected for ${config.focus}. Add analyzers to produce evidence-bound findings.`,
+            usedGemini: false,
+        };
+    }
+    const fallbackLines = insights.issues.map((issue, index) => formatIssueLine(index, issue, buildLaymanMessage(issue), config.showDetails, config.detailsLimit));
+    const actionItems = insights.issues
+        .map(buildActionItem)
+        .filter((item) => Boolean(item));
+    const apiKey = (0, gemini_client_1.getGeminiApiKey)();
+    if (!apiKey) {
+        return {
+            content: fallbackLines.join("\n\n"),
+            usedGemini: false,
+            actionItems,
+        };
+    }
+    const model = process.env.GEMINI_MODEL ?? "gemini-2.5-flash";
+    const issuesWithId = insights.issues.map((issue, index) => ({
+        ...issue,
+        id: index + 1,
+    }));
+    try {
+        const prompt = buildGeminiPrompt(config, issuesWithId);
+        const responseText = await (0, gemini_client_1.callGeminiNarrator)({
+            apiKey,
+            model,
+            prompt,
+        });
+        const parsed = extractJsonArray(responseText);
+        const byId = new Map();
+        for (const item of parsed) {
+            if (typeof item?.id !== "number" || typeof item?.text !== "string") {
+                continue;
+            }
+            byId.set(item.id, normalizeGeminiText(item.text));
+        }
+        const lines = issuesWithId.map((issue, index) => {
+            if (!issue.evidenceComplete) {
+                return formatIssueLine(index, issue, "not enough data", config.showDetails, config.detailsLimit);
+            }
+            const geminiText = byId.get(issue.id);
+            if (!geminiText) {
+                return fallbackLines[index];
+            }
+            if (geminiText.toLowerCase() === "not enough data") {
+                return fallbackLines[index];
+            }
+            return formatIssueLine(index, issue, geminiText, config.showDetails, config.detailsLimit);
+        });
+        return { content: lines.join("\n\n"), usedGemini: true };
+    }
+    catch {
+        return {
+            content: fallbackLines.join("\n\n"),
+            usedGemini: false,
+            actionItems,
+        };
+    }
+}

package/dist/index.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("dotenv/config");
+const pipeline_1 = require("./pipeline");
+(0, pipeline_1.runPipeline)(process.argv.slice(2))
+    .then((output) => {
+    process.stdout.write(output);
+})
+    .catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`${message}\n`);
+    process.exitCode = 1;
+});

package/dist/pipeline.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPipeline = runPipeline;
+const cli_agent_1 = require("./agents/cli-agent");
+const code_analysis_agent_1 = require("./agents/code-analysis-agent");
+const evidence_guard_agent_1 = require("./agents/evidence-guard-agent");
+const fix_apply_agent_1 = require("./agents/fix-apply-agent");
+const fix_it_agent_1 = require("./agents/fix-it-agent");
+const insight_aggregator_agent_1 = require("./agents/insight-aggregator-agent");
+const output_formatter_agent_1 = require("./agents/output-formatter-agent");
+const repo_scanner_agent_1 = require("./agents/repo-scanner-agent");
+const roast_narrator_agent_1 = require("./agents/roast-narrator-agent");
+async function runPipeline(argv) {
+    const cliConfig = (0, cli_agent_1.runCliAgent)(argv);
+    const scanResult = await (0, repo_scanner_agent_1.runRepoScannerAgent)(cliConfig);
+    const analysisResult = await (0, code_analysis_agent_1.runCodeAnalysisAgent)(cliConfig, scanResult);
+    const insights = (0, insight_aggregator_agent_1.runInsightAggregatorAgent)(scanResult, analysisResult);
+    const guardedInsights = (0, evidence_guard_agent_1.runEvidenceGuardAgent)(insights);
+    const fixResult = cliConfig.enableFixes
+        ? await (0, fix_it_agent_1.runFixItAgent)(cliConfig, scanResult, analysisResult, guardedInsights)
+        : undefined;
+    if (fixResult && cliConfig.applyFixes) {
+        fixResult.applyResult = await (0, fix_apply_agent_1.runFixApplyAgent)(cliConfig, fixResult);
+    }
+    const roast = await (0, roast_narrator_agent_1.runRoastNarratorAgent)(cliConfig, guardedInsights);
+    const formatted = (0, output_formatter_agent_1.runOutputFormatterAgent)(cliConfig, roast, fixResult, analysisResult);
+    return formatted.text;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "coderoast",
+  "version": "0.1.0",
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "demo:fix": "node scripts/demo-fix.js",
+    "demo:judge": "node scripts/demo-judge.js",
+    "start": "node dist/index.js",
+    "typecheck": "tsc --noEmit",
+    "test": "npm run build && node --test tests/**/*.test.js"
+  },
+  "bin": {
+    "coderoast": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "Agents.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@google/genai": "^1.38.0",
+    "dotenv": "^17.2.3",
+    "ignore": "^5.3.1",
+    "typescript": "^5.0.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.0.0",
+    "@types/node": "^20.11.0",
+    "@typescript-eslint/eslint-plugin": "^8.0.0",
+    "@typescript-eslint/parser": "^8.0.0",
+    "eslint": "^9.0.0",
+    "globals": "^15.0.0"
+  }
+}