@sweny-ai/core 0.1.77 → 0.1.79

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

@@ -1,312 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { readFileSync, existsSync } from "node:fs";
-import { resolve, relative } from "node:path";
-import { execSync } from "node:child_process";
-/**
- * Version consistency tests — ensure the v5 migration is complete
- * and prevent regressions when the action version changes.
- *
- * These tests validate that:
- * 1. No stale v4 action references remain in source or docs
- * 2. The README uses dark-mode-safe logo rendering
- * 3. The CLI new wizard generates the correct action version
- * 4. Docs code blocks don't mix the generic action with triage-only inputs
- */
-const ROOT = resolve(import.meta.dirname, "..", "..", "..", "..");
-const CURRENT_ACTION_VERSION = "v5";
-/** The previous action version — split into pieces so git grep doesn't match this file */
-const PREV_VERSION = `v${"4"}`;
-/** Files that are historical records — allowed to reference old versions */
-const HISTORICAL_GLOBS = ["docs/superpowers/", ".tasks/", "node_modules/", ".changeset/", "CHANGELOG"];
-function isHistorical(filePath) {
-    const rel = relative(ROOT, filePath);
-    return HISTORICAL_GLOBS.some((g) => rel.startsWith(g));
-}
-/**
- * Use git grep for fast, indexed search across the repo.
- * Returns array of "file:line:content" strings.
- */
-function gitGrep(pattern, paths = ["."]) {
-    try {
-        const pathArgs = paths.map((p) => `"${p}"`).join(" ");
-        const result = execSync(`git grep -n "${pattern}" -- ${pathArgs}`, {
-            cwd: ROOT,
-            encoding: "utf-8",
-            maxBuffer: 10 * 1024 * 1024,
-        });
-        return result.trim().split("\n").filter(Boolean);
-    }
-    catch {
-        // git grep exits 1 when no matches — that's fine
-        return [];
-    }
-}
-// ─── 1. No stale v4 references ──────────────────────────────────────
-describe("action version consistency", () => {
-    it(`has no swenyai/sweny@${PREV_VERSION} references in source or docs`, () => {
-        const matches = gitGrep(`swenyai/sweny@${PREV_VERSION}`);
-        const live = matches.filter((m) => {
-            const file = resolve(ROOT, m.split(":")[0]);
-            return !isHistorical(file);
-        });
-        if (live.length > 0) {
-            const summary = live
-                .map((m) => {
-                const [f, line] = m.split(":");
-                return `  ${f}:${line}`;
-            })
-                .join("\n");
-            expect.fail(`Found ${live.length} stale swenyai/sweny@${PREV_VERSION} reference(s):\n${summary}\n\n` +
-                `All live references should use swenyai/sweny@${CURRENT_ACTION_VERSION}`);
-        }
-    });
-    it("CLAUDE.md references the current action version", () => {
-        const claude = readFileSync(resolve(ROOT, "CLAUDE.md"), "utf-8");
-        expect(claude).toContain(`swenyai/sweny@${CURRENT_ACTION_VERSION}`);
-        expect(claude).not.toContain(`swenyai/sweny@${PREV_VERSION}`);
-    });
-    it("CLAUDE.md package table references the current version", () => {
-        const claude = readFileSync(resolve(ROOT, "CLAUDE.md"), "utf-8");
-        expect(claude).toMatch(new RegExp(`@sweny-ai/core.*${CURRENT_ACTION_VERSION}`));
-    });
-    it("CLI new wizard generates workflows with the current action version", () => {
-        const newSrc = readFileSync(resolve(ROOT, "packages/core/src/cli/new.ts"), "utf-8");
-        expect(newSrc).toContain(`swenyai/sweny@${CURRENT_ACTION_VERSION}`);
-        expect(newSrc).not.toContain(`swenyai/sweny@${PREV_VERSION}`);
-    });
-});
-// ─── 2. README quality ──────────────────────────────────────────────
-describe("README", () => {
-    const readme = readFileSync(resolve(ROOT, "README.md"), "utf-8");
-    it("uses <picture> element for dark mode logo", () => {
-        expect(readme).toContain("<picture>");
-        expect(readme).toContain("prefers-color-scheme: dark");
-        expect(readme).toContain("prefers-color-scheme: light");
-    });
-    it("maps dark scheme to light logo and light scheme to dark logo", () => {
-        // Dark background needs light (white) text logo
-        expect(readme).toMatch(/prefers-color-scheme:\s*dark.*logo-lockup-light\.svg/s);
-        // Light background needs dark text logo
-        expect(readme).toMatch(/prefers-color-scheme:\s*light.*logo-lockup-dark\.svg/s);
-    });
-    it("references both logo assets that exist on disk", () => {
-        expect(existsSync(resolve(ROOT, "assets/logo-lockup-dark.svg"))).toBe(true);
-        expect(existsSync(resolve(ROOT, "assets/logo-lockup-light.svg"))).toBe(true);
-    });
-    it("does not use the old Recipes heading", () => {
-        expect(readme).not.toMatch(/^## Recipes$/m);
-    });
-    it("has a GitHub Actions section with the multi-repo table", () => {
-        expect(readme).toMatch(/^## GitHub Actions$/m);
-        expect(readme).toContain("swenyai/triage@v1");
-        expect(readme).toContain("swenyai/e2e@v1");
-        expect(readme).toContain(`swenyai/sweny@${CURRENT_ACTION_VERSION}`);
-    });
-});
-// ─── 3. action.yml describes a generic workflow runner ──────────────
-describe("action.yml", () => {
-    const actionYml = readFileSync(resolve(ROOT, "action.yml"), "utf-8");
-    it("has a description under 125 characters", () => {
-        const match = actionYml.match(/^description:\s*"(.+)"$/m);
-        expect(match).not.toBeNull();
-        expect(match[1].length).toBeLessThan(125);
-    });
-    it("requires a workflow input", () => {
-        expect(actionYml).toContain("workflow:");
-    });
-    it("does not have triage-specific inputs", () => {
-        // These belong on swenyai/triage, not the generic runner
-        const triageInputs = [
-            "observability-provider",
-            "sentry-auth-token",
-            "dd-api-key",
-            "dd-app-key",
-            "issue-tracker-provider",
-            "linear-api-key",
-            "dry-run",
-            "time-range",
-            "severity-focus",
-        ];
-        for (const input of triageInputs) {
-            expect(actionYml).not.toContain(`${input}:`);
-        }
-    });
-    it("runs sweny workflow run", () => {
-        expect(actionYml).toMatch(/sweny workflow run/);
-    });
-});
-// ─── 4. Docs code blocks don't mix generic action with triage inputs ─
-describe("docs action code blocks", () => {
-    const TRIAGE_ONLY_INPUTS = [
-        "observability-provider",
-        "sentry-auth-token",
-        "sentry-org",
-        "sentry-project",
-        "dd-api-key",
-        "dd-app-key",
-        "issue-tracker-provider",
-        "linear-api-key",
-        "linear-team-id",
-        "dry-run:",
-        "time-range",
-        "severity-focus",
-        "service-filter",
-        "investigation-depth",
-    ];
-    /**
-     * Extract YAML code blocks that reference swenyai/sweny@v5
-     * and check they don't use triage-only inputs.
-     */
-    function findMisusedBlocks(filePath) {
-        if (!existsSync(filePath))
-            return [];
-        const content = readFileSync(filePath, "utf-8");
-        const blocks = content.match(/```ya?ml[\s\S]*?```/g) || [];
-        const issues = [];
-        for (const block of blocks) {
-            if (!block.includes(`swenyai/sweny@${CURRENT_ACTION_VERSION}`))
-                continue;
-            for (const input of TRIAGE_ONLY_INPUTS) {
-                if (block.includes(input)) {
-                    issues.push(`${relative(ROOT, filePath)}: code block uses swenyai/sweny@${CURRENT_ACTION_VERSION} with triage-only input "${input}"`);
-                    break; // one issue per block is enough
-                }
-            }
-        }
-        return issues;
-    }
-    // These are the docs files that show GitHub Action examples
-    const ACTION_DOC_FILES = [
-        "packages/web/src/content/docs/action/index.md",
-        "packages/web/src/content/docs/action/examples.md",
-        "packages/web/src/content/docs/action/scheduling.md",
-        "packages/web/src/content/docs/action/inputs.md",
-        "packages/web/src/content/docs/action/service-map.md",
-        "packages/web/src/content/docs/index.mdx",
-        "packages/web/src/content/docs/getting-started/quick-start.md",
-        "packages/web/src/content/docs/workflows/triage.md",
-        "packages/web/src/content/docs/workflows/implement.md",
-        "packages/web/src/content/docs/cloud/getting-started.mdx",
-        "packages/web/src/content/docs/advanced/mcp-servers.md",
-        "packages/web/src/content/docs/advanced/troubleshooting.md",
-    ];
-    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` +
-                allIssues.map((i) => `  ${i}`).join("\n"));
-        }
-    });
-    it("every swenyai/sweny@v5 code block has a workflow: input", () => {
-        const issues = [];
-        for (const f of ACTION_DOC_FILES) {
-            const filePath = resolve(ROOT, f);
-            if (!existsSync(filePath))
-                continue;
-            const content = readFileSync(filePath, "utf-8");
-            const blocks = content.match(/```ya?ml[\s\S]*?```/g) || [];
-            for (const block of blocks) {
-                if (!block.includes(`swenyai/sweny@${CURRENT_ACTION_VERSION}`))
-                    continue;
-                if (!block.includes("workflow:")) {
-                    issues.push(`${relative(ROOT, filePath)}: code block uses swenyai/sweny@${CURRENT_ACTION_VERSION} without workflow: input`);
-                }
-            }
-        }
-        if (issues.length > 0) {
-            expect.fail(`The generic runner requires a workflow: input.\n` + issues.map((i) => `  ${i}`).join("\n"));
-        }
-    });
-});
-// ─── 5. Internal doc links resolve ──────────────────────────────────
-describe("docs internal links", () => {
-    const DOCS_ROOT = resolve(ROOT, "packages/web/src/content/docs");
-    /**
-     * Extract markdown links like [text](/path/) and verify the target exists.
-     * Only checks internal absolute links (starting with /).
-     */
-    function findBrokenLinks(filePath) {
-        if (!existsSync(filePath))
-            return [];
-        const content = readFileSync(filePath, "utf-8");
-        const broken = [];
-        // Match [text](/path/) and [text](/path/#anchor) but skip external URLs
-        const linkPattern = /\[([^\]]*)\]\(\/([^)#]*?)\/?\)/g;
-        let match;
-        while ((match = linkPattern.exec(content)) !== null) {
-            const linkPath = match[2];
-            // Map /action/ → action/index.md, /action/inputs/ → action/inputs.md
-            const candidates = [
-                resolve(DOCS_ROOT, linkPath, "index.md"),
-                resolve(DOCS_ROOT, linkPath, "index.mdx"),
-                resolve(DOCS_ROOT, `${linkPath}.md`),
-                resolve(DOCS_ROOT, `${linkPath}.mdx`),
-            ];
-            if (!candidates.some((c) => existsSync(c))) {
-                broken.push(`${relative(ROOT, filePath)}: broken link [${match[1]}](/${linkPath}/)`);
-            }
-        }
-        return broken;
-    }
-    const KEY_DOCS = [
-        "packages/web/src/content/docs/action/index.md",
-        "packages/web/src/content/docs/action/inputs.md",
-        "packages/web/src/content/docs/action/examples.md",
-        "packages/web/src/content/docs/action/scheduling.md",
-        "packages/web/src/content/docs/action/service-map.md",
-        "packages/web/src/content/docs/index.mdx",
-        "packages/web/src/content/docs/getting-started/quick-start.md",
-    ];
-    it("key action docs have no broken internal links", () => {
-        const allBroken = KEY_DOCS.flatMap((f) => findBrokenLinks(resolve(ROOT, f)));
-        if (allBroken.length > 0) {
-            expect.fail(`Found ${allBroken.length} broken link(s):\n` + allBroken.map((b) => `  ${b}`).join("\n"));
-        }
-    });
-});
-// ─── 6. Three-action architecture documented ────────────────────────
-describe("three-action architecture", () => {
-    it("action/index.md documents all three actions", () => {
-        const content = readFileSync(resolve(ROOT, "packages/web/src/content/docs/action/index.md"), "utf-8");
-        expect(content).toContain("swenyai/triage@v1");
-        expect(content).toContain("swenyai/e2e@v1");
-        expect(content).toContain(`swenyai/sweny@${CURRENT_ACTION_VERSION}`);
-    });
-    it("action/inputs.md has sections for all three actions", () => {
-        const content = readFileSync(resolve(ROOT, "packages/web/src/content/docs/action/inputs.md"), "utf-8");
-        expect(content).toMatch(/## Generic runner inputs/);
-        expect(content).toMatch(/## Triage action inputs/);
-        expect(content).toMatch(/## E2E action inputs/);
-    });
-    it("README Actions table lists all three actions", () => {
-        const readme = readFileSync(resolve(ROOT, "README.md"), "utf-8");
-        expect(readme).toContain("swenyai/triage@v1");
-        expect(readme).toContain("swenyai/e2e@v1");
-        expect(readme).toContain(`swenyai/sweny@${CURRENT_ACTION_VERSION}`);
-    });
-});
-// ─── 7. Input naming consistency ────────────────────────────────────
-describe("input naming consistency", () => {
-    const DOCS_DIR = resolve(ROOT, "packages/web/src/content/docs");
-    it("docs use issue-override, not linear-issue", () => {
-        const matches = gitGrep("linear-issue", ["packages/web/src/content/docs/"]);
-        if (matches.length > 0) {
-            expect.fail(`Found "linear-issue" in docs — the triage action input is "issue-override":\n` +
-                matches.map((m) => `  ${m.split(":").slice(0, 2).join(":")}`).join("\n"));
-        }
-    });
-    it("docs use mcp-servers-json, not bare mcp-servers as an input name", () => {
-        // Match `mcp-servers:` or `mcp-servers |` in YAML (the input name), but NOT
-        // `mcp-servers-json` or prose text mentioning "MCP servers" as a concept
-        const matches = gitGrep("mcp-servers[^-]", ["packages/web/src/content/docs/"]);
-        const inputRefs = matches.filter((m) => {
-            const content = m.split(":").slice(2).join(":");
-            // Only flag YAML input usage, not prose text
-            return /^\s*(mcp-servers:|mcp-servers\s*\|)/.test(content);
-        });
-        if (inputRefs.length > 0) {
-            expect.fail(`Found bare "mcp-servers" as an input — the triage action input is "mcp-servers-json":\n` +
-                inputRefs.map((m) => `  ${m.split(":").slice(0, 2).join(":")}`).join("\n"));
-        }
-    });
-});

package/dist/__tests__/workflow-builder.test.d.ts

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

package/dist/__tests__/workflow-builder.test.js

@@ -1,110 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { buildSystemPrompt, deriveWorkflowVariables } from "../workflow-builder.js";
-const fakeSkill = (id, config = {}) => ({
-    id,
-    name: id,
-    description: `${id} skill`,
-    category: "general",
-    config,
-    tools: [],
-});
-describe("buildSystemPrompt", () => {
-    it("includes config fields in the skill list", () => {
-        const skills = [
-            fakeSkill("github", {
-                GITHUB_TOKEN: { description: "GitHub token", required: true, env: "GITHUB_TOKEN" },
-            }),
-        ];
-        const prompt = buildSystemPrompt(skills);
-        expect(prompt).toContain("- github: github skill");
-        expect(prompt).toContain("Config: GITHUB_TOKEN (required)");
-    });
-    it("shows optional config fields", () => {
-        const skills = [
-            fakeSkill("slack", {
-                SLACK_WEBHOOK_URL: { description: "Webhook URL", required: false, env: "SLACK_WEBHOOK_URL" },
-                SLACK_BOT_TOKEN: { description: "Bot token", required: false, env: "SLACK_BOT_TOKEN" },
-            }),
-        ];
-        const prompt = buildSystemPrompt(skills);
-        expect(prompt).toContain("SLACK_WEBHOOK_URL (optional)");
-        expect(prompt).toContain("SLACK_BOT_TOKEN (optional)");
-    });
-    it("omits Config line for skills with no config", () => {
-        const skills = [fakeSkill("simple")];
-        const prompt = buildSystemPrompt(skills);
-        expect(prompt).toContain("- simple: simple skill");
-        expect(prompt).not.toContain("Config:");
-    });
-});
-describe("deriveWorkflowVariables", () => {
-    const workflow = {
-        id: "test",
-        name: "test",
-        description: "test workflow",
-        entry: "gather",
-        nodes: {
-            gather: {
-                name: "Gather",
-                instruction: "gather data",
-                skills: ["github", "slack"],
-            },
-        },
-        edges: [],
-    };
-    it("always includes ANTHROPIC_API_KEY first", () => {
-        const vars = deriveWorkflowVariables(workflow, []);
-        expect(vars[0].name).toBe("ANTHROPIC_API_KEY");
-        expect(vars[0].required).toBe(true);
-    });
-    it("derives variables from referenced skills", () => {
-        const skills = [
-            fakeSkill("github", {
-                GITHUB_TOKEN: { description: "GitHub token", required: true, env: "GITHUB_TOKEN" },
-            }),
-            fakeSkill("slack", {
-                SLACK_WEBHOOK_URL: { description: "Webhook URL", required: false, env: "SLACK_WEBHOOK_URL" },
-            }),
-        ];
-        const vars = deriveWorkflowVariables(workflow, skills);
-        const names = vars.map((v) => v.name);
-        expect(names).toContain("GITHUB_TOKEN");
-        expect(names).toContain("SLACK_WEBHOOK_URL");
-    });
-    it("deduplicates env vars across skills", () => {
-        const multiNodeWorkflow = {
-            ...workflow,
-            nodes: {
-                a: { name: "A", instruction: "a", skills: ["github"] },
-                b: { name: "B", instruction: "b", skills: ["github"] },
-            },
-        };
-        const skills = [
-            fakeSkill("github", {
-                GITHUB_TOKEN: { description: "GitHub token", required: true, env: "GITHUB_TOKEN" },
-            }),
-        ];
-        const vars = deriveWorkflowVariables(multiNodeWorkflow, skills);
-        const tokenCount = vars.filter((v) => v.name === "GITHUB_TOKEN").length;
-        expect(tokenCount).toBe(1);
-    });
-    it("skips skills not in the available list", () => {
-        const vars = deriveWorkflowVariables(workflow, []);
-        // Only ANTHROPIC_API_KEY
-        expect(vars).toHaveLength(1);
-    });
-    it("includes custom skills with config", () => {
-        const customWorkflow = {
-            ...workflow,
-            nodes: { tax: { name: "Tax", instruction: "do taxes", skills: ["my-tax-tool"] } },
-        };
-        const skills = [
-            fakeSkill("my-tax-tool", {
-                MY_TAX_KEY: { description: "Tax API key", required: true, env: "MY_TAX_KEY" },
-            }),
-        ];
-        const vars = deriveWorkflowVariables(customWorkflow, skills);
-        expect(vars.find((v) => v.name === "MY_TAX_KEY")).toBeDefined();
-        expect(vars.find((v) => v.name === "MY_TAX_KEY")?.skill).toBe("my-tax-tool");
-    });
-});

package/dist/__tests__/workflow-yaml.test.d.ts

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

package/dist/__tests__/workflow-yaml.test.js

@@ -1,201 +0,0 @@
-/**
- * Tests for YAML-based built-in workflows.
- *
- * Validates that the YAML files are correctly loaded, structurally valid,
- * match the Workflow type, and that the browser bundle is consistent.
- */
-import { describe, it, expect } from "vitest";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { fileURLToPath } from "node:url";
-import { parse as parseYaml } from "yaml";
-import { triageWorkflow, implementWorkflow, seedContentWorkflow } from "../workflows/index.js";
-import { validateWorkflow, workflowZ } from "../schema.js";
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const workflowDir = path.join(__dirname, "..", "workflows");
-// ─── YAML file existence & parsing ──────────────────────────────
-describe("workflow YAML files", () => {
-    const yamlFiles = ["triage.yml", "implement.yml", "seed-content.yml"];
-    for (const file of yamlFiles) {
-        it(`${file} exists on disk`, () => {
-            const filePath = path.join(workflowDir, file);
-            expect(fs.existsSync(filePath)).toBe(true);
-        });
-        it(`${file} is valid YAML`, () => {
-            const content = fs.readFileSync(path.join(workflowDir, file), "utf-8");
-            expect(() => parseYaml(content)).not.toThrow();
-        });
-        it(`${file} parses to an object with required Workflow fields`, () => {
-            const content = fs.readFileSync(path.join(workflowDir, file), "utf-8");
-            const data = parseYaml(content);
-            expect(data).toHaveProperty("id");
-            expect(data).toHaveProperty("name");
-            expect(data).toHaveProperty("entry");
-            expect(data).toHaveProperty("nodes");
-            expect(data).toHaveProperty("edges");
-            expect(typeof data.id).toBe("string");
-            expect(typeof data.name).toBe("string");
-            expect(typeof data.entry).toBe("string");
-            expect(typeof data.nodes).toBe("object");
-            expect(Array.isArray(data.edges)).toBe(true);
-        });
-        it(`${file} passes Zod schema validation`, () => {
-            const content = fs.readFileSync(path.join(workflowDir, file), "utf-8");
-            const data = parseYaml(content);
-            expect(() => workflowZ.parse(data)).not.toThrow();
-        });
-    }
-});
-// ─── Loaded workflow objects ────────────────────────────────────
-describe("loaded workflow objects", () => {
-    const workflows = [
-        ["triage", triageWorkflow],
-        ["implement", implementWorkflow],
-        ["seed-content", seedContentWorkflow],
-    ];
-    for (const [name, workflow] of workflows) {
-        describe(name, () => {
-            it("has correct id", () => {
-                expect(workflow.id).toBe(name);
-            });
-            it("has a non-empty name", () => {
-                expect(workflow.name.length).toBeGreaterThan(0);
-            });
-            it("entry node exists in nodes", () => {
-                expect(workflow.nodes).toHaveProperty(workflow.entry);
-            });
-            it("passes structural validation (no cycles, all reachable)", () => {
-                const errors = validateWorkflow(workflow);
-                expect(errors).toEqual([]);
-            });
-            it("every node has a non-empty instruction", () => {
-                for (const [nodeId, node] of Object.entries(workflow.nodes)) {
-                    const instr = node.instruction;
-                    if (typeof instr === "string") {
-                        expect(instr.length, `node "${nodeId}" has empty instruction`).toBeGreaterThan(0);
-                    }
-                    else {
-                        // Object-form Source — always truthy if it exists
-                        expect(instr, `node "${nodeId}" has falsy instruction`).toBeTruthy();
-                    }
-                }
-            });
-            it("every node has a name", () => {
-                for (const [nodeId, node] of Object.entries(workflow.nodes)) {
-                    expect(node.name.length, `node "${nodeId}" has empty name`).toBeGreaterThan(0);
-                }
-            });
-            it("all edge sources reference existing nodes", () => {
-                const nodeIds = new Set(Object.keys(workflow.nodes));
-                for (const edge of workflow.edges) {
-                    expect(nodeIds.has(edge.from), `edge source "${edge.from}" not in nodes`).toBe(true);
-                }
-            });
-            it("all edge targets reference existing nodes", () => {
-                const nodeIds = new Set(Object.keys(workflow.nodes));
-                for (const edge of workflow.edges) {
-                    expect(nodeIds.has(edge.to), `edge target "${edge.to}" not in nodes`).toBe(true);
-                }
-            });
-            it("has no self-loops", () => {
-                for (const edge of workflow.edges) {
-                    expect(edge.from, `self-loop on "${edge.from}"`).not.toBe(edge.to);
-                }
-            });
-            it("all non-terminal nodes have at least one outgoing edge", () => {
-                const nodeIds = Object.keys(workflow.nodes);
-                const nodesWithOutgoing = new Set(workflow.edges.map((e) => e.from));
-                const terminalNodes = nodeIds.filter((id) => !nodesWithOutgoing.has(id));
-                // Terminal nodes are fine (they're leaf nodes), but there should be at least one
-                // non-terminal node unless it's a single-node workflow
-                if (nodeIds.length > 1) {
-                    expect(nodesWithOutgoing.size).toBeGreaterThan(0);
-                }
-            });
-        });
-    }
-});
-// ─── Triage workflow specifics ──────────────────────────────────
-describe("triage workflow specifics", () => {
-    it("has 7 nodes", () => {
-        expect(Object.keys(triageWorkflow.nodes).length).toBe(7);
-    });
-    it("starts at gather", () => {
-        expect(triageWorkflow.entry).toBe("gather");
-    });
-    it("has conditional edges from investigate", () => {
-        const investigateEdges = triageWorkflow.edges.filter((e) => e.from === "investigate");
-        expect(investigateEdges.length).toBe(2);
-        expect(investigateEdges.every((e) => e.when)).toBe(true);
-    });
-    it("notify is reachable from all branches", () => {
-        const toNotify = triageWorkflow.edges.filter((e) => e.to === "notify");
-        expect(toNotify.length).toBeGreaterThanOrEqual(3);
-    });
-    it("investigate node has structured output schema", () => {
-        expect(triageWorkflow.nodes.investigate.output).toBeDefined();
-        expect(triageWorkflow.nodes.investigate.output.type).toBe("object");
-        expect(triageWorkflow.nodes.investigate.output.required).toContain("findings");
-    });
-});
-// ─── Implement workflow specifics ───────────────────────────────
-describe("implement workflow specifics", () => {
-    it("has 5 nodes", () => {
-        expect(Object.keys(implementWorkflow.nodes).length).toBe(5);
-    });
-    it("starts at analyze", () => {
-        expect(implementWorkflow.entry).toBe("analyze");
-    });
-    it("has conditional edges from analyze", () => {
-        const analyzeEdges = implementWorkflow.edges.filter((e) => e.from === "analyze");
-        expect(analyzeEdges.length).toBe(2);
-        expect(analyzeEdges.every((e) => e.when)).toBe(true);
-    });
-    it("skip routes to notify (team always gets notified)", () => {
-        const skipToNotify = implementWorkflow.edges.find((e) => e.from === "skip" && e.to === "notify");
-        expect(skipToNotify).toBeDefined();
-    });
-    it("analyze node has structured output schema", () => {
-        expect(implementWorkflow.nodes.analyze.output).toBeDefined();
-        expect(implementWorkflow.nodes.analyze.output.type).toBe("object");
-    });
-});
-// ─── Browser bundle consistency ─────────────────────────────────
-describe("browser bundle", () => {
-    const browserPath = path.join(__dirname, "..", "..", "dist", "workflows", "browser.js");
-    it("exists in dist", () => {
-        expect(fs.existsSync(browserPath)).toBe(true);
-    });
-    it("triage workflow is deeply equal", async () => {
-        const browser = await import(browserPath);
-        expect(browser.triageWorkflow).toEqual(JSON.parse(JSON.stringify(triageWorkflow)));
-    });
-    it("implement workflow is deeply equal", async () => {
-        const browser = await import(browserPath);
-        expect(browser.implementWorkflow).toEqual(JSON.parse(JSON.stringify(implementWorkflow)));
-    });
-    it("seed-content workflow is deeply equal", async () => {
-        const browser = await import(browserPath);
-        expect(browser.seedContentWorkflow).toEqual(JSON.parse(JSON.stringify(seedContentWorkflow)));
-    });
-    it("exports exactly the expected workflow names", async () => {
-        const browser = await import(browserPath);
-        const exportedKeys = Object.keys(browser).sort();
-        expect(exportedKeys).toEqual(["implementWorkflow", "seedContentWorkflow", "triageWorkflow"]);
-    });
-});
-// ─── Zod runtime validation ─────────────────────────────────────
-describe("runtime Zod validation in loader", () => {
-    it("workflows are Zod-validated at load time (not just cast)", () => {
-        // The loader uses workflowZ.parse(), so invalid YAML would throw at import.
-        // If we got here, all 3 workflows passed Zod validation at module load.
-        // Verify by checking the parsed output has Zod's default-applied fields.
-        expect(triageWorkflow.description).toBeDefined();
-        expect(implementWorkflow.description).toBeDefined();
-        expect(seedContentWorkflow.description).toBeDefined();
-        // Zod applies .default([]) to skills arrays — verify it works
-        for (const node of Object.values(triageWorkflow.nodes)) {
-            expect(Array.isArray(node.skills)).toBe(true);
-        }
-    });
-});

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

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