coderoast 0.1.0

package/dist/agents/code-analysis-agent.js

@@ -0,0 +1,438 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DUPLICATE_MIN_OCCURRENCES = exports.DUPLICATE_MAX_LINES = exports.DUPLICATE_MIN_LINES = exports.LONG_FUNCTION_LOC = void 0;
+exports.runCodeAnalysisAgent = runCodeAnalysisAgent;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const typescript_1 = __importDefault(require("typescript"));
+exports.LONG_FUNCTION_LOC = 50;
+exports.DUPLICATE_MIN_LINES = 10;
+exports.DUPLICATE_MAX_LINES = 50;
+exports.DUPLICATE_MIN_OCCURRENCES = 2;
+const JS_TS_EXTENSIONS = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
+const TEST_DIR_NAMES = new Set(["__tests__", "test", "tests"]);
+function getScriptKind(extension) {
+    switch (extension) {
+        case ".tsx":
+            return typescript_1.default.ScriptKind.TSX;
+        case ".jsx":
+            return typescript_1.default.ScriptKind.JSX;
+        case ".js":
+            return typescript_1.default.ScriptKind.JS;
+        case ".mjs":
+            return typescript_1.default.ScriptKind.JS;
+        case ".cjs":
+            return typescript_1.default.ScriptKind.JS;
+        default:
+            return typescript_1.default.ScriptKind.TS;
+    }
+}
+function getLineRange(node, sourceFile) {
+    const start = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+    const end = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
+    return { startLine: start.line + 1, endLine: end.line + 1 };
+}
+function normalizeContent(content) {
+    const withoutBlockComments = content.replace(/\/\*[\s\S]*?\*\//g, (match) => {
+        return match.replace(/[^\n]/g, "");
+    });
+    const withoutLineComments = withoutBlockComments.replace(/\/\/.*$/gm, "");
+    const rawLines = withoutLineComments.split(/\r?\n/);
+    const normalizedLines = [];
+    const lineNumbers = [];
+    for (let i = 0; i < rawLines.length; i += 1) {
+        const normalized = rawLines[i].replace(/\s+/g, " ").trim();
+        if (normalized.length === 0) {
+            continue;
+        }
+        normalizedLines.push(normalized);
+        lineNumbers.push(i + 1);
+    }
+    return { normalizedLines, lineNumbers };
+}
+function hashString(value) {
+    let hash = 5381;
+    for (let i = 0; i < value.length; i += 1) {
+        hash = (hash * 33) ^ value.charCodeAt(i);
+    }
+    return (hash >>> 0).toString(16);
+}
+function isTestPath(relativePath) {
+    const segments = relativePath.split("/");
+    if (segments.some((segment) => TEST_DIR_NAMES.has(segment))) {
+        return true;
+    }
+    const fileName = node_path_1.default.posix.basename(relativePath);
+    return /\.(spec|test)\.[jt]sx?$/.test(fileName);
+}
+function toAbsolutePath(rootPath, relativePath) {
+    const parts = relativePath.split("/");
+    return node_path_1.default.resolve(rootPath, node_path_1.default.join(...parts));
+}
+function collectImports(sourceFile) {
+    const imports = [];
+    const addImport = (specifier, node) => {
+        const { startLine, endLine } = getLineRange(node, sourceFile);
+        imports.push({ specifier, startLine, endLine });
+    };
+    const visit = (node) => {
+        if (typescript_1.default.isImportDeclaration(node) && node.moduleSpecifier && typescript_1.default.isStringLiteral(node.moduleSpecifier)) {
+            addImport(node.moduleSpecifier.text, node);
+        }
+        else if (typescript_1.default.isExportDeclaration(node) &&
+            node.moduleSpecifier &&
+            typescript_1.default.isStringLiteral(node.moduleSpecifier)) {
+            addImport(node.moduleSpecifier.text, node);
+        }
+        else if (typescript_1.default.isImportEqualsDeclaration(node)) {
+            const ref = node.moduleReference;
+            if (typescript_1.default.isExternalModuleReference(ref) && ref.expression && typescript_1.default.isStringLiteral(ref.expression)) {
+                addImport(ref.expression.text, node);
+            }
+        }
+        else if (typescript_1.default.isCallExpression(node)) {
+            if (typescript_1.default.isIdentifier(node.expression) &&
+                node.expression.text === "require" &&
+                node.arguments.length === 1 &&
+                typescript_1.default.isStringLiteral(node.arguments[0])) {
+                addImport(node.arguments[0].text, node);
+            }
+            else if (node.expression.kind === typescript_1.default.SyntaxKind.ImportKeyword && node.arguments.length === 1) {
+                const arg = node.arguments[0];
+                if (typescript_1.default.isStringLiteral(arg)) {
+                    addImport(arg.text, node);
+                }
+            }
+        }
+        typescript_1.default.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return imports;
+}
+function getFunctionName(node, sourceFile) {
+    if (typescript_1.default.isFunctionDeclaration(node) && node.name) {
+        return node.name.text;
+    }
+    if ((typescript_1.default.isMethodDeclaration(node) ||
+        typescript_1.default.isMethodSignature(node) ||
+        typescript_1.default.isGetAccessorDeclaration(node) ||
+        typescript_1.default.isSetAccessorDeclaration(node)) &&
+        node.name) {
+        return node.name.getText(sourceFile);
+    }
+    if (typescript_1.default.isConstructorDeclaration(node)) {
+        return "constructor";
+    }
+    const parent = node.parent;
+    if (parent) {
+        if (typescript_1.default.isVariableDeclaration(parent) && typescript_1.default.isIdentifier(parent.name)) {
+            return parent.name.text;
+        }
+        if (typescript_1.default.isPropertyAssignment(parent) || typescript_1.default.isPropertyDeclaration(parent)) {
+            if (typescript_1.default.isIdentifier(parent.name)) {
+                return parent.name.text;
+            }
+            return parent.name.getText(sourceFile);
+        }
+    }
+    return "<anonymous>";
+}
+function collectFunctionLengths(sourceFile, filePath) {
+    const functions = [];
+    const visit = (node) => {
+        if (typescript_1.default.isFunctionLike(node) && "body" in node && node.body) {
+            const start = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+            const end = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
+            const startLine = start.line + 1;
+            const endLine = end.line + 1;
+            const length = endLine - startLine + 1;
+            functions.push({
+                file: filePath,
+                name: getFunctionName(node, sourceFile),
+                length,
+                startLine,
+                endLine,
+            });
+        }
+        typescript_1.default.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return functions;
+}
+function resolveImportPath(importerPath, specifier, filePaths) {
+    if (!specifier.startsWith(".")) {
+        return null;
+    }
+    const baseDir = node_path_1.default.posix.dirname(importerPath);
+    const combined = node_path_1.default.posix.normalize(node_path_1.default.posix.join(baseDir, specifier));
+    const hasExtension = node_path_1.default.posix.extname(combined) !== "";
+    const candidates = [];
+    if (hasExtension) {
+        candidates.push(combined);
+    }
+    else {
+        for (const extension of JS_TS_EXTENSIONS) {
+            candidates.push(`${combined}${extension}`);
+            candidates.push(node_path_1.default.posix.join(combined, `index${extension}`));
+        }
+    }
+    for (const candidate of candidates) {
+        if (filePaths.has(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function collectDuplicateBlocks(files) {
+    const candidates = new Map();
+    const fileIndex = new Map();
+    for (const file of files) {
+        fileIndex.set(file.path, file);
+        const totalLines = file.normalizedLines.length;
+        if (totalLines < exports.DUPLICATE_MIN_LINES) {
+            continue;
+        }
+        for (let start = 0; start <= totalLines - exports.DUPLICATE_MIN_LINES; start += 1) {
+            const blockLines = file.normalizedLines.slice(start, start + exports.DUPLICATE_MIN_LINES);
+            const blockKey = blockLines.join("\n");
+            const group = candidates.get(blockKey);
+            if (group) {
+                group.push({ file: file.path, startIndex: start });
+            }
+            else {
+                candidates.set(blockKey, [{ file: file.path, startIndex: start }]);
+            }
+        }
+    }
+    const duplicatesMap = new Map();
+    for (const [, occurrences] of candidates) {
+        if (occurrences.length < exports.DUPLICATE_MIN_OCCURRENCES) {
+            continue;
+        }
+        const baseline = occurrences[0];
+        const baselineFile = fileIndex.get(baseline.file);
+        if (!baselineFile) {
+            continue;
+        }
+        let length = exports.DUPLICATE_MIN_LINES;
+        for (let offset = exports.DUPLICATE_MIN_LINES; offset < exports.DUPLICATE_MAX_LINES; offset += 1) {
+            const baselineIndex = baseline.startIndex + offset;
+            if (baselineIndex >= baselineFile.normalizedLines.length) {
+                break;
+            }
+            const expected = baselineFile.normalizedLines[baselineIndex];
+            let allMatch = true;
+            for (const occurrence of occurrences) {
+                const file = fileIndex.get(occurrence.file);
+                if (!file || occurrence.startIndex + offset >= file.normalizedLines.length) {
+                    allMatch = false;
+                    break;
+                }
+                if (file.normalizedLines[occurrence.startIndex + offset] !== expected) {
+                    allMatch = false;
+                    break;
+                }
+            }
+            if (!allMatch) {
+                break;
+            }
+            length += 1;
+        }
+        const extendedBlockLines = baselineFile.normalizedLines.slice(baseline.startIndex, baseline.startIndex + length);
+        const extendedKey = extendedBlockLines.join("\n");
+        const hash = hashString(extendedKey);
+        let entry = duplicatesMap.get(extendedKey);
+        if (!entry) {
+            entry = {
+                block: {
+                    hash,
+                    length,
+                    occurrences: [],
+                },
+                occurrenceKeys: new Set(),
+            };
+            duplicatesMap.set(extendedKey, entry);
+        }
+        for (const occurrence of occurrences) {
+            const file = fileIndex.get(occurrence.file);
+            if (!file) {
+                continue;
+            }
+            const startLine = file.lineNumbers[occurrence.startIndex];
+            const endIndex = occurrence.startIndex + length - 1;
+            if (startLine === undefined || endIndex >= file.lineNumbers.length) {
+                continue;
+            }
+            const endLine = file.lineNumbers[endIndex];
+            const occurrenceKey = `${occurrence.file}:${startLine}:${endLine}`;
+            if (entry.occurrenceKeys.has(occurrenceKey)) {
+                continue;
+            }
+            entry.occurrenceKeys.add(occurrenceKey);
+            entry.block.occurrences.push({
+                file: occurrence.file,
+                startLine,
+                endLine,
+            });
+        }
+    }
+    const blocks = [];
+    for (const entry of duplicatesMap.values()) {
+        if (entry.block.occurrences.length >= exports.DUPLICATE_MIN_OCCURRENCES) {
+            blocks.push(entry.block);
+        }
+    }
+    return blocks;
+}
+function collectCircularDependencies(files, filePaths) {
+    const graph = new Map();
+    for (const file of files) {
+        const edges = new Map();
+        for (const ref of file.imports) {
+            const resolved = resolveImportPath(file.path, ref.specifier, filePaths);
+            if (!resolved) {
+                continue;
+            }
+            const ranges = edges.get(resolved) ?? [];
+            ranges.push({ startLine: ref.startLine, endLine: ref.endLine });
+            edges.set(resolved, ranges);
+        }
+        graph.set(file.path, edges);
+    }
+    const cycles = [];
+    const seen = new Set();
+    for (const [from, targets] of graph) {
+        for (const [to, ranges] of targets) {
+            const reverseRanges = graph.get(to)?.get(from);
+            if (!reverseRanges || reverseRanges.length === 0) {
+                continue;
+            }
+            const key = [from, to].sort().join("::");
+            if (seen.has(key)) {
+                continue;
+            }
+            seen.add(key);
+            const fromRange = ranges[0];
+            const toRange = reverseRanges[0];
+            cycles.push({
+                from,
+                to,
+                fromStartLine: fromRange.startLine,
+                fromEndLine: fromRange.endLine,
+                toStartLine: toRange.startLine,
+                toEndLine: toRange.endLine,
+            });
+        }
+    }
+    return cycles;
+}
+function buildDependencySummary(files, filePaths, cycles) {
+    const outCounts = new Map();
+    const inCounts = new Map();
+    for (const file of files) {
+        for (const ref of file.imports) {
+            const resolved = resolveImportPath(file.path, ref.specifier, filePaths);
+            if (!resolved) {
+                continue;
+            }
+            const outSet = outCounts.get(file.path) ?? new Set();
+            outSet.add(resolved);
+            outCounts.set(file.path, outSet);
+            const inSet = inCounts.get(resolved) ?? new Set();
+            inSet.add(file.path);
+            inCounts.set(resolved, inSet);
+        }
+    }
+    const topImporters = [...outCounts.entries()]
+        .map(([file, imports]) => ({ file, imports: imports.size }))
+        .sort((a, b) => b.imports - a.imports)
+        .slice(0, 5);
+    const topImported = [...inCounts.entries()]
+        .map(([file, importedBy]) => ({ file, importedBy: importedBy.size }))
+        .sort((a, b) => b.importedBy - a.importedBy)
+        .slice(0, 5);
+    let edges = 0;
+    for (const imports of outCounts.values()) {
+        edges += imports.size;
+    }
+    const sampleCycle = cycles.length > 0 ? { from: cycles[0].from, to: cycles[0].to } : undefined;
+    return {
+        nodes: filePaths.size,
+        edges,
+        topImporters,
+        topImported,
+        cycles: cycles.length,
+        sampleCycle,
+    };
+}
+async function runCodeAnalysisAgent(config, scan, overrides) {
+    const rootPath = node_path_1.default.resolve(config.path);
+    const files = scan.files.filter((file) => JS_TS_EXTENSIONS.has(file.extension));
+    const normalizedFiles = [];
+    const allFunctions = [];
+    const testFiles = [];
+    for (const file of files) {
+        const relativePath = file.path;
+        if (isTestPath(relativePath)) {
+            testFiles.push(relativePath);
+        }
+        const absolutePath = toAbsolutePath(rootPath, relativePath);
+        let content;
+        const overrideContent = overrides?.[relativePath];
+        if (overrideContent !== undefined) {
+            content = overrideContent;
+        }
+        else {
+            try {
+                content = await promises_1.default.readFile(absolutePath, "utf8");
+            }
+            catch {
+                continue;
+            }
+        }
+        const scriptKind = getScriptKind(file.extension);
+        const sourceFile = typescript_1.default.createSourceFile(relativePath, content, typescript_1.default.ScriptTarget.Latest, true, scriptKind);
+        allFunctions.push(...collectFunctionLengths(sourceFile, relativePath));
+        const { normalizedLines, lineNumbers } = normalizeContent(content);
+        normalizedFiles.push({
+            path: relativePath,
+            extension: file.extension,
+            normalizedLines,
+            lineNumbers,
+            imports: collectImports(sourceFile),
+        });
+    }
+    const totalFunctions = allFunctions.length;
+    const maxFunctionLength = totalFunctions
+        ? Math.max(...allFunctions.map((fn) => fn.length))
+        : 0;
+    const avgFunctionLength = totalFunctions
+        ? Math.round((allFunctions.reduce((sum, fn) => sum + fn.length, 0) / totalFunctions) * 100) / 100
+        : 0;
+    const longFunctions = allFunctions.filter((fn) => fn.length >= exports.LONG_FUNCTION_LOC);
+    const duplicateBlocks = collectDuplicateBlocks(normalizedFiles);
+    const filePathSet = new Set(normalizedFiles.map((file) => file.path));
+    const circularDependencies = collectCircularDependencies(normalizedFiles, filePathSet);
+    const dependencySummary = buildDependencySummary(normalizedFiles, filePathSet, circularDependencies);
+    return {
+        metrics: {
+            maxFunctionLength,
+            avgFunctionLength,
+            duplicateBlocks: duplicateBlocks.length,
+            totalFunctions,
+        },
+        signals: {
+            longFunctions,
+            duplicateBlocks,
+            circularDependencies,
+            testPresence: {
+                hasTests: testFiles.length > 0,
+                testFiles: testFiles.sort(),
+            },
+        },
+        dependencySummary,
+    };
+}

package/dist/agents/evidence-guard-agent.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runEvidenceGuardAgent = runEvidenceGuardAgent;
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function isValidLine(value) {
+    return typeof value === "number" && Number.isInteger(value) && value > 0;
+}
+function isValidMetricValue(value) {
+    if (typeof value === "number") {
+        return Number.isFinite(value) && value >= 0;
+    }
+    if (typeof value === "string") {
+        return value.trim().length > 0;
+    }
+    return false;
+}
+function validateEvidence(issue) {
+    if (!issue.evidence || issue.evidence.length === 0) {
+        return {
+            ...issue,
+            evidenceComplete: false,
+            missingEvidenceReason: "No evidence items provided.",
+        };
+    }
+    for (const item of issue.evidence) {
+        if (!isNonEmptyString(item.file)) {
+            return {
+                ...issue,
+                evidenceComplete: false,
+                missingEvidenceReason: "Evidence item missing file path.",
+            };
+        }
+        if (!isValidLine(item.startLine) || !isValidLine(item.endLine)) {
+            return {
+                ...issue,
+                evidenceComplete: false,
+                missingEvidenceReason: "Evidence item missing line range.",
+            };
+        }
+        if (item.endLine < item.startLine) {
+            return {
+                ...issue,
+                evidenceComplete: false,
+                missingEvidenceReason: "Evidence item line range is invalid.",
+            };
+        }
+        if (!item.metrics || item.metrics.length === 0) {
+            return {
+                ...issue,
+                evidenceComplete: false,
+                missingEvidenceReason: "Evidence item missing metrics.",
+            };
+        }
+        for (const metric of item.metrics) {
+            if (!metric.type || !isValidMetricValue(metric.value)) {
+                return {
+                    ...issue,
+                    evidenceComplete: false,
+                    missingEvidenceReason: "Evidence item has invalid metric.",
+                };
+            }
+        }
+    }
+    return { ...issue, evidenceComplete: true };
+}
+function runEvidenceGuardAgent(insights) {
+    const issues = insights.issues.map((issue) => validateEvidence({ ...issue, evidenceComplete: true }));
+    return { issues };
+}

package/dist/agents/fix-apply-agent.js

@@ -0,0 +1,134 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runFixApplyAgent = runFixApplyAgent;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+function runGit(command, cwd) {
+    return (0, node_child_process_1.execSync)(`git ${command}`, { cwd, stdio: ["ignore", "pipe", "pipe"] })
+        .toString()
+        .trim();
+}
+function getRepoRoot(rootPath) {
+    return runGit("rev-parse --show-toplevel", rootPath);
+}
+function isWorkingTreeClean(rootPath) {
+    const status = runGit("status --porcelain", rootPath);
+    return status.length === 0;
+}
+function getCurrentBranch(rootPath) {
+    return runGit("rev-parse --abbrev-ref HEAD", rootPath);
+}
+function branchExists(rootPath, name) {
+    const result = runGit(`branch --list ${name}`, rootPath);
+    return result.length > 0;
+}
+function buildBranchName(rootPath, requested) {
+    const base = requested?.trim() ||
+        `coderoast-fix-${new Date().toISOString().replace(/[-:T]/g, "").slice(0, 14)}`;
+    if (!branchExists(rootPath, base)) {
+        return base;
+    }
+    let counter = 1;
+    while (branchExists(rootPath, `${base}-${counter}`)) {
+        counter += 1;
+    }
+    return `${base}-${counter}`;
+}
+async function writeTempPatch(contents) {
+    const tempDir = await promises_1.default.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), "coderoast-patch-"));
+    const patchPath = node_path_1.default.join(tempDir, "fix.patch");
+    await promises_1.default.writeFile(patchPath, contents);
+    return patchPath;
+}
+async function runFixApplyAgent(config, fixResult) {
+    const rootPath = node_path_1.default.resolve(config.path);
+    const patches = fixResult.suggestions
+        .filter((suggestion) => suggestion.verified && suggestion.patch)
+        .map((suggestion) => suggestion.patch.trim())
+        .filter((patch) => patch.length > 0);
+    if (patches.length === 0) {
+        return {
+            status: "skipped",
+            message: "Apply skipped: no verified patches to apply.",
+        };
+    }
+    let repoRoot = "";
+    try {
+        repoRoot = getRepoRoot(rootPath);
+    }
+    catch {
+        return {
+            status: "failed",
+            message: "Apply failed: not inside a git repository.",
+        };
+    }
+    if (!isWorkingTreeClean(repoRoot)) {
+        return {
+            status: "failed",
+            message: "Apply failed: working tree is not clean. Commit or stash changes first.",
+        };
+    }
+    const branch = buildBranchName(repoRoot, config.fixBranch);
+    const currentBranch = getCurrentBranch(repoRoot);
+    try {
+        runGit(`checkout -b ${branch}`, repoRoot);
+    }
+    catch {
+        return {
+            status: "failed",
+            message: `Apply failed: could not create branch ${branch}.`,
+            branch,
+        };
+    }
+    let patchPath = "";
+    try {
+        patchPath = await writeTempPatch(patches.join("\n\n") + "\n");
+        (0, node_child_process_1.execSync)(`git apply --whitespace=nowarn "${patchPath}"`, {
+            cwd: repoRoot,
+            stdio: "inherit",
+        });
+    }
+    catch {
+        try {
+            runGit(`checkout ${currentBranch}`, repoRoot);
+            runGit(`branch -D ${branch}`, repoRoot);
+        }
+        catch {
+            // ignore rollback errors
+        }
+        return {
+            status: "failed",
+            message: "Apply failed: patch could not be applied cleanly.",
+            branch,
+        };
+    }
+    const testCommand = config.fixTestCmd ?? "npm test";
+    let testsPassed = true;
+    try {
+        (0, node_child_process_1.execSync)(testCommand, { cwd: repoRoot, stdio: "inherit" });
+    }
+    catch {
+        testsPassed = false;
+    }
+    if (!testsPassed) {
+        return {
+            status: "failed",
+            message: "Apply failed: tests did not pass.",
+            branch,
+            testCommand,
+            testsPassed,
+        };
+    }
+    return {
+        status: "applied",
+        message: "Apply succeeded: patch applied on a new branch with passing tests.",
+        branch,
+        testCommand,
+        testsPassed,
+    };
+}