ci-triage 0.1.0

package/dist/parser.js

@@ -0,0 +1,202 @@
+const ANSI_REGEX = /\x1B\[[0-?]*[ -/]*[@-~]/g;
+const TIMESTAMP_PREFIX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z\s*/;
+const MAX_LINES = 25_000;
+const ERROR_LINE_REGEX = [
+    /^##\[error\](.+)$/i,
+    /^FATAL ERROR:\s+.+$/i,
+    /^(?:Error|TypeError|ReferenceError|SyntaxError|AssertionError|panic):\s+.+$/i,
+    /^npm ERR!\s+.+$/i,
+    /^FAIL\b.+$/,
+    /^FAILED\b.+$/,
+    /^Caused by:\s+.+$/i,
+    /\b(?:heap out of memory|permission denied|cannot find module|failed to start container|no such image)\b/i,
+    /\b(?:eacces|enoent|econnrefused|etimedout|timed out|rate limit(?:ed)?|too many requests)\b/i,
+    /\b(?:environment variable .* not set|missing env(?:ironment)? variable|undefined env)\b/i,
+    /\b(?:npm audit|vulnerabilities|eslint|linting failed|error ts\d{4})\b/i,
+    /\berror\s+TS\d{4}\b/i,
+    /^Process completed with exit code\s+\d+/i,
+];
+const STACK_LINE_REGEX = [
+    /^\s*at\s+.+$/,
+    /^\s*\.\.\.\s*\d+\s*more$/,
+    /^\s*File\s+".+",\s+line\s+\d+/,
+];
+function stripAnsiAndTimestamps(input) {
+    return input
+        .replace(ANSI_REGEX, '')
+        .split(/\r?\n/)
+        .map((line) => line.replace(TIMESTAMP_PREFIX, ''))
+        .join('\n');
+}
+function sanitizeLine(line) {
+    return line.replace(/[^\x09\x0A\x0D\x20-\x7E]/g, '').trimEnd();
+}
+/** Track last seen job/step from tab-delimited log lines */
+let lastTabStep = null;
+function parseStepName(line) {
+    const groupRun = line.match(/^##\[group\]Run\s+(.+)$/i);
+    if (groupRun) {
+        return groupRun[1].trim();
+    }
+    const groupStep = line.match(/^##\[group\](.+)$/i);
+    if (groupStep) {
+        return groupStep[1].trim();
+    }
+    const runLine = line.match(/^Run\s+(.+)$/);
+    if (runLine) {
+        return runLine[1].trim();
+    }
+    // GitHub Actions --log-failed format: "jobName\tstepName\ttimestamp message"
+    const tabParts = line.split('\t');
+    if (tabParts.length >= 3) {
+        const stepCandidate = tabParts[1].trim();
+        if (stepCandidate && stepCandidate !== lastTabStep) {
+            lastTabStep = stepCandidate;
+            return stepCandidate;
+        }
+    }
+    return null;
+}
+function parseLocation(line) {
+    const parenLocation = line.match(/\(([\w./\\-]+):(\d+):(\d+)\)/);
+    if (parenLocation) {
+        return {
+            file: parenLocation[1],
+            line: Number(parenLocation[2]),
+            column: Number(parenLocation[3]),
+        };
+    }
+    const fileLineCol = line.match(/(^|\s)([\w./\\-]+):(\d+):(\d+)(\s|$)/);
+    if (fileLineCol) {
+        return {
+            file: fileLineCol[2],
+            line: Number(fileLineCol[3]),
+            column: Number(fileLineCol[4]),
+        };
+    }
+    const fileLine = line.match(/(^|\s)([\w./\\-]+):(\d+)(\s|$)/);
+    if (fileLine) {
+        return {
+            file: fileLine[2],
+            line: Number(fileLine[3]),
+        };
+    }
+    const pythonStyle = line.match(/File\s+"([^"]+)",\s+line\s+(\d+)/);
+    if (pythonStyle) {
+        return {
+            file: pythonStyle[1],
+            line: Number(pythonStyle[2]),
+        };
+    }
+    return undefined;
+}
+function isErrorStart(line) {
+    return ERROR_LINE_REGEX.some((re) => re.test(line));
+}
+function isStackLine(line) {
+    return STACK_LINE_REGEX.some((re) => re.test(line));
+}
+function toErrorMessage(line) {
+    const m = line.match(/^##\[error\](.+)$/i);
+    if (m) {
+        return m[1].trim();
+    }
+    return line.trim();
+}
+function dedupeFailures(failures) {
+    const seen = new Set();
+    const deduped = [];
+    for (const failure of failures) {
+        const key = `${failure.stepName}|${failure.error}|${failure.location?.file ?? ''}|${failure.location?.line ?? ''}`;
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        deduped.push(failure);
+    }
+    return deduped;
+}
+export function parseFailures(rawLog) {
+    if (!rawLog || rawLog.trim().length === 0) {
+        return [];
+    }
+    const cleanedLog = stripAnsiAndTimestamps(rawLog);
+    const lines = cleanedLog
+        .split(/\r?\n/)
+        .slice(0, MAX_LINES)
+        .map(sanitizeLine);
+    const failures = [];
+    let currentStep = 'Unknown step';
+    let active = null;
+    const flush = () => {
+        if (!active) {
+            return;
+        }
+        active.error = active.error.trim();
+        if (active.error.length > 0) {
+            failures.push(active);
+        }
+        active = null;
+    };
+    for (const line of lines) {
+        if (!line) {
+            if (active) {
+                active.rawLines.push('');
+            }
+            continue;
+        }
+        const step = parseStepName(line);
+        if (step) {
+            currentStep = step;
+            flush();
+            continue;
+        }
+        if (/^##\[endgroup\]/i.test(line)) {
+            flush();
+            continue;
+        }
+        if (isErrorStart(line)) {
+            flush();
+            active = {
+                stepName: currentStep,
+                error: toErrorMessage(line),
+                stack: [],
+                rawLines: [line],
+            };
+            const loc = parseLocation(line);
+            if (loc) {
+                active.location = loc;
+            }
+            continue;
+        }
+        if (!active) {
+            continue;
+        }
+        active.rawLines.push(line);
+        if (isStackLine(line)) {
+            active.stack.push(line.trim());
+            if (!active.location) {
+                const loc = parseLocation(line);
+                if (loc) {
+                    active.location = loc;
+                }
+            }
+            continue;
+        }
+        const continuation = /^\s+/.test(line) || /^\^+$/.test(line) || /^\.{3}/.test(line);
+        if (continuation || line.startsWith('> ') || line.startsWith('|')) {
+            active.error = `${active.error}\n${line.trim()}`;
+            continue;
+        }
+        const inlineLoc = parseLocation(line);
+        if (inlineLoc && !active.location) {
+            active.location = inlineLoc;
+            active.stack.push(line.trim());
+            continue;
+        }
+        // New unrelated line ends the active block.
+        flush();
+    }
+    flush();
+    return dedupeFailures(failures);
+}

package/dist/reporter.js

@@ -0,0 +1,115 @@
+function makeFailureEntry(item) {
+    return {
+        type: item.classification.type,
+        file: item.location?.file,
+        line: item.location?.line,
+        error: item.error,
+        stack: item.stack.length > 0 ? item.stack.join('\n') : undefined,
+        flaky: {
+            is_flaky: false,
+            confidence: 0,
+            pass_rate_7d: 0,
+            last_5_runs: [],
+        },
+        severity: item.classification.severity,
+        category: item.classification.category,
+        suggested_fix: item.classification.suggestedFix,
+    };
+}
+function buildSteps(failures) {
+    const map = new Map();
+    for (const failure of failures) {
+        const key = failure.stepName || 'Unknown step';
+        const existing = map.get(key);
+        if (!existing) {
+            map.set(key, {
+                name: key,
+                status: 'failed',
+                log_lines: failure.rawLines.length,
+                failures: [makeFailureEntry(failure)],
+            });
+            continue;
+        }
+        existing.log_lines += failure.rawLines.length;
+        existing.failures.push(makeFailureEntry(failure));
+    }
+    return [...map.values()];
+}
+export function buildJsonReport(input) {
+    const steps = buildSteps(input.failures);
+    const categories = {};
+    for (const failure of input.failures) {
+        categories[failure.classification.category] = (categories[failure.classification.category] ?? 0) + 1;
+    }
+    const topCategory = Object.entries(categories).sort((a, b) => b[1] - a[1])[0]?.[0] ?? 'unknown';
+    return {
+        version: '1.0',
+        repo: input.repo,
+        run_id: input.run.databaseId,
+        run_url: input.run.url,
+        commit: input.metadata?.headSha ?? '',
+        branch: input.metadata?.headBranch ?? '',
+        pr: null,
+        timestamp: new Date().toISOString(),
+        status: input.run.conclusion === 'failure' ? 'failed' : 'success',
+        duration_ms: 0,
+        jobs: [
+            {
+                name: input.run.workflowName,
+                status: input.run.conclusion === 'failure' ? 'failed' : 'success',
+                steps,
+            },
+        ],
+        summary: {
+            total_failures: input.failures.length,
+            flaky_count: 0,
+            real_count: input.failures.length,
+            categories,
+            root_cause: topCategory === 'unknown' ? 'Unknown root cause from failed logs.' : `Most failures are ${topCategory}.`,
+            action: topCategory === 'timeout' || topCategory === 'network_error' ? 'retry' : 'fix',
+        },
+    };
+}
+export function toJson(report) {
+    return `${JSON.stringify(report, null, 2)}\n`;
+}
+export function toMarkdown(report) {
+    const lines = [
+        `# CI Failure Triage (${report.repo})`,
+        '',
+        `- run: ${report.run_url}`,
+        `- workflow: ${report.jobs[0]?.name ?? 'Unknown'}`,
+        `- failures: ${report.summary.total_failures}`,
+        `- root cause: ${report.summary.root_cause}`,
+        '',
+    ];
+    for (const step of report.jobs[0]?.steps ?? []) {
+        lines.push(`## Step: ${step.name}`);
+        for (const failure of step.failures) {
+            lines.push(`- category: ${failure.category}`);
+            lines.push(`- severity: ${failure.severity}`);
+            lines.push(`- error: ${failure.error}`);
+            if (failure.file) {
+                lines.push(`- location: ${failure.file}${failure.line ? `:${failure.line}` : ''}`);
+            }
+            lines.push(`- suggested fix: ${failure.suggested_fix}`);
+            lines.push('');
+        }
+    }
+    return lines.join('\n').trimEnd() + '\n';
+}
+export function toConsoleText(report) {
+    const lines = [
+        `${report.jobs[0]?.name ?? 'workflow'}: ${report.summary.total_failures} failure(s)`,
+        `run: ${report.run_url}`,
+        `root cause: ${report.summary.root_cause}`,
+    ];
+    for (const step of report.jobs[0]?.steps ?? []) {
+        for (const failure of step.failures) {
+            lines.push(`- [${failure.severity}] ${failure.category} in ${step.name}`);
+            lines.push(`  error: ${failure.error}`);
+            lines.push(`  fix: ${failure.suggested_fix}`);
+        }
+    }
+    return `${lines.join('\n')}\n`;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "ci-triage",
+  "version": "0.1.0",
+  "description": "Open-source CI failure triage for humans and agents — smart log parsing, flake detection, structured JSON, MCP server.",
+  "type": "module",
+  "bin": {
+    "ci-triage": "dist/index.js",
+    "ci-triage-mcp": "dist/mcp-server.js"
+  },
+  "files": [
+    "dist",
+    "action.yml",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "lint": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run"
+  },
+  "keywords": [
+    "ci",
+    "triage",
+    "github-actions",
+    "flaky-tests",
+    "mcp",
+    "coding-agent",
+    "devtools",
+    "ci-cd"
+  ],
+  "author": "clankamode",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/clankamode/ci-triage.git"
+  },
+  "homepage": "https://github.com/clankamode/ci-triage",
+  "devDependencies": {
+    "@types/node": "^22.13.10",
+    "typescript": "^5.9.2",
+    "vitest": "^4.0.18"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "fast-xml-parser": "^5.4.1",
+    "zod": "^4.3.6"
+  }
+}