@sweny-ai/core 0.1.76 → 0.1.78

package/dist/cli/__tests__/diagram.test.js

@@ -1,225 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { runWorkflowDiagram, resolveUseBlock } from "../diagram.js";
-const sampleWorkflow = {
-    id: "sample",
-    name: "Sample",
-    description: "sample",
-    entry: "a",
-    nodes: {
-        a: { name: "A", instruction: "do a", skills: [] },
-        b: { name: "B", instruction: "do b", skills: [] },
-    },
-    edges: [{ from: "a", to: "b" }],
-};
-// Minimal in-memory writable stream that accumulates text. Avoids the
-// overhead of real Node streams for these pure-output assertions.
-function captureStream() {
-    const chunks = [];
-    const stream = {
-        write: (chunk) => {
-            chunks.push(typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8"));
-            return true;
-        },
-    };
-    return {
-        stream,
-        get text() {
-            return chunks.join("");
-        },
-    };
-}
-describe("resolveUseBlock", () => {
-    // Centralized behavior test — the renderer is a tiny switch around this
-    // so keeping the rules here as one table makes the policy easy to audit.
-    it("returns false by default (stdout, no -o, no flags)", () => {
-        expect(resolveUseBlock({})).toBe(false);
-    });
-    it("returns true when --block is explicit", () => {
-        expect(resolveUseBlock({ block: true })).toBe(true);
-    });
-    it("returns false when --no-block is explicit, even for .md", () => {
-        expect(resolveUseBlock({ block: false, output: "diagram.md" })).toBe(false);
-    });
-    it("infers true for .md output", () => {
-        expect(resolveUseBlock({ output: "diagram.md" })).toBe(true);
-    });
-    it("infers true for .markdown output", () => {
-        expect(resolveUseBlock({ output: "diagram.markdown" })).toBe(true);
-    });
-    it("infers false for .mmd output", () => {
-        expect(resolveUseBlock({ output: "diagram.mmd" })).toBe(false);
-    });
-    it("infers false for .mermaid output", () => {
-        expect(resolveUseBlock({ output: "diagram.mermaid" })).toBe(false);
-    });
-    it("infers false for any other extension (.txt, no ext, etc.)", () => {
-        expect(resolveUseBlock({ output: "diagram.txt" })).toBe(false);
-        expect(resolveUseBlock({ output: "diagram" })).toBe(false);
-    });
-    it("is case-insensitive on extension", () => {
-        expect(resolveUseBlock({ output: "Diagram.MD" })).toBe(true);
-        expect(resolveUseBlock({ output: "Diagram.MMD" })).toBe(false);
-    });
-    it("lets explicit --block override .mmd extension", () => {
-        expect(resolveUseBlock({ block: true, output: "diagram.mmd" })).toBe(true);
-    });
-});
-describe("runWorkflowDiagram", () => {
-    let tmpdir;
-    const loadWorkflowFile = vi.fn((_f) => sampleWorkflow);
-    const exit = vi.fn();
-    beforeEach(() => {
-        tmpdir = fs.mkdtempSync(path.join(os.tmpdir(), "sweny-diagram-test-"));
-        loadWorkflowFile.mockClear();
-        exit.mockClear();
-    });
-    afterEach(() => {
-        fs.rmSync(tmpdir, { recursive: true, force: true });
-    });
-    describe("stdout — default behavior", () => {
-        it("writes RAW mermaid (no fence, no title frontmatter) by default", () => {
-            // This is the Mermaid-CLI / Live-Editor-compatible output. No ```,
-            // no `---\ntitle: …\n---` — just `graph TB` and the nodes.
-            const stdout = captureStream();
-            const stderr = captureStream();
-            runWorkflowDiagram("any.yml", {}, { loadWorkflowFile, stdout: stdout.stream, stderr: stderr.stream, exit });
-            expect(stdout.text).not.toMatch(/```mermaid/);
-            expect(stdout.text).not.toMatch(/^---\ntitle:/);
-            expect(stdout.text).toMatch(/^graph TB/);
-            expect(exit).not.toHaveBeenCalled();
-        });
-        it("wraps in a ```mermaid fence when --block is explicit", () => {
-            const stdout = captureStream();
-            runWorkflowDiagram("any.yml", { block: true }, { loadWorkflowFile, stdout: stdout.stream, stderr: captureStream().stream, exit });
-            expect(stdout.text).toMatch(/^```mermaid\n/);
-            expect(stdout.text).toMatch(/\n```\n$/);
-        });
-        it("honors --direction LR", () => {
-            const stdout = captureStream();
-            runWorkflowDiagram("any.yml", { direction: "LR" }, { loadWorkflowFile, stdout: stdout.stream, stderr: captureStream().stream, exit });
-            expect(stdout.text).toMatch(/graph LR/);
-        });
-        it("emits --title as frontmatter only when explicitly set", () => {
-            const stdout = captureStream();
-            runWorkflowDiagram("any.yml", { title: "Custom Title" }, { loadWorkflowFile, stdout: stdout.stream, stderr: captureStream().stream, exit });
-            expect(stdout.text).toMatch(/^---\ntitle: Custom Title\n---\n/);
-            expect(stdout.text).toContain("graph TB");
-        });
-        it("does NOT default title to the workflow name", () => {
-            // Regression guard: previously we auto-filled `title` from workflow.name,
-            // which broke mmdc / mermaid-live because they don't accept title frontmatter.
-            const stdout = captureStream();
-            runWorkflowDiagram("any.yml", {}, { loadWorkflowFile, stdout: stdout.stream, stderr: captureStream().stream, exit });
-            expect(stdout.text).not.toMatch(/title:/);
-            expect(stdout.text).not.toContain("Sample"); // workflow.name
-        });
-    });
-    describe("-o / --output file", () => {
-        it("writes raw mermaid to .mmd (default)", () => {
-            const out = path.join(tmpdir, "diagram.mmd");
-            const stderr = captureStream();
-            runWorkflowDiagram("any.yml", { output: out }, { loadWorkflowFile, stdout: captureStream().stream, stderr: stderr.stream, exit });
-            const contents = fs.readFileSync(out, "utf8");
-            expect(contents).not.toMatch(/```mermaid/);
-            expect(contents).not.toMatch(/title:/);
-            expect(contents).toMatch(/^graph TB/);
-            expect(stderr.text).toMatch(/✓ Wrote diagram to/);
-        });
-        it("writes raw mermaid to .mermaid (Mermaid CLI's canonical extension)", () => {
-            const out = path.join(tmpdir, "diagram.mermaid");
-            runWorkflowDiagram("any.yml", { output: out }, { loadWorkflowFile, stdout: captureStream().stream, stderr: captureStream().stream, exit });
-            const contents = fs.readFileSync(out, "utf8");
-            expect(contents).not.toMatch(/```mermaid/);
-            expect(contents).toMatch(/^graph TB/);
-        });
-        it("writes fenced markdown to .md", () => {
-            const out = path.join(tmpdir, "diagram.md");
-            runWorkflowDiagram("any.yml", { output: out }, { loadWorkflowFile, stdout: captureStream().stream, stderr: captureStream().stream, exit });
-            const contents = fs.readFileSync(out, "utf8");
-            expect(contents).toMatch(/^```mermaid\n/);
-            expect(contents).toMatch(/\n```\n$/);
-        });
-        it("writes raw mermaid for unknown extensions (no longer falls back to fenced)", () => {
-            // Behavior change: previously .txt and friends got fenced as the
-            // "safe default". Now raw mermaid is the safe default because that's
-            // what every renderer actually accepts.
-            const out = path.join(tmpdir, "diagram.txt");
-            runWorkflowDiagram("any.yml", { output: out }, { loadWorkflowFile, stdout: captureStream().stream, stderr: captureStream().stream, exit });
-            const contents = fs.readFileSync(out, "utf8");
-            expect(contents).not.toMatch(/```mermaid/);
-            expect(contents).toMatch(/graph TB/);
-        });
-        it("creates parent directories as needed (-o nested/subdir/file.mmd)", () => {
-            const out = path.join(tmpdir, "a", "b", "c", "diagram.mmd");
-            runWorkflowDiagram("any.yml", { output: out }, { loadWorkflowFile, stdout: captureStream().stream, stderr: captureStream().stream, exit });
-            expect(fs.existsSync(out)).toBe(true);
-            expect(fs.readFileSync(out, "utf8")).toMatch(/graph TB/);
-        });
-        it("does not write anything to stdout when -o is set", () => {
-            const stdout = captureStream();
-            const out = path.join(tmpdir, "diagram.mmd");
-            runWorkflowDiagram("any.yml", { output: out }, { loadWorkflowFile, stdout: stdout.stream, stderr: captureStream().stream, exit });
-            expect(stdout.text).toBe("");
-        });
-    });
-    describe("explicit --block / --no-block override extension inference", () => {
-        it("explicit --block wins over .mmd (writes fenced to .mmd)", () => {
-            const out = path.join(tmpdir, "diagram.mmd");
-            runWorkflowDiagram("any.yml", { output: out, block: true }, { loadWorkflowFile, stdout: captureStream().stream, stderr: captureStream().stream, exit });
-            expect(fs.readFileSync(out, "utf8")).toMatch(/```mermaid/);
-        });
-        it("explicit --no-block wins over .md (writes raw to .md)", () => {
-            const out = path.join(tmpdir, "diagram.md");
-            runWorkflowDiagram("any.yml", { output: out, block: false }, { loadWorkflowFile, stdout: captureStream().stream, stderr: captureStream().stream, exit });
-            expect(fs.readFileSync(out, "utf8")).not.toMatch(/```mermaid/);
-        });
-    });
-    describe("builtin workflow names", () => {
-        it("resolves 'triage' without calling loadWorkflowFile", () => {
-            const stdout = captureStream();
-            runWorkflowDiagram("triage", {}, { loadWorkflowFile, stdout: stdout.stream, stderr: captureStream().stream, exit });
-            expect(loadWorkflowFile).not.toHaveBeenCalled();
-            expect(stdout.text).toMatch(/graph TB/);
-            // Confirm built-in renders raw by default too.
-            expect(stdout.text).not.toMatch(/```mermaid/);
-        });
-        it("resolves 'implement' without calling loadWorkflowFile", () => {
-            const stdout = captureStream();
-            runWorkflowDiagram("implement", {}, { loadWorkflowFile, stdout: stdout.stream, stderr: captureStream().stream, exit });
-            expect(loadWorkflowFile).not.toHaveBeenCalled();
-            expect(stdout.text.length).toBeGreaterThan(0);
-        });
-        it("resolves 'seed-content' without calling loadWorkflowFile", () => {
-            const stdout = captureStream();
-            runWorkflowDiagram("seed-content", {}, { loadWorkflowFile, stdout: stdout.stream, stderr: captureStream().stream, exit });
-            expect(loadWorkflowFile).not.toHaveBeenCalled();
-            expect(stdout.text.length).toBeGreaterThan(0);
-        });
-    });
-    describe("error handling", () => {
-        it("exits with code 1 and prints an error when loadWorkflowFile throws", () => {
-            const stderr = captureStream();
-            const throwingLoader = vi.fn(() => {
-                throw new Error("file not found: missing.yml");
-            });
-            runWorkflowDiagram("missing.yml", {}, { loadWorkflowFile: throwingLoader, stdout: captureStream().stream, stderr: stderr.stream, exit });
-            expect(exit).toHaveBeenCalledWith(1);
-            expect(stderr.text).toMatch(/file not found/);
-        });
-        it("exits with code 1 when the output path is unwritable", () => {
-            // Point -o at a path where the parent is a file (not a dir). mkdirSync
-            // with recursive:true will throw EEXIST, writeFileSync then fails. We
-            // specifically want to assert the error path doesn't crash the process.
-            const blocker = path.join(tmpdir, "blocker");
-            fs.writeFileSync(blocker, "im-a-file");
-            const out = path.join(blocker, "diagram.mmd");
-            const stderr = captureStream();
-            runWorkflowDiagram("any.yml", { output: out }, { loadWorkflowFile, stdout: captureStream().stream, stderr: stderr.stream, exit });
-            expect(exit).toHaveBeenCalledWith(1);
-            expect(stderr.text).toMatch(/Error:/);
-        });
-    });
-});

package/dist/cli/__tests__/report-cloud.test.d.ts

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

package/dist/cli/__tests__/report-cloud.test.js

@@ -1,165 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-describe("reportToCloud", () => {
-    let reportToCloud;
-    const fetchMock = vi.fn();
-    beforeEach(async () => {
-        fetchMock.mockReset();
-        fetchMock.mockResolvedValue(new Response(JSON.stringify({ run_url: "https://cloud.sweny.ai/runs/abc" }), { status: 200 }));
-        vi.spyOn(globalThis, "fetch").mockImplementation(fetchMock);
-        // Dynamic import to handle any module-level side effects
-        const mod = await import("../cloud-report.js");
-        reportToCloud = mod.reportToCloud;
-    });
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-    function makeConfig(overrides = {}) {
-        return {
-            cloudToken: "",
-            githubToken: "",
-            repository: "acme/widget",
-            codingAgentProvider: "claude",
-            anthropicApiKey: "",
-            claudeOauthToken: "",
-            openaiApiKey: "",
-            geminiApiKey: "",
-            observabilityProviders: [],
-            observabilityCredentials: {},
-            issueTrackerProvider: "",
-            linearApiKey: "",
-            linearTeamId: "",
-            linearBugLabelId: "",
-            linearTriageLabelId: "",
-            linearStateBacklog: "",
-            linearStateInProgress: "",
-            linearStatePeerReview: "",
-            timeRange: "",
-            severityFocus: "",
-            serviceFilter: "",
-            investigationDepth: "",
-            maxInvestigateTurns: 50,
-            maxImplementTurns: 40,
-            baseBranch: "main",
-            prLabels: [],
-            issueLabels: [],
-            dryRun: false,
-            reviewMode: "review",
-            noveltyMode: false,
-            issueOverride: "",
-            additionalInstructions: "",
-            serviceMapPath: "",
-            botToken: "",
-            sourceControlProvider: "",
-            jiraBaseUrl: "",
-            jiraEmail: "",
-            jiraApiToken: "",
-            gitlabToken: "",
-            gitlabProjectId: "",
-            gitlabBaseUrl: "",
-            notificationProvider: "",
-            notificationWebhookUrl: "",
-            sendgridApiKey: "",
-            emailFrom: "",
-            emailTo: "",
-            webhookSigningSecret: "",
-            repositoryOwner: "",
-            json: false,
-            stream: false,
-            bell: false,
-            cacheDir: "",
-            cacheTtl: 0,
-            noCache: false,
-            outputDir: "",
-            mcpServers: {},
-            workspaceTools: [],
-            rules: [],
-            context: [],
-            offline: false,
-            fetchAuth: {},
-            ...overrides,
-        };
-    }
-    function makeResults() {
-        return new Map([
-            [
-                "investigate",
-                {
-                    status: "success",
-                    data: { findings: [{ id: "F1" }], recommendation: "implement" },
-                    toolCalls: [],
-                },
-            ],
-            [
-                "create_pr",
-                {
-                    status: "success",
-                    data: { prUrl: "https://github.com/acme/widget/pull/7", prNumber: 7 },
-                    toolCalls: [],
-                },
-            ],
-        ]);
-    }
-    it("does NOT call fetch when cloudToken is empty", async () => {
-        await reportToCloud(makeResults(), 1000, makeConfig({ cloudToken: "" }), "triage");
-        expect(fetchMock).not.toHaveBeenCalled();
-    });
-    it("does NOT call fetch when repository is missing", async () => {
-        const orig = process.env.GITHUB_REPOSITORY;
-        delete process.env.GITHUB_REPOSITORY;
-        try {
-            await reportToCloud(makeResults(), 1000, makeConfig({ cloudToken: "sweny_pk_x", repository: "" }), "triage");
-            expect(fetchMock).not.toHaveBeenCalled();
-        }
-        finally {
-            if (orig !== undefined)
-                process.env.GITHUB_REPOSITORY = orig;
-        }
-    });
-    it("calls fetch with Bearer cloudToken when token is set", async () => {
-        await reportToCloud(makeResults(), 1000, makeConfig({ cloudToken: "sweny_pk_abc" }), "triage");
-        expect(fetchMock).toHaveBeenCalledTimes(1);
-        const [, init] = fetchMock.mock.calls[0];
-        expect(init.headers.Authorization).toBe("Bearer sweny_pk_abc");
-    });
-    it("does NOT send GITHUB_TOKEN in Authorization header", async () => {
-        await reportToCloud(makeResults(), 1000, makeConfig({ cloudToken: "sweny_pk_abc", githubToken: "ghs_evil" }), "triage");
-        const [, init] = fetchMock.mock.calls[0];
-        expect(init.headers.Authorization).not.toContain("ghs_evil");
-        expect(init.headers.Authorization).not.toMatch(/^token /);
-    });
-    it("posts to SWENY_CLOUD_URL override when set", async () => {
-        process.env.SWENY_CLOUD_URL = "https://cloud.example.test";
-        try {
-            await reportToCloud(makeResults(), 1000, makeConfig({ cloudToken: "sweny_pk_abc" }), "triage");
-            const [url] = fetchMock.mock.calls[0];
-            expect(url).toBe("https://cloud.example.test/api/report");
-        }
-        finally {
-            delete process.env.SWENY_CLOUD_URL;
-        }
-    });
-    it("silently swallows network failures", async () => {
-        fetchMock.mockRejectedValue(new Error("ECONNREFUSED"));
-        await expect(reportToCloud(makeResults(), 1000, makeConfig({ cloudToken: "sweny_pk_abc" }), "triage")).resolves.toBeUndefined();
-    });
-    it("prints the run URL when response includes one", async () => {
-        const logSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        await reportToCloud(makeResults(), 1000, makeConfig({ cloudToken: "sweny_pk_abc" }), "triage");
-        const output = logSpy.mock.calls.flat().join(" ");
-        expect(output).toContain("cloud.sweny.ai/runs/abc");
-        logSpy.mockRestore();
-    });
-    it("payload contains owner, repo, workflow, duration_ms, findings, nodes", async () => {
-        await reportToCloud(makeResults(), 1234, makeConfig({ cloudToken: "sweny_pk_abc" }), "triage");
-        const [, init] = fetchMock.mock.calls[0];
-        const body = JSON.parse(init.body);
-        expect(body).toMatchObject({
-            owner: "acme",
-            repo: "widget",
-            workflow: "triage",
-            duration_ms: 1234,
-        });
-        expect(Array.isArray(body.findings)).toBe(true);
-        expect(Array.isArray(body.nodes)).toBe(true);
-    });
-});

package/dist/cli/__tests__/upgrade.test.d.ts

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