ci-triage 0.2.0 → 0.3.1

package/dist/parser.js

@@ -1,3 +1,4 @@
+import { infraParsers } from './parsers/index.js';
 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;
@@ -10,7 +11,12 @@ const ERROR_LINE_REGEX = [
     /^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(?:command not found|script returned exit code|the command exited with)\b/i,
     /\b(?:eacces|enoent|econnrefused|etimedout|timed out|rate limit(?:ed)?|too many requests)\b/i,
+    /\bcurl:\s*\(\d+\).*(?:4\d{2}|5\d{2})\b/i,
+    /\b(?:http(?:\/\d(?:\.\d)?)?\s+|status(?: code)?[:=]?\s*)(?:4\d{2}|5\d{2})\b/i,
+    /\b(?:pages?\s+(?:deploy|deployment).*(?:failed|error)|failed to create deployment)\b/i,
+    /\b(?:codeql|code[- ]scanning).*(?:workflow error|analysis failed|database .* failed|required permissions|init failed|analyze failed)\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,
@@ -200,3 +206,114 @@ export function parseFailures(rawLog) {
     flush();
     return dedupeFailures(failures);
 }
+function hasErrorContext(line) {
+    return /\b(?:error|failed|failure|denied|invalid|missing|not found|unable|cannot)\b/i.test(line);
+}
+function inferStepName(lines, index) {
+    for (let i = index; i >= 0 && i >= index - 40; i -= 1) {
+        const step = parseStepName(lines[i] ?? '');
+        if (step) {
+            return step;
+        }
+    }
+    return 'Unknown step';
+}
+function createInfraFailure(lines, index, error) {
+    const line = lines[index] ?? '';
+    const location = parseLocation(line);
+    const stack = [];
+    if (index + 1 < lines.length && isStackLine(lines[index + 1] ?? '')) {
+        stack.push((lines[index + 1] ?? '').trim());
+    }
+    return {
+        stepName: inferStepName(lines, index),
+        error: error.trim(),
+        stack,
+        location,
+        rawLines: [line],
+    };
+}
+export function parseInfraFailures(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 = [];
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i] ?? '';
+        if (!line) {
+            continue;
+        }
+        const context = `${lines[i - 1] ?? ''}\n${line}\n${lines[i + 1] ?? ''}`;
+        const matchedByHandler = infraParsers
+            .map((handler) => handler({
+            line,
+            prevLine: lines[i - 1] ?? '',
+            nextLine: lines[i + 1] ?? '',
+            context,
+        }))
+            .find((value) => Boolean(value));
+        if (matchedByHandler) {
+            failures.push(createInfraFailure(lines, i, matchedByHandler));
+            continue;
+        }
+        // GitHub Actions explicit step failure line.
+        const processExit = line.match(/\bError:\s*Process completed with exit code\s+(\d+)\b/i);
+        if (processExit && Number(processExit[1]) !== 0) {
+            failures.push(createInfraFailure(lines, i, line));
+            continue;
+        }
+        // Missing env/token in error context.
+        if (/\b(?:GITHUB_TOKEN|GH_TOKEN|GITLAB_TOKEN|CIRCLE_TOKEN)\b/.test(line) && hasErrorContext(line)) {
+            failures.push(createInfraFailure(lines, i, line));
+            continue;
+        }
+        // Input/output file conflicts.
+        if (/\binput file is output file\b/i.test(line) || /\bis the same file\b/i.test(line)) {
+            failures.push(createInfraFailure(lines, i, line));
+            continue;
+        }
+        // CodeQL/configuration/workflow errors.
+        if ((/\bconfiguration error\b/i.test(line) && /\b(?:codeql|code[- ]scanning)\b/i.test(context)) ||
+            (/\b(?:workflow error|analysis failed|database .* failed|required permissions|init failed|analyze failed|autobuild failed)\b/i.test(line) &&
+                /\b(?:codeql|code[- ]scanning|github\/codeql-action)\b/i.test(context))) {
+            failures.push(createInfraFailure(lines, i, line));
+            continue;
+        }
+        // npm/node failures.
+        if (/\bnpm ERR!\b/i.test(line) || /\bCannot find module\b/i.test(line)) {
+            failures.push(createInfraFailure(lines, i, line));
+            continue;
+        }
+        // Generic exit code failures not already captured.
+        const genericExit = line.match(/\bexit code\s+([1-9]\d*)\b/i);
+        if (genericExit) {
+            failures.push(createInfraFailure(lines, i, line));
+            continue;
+        }
+        // Generic explicit error prefix catch for shell-like errors.
+        if (/^error:\s+.+$/i.test(line) && !/\bexit code\s+0\b/i.test(line)) {
+            failures.push(createInfraFailure(lines, i, line));
+            continue;
+        }
+    }
+    return dedupeFailures(failures);
+}
+export function parseAllFailures(rawLog) {
+    const combined = [...parseFailures(rawLog), ...parseInfraFailures(rawLog)];
+    const seen = new Set();
+    const deduped = [];
+    for (const failure of combined) {
+        const key = failure.error.trim();
+        if (!key || seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        deduped.push(failure);
+    }
+    return deduped;
+}

package/dist/parsers/deploy-pages-failure.js

@@ -0,0 +1,33 @@
+const GITHUB_PAGES_PATTERNS = [
+    /\bError:\s*Get Pages site failed\b/i,
+    /\bfailed to create deployment\b/i,
+    /\bpages?\s+(?:deploy|deployment).*(?:failed|error)\b/i,
+];
+const VERCEL_PATTERNS = [
+    /\bvercel\b.*\b(?:error|failed|failure)\b/i,
+    /\b(?:vercel|vc)\s+deploy\b.*\b(?:error|failed)\b/i,
+    /\b(?:project|team)\s+not found\b.*\bvercel\b/i,
+    /\bNo Output Directory named\b/i,
+    /\bCommand\s+\".+\"\s+exited with\s+[1-9]\d*\b/i,
+];
+const CLOUDFLARE_PATTERNS = [
+    /\bcloudflare\b.*\b(?:error|failed|failure)\b/i,
+    /\bcloudflare pages\b.*\b(?:error|failed|failure)\b/i,
+    /\bwrangler\b.*\b(?:error|failed|failure)\b/i,
+    /\bA request to the Cloudflare API\b.*\bfailed\b/i,
+];
+export const parseDeployPagesFailure = ({ line, context }) => {
+    if (GITHUB_PAGES_PATTERNS.some((pattern) => pattern.test(line))) {
+        return line.trim();
+    }
+    if (/\bHttpError:\s*Not Found\b/i.test(line) && /\b(?:pages?|deploy)\b/i.test(context)) {
+        return line.trim();
+    }
+    if (VERCEL_PATTERNS.some((pattern) => pattern.test(line))) {
+        return line.trim();
+    }
+    if (CLOUDFLARE_PATTERNS.some((pattern) => pattern.test(line))) {
+        return line.trim();
+    }
+    return null;
+};

package/dist/parsers/http-error.js

@@ -0,0 +1,13 @@
+const HTTP_PATTERNS = [
+    /\bHTTP(?:\/\d(?:\.\d)?)?\s+(?:4\d{2}|5\d{2})\b/i,
+    /\b(?:status|status code)[:=]?\s*(?:4\d{2}|5\d{2})\b/i,
+    /\bcurl:\s*\(\d+\).*(?:4\d{2}|5\d{2})\b/i,
+    /\bfetch\b.*\b(?:HTTP|status|status code)[:=]?\s*(?:4\d{2}|5\d{2})\b/i,
+    /\b(?:4\d{2}|5\d{2})\s+(?:Bad Request|Unauthorized|Forbidden|Not Found|Too Many Requests|Internal Server Error|Bad Gateway|Service Unavailable|Gateway Timeout)\b/i,
+];
+export const parseHttpError = ({ line }) => {
+    if (HTTP_PATTERNS.some((pattern) => pattern.test(line))) {
+        return line.trim();
+    }
+    return null;
+};

package/dist/parsers/index.js

@@ -0,0 +1,9 @@
+import { parseDeployPagesFailure } from './deploy-pages-failure.js';
+import { parseHttpError } from './http-error.js';
+import { parseShellScriptFailure } from './shell-failure.js';
+export const infraParsers = [
+    parseShellScriptFailure,
+    parseHttpError,
+    parseDeployPagesFailure,
+];
+export { parseDeployPagesFailure, parseHttpError, parseShellScriptFailure };

package/dist/parsers/shell-failure.js

@@ -0,0 +1,14 @@
+const SHELL_PATTERNS = [
+    /^.+:\s*line\s+\d+:\s*.+$/i,
+    /\bcommand not found\b/i,
+    /\bpermission denied\b/i,
+    /\bno such file or directory\b/i,
+    /\b(?:script returned exit code|the command exited with)\s*([1-9]\d*)\b/i,
+    /\bexit code\s+([1-9]\d*)\b/i,
+];
+export const parseShellScriptFailure = ({ line }) => {
+    if (SHELL_PATTERNS.some((pattern) => pattern.test(line))) {
+        return line.trim();
+    }
+    return null;
+};

package/dist/parsers/types.js

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

package/dist/providers/index.js

@@ -12,10 +12,18 @@ const providers = {
     circleci: () => new CircleCiProvider(),
 };
 /**
- * Detect CI provider by local repo markers.
- * Checks cwd and common project root indicators.
+ * Detect CI provider by environment variables first, then local repo markers.
+ * Env vars take priority so detection works in temp checkout dirs (e.g. /tmp).
  */
 export function detectProvider(cwd = process.cwd()) {
+    // Environment-variable detection (reliable in CI; works from any cwd)
+    if (process.env['GITLAB_CI'])
+        return 'gitlab';
+    if (process.env['CIRCLECI'])
+        return 'circleci';
+    if (process.env['GITHUB_ACTIONS'])
+        return 'github';
+    // Fallback: filesystem markers in the working directory
     if (existsSync(join(cwd, '.gitlab-ci.yml')))
         return 'gitlab';
     if (existsSync(join(cwd, '.circleci')))

package/dist/repo-context.js

@@ -0,0 +1,97 @@
+import { execFile } from 'node:child_process';
+function runGh(args) {
+    return new Promise((resolve, reject) => {
+        execFile('gh', args, { encoding: 'utf8' }, (error, stdout, stderr) => {
+            if (error) {
+                const err = error;
+                err.stdout = stdout ?? '';
+                err.stderr = stderr ?? '';
+                reject(err);
+                return;
+            }
+            resolve({ stdout: stdout ?? '', stderr: stderr ?? '' });
+        });
+    });
+}
+function parseScopes(statusOutput) {
+    const line = statusOutput
+        .split('\n')
+        .map((l) => l.trim())
+        .find((l) => /^token scopes:/i.test(l));
+    if (!line)
+        return [];
+    const raw = line.replace(/^token scopes:\s*/i, '').replace(/'/g, '').trim();
+    if (!raw || /^none$/i.test(raw))
+        return [];
+    return raw
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean);
+}
+function normalizePlan(planName) {
+    const normalized = (planName ?? '').toLowerCase();
+    if (normalized.includes('enterprise'))
+        return 'enterprise';
+    if (normalized.includes('team'))
+        return 'team';
+    if (normalized.includes('pro'))
+        return 'pro';
+    if (normalized.includes('free'))
+        return 'free';
+    return undefined;
+}
+export async function fetchRepoContext(repo) {
+    let repoInfo;
+    try {
+        const { stdout } = await runGh(['api', `repos/${repo}`]);
+        repoInfo = JSON.parse(stdout);
+    }
+    catch {
+        return null;
+    }
+    const context = {
+        repo,
+        private: repoInfo.private ?? false,
+        visibility: repoInfo.visibility ?? (repoInfo.private ? 'private' : 'public'),
+        hasPages: repoInfo.has_pages ?? false,
+        pagesEnabled: false,
+        defaultBranch: repoInfo.default_branch ?? '',
+        workflowFiles: [],
+        hasCodeScanning: false,
+        tokenScopes: [],
+        plan: normalizePlan(repoInfo.owner?.plan?.name ?? repoInfo.plan?.name),
+    };
+    try {
+        const { stdout } = await runGh(['api', `repos/${repo}/contents/.github/workflows`]);
+        const workflows = JSON.parse(stdout);
+        const files = Array.isArray(workflows) ? workflows : [workflows];
+        context.workflowFiles = files
+            .map((f) => f?.name ?? '')
+            .filter((name) => /\.ya?ml$/i.test(name));
+    }
+    catch {
+        context.workflowFiles = [];
+    }
+    try {
+        await runGh(['api', `repos/${repo}/pages`]);
+        context.pagesEnabled = true;
+    }
+    catch {
+        context.pagesEnabled = false;
+    }
+    try {
+        await runGh(['api', `repos/${repo}/code-scanning/alerts`, '-f', 'per_page=1']);
+        context.hasCodeScanning = true;
+    }
+    catch {
+        context.hasCodeScanning = false;
+    }
+    try {
+        const { stdout, stderr } = await runGh(['auth', 'status']);
+        context.tokenScopes = parseScopes(`${stdout}\n${stderr}`);
+    }
+    catch {
+        context.tokenScopes = [];
+    }
+    return context;
+}

package/dist/reporter.js

@@ -14,6 +14,7 @@ function makeFailureEntry(item) {
         severity: item.classification.severity,
         category: item.classification.category,
         suggested_fix: item.classification.suggestedFix,
+        fix_action: item.classification.fixAction,
     };
 }
 function buildSteps(failures) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ci-triage",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Open-source CI failure triage for humans and agents — smart log parsing, flake detection, structured JSON, MCP server.",
   "type": "module",
   "bin": {
@@ -10,6 +10,7 @@
   "files": [
     "dist",
     "action.yml",
+    "CHANGELOG.md",
     "README.md",
     "LICENSE"
   ],
@@ -40,7 +41,7 @@
   "homepage": "https://github.com/clankamode/ci-triage",
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",
-    "@types/node": "^22.13.10",
+    "@types/node": "^25.3.1",
     "typescript": "^5.9.2",
     "vitest": "^4.0.18"
   },