coderoast 0.1.0

package/dist/agents/insight-aggregator-agent.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInsightAggregatorAgent = runInsightAggregatorAgent;
+const MAX_LONG_FUNCTIONS = 5;
+const MAX_DUPLICATE_BLOCKS = 3;
+const MAX_DUPLICATE_OCCURRENCES = 3;
+const MAX_CIRCULAR_CYCLES = 3;
+function buildLongFunctionEvidence(longFunctions) {
+    return [...longFunctions]
+        .sort((a, b) => b.length - a.length)
+        .slice(0, MAX_LONG_FUNCTIONS)
+        .map((fn) => ({
+        file: fn.file,
+        startLine: fn.startLine,
+        endLine: fn.endLine,
+        metrics: [{ type: "loc", value: fn.length }],
+    }));
+}
+function buildDuplicateEvidence(duplicateBlocks) {
+    const blocks = [...duplicateBlocks]
+        .sort((a, b) => b.occurrences.length - a.occurrences.length || b.length - a.length)
+        .slice(0, MAX_DUPLICATE_BLOCKS);
+    const evidence = [];
+    for (const block of blocks) {
+        const occurrences = block.occurrences.slice(0, MAX_DUPLICATE_OCCURRENCES);
+        for (const occurrence of occurrences) {
+            evidence.push({
+                file: occurrence.file,
+                startLine: occurrence.startLine,
+                endLine: occurrence.endLine,
+                metrics: [
+                    { type: "loc", value: block.length },
+                    { type: "count", value: block.occurrences.length },
+                    { type: "hash", value: block.hash },
+                ],
+            });
+        }
+    }
+    return evidence;
+}
+function buildCircularEvidence(circularDependencies) {
+    const evidence = [];
+    const cycles = circularDependencies.slice(0, MAX_CIRCULAR_CYCLES);
+    for (const cycle of cycles) {
+        evidence.push({
+            file: cycle.from,
+            startLine: cycle.fromStartLine,
+            endLine: cycle.fromEndLine,
+            metrics: [{ type: "count", value: 1 }],
+        });
+        evidence.push({
+            file: cycle.to,
+            startLine: cycle.toStartLine,
+            endLine: cycle.toEndLine,
+            metrics: [{ type: "count", value: 1 }],
+        });
+    }
+    return evidence;
+}
+function runInsightAggregatorAgent(_scan, analysis) {
+    const issues = [];
+    if (analysis.signals.longFunctions.length > 0) {
+        issues.push({
+            type: "maintainability",
+            signal: "longFunctions",
+            confidence: "medium",
+            evidence: buildLongFunctionEvidence(analysis.signals.longFunctions),
+        });
+    }
+    if (analysis.signals.duplicateBlocks.length > 0) {
+        issues.push({
+            type: "duplication",
+            signal: "duplicateBlocks",
+            confidence: "high",
+            evidence: buildDuplicateEvidence(analysis.signals.duplicateBlocks),
+        });
+    }
+    if (analysis.signals.circularDependencies.length > 0) {
+        issues.push({
+            type: "architecture",
+            signal: "circularDependencies",
+            confidence: "high",
+            evidence: buildCircularEvidence(analysis.signals.circularDependencies),
+        });
+    }
+    if (!analysis.signals.testPresence.hasTests) {
+        issues.push({
+            type: "testing",
+            signal: "testPresence",
+            confidence: "medium",
+            evidence: [],
+        });
+    }
+    return { issues };
+}

package/dist/agents/output-formatter-agent.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runOutputFormatterAgent = runOutputFormatterAgent;
+function humanizeFixMessage(message) {
+    const mappings = [
+        {
+            pattern: /Malformed hunk header/i,
+            replacement: "The AI response was not a valid patch format.",
+        },
+        {
+            pattern: /Patch contains no changes/i,
+            replacement: "The AI did not include any actual code changes.",
+        },
+        {
+            pattern: /outside evidence/i,
+            replacement: "The change touched code outside the allowed evidence range.",
+        },
+        {
+            pattern: /Empty patch response/i,
+            replacement: "The AI did not return a patch.",
+        },
+        {
+            pattern: /Long function length reduced/i,
+            replacement: "This change would shorten a long function.",
+        },
+        {
+            pattern: /Long function length did not improve/i,
+            replacement: "This change does not shorten the long function.",
+        },
+        {
+            pattern: /Duplicate blocks reduced/i,
+            replacement: "This change would reduce repeated code.",
+        },
+        {
+            pattern: /Duplicate blocks did not improve/i,
+            replacement: "This change does not reduce repeated code.",
+        },
+    ];
+    for (const mapping of mappings) {
+        if (mapping.pattern.test(message)) {
+            return mapping.replacement;
+        }
+    }
+    return message;
+}
+function formatFixSummary(suggestion) {
+    const status = suggestion.verified ? "Fix preview looks good" : "Fix preview failed";
+    const detail = humanizeFixMessage(suggestion.verificationMessage);
+    return `${suggestion.issueId}. [${suggestion.issueType}] ${status}: ${detail}`;
+}
+function formatPreviewSummary(summary) {
+    const lines = ["", "Impact Summary (preview)"];
+    const before = summary.before;
+    if (!summary.after || !summary.delta) {
+        lines.push("No verified patches to compare yet.");
+        return lines;
+    }
+    const after = summary.after;
+    const delta = summary.delta;
+    lines.push(`Max function length: ${before.maxFunctionLength} -> ${after.maxFunctionLength} (${delta.maxFunctionLength})`);
+    lines.push(`Avg function length: ${before.avgFunctionLength} -> ${after.avgFunctionLength} (${delta.avgFunctionLength})`);
+    lines.push(`Duplicate blocks: ${before.duplicateBlocks} -> ${after.duplicateBlocks} (${delta.duplicateBlocks})`);
+    lines.push(`Total functions: ${before.totalFunctions} -> ${after.totalFunctions} (${delta.totalFunctions})`);
+    if (summary.note) {
+        lines.push(summary.note);
+    }
+    return lines;
+}
+function formatApplyResult(result) {
+    const lines = ["", "Proof-Locked Apply"];
+    lines.push(result.message);
+    if (result.branch) {
+        lines.push(`Branch: ${result.branch}`);
+    }
+    if (result.testCommand) {
+        lines.push(`Tests: ${result.testCommand}`);
+    }
+    if (result.testsPassed !== undefined) {
+        lines.push(`Tests passed: ${result.testsPassed ? "yes" : "no"}`);
+    }
+    return lines;
+}
+function formatArchitectureSummary(analysis) {
+    if (!analysis?.dependencySummary) {
+        return [];
+    }
+    const summary = analysis.dependencySummary;
+    const lines = ["", "Architecture Map"];
+    lines.push(`Internal modules: ${summary.nodes}`);
+    lines.push(`Import links: ${summary.edges}`);
+    if (summary.topImporters.length > 0) {
+        lines.push("Top importers:");
+        for (const entry of summary.topImporters) {
+            lines.push(`- ${entry.file} (${entry.imports})`);
+        }
+    }
+    if (summary.topImported.length > 0) {
+        lines.push("Most imported:");
+        for (const entry of summary.topImported) {
+            lines.push(`- ${entry.file} (${entry.importedBy})`);
+        }
+    }
+    if (summary.cycles > 0 && summary.sampleCycle) {
+        lines.push(`Cycles detected: ${summary.cycles}`);
+        lines.push(`Example cycle: ${summary.sampleCycle.from} ↔ ${summary.sampleCycle.to}`);
+    }
+    else {
+        lines.push("Cycles detected: 0");
+    }
+    return lines;
+}
+function runOutputFormatterAgent(config, roast, fixResult, analysis) {
+    const title = `CodeRoast (${config.severity}, ${config.focus})`;
+    const divider = "-".repeat(title.length);
+    const sections = [`${title}\n${divider}\n${roast.content}`];
+    if (roast.actionItems && roast.actionItems.length > 0 && roast.usedGemini === false) {
+        sections.push(["", "Action Items", ...roast.actionItems.map((item) => `- ${item}`)].join("\n"));
+    }
+    if (analysis?.dependencySummary) {
+        sections.push(formatArchitectureSummary(analysis).join("\n").trimEnd());
+    }
+    if (fixResult?.previewSummary) {
+        sections.push(formatPreviewSummary(fixResult.previewSummary).join("\n").trimEnd());
+    }
+    if (fixResult && fixResult.suggestions.length > 0) {
+        const fixLines = ["", "Fix-It (preview)"];
+        let hiddenPatch = false;
+        for (const suggestion of fixResult.suggestions) {
+            fixLines.push(formatFixSummary(suggestion));
+            if (config.showDetails && suggestion.verificationDetails) {
+                fixLines.push(`Details: ${suggestion.verificationDetails}`);
+            }
+            if (suggestion.debugPaths && suggestion.debugPaths.length > 0) {
+                fixLines.push("Debug output:");
+                for (const debugPath of suggestion.debugPaths) {
+                    fixLines.push(`- ${debugPath}`);
+                }
+            }
+            if (config.showDetails && suggestion.patch) {
+                fixLines.push(suggestion.patch);
+            }
+            else if (suggestion.patch) {
+                hiddenPatch = true;
+            }
+            fixLines.push("");
+        }
+        if (hiddenPatch && !config.showDetails) {
+            fixLines.push("Run with --details to see the patch diff.");
+        }
+        sections.push(fixLines.join("\n").trimEnd());
+    }
+    if (fixResult?.applyResult) {
+        sections.push(formatApplyResult(fixResult.applyResult).join("\n").trimEnd());
+    }
+    return {
+        text: `${sections.join("\n")}\n`,
+    };
+}

package/dist/agents/repo-scanner-agent.js

@@ -0,0 +1,407 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runRepoScannerAgent = runRepoScannerAgent;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const ignore_1 = __importDefault(require("ignore"));
+const DEFAULT_MAX_FILE_SIZE_BYTES = 5 * 1024 * 1024;
+const MAX_BINARY_CHECK_BYTES = 8000;
+const MAX_IGNORED_PATHS = 50;
+const NO_EXTENSION_KEY = "<none>";
+const AUTO_IGNORE_DIRS = [".git", "node_modules", "dist", "build", ".next", "out", ".turbo"];
+const PROJECT_FILE_NAMES = new Set([
+    "package.json",
+    "tsconfig.json",
+    "requirements.txt",
+    "pyproject.toml",
+    "go.mod",
+]);
+const ENTRY_ROOT_BASE_NAMES = new Set(["app", "server"]);
+const ENTRY_SRC_BASE_NAMES = new Set(["index", "main"]);
+const LANGUAGE_BY_EXTENSION = {
+    ".ts": "ts",
+    ".tsx": "ts",
+    ".js": "js",
+    ".jsx": "js",
+    ".mjs": "js",
+    ".cjs": "js",
+    ".json": "json",
+    ".yml": "yaml",
+    ".yaml": "yaml",
+    ".toml": "toml",
+    ".py": "py",
+    ".go": "go",
+    ".rs": "rs",
+    ".java": "java",
+    ".kt": "kt",
+    ".cs": "cs",
+    ".rb": "rb",
+    ".php": "php",
+    ".swift": "swift",
+    ".scala": "scala",
+    ".sh": "shell",
+    ".ps1": "powershell",
+    ".html": "html",
+    ".css": "css",
+    ".scss": "scss",
+    ".sass": "sass",
+    ".less": "less",
+    ".sql": "sql",
+};
+const TEXT_EXTENSIONS = new Set([
+    ...Object.keys(LANGUAGE_BY_EXTENSION),
+    ".md",
+    ".mdx",
+    ".txt",
+    ".ini",
+    ".env",
+    ".xml",
+    ".csv",
+    ".tsv",
+    ".graphql",
+    ".gql",
+    ".vue",
+    ".svelte",
+    ".astro",
+    ".lock",
+]);
+const BINARY_EXTENSIONS = new Set([
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".webp",
+    ".bmp",
+    ".ico",
+    ".tiff",
+    ".psd",
+    ".ai",
+    ".sketch",
+    ".zip",
+    ".tar",
+    ".gz",
+    ".tgz",
+    ".7z",
+    ".rar",
+    ".pdf",
+    ".exe",
+    ".dll",
+    ".so",
+    ".dylib",
+    ".class",
+    ".jar",
+    ".war",
+    ".mp3",
+    ".mp4",
+    ".mov",
+    ".avi",
+    ".mkv",
+    ".woff",
+    ".woff2",
+    ".ttf",
+    ".eot",
+    ".otf",
+    ".db",
+    ".sqlite",
+    ".sqlite3",
+    ".bin",
+    ".dat",
+]);
+function toPosixPath(value) {
+    return value.split(node_path_1.default.sep).join("/");
+}
+function normalizeRelativePath(value) {
+    const normalized = toPosixPath(node_path_1.default.normalize(value));
+    return normalized.replace(/^\.\/+/, "");
+}
+function increment(record, key) {
+    record[key] = (record[key] ?? 0) + 1;
+}
+function isBinaryExtension(extension) {
+    return BINARY_EXTENSIONS.has(extension);
+}
+function shouldCheckBinary(extension) {
+    if (!extension) {
+        return true;
+    }
+    return !TEXT_EXTENSIONS.has(extension);
+}
+async function isBinaryFile(filePath, size) {
+    const bytesToRead = Math.min(size, MAX_BINARY_CHECK_BYTES);
+    if (bytesToRead === 0) {
+        return false;
+    }
+    let handle;
+    try {
+        handle = await node_fs_1.default.promises.open(filePath, "r");
+        const buffer = Buffer.alloc(bytesToRead);
+        await handle.read(buffer, 0, bytesToRead, 0);
+        return buffer.includes(0);
+    }
+    catch {
+        return true;
+    }
+    finally {
+        if (handle) {
+            await handle.close().catch(() => undefined);
+        }
+    }
+}
+async function readGitignore(rootPath) {
+    try {
+        const content = await node_fs_1.default.promises.readFile(node_path_1.default.join(rootPath, ".gitignore"), "utf8");
+        return content.split(/\r?\n/);
+    }
+    catch {
+        return [];
+    }
+}
+async function createIgnoreMatcher(rootPath) {
+    const matcher = (0, ignore_1.default)();
+    const gitignoreLines = await readGitignore(rootPath);
+    if (gitignoreLines.length > 0) {
+        matcher.add(gitignoreLines);
+    }
+    matcher.add(AUTO_IGNORE_DIRS.map((dir) => `${dir}/`));
+    return (relativePath, isDir) => {
+        if (!relativePath) {
+            return false;
+        }
+        const target = isDir ? `${relativePath}/` : relativePath;
+        return matcher.ignores(target);
+    };
+}
+function isWithinRoot(rootPath, targetPath) {
+    const relative = node_path_1.default.relative(rootPath, targetPath);
+    if (!relative) {
+        return false;
+    }
+    return !relative.startsWith("..") && !node_path_1.default.isAbsolute(relative);
+}
+async function safeStat(filePath) {
+    try {
+        return await node_fs_1.default.promises.stat(filePath);
+    }
+    catch {
+        return null;
+    }
+}
+function isEntryPointPath(relativePath) {
+    const normalized = relativePath;
+    const parts = normalized.split("/");
+    const extension = node_path_1.default.posix.extname(normalized);
+    const baseName = node_path_1.default.posix.basename(normalized, extension);
+    if (parts.length === 2 && parts[0] === "src" && ENTRY_SRC_BASE_NAMES.has(baseName)) {
+        return true;
+    }
+    if (parts.length === 1 && ENTRY_ROOT_BASE_NAMES.has(baseName)) {
+        return true;
+    }
+    return false;
+}
+async function resolvePackageEntryPoints(rootPath, maxFileSizeBytes, shouldIgnore) {
+    const packageRelativePath = "package.json";
+    if (shouldIgnore(packageRelativePath, false)) {
+        return [];
+    }
+    const packagePath = node_path_1.default.join(rootPath, packageRelativePath);
+    const stats = await safeStat(packagePath);
+    if (!stats || !stats.isFile()) {
+        return [];
+    }
+    if (stats.size > maxFileSizeBytes) {
+        return [];
+    }
+    let packageJson;
+    try {
+        const content = await node_fs_1.default.promises.readFile(packagePath, "utf8");
+        packageJson = JSON.parse(content);
+    }
+    catch {
+        return [];
+    }
+    const entries = [];
+    if (packageJson && typeof packageJson === "object") {
+        const data = packageJson;
+        if (typeof data.main === "string") {
+            entries.push(data.main);
+        }
+        if (typeof data.bin === "string") {
+            entries.push(data.bin);
+        }
+        else if (data.bin && typeof data.bin === "object") {
+            for (const value of Object.values(data.bin)) {
+                if (typeof value === "string") {
+                    entries.push(value);
+                }
+            }
+        }
+    }
+    const entryPoints = [];
+    for (const entry of entries) {
+        const normalized = normalizeRelativePath(entry);
+        if (!normalized) {
+            continue;
+        }
+        const absolute = node_path_1.default.resolve(rootPath, normalized);
+        if (!isWithinRoot(rootPath, absolute)) {
+            continue;
+        }
+        const entryStats = await safeStat(absolute);
+        if (!entryStats || !entryStats.isFile()) {
+            continue;
+        }
+        entryPoints.push(toPosixPath(node_path_1.default.relative(rootPath, absolute)));
+    }
+    return entryPoints;
+}
+function toSortedRecord(record) {
+    const sorted = {};
+    for (const key of Object.keys(record).sort()) {
+        sorted[key] = record[key];
+    }
+    return sorted;
+}
+function bytesToMB(bytes) {
+    if (bytes === 0) {
+        return 0;
+    }
+    return Math.round((bytes / (1024 * 1024)) * 100) / 100;
+}
+function getMaxFileSizeBytes(config) {
+    if (!config.maxFileSizeMB || config.maxFileSizeMB <= 0) {
+        return DEFAULT_MAX_FILE_SIZE_BYTES;
+    }
+    return config.maxFileSizeMB * 1024 * 1024;
+}
+async function runRepoScannerAgent(config) {
+    const rootPath = node_path_1.default.resolve(config.path);
+    const maxFileSizeBytes = getMaxFileSizeBytes(config);
+    const shouldIgnore = await createIgnoreMatcher(rootPath);
+    const deadline = typeof config.scanTimeoutMs === "number" && config.scanTimeoutMs > 0
+        ? Date.now() + config.scanTimeoutMs
+        : null;
+    const scanState = {
+        languages: {},
+        fileTypes: {},
+        totalFiles: 0,
+        totalFolders: 0,
+        entryPoints: new Set(),
+        projectFiles: new Set(),
+        ignoredCount: 0,
+        ignoredPaths: new Set(),
+        repoSizeBytes: 0,
+        files: [],
+        warnings: [],
+    };
+    const pending = [rootPath];
+    let timedOut = false;
+    while (pending.length > 0) {
+        if (deadline && Date.now() > deadline) {
+            timedOut = true;
+            break;
+        }
+        const currentPath = pending.pop();
+        if (!currentPath) {
+            continue;
+        }
+        let directory = null;
+        try {
+            directory = await node_fs_1.default.promises.opendir(currentPath);
+        }
+        catch {
+            scanState.warnings.push(`Unable to read directory: ${currentPath}`);
+            continue;
+        }
+        scanState.totalFolders += 1;
+        for await (const entry of directory) {
+            if (deadline && Date.now() > deadline) {
+                timedOut = true;
+                break;
+            }
+            if (entry.isSymbolicLink()) {
+                continue;
+            }
+            const fullPath = node_path_1.default.join(currentPath, entry.name);
+            const relativePath = toPosixPath(node_path_1.default.relative(rootPath, fullPath));
+            const isDir = entry.isDirectory();
+            if (shouldIgnore(relativePath, isDir)) {
+                scanState.ignoredCount += 1;
+                if (isDir && scanState.ignoredPaths.size < MAX_IGNORED_PATHS) {
+                    scanState.ignoredPaths.add(relativePath);
+                }
+                continue;
+            }
+            if (isDir) {
+                pending.push(fullPath);
+                continue;
+            }
+            if (!entry.isFile()) {
+                continue;
+            }
+            const stats = await safeStat(fullPath);
+            if (!stats || !stats.isFile()) {
+                scanState.warnings.push(`Unable to stat file: ${fullPath}`);
+                continue;
+            }
+            scanState.repoSizeBytes += stats.size;
+            if (PROJECT_FILE_NAMES.has(entry.name)) {
+                scanState.projectFiles.add(relativePath);
+            }
+            if (isEntryPointPath(relativePath)) {
+                scanState.entryPoints.add(relativePath);
+            }
+            if (stats.size > maxFileSizeBytes) {
+                continue;
+            }
+            const extension = node_path_1.default.extname(entry.name).toLowerCase();
+            if (isBinaryExtension(extension)) {
+                continue;
+            }
+            if (shouldCheckBinary(extension)) {
+                const binary = await isBinaryFile(fullPath, stats.size);
+                if (binary) {
+                    continue;
+                }
+            }
+            const language = LANGUAGE_BY_EXTENSION[extension] ?? "other";
+            scanState.files.push({
+                path: relativePath,
+                sizeBytes: stats.size,
+                extension,
+                language,
+            });
+            scanState.totalFiles += 1;
+            increment(scanState.fileTypes, extension || NO_EXTENSION_KEY);
+            increment(scanState.languages, language);
+        }
+        if (timedOut) {
+            break;
+        }
+    }
+    const packageEntryPoints = await resolvePackageEntryPoints(rootPath, maxFileSizeBytes, shouldIgnore);
+    for (const entryPoint of packageEntryPoints) {
+        scanState.entryPoints.add(entryPoint);
+    }
+    if (timedOut) {
+        scanState.warnings.push("Scan timed out");
+    }
+    const result = {
+        languages: toSortedRecord(scanState.languages),
+        fileTypes: toSortedRecord(scanState.fileTypes),
+        totalFiles: scanState.totalFiles,
+        totalFolders: scanState.totalFolders,
+        entryPoints: Array.from(scanState.entryPoints).sort(),
+        projectFiles: Array.from(scanState.projectFiles).sort(),
+        ignoredCount: scanState.ignoredCount,
+        repoSizeMB: bytesToMB(scanState.repoSizeBytes),
+        files: scanState.files.sort((a, b) => a.path.localeCompare(b.path)),
+    };
+    if (scanState.ignoredPaths.size > 0) {
+        result.ignoredPaths = Array.from(scanState.ignoredPaths).sort();
+    }
+    return result;
+}