@sweny-ai/core 0.1.43 → 0.1.45

package/dist/__tests__/version-consistency.test.js

@@ -189,11 +189,7 @@ describe("docs action code blocks", () => {
         "packages/web/src/content/docs/advanced/mcp-servers.md",
         "packages/web/src/content/docs/advanced/troubleshooting.md",
     ];
-    // NOTE: This test is currently expected to fail — the action docs
-    // still show triage-specific inputs under swenyai/sweny@v5.
-    // This is tracked as a known issue from the multi-repo split.
-    // Remove .todo once the docs are migrated to use swenyai/triage@v1.
-    it.todo("no docs code block uses swenyai/sweny@v5 with triage-only inputs", () => {
+    it("no docs code block uses swenyai/sweny@v5 with triage-only inputs", () => {
         const allIssues = ACTION_DOC_FILES.flatMap((f) => findMisusedBlocks(resolve(ROOT, f)));
         if (allIssues.length > 0) {
             expect.fail(`Found ${allIssues.length} code block(s) mixing swenyai/sweny@${CURRENT_ACTION_VERSION} with triage-only inputs:\n` +

package/dist/cli/config.js

@@ -11,7 +11,7 @@ export function registerTriageCommand(program) {
         .option("--observability-provider <provider>", "Observability provider (default: datadog)")
         .option("--issue-tracker-provider <provider>", "Issue tracker provider (default: github-issues)")
         .option("--source-control-provider <provider>", "Source control provider (default: github)")
-        .option("--notification-provider <provider>", "Notification provider (default: console)")
+        .option("--notification-provider <provider>", "Notification provider: console, github-summary, slack, teams, discord, webhook, email, file (default: console)")
         .option("--time-range <range>", "Time range to analyze (default: 24h)")
         .option("--severity-focus <focus>", "Severity level focus (default: errors)")
         .option("--service-filter <filter>", "Service filter pattern (default: *)")
@@ -355,7 +355,10 @@ export function validateInputs(config) {
     // Notification credentials by provider
     switch (config.notificationProvider) {
         case "console":
-            // No credentials needed
+        case "github-summary":
+            // No credentials needed. github-summary writes a markdown summary to the
+            // file at $GITHUB_STEP_SUMMARY when running inside GitHub Actions; outside
+            // Actions it behaves like console.
             break;
         case "slack":
         case "teams":
@@ -376,7 +379,7 @@ export function validateInputs(config) {
             // No external credentials needed
             break;
         default:
-            errors.push(`Unknown --notification-provider "${config.notificationProvider}". Valid values: console, slack, teams, discord, webhook, email, file`);
+            errors.push(`Unknown --notification-provider "${config.notificationProvider}". Valid values: console, github-summary, slack, teams, discord, webhook, email, file`);
     }
     // Workspace tools: reject unknown names early
     for (const tool of config.workspaceTools) {

package/dist/cli/config.test.d.ts

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

package/dist/cli/config.test.js

@@ -0,0 +1,111 @@
+import { describe, it, expect } from "vitest";
+import { validateInputs } from "./config.js";
+/**
+ * Focused tests for validateInputs() — specifically the notification-provider
+ * switch. Regressions here break every `swenyai/triage` action run because
+ * that action passes --notification-provider github-summary by default.
+ */
+function baseConfig(overrides = {}) {
+    return {
+        codingAgentProvider: "claude",
+        anthropicApiKey: "sk-ant-test",
+        claudeOauthToken: "",
+        openaiApiKey: "",
+        geminiApiKey: "",
+        observabilityProvider: "file",
+        observabilityCredentials: {},
+        issueTrackerProvider: "file",
+        linearApiKey: "",
+        linearTeamId: "",
+        linearBugLabelId: "",
+        linearTriageLabelId: "",
+        linearStateBacklog: "",
+        linearStateInProgress: "",
+        linearStatePeerReview: "",
+        timeRange: "24h",
+        severityFocus: "errors",
+        serviceFilter: "*",
+        investigationDepth: "standard",
+        maxInvestigateTurns: 50,
+        maxImplementTurns: 30,
+        baseBranch: "main",
+        prLabels: ["agent"],
+        issueLabels: [],
+        dryRun: false,
+        reviewMode: "review",
+        noveltyMode: true,
+        issueOverride: "",
+        additionalInstructions: "",
+        serviceMapPath: ".github/service-map.yml",
+        githubToken: "ghp_test",
+        botToken: "",
+        sourceControlProvider: "github",
+        jiraBaseUrl: "",
+        jiraEmail: "",
+        jiraApiToken: "",
+        gitlabToken: "",
+        gitlabProjectId: "",
+        gitlabBaseUrl: "https://gitlab.com",
+        notificationProvider: "console",
+        notificationWebhookUrl: "",
+        sendgridApiKey: "",
+        emailFrom: "",
+        emailTo: "",
+        webhookSigningSecret: "",
+        repository: "acme/app",
+        repositoryOwner: "",
+        json: false,
+        stream: false,
+        bell: false,
+        cacheDir: ".sweny/cache",
+        cacheTtl: 86400,
+        noCache: false,
+        outputDir: ".sweny/output",
+        mcpServers: {},
+        workspaceTools: [],
+        rules: [],
+        context: [],
+        ...overrides,
+    };
+}
+describe("validateInputs — notification provider", () => {
+    it("accepts console (no credentials required)", () => {
+        const errors = validateInputs(baseConfig({ notificationProvider: "console" }));
+        expect(errors.filter((e) => e.includes("notification-provider"))).toEqual([]);
+    });
+    it("accepts github-summary (no credentials required)", () => {
+        // Regression guard: the `swenyai/triage` composite action passes this as
+        // its default. If the validator stops accepting it every scheduled run
+        // across every consumer immediately breaks.
+        const errors = validateInputs(baseConfig({ notificationProvider: "github-summary" }));
+        expect(errors.filter((e) => e.includes("notification-provider"))).toEqual([]);
+    });
+    it("accepts file (no credentials required)", () => {
+        const errors = validateInputs(baseConfig({ notificationProvider: "file" }));
+        expect(errors.filter((e) => e.includes("notification-provider"))).toEqual([]);
+    });
+    it("requires NOTIFICATION_WEBHOOK_URL for slack", () => {
+        const errors = validateInputs(baseConfig({ notificationProvider: "slack", notificationWebhookUrl: "" }));
+        expect(errors.some((e) => e.includes("NOTIFICATION_WEBHOOK_URL"))).toBe(true);
+    });
+    it("accepts slack when NOTIFICATION_WEBHOOK_URL is set", () => {
+        const errors = validateInputs(baseConfig({
+            notificationProvider: "slack",
+            notificationWebhookUrl: "https://hooks.slack.com/services/T/B/X",
+        }));
+        expect(errors.filter((e) => e.includes("notification"))).toEqual([]);
+    });
+    it("requires sendgrid credentials for email", () => {
+        const errors = validateInputs(baseConfig({ notificationProvider: "email" }));
+        expect(errors.some((e) => e.includes("SENDGRID_API_KEY"))).toBe(true);
+        expect(errors.some((e) => e.includes("EMAIL_FROM"))).toBe(true);
+        expect(errors.some((e) => e.includes("EMAIL_TO"))).toBe(true);
+    });
+    it("rejects unknown providers and lists github-summary in the error", () => {
+        const errors = validateInputs(baseConfig({ notificationProvider: "bogus" }));
+        const err = errors.find((e) => e.includes("Unknown --notification-provider"));
+        expect(err).toBeDefined();
+        expect(err).toContain("github-summary");
+        expect(err).toContain("console");
+    });
+});

package/dist/cli/main.js

@@ -25,7 +25,7 @@ import { buildCredentialMap } from "./credentials.js";
 import { runInit } from "./init.js";
 import { runE2eInit, runE2eRun } from "./e2e.js";
 import { registerTriageCommand, registerImplementCommand, parseCliInputs, validateInputs, validateWarnings, } from "./config.js";
-import { c, formatBanner, getStepDetails, formatStepLine, formatDagResultHuman, formatResultJson, formatValidationErrors, formatCrashError, formatCheckResults, } from "./output.js";
+import { c, formatBanner, getStepDetails, formatStepLine, formatDagResultHuman, formatDagResultMarkdown, formatResultJson, formatValidationErrors, formatCrashError, formatCheckResults, } from "./output.js";
 import { checkProviderConnectivity } from "./check.js";
 import { registerSetupCommand } from "./setup.js";
 // ── Stream observer (NDJSON) ────────────────────────────────────────
@@ -350,6 +350,17 @@ triageCmd.action(async (options) => {
         else {
             console.log(formatDagResultHuman(results, durationMs, config));
         }
+        // GitHub Actions step summary
+        if (config.notificationProvider === "github-summary" && process.env.GITHUB_STEP_SUMMARY) {
+            try {
+                const md = formatDagResultMarkdown(results, durationMs, config);
+                fs.appendFileSync(process.env.GITHUB_STEP_SUMMARY, md);
+            }
+            catch (err) {
+                // Don't fail the run if the summary file can't be written
+                console.error(c.subtle(`  ⚠ could not write GITHUB_STEP_SUMMARY: ${err instanceof Error ? err.message : err}`));
+            }
+        }
         // Terminal bell
         if (config.bell)
             process.stderr.write("\x07");
@@ -364,6 +375,16 @@ triageCmd.action(async (options) => {
         else {
             console.error(formatCrashError(error));
         }
+        // Best-effort GitHub Actions step summary on crash
+        if (config.notificationProvider === "github-summary" && process.env.GITHUB_STEP_SUMMARY) {
+            try {
+                const msg = error instanceof Error ? error.message : "Unknown error";
+                fs.appendFileSync(process.env.GITHUB_STEP_SUMMARY, `## ❌ SWEny Triage Crashed\n\n\`\`\`\n${msg}\n\`\`\`\n`);
+            }
+            catch {
+                // ignore
+            }
+        }
         // Terminal bell even on crash
         if (config.bell)
             process.stderr.write("\x07");

package/dist/cli/output.d.ts

@@ -24,3 +24,13 @@ export declare function extractCredentialHint(err: unknown): string | null;
 export declare function formatCrashError(error: unknown): string;
 export declare function formatCheckResults(results: CheckResult[]): string;
 export declare function formatResultJson(results: Map<string, NodeResult>): string;
+/**
+ * Format triage results as GitHub-flavored markdown for `$GITHUB_STEP_SUMMARY`.
+ *
+ * Designed to render nicely in the GitHub Actions job summary panel:
+ *   - Status line with an emoji for quick visual scanning
+ *   - Links to any created issues or PRs
+ *   - Findings table (for dry runs or no-action results)
+ *   - Error detail when a node failed
+ */
+export declare function formatDagResultMarkdown(results: Map<string, NodeResult>, durationMs: number, config?: CliConfig): string;

package/dist/cli/output.js

@@ -404,6 +404,126 @@ export function formatCheckResults(results) {
 export function formatResultJson(results) {
     return JSON.stringify(Object.fromEntries(results), null, 2);
 }
+// ── Markdown output (for GitHub Actions step summary) ───────────
+/**
+ * Format triage results as GitHub-flavored markdown for `$GITHUB_STEP_SUMMARY`.
+ *
+ * Designed to render nicely in the GitHub Actions job summary panel:
+ *   - Status line with an emoji for quick visual scanning
+ *   - Links to any created issues or PRs
+ *   - Findings table (for dry runs or no-action results)
+ *   - Error detail when a node failed
+ */
+export function formatDagResultMarkdown(results, durationMs, config) {
+    const duration = formatDuration(durationMs);
+    const lines = [];
+    // Detect failure anywhere in the DAG
+    let failedNodeId;
+    let failedResult;
+    for (const [nodeId, result] of results) {
+        if (result.status === "failed") {
+            failedNodeId = nodeId;
+            failedResult = result;
+            break;
+        }
+    }
+    if (failedResult) {
+        lines.push(`## ❌ SWEny Triage Failed`);
+        lines.push("");
+        lines.push(`**Failed at:** \`${failedNodeId}\`  `);
+        lines.push(`**Duration:** ${duration}`);
+        if (failedResult.data?.error) {
+            lines.push("");
+            lines.push("```");
+            lines.push(String(failedResult.data.error));
+            lines.push("```");
+        }
+        return lines.join("\n") + "\n";
+    }
+    const investigateData = results.get("investigate")?.data;
+    const issueData = results.get("create_issue")?.data;
+    const prData = results.get("create_pr")?.data;
+    const novelCount = investigateData?.novel_count ?? 0;
+    const highestSeverity = investigateData?.highest_severity;
+    const findings = investigateData?.findings;
+    // Header — pick the most informative title
+    if (prData?.prUrl) {
+        lines.push(`## ✅ SWEny Triage — PR opened`);
+    }
+    else if (issueData?.issueIdentifier || issueData?.issueUrl) {
+        lines.push(`## ✅ SWEny Triage — Issue created`);
+    }
+    else if (config?.dryRun) {
+        lines.push(`## 🔍 SWEny Triage — Dry run complete`);
+    }
+    else if (novelCount === 0) {
+        lines.push(`## ✅ SWEny Triage — No new incidents`);
+    }
+    else {
+        lines.push(`## ℹ️ SWEny Triage — No action taken`);
+    }
+    lines.push("");
+    lines.push(`**Duration:** ${duration}  `);
+    if (config?.serviceFilter && config.serviceFilter !== "*") {
+        lines.push(`**Service filter:** \`${config.serviceFilter}\`  `);
+    }
+    if (config?.timeRange) {
+        lines.push(`**Time range:** ${config.timeRange}  `);
+    }
+    if (highestSeverity) {
+        lines.push(`**Highest severity:** ${highestSeverity}  `);
+    }
+    lines.push(`**Novel findings:** ${novelCount}`);
+    // Issue and PR links
+    if (issueData?.issueIdentifier || issueData?.issueUrl) {
+        lines.push("");
+        lines.push("### 📋 Issue");
+        const id = issueData.issueIdentifier ? `**${String(issueData.issueIdentifier)}** — ` : "";
+        const title = issueData.issueTitle ? String(issueData.issueTitle) : "";
+        const url = issueData.issueUrl ? String(issueData.issueUrl) : "";
+        if (url) {
+            lines.push(`${id}[${title || url}](${url})`);
+        }
+        else {
+            lines.push(`${id}${title}`);
+        }
+    }
+    if (prData?.prUrl) {
+        lines.push("");
+        lines.push("### 🔧 Pull request");
+        const num = prData.prNumber ? `#${String(prData.prNumber)}` : "";
+        lines.push(`[${num || String(prData.prUrl)}](${String(prData.prUrl)})`);
+    }
+    // Findings table — mostly useful for dry runs and no-action results
+    if (findings && findings.length > 0 && !prData?.prUrl) {
+        lines.push("");
+        lines.push("### 🔎 Findings");
+        lines.push("");
+        lines.push("| Severity | Title | Status |");
+        lines.push("| --- | --- | --- |");
+        for (const f of findings.slice(0, 10)) {
+            const sev = String(f.severity ?? "—");
+            const title = String(f.title ?? "").replace(/\|/g, "\\|");
+            const status = f.is_duplicate ? "duplicate" : "novel";
+            lines.push(`| ${sev} | ${title} | ${status} |`);
+        }
+        if (findings.length > 10) {
+            lines.push("");
+            lines.push(`_…and ${findings.length - 10} more_`);
+        }
+    }
+    // Recommendation / next step
+    const rec = investigateData?.recommendation;
+    if (rec) {
+        lines.push("");
+        lines.push(`**Next:** ${String(rec)}`);
+    }
+    if (config?.dryRun) {
+        lines.push("");
+        lines.push("_Dry run mode — no side effects were taken._");
+    }
+    return lines.join("\n") + "\n";
+}
 // ── Helpers ─────────────────────────────────────────────────────
 function formatDuration(ms) {
     const s = Math.round(ms / 1000);

package/dist/cli/output.test.d.ts

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

package/dist/cli/output.test.js

@@ -0,0 +1,107 @@
+import { describe, it, expect } from "vitest";
+import { formatDagResultMarkdown } from "./output.js";
+function success(data = {}) {
+    return { status: "success", data, toolCalls: [] };
+}
+function failed(data = {}) {
+    return { status: "failed", data, toolCalls: [] };
+}
+function minimalConfig(overrides = {}) {
+    return {
+        timeRange: "6h",
+        serviceFilter: "permit-service",
+        dryRun: false,
+        ...overrides,
+    };
+}
+describe("formatDagResultMarkdown", () => {
+    it("renders a success header with issue + PR when both exist", () => {
+        const results = new Map([
+            [
+                "investigate",
+                success({ novel_count: 1, highest_severity: "high", findings: [{ severity: "high", title: "500 on /parse" }] }),
+            ],
+            [
+                "create_issue",
+                success({
+                    issueIdentifier: "OFF-1234",
+                    issueTitle: "Parse failure",
+                    issueUrl: "https://linear.app/acme/issue/OFF-1234",
+                }),
+            ],
+            ["create_pr", success({ prNumber: 42, prUrl: "https://github.com/acme/app/pull/42" })],
+        ]);
+        const md = formatDagResultMarkdown(results, 15_000, minimalConfig());
+        expect(md).toContain("## ✅ SWEny Triage — PR opened");
+        expect(md).toContain("**Duration:** 15s");
+        expect(md).toContain("**Service filter:** `permit-service`");
+        expect(md).toContain("**Highest severity:** high");
+        expect(md).toContain("OFF-1234");
+        expect(md).toContain("https://linear.app/acme/issue/OFF-1234");
+        expect(md).toContain("#42");
+        expect(md).toContain("https://github.com/acme/app/pull/42");
+    });
+    it("renders an issue-only result when no PR was opened", () => {
+        const results = new Map([
+            ["investigate", success({ novel_count: 1, highest_severity: "medium" })],
+            [
+                "create_issue",
+                success({ issueIdentifier: "OFF-5", issueTitle: "Investigate warning", issueUrl: "https://linear.app/x/5" }),
+            ],
+        ]);
+        const md = formatDagResultMarkdown(results, 5_000, minimalConfig());
+        expect(md).toContain("## ✅ SWEny Triage — Issue created");
+        expect(md).toContain("OFF-5");
+        expect(md).not.toContain("Pull request");
+    });
+    it("renders a clean no-incident result when novel_count is 0", () => {
+        const results = new Map([["investigate", success({ novel_count: 0 })]]);
+        const md = formatDagResultMarkdown(results, 3_000, minimalConfig());
+        expect(md).toContain("## ✅ SWEny Triage — No new incidents");
+        expect(md).toContain("**Novel findings:** 0");
+    });
+    it("renders a findings table in dry-run mode", () => {
+        const results = new Map([
+            [
+                "investigate",
+                success({
+                    novel_count: 2,
+                    highest_severity: "high",
+                    findings: [
+                        { severity: "high", title: "OOM in worker", is_duplicate: false },
+                        { severity: "low", title: "Stale metric", is_duplicate: true },
+                    ],
+                }),
+            ],
+        ]);
+        const md = formatDagResultMarkdown(results, 9_000, minimalConfig({ dryRun: true }));
+        expect(md).toContain("## 🔍 SWEny Triage — Dry run complete");
+        expect(md).toContain("| Severity | Title | Status |");
+        expect(md).toContain("| high | OOM in worker | novel |");
+        expect(md).toContain("| low | Stale metric | duplicate |");
+        expect(md).toContain("_Dry run mode — no side effects were taken._");
+    });
+    it("renders a failure summary when a node failed", () => {
+        const results = new Map([
+            ["gather", success()],
+            ["investigate", failed({ error: "Rate limited by Anthropic API" })],
+        ]);
+        const md = formatDagResultMarkdown(results, 2_000, minimalConfig());
+        expect(md).toContain("## ❌ SWEny Triage Failed");
+        expect(md).toContain("**Failed at:** `investigate`");
+        expect(md).toContain("Rate limited by Anthropic API");
+    });
+    it("escapes pipe characters in finding titles so the table stays valid", () => {
+        const results = new Map([
+            [
+                "investigate",
+                success({
+                    novel_count: 1,
+                    findings: [{ severity: "high", title: "broken | pipe | title" }],
+                }),
+            ],
+        ]);
+        const md = formatDagResultMarkdown(results, 1_000, minimalConfig({ dryRun: true }));
+        expect(md).toContain("broken \\| pipe \\| title");
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sweny-ai/core",
-  "version": "0.1.43",
+  "version": "0.1.45",
   "type": "module",
   "bin": {
     "sweny": "./dist/cli/main.js"