ci-triage 0.2.0 → 0.3.0

package/dist/parser.js

@@ -200,3 +200,119 @@ 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] ?? ''}`;
+        // Shell script/runtime errors from bash/sh.
+        if (/^.+:\s*line\s+\d+:\s*.+$/i.test(line) ||
+            /\bcommand not found\b/i.test(line) ||
+            /\bpermission denied\b/i.test(line) ||
+            /\bno such file or directory\b/i.test(line)) {
+            failures.push(createInfraFailure(lines, i, line));
+            continue;
+        }
+        // HTTP errors.
+        if (/\bHTTP\s*(?:403|404|429|5\d{2})\b/i.test(line) || /\b(?:403 Forbidden|404 Not Found)\b/i.test(line)) {
+            failures.push(createInfraFailure(lines, i, line));
+            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;
+        }
+        // GitHub Pages deploy failures.
+        if (/\bError:\s*Get Pages site failed\b/i.test(line) ||
+            (/\bHttpError:\s*Not Found\b/i.test(line) && /\bpages?\b/i.test(context))) {
+            failures.push(createInfraFailure(lines, i, line));
+            continue;
+        }
+        // CodeQL/configuration errors.
+        if (/\bconfiguration error\b/i.test(line) && /\b(?:codeql|code[- ]scanning)\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/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.0",
   "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"
   ],