@sweny-ai/core 0.1.0

package/dist/cli/renderer.test.js

@@ -0,0 +1,302 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { DagRenderer, stripAnsi } from "./renderer.js";
+const testWorkflow = {
+    id: "test",
+    name: "Test Workflow",
+    description: "A simple test workflow",
+    nodes: {
+        gather: { name: "Gather Context", instruction: "Gather", skills: [] },
+        investigate: { name: "Investigate", instruction: "Investigate", skills: [] },
+        report: { name: "Report", instruction: "Report", skills: [] },
+    },
+    edges: [
+        { from: "gather", to: "investigate" },
+        { from: "investigate", to: "report" },
+    ],
+    entry: "gather",
+};
+describe("DagRenderer", () => {
+    let renderer;
+    beforeEach(() => {
+        renderer = new DagRenderer(testWorkflow, { animate: false });
+    });
+    it("starts all nodes in pending state", () => {
+        expect(renderer.getNodeState("gather")).toBe("pending");
+        expect(renderer.getNodeState("investigate")).toBe("pending");
+        expect(renderer.getNodeState("report")).toBe("pending");
+    });
+    it("tracks node state: pending → running on node:enter", () => {
+        const event = { type: "node:enter", node: "gather", instruction: "Gather" };
+        renderer.update(event);
+        expect(renderer.getNodeState("gather")).toBe("running");
+        expect(renderer.getNodeState("investigate")).toBe("pending");
+    });
+    it("tracks node state: running → completed on node:exit success", () => {
+        renderer.update({ type: "node:enter", node: "gather", instruction: "Gather" });
+        renderer.update({
+            type: "node:exit",
+            node: "gather",
+            result: { status: "success", data: {}, toolCalls: [] },
+        });
+        expect(renderer.getNodeState("gather")).toBe("completed");
+    });
+    it("tracks node state: running → failed on node:exit failed", () => {
+        renderer.update({ type: "node:enter", node: "gather", instruction: "Gather" });
+        renderer.update({
+            type: "node:exit",
+            node: "gather",
+            result: { status: "failed", data: {}, toolCalls: [] },
+        });
+        expect(renderer.getNodeState("gather")).toBe("failed");
+    });
+    it("tracks failed nodes", () => {
+        renderer.update({ type: "node:enter", node: "investigate", instruction: "Investigate" });
+        renderer.update({
+            type: "node:exit",
+            node: "investigate",
+            result: { status: "failed", data: { error: "timeout" }, toolCalls: [] },
+        });
+        expect(renderer.getNodeState("investigate")).toBe("failed");
+    });
+    it("counts tool calls per node", () => {
+        expect(renderer.getToolCallCount("gather")).toBe(0);
+        renderer.update({ type: "node:enter", node: "gather", instruction: "Gather" });
+        renderer.update({ type: "tool:call", node: "gather", tool: "search", input: {} });
+        renderer.update({ type: "tool:call", node: "gather", tool: "fetch", input: {} });
+        expect(renderer.getToolCallCount("gather")).toBe(2);
+        expect(renderer.getToolCallCount("investigate")).toBe(0);
+    });
+    it("counts tool calls across multiple nodes independently", () => {
+        renderer.update({ type: "node:enter", node: "gather", instruction: "Gather" });
+        renderer.update({ type: "tool:call", node: "gather", tool: "search", input: {} });
+        renderer.update({ type: "node:exit", node: "gather", result: { status: "success", data: {}, toolCalls: [] } });
+        renderer.update({ type: "node:enter", node: "investigate", instruction: "Investigate" });
+        renderer.update({ type: "tool:call", node: "investigate", tool: "read", input: {} });
+        renderer.update({ type: "tool:call", node: "investigate", tool: "write", input: {} });
+        renderer.update({ type: "tool:call", node: "investigate", tool: "run", input: {} });
+        expect(renderer.getToolCallCount("gather")).toBe(1);
+        expect(renderer.getToolCallCount("investigate")).toBe(3);
+    });
+    it("renders to string without crashing", () => {
+        const output = renderer.renderToString();
+        expect(typeof output).toBe("string");
+        expect(output.length).toBeGreaterThan(0);
+    });
+    it("output contains all node names", () => {
+        const output = renderer.renderToString();
+        expect(output).toContain("Gather Context");
+        expect(output).toContain("Investigate");
+        expect(output).toContain("Report");
+    });
+    it("topological order starts from entry node", () => {
+        const output = renderer.renderToString();
+        const gatherIdx = output.indexOf("Gather Context");
+        const investigateIdx = output.indexOf("Investigate");
+        const reportIdx = output.indexOf("Report");
+        expect(gatherIdx).toBeLessThan(investigateIdx);
+        expect(investigateIdx).toBeLessThan(reportIdx);
+    });
+    it("shows running status icon for active node", () => {
+        renderer.update({ type: "node:enter", node: "gather", instruction: "Gather" });
+        const output = renderer.renderToString();
+        // ◉ is the running icon
+        expect(output).toContain("◉");
+    });
+    it("shows completed status icon for finished node", () => {
+        renderer.update({ type: "node:enter", node: "gather", instruction: "Gather" });
+        renderer.update({
+            type: "node:exit",
+            node: "gather",
+            result: { status: "success", data: {}, toolCalls: [] },
+        });
+        const output = renderer.renderToString();
+        // ● is the completed icon
+        expect(output).toContain("●");
+    });
+    it("shows failed status icon for failed node", () => {
+        renderer.update({ type: "node:enter", node: "gather", instruction: "Gather" });
+        renderer.update({
+            type: "node:exit",
+            node: "gather",
+            result: { status: "failed", data: {}, toolCalls: [] },
+        });
+        const output = renderer.renderToString();
+        // ✕ is the failed icon
+        expect(output).toContain("✕");
+    });
+    it("returns pending state for unknown node id", () => {
+        expect(renderer.getNodeState("nonexistent")).toBe("pending");
+    });
+    it("returns 0 tool calls for unknown node id", () => {
+        expect(renderer.getToolCallCount("nonexistent")).toBe(0);
+    });
+    it("includes a legend in the output", () => {
+        const output = renderer.renderToString();
+        // Legend should mention at least pending and completed
+        expect(output).toContain("○");
+        expect(output).toContain("●");
+    });
+    it("handles workflow:start event without crashing", () => {
+        const event = { type: "workflow:start", workflow: "test" };
+        expect(() => renderer.update(event)).not.toThrow();
+    });
+    it("handles workflow:end event without crashing", () => {
+        const event = {
+            type: "workflow:end",
+            results: {
+                gather: { status: "success", data: {}, toolCalls: [] },
+            },
+        };
+        expect(() => renderer.update(event)).not.toThrow();
+    });
+    it("handles route event without crashing", () => {
+        const event = { type: "route", from: "gather", to: "investigate", reason: "next" };
+        expect(() => renderer.update(event)).not.toThrow();
+    });
+    describe("uniform box widths", () => {
+        const mixedWidthWorkflow = {
+            id: "mixed",
+            name: "Mixed Width Workflow",
+            description: "Nodes with varying name lengths",
+            nodes: {
+                a: { name: "A", instruction: "Short", skills: [] },
+                b: { name: "Gather Context and Analyze", instruction: "Long name", skills: [] },
+                c: { name: "Report", instruction: "Medium", skills: [] },
+            },
+            edges: [
+                { from: "a", to: "b" },
+                { from: "b", to: "c" },
+            ],
+            entry: "a",
+        };
+        it("all top-border lines have the same width", () => {
+            const r = new DagRenderer(mixedWidthWorkflow, { animate: false });
+            const output = stripAnsi(r.renderToString());
+            const topLines = output.split("\n").filter((l) => l.includes("┌") && l.includes("┐"));
+            expect(topLines.length).toBe(3);
+            const widths = topLines.map((l) => l.trim().length);
+            expect(new Set(widths).size).toBe(1); // all same width
+        });
+        it("output contains ▼ arrowhead on non-first boxes", () => {
+            const r = new DagRenderer(mixedWidthWorkflow, { animate: false });
+            const output = stripAnsi(r.renderToString());
+            expect(output).toContain("▼");
+        });
+        it("▼ is positioned between box borders", () => {
+            const r = new DagRenderer(mixedWidthWorkflow, { animate: false });
+            const output = stripAnsi(r.renderToString());
+            const arrowLines = output.split("\n").filter((l) => l.includes("▼"));
+            for (const line of arrowLines) {
+                // ▼ should be inside a top border: ┌───▼───┐
+                expect(line).toMatch(/┌─*▼─*┐/);
+            }
+        });
+        it("bottom of non-terminal boxes has centered ┬", () => {
+            const r = new DagRenderer(mixedWidthWorkflow, { animate: false });
+            const output = stripAnsi(r.renderToString());
+            const bottomLinesWithT = output.split("\n").filter((l) => l.includes("┬"));
+            // A and B are non-terminal, so 2 lines with ┬
+            expect(bottomLinesWithT.length).toBe(2);
+            for (const line of bottomLinesWithT) {
+                expect(line).toMatch(/└─*┬─*┘/);
+            }
+        });
+        it("vertical connector uses centered │", () => {
+            const r = new DagRenderer(mixedWidthWorkflow, { animate: false });
+            const output = stripAnsi(r.renderToString());
+            // Find lines that are purely vertical connectors (between boxes)
+            const lines = output.split("\n");
+            const connectorLines = lines.filter((l) => l.trim() === "│");
+            expect(connectorLines.length).toBeGreaterThan(0);
+            // The │ should be centered relative to the box width
+            const topLine = lines.find((l) => l.includes("┌") && l.includes("┐"));
+            const tIdx = topLine.indexOf("┌");
+            const boxWidth = topLine.lastIndexOf("┐") - tIdx + 1;
+            const expectedCol = tIdx + Math.floor(boxWidth / 2);
+            for (const cl of connectorLines) {
+                expect(cl.indexOf("│")).toBe(expectedCol);
+            }
+        });
+    });
+    describe("branching layout", () => {
+        const branchingWorkflow = {
+            id: "triage",
+            name: "Triage Test",
+            description: "A branching workflow",
+            nodes: {
+                gather: { name: "Gather Context", instruction: "Gather", skills: [] },
+                investigate: { name: "Investigate", instruction: "Investigate", skills: [] },
+                create_ticket: { name: "Create Ticket", instruction: "Create", skills: [] },
+                skip: { name: "Skip", instruction: "Skip", skills: [] },
+                notify: { name: "Notify", instruction: "Notify", skills: [] },
+            },
+            edges: [
+                { from: "gather", to: "investigate" },
+                { from: "investigate", to: "create_ticket" },
+                { from: "investigate", to: "skip" },
+                { from: "create_ticket", to: "notify" },
+            ],
+            entry: "gather",
+        };
+        it("output contains both branch children", () => {
+            const r = new DagRenderer(branchingWorkflow, { animate: false });
+            const output = stripAnsi(r.renderToString());
+            expect(output).toContain("Create Ticket");
+            expect(output).toContain("Skip");
+        });
+        it("output contains ┴ fork character", () => {
+            const r = new DagRenderer(branchingWorkflow, { animate: false });
+            const output = stripAnsi(r.renderToString());
+            expect(output).toContain("┴");
+        });
+        it("state tracking works through branches", () => {
+            const r = new DagRenderer(branchingWorkflow, { animate: false });
+            r.update({ type: "node:enter", node: "gather", instruction: "Gather" });
+            r.update({ type: "node:exit", node: "gather", result: { status: "success", data: {}, toolCalls: [] } });
+            r.update({ type: "node:enter", node: "investigate", instruction: "Investigate" });
+            r.update({ type: "node:exit", node: "investigate", result: { status: "success", data: {}, toolCalls: [] } });
+            r.update({ type: "node:enter", node: "create_ticket", instruction: "Create" });
+            expect(r.getNodeState("gather")).toBe("completed");
+            expect(r.getNodeState("investigate")).toBe("completed");
+            expect(r.getNodeState("create_ticket")).toBe("running");
+            expect(r.getNodeState("skip")).toBe("pending");
+            expect(r.getNodeState("notify")).toBe("pending");
+        });
+        it("topological order: Gather before Investigate before Notify", () => {
+            const r = new DagRenderer(branchingWorkflow, { animate: false });
+            const output = stripAnsi(r.renderToString());
+            const gatherIdx = output.indexOf("Gather Context");
+            const investigateIdx = output.indexOf("Investigate");
+            const notifyIdx = output.indexOf("Notify");
+            expect(gatherIdx).toBeLessThan(investigateIdx);
+            expect(investigateIdx).toBeLessThan(notifyIdx);
+        });
+        it("falls back to sequential for 3+ children", () => {
+            const tripleWorkflow = {
+                id: "triple",
+                name: "Triple Branch",
+                description: "Three-way branch",
+                nodes: {
+                    start: { name: "Start", instruction: "Start", skills: [] },
+                    a: { name: "Branch A", instruction: "A", skills: [] },
+                    b: { name: "Branch B", instruction: "B", skills: [] },
+                    c: { name: "Branch C", instruction: "C", skills: [] },
+                },
+                edges: [
+                    { from: "start", to: "a" },
+                    { from: "start", to: "b" },
+                    { from: "start", to: "c" },
+                ],
+                entry: "start",
+            };
+            const r = new DagRenderer(tripleWorkflow, { animate: false });
+            const output = stripAnsi(r.renderToString());
+            // Should NOT have ┴ fork — sequential fallback
+            expect(output).not.toContain("┴");
+            // But all branches are present
+            expect(output).toContain("Branch A");
+            expect(output).toContain("Branch B");
+            expect(output).toContain("Branch C");
+        });
+    });
+});

package/dist/cli/setup.d.ts

@@ -0,0 +1,11 @@
+/**
+ * sweny setup <provider>
+ *
+ * Creates the standard SWEny label set in the configured issue tracker / source control
+ * provider, then prints a config snippet with the resolved IDs ready to paste into
+ * .sweny.yml or GitHub Actions secrets.
+ */
+import type { Command } from "commander";
+export declare function setupLinear(apiKey: string, teamId: string): Promise<void>;
+export declare function setupGithub(token: string, repo: string): Promise<void>;
+export declare function registerSetupCommand(program: Command): void;

package/dist/cli/setup.js

@@ -0,0 +1,310 @@
+/**
+ * sweny setup <provider>
+ *
+ * Creates the standard SWEny label set in the configured issue tracker / source control
+ * provider, then prints a config snippet with the resolved IDs ready to paste into
+ * .sweny.yml or GitHub Actions secrets.
+ */
+import chalk from "chalk";
+const LINEAR_API_URL = "https://api.linear.app/graphql";
+const GITHUB_API_URL = "https://api.github.com";
+const SIGNAL_LABELS = [
+    {
+        name: "agent-needs-input",
+        color: "CA8A04",
+        description: "Agent hit a decision point — needs human clarification before it can proceed",
+    },
+    {
+        name: "agent-error",
+        color: "B91C1C",
+        description: "Unexpected technical failure during agent execution — needs human investigation",
+    },
+    {
+        name: "human-only",
+        color: "6B7280",
+        description: "Guard rail — automation must not touch this issue or PR",
+    },
+    {
+        name: "needs-review",
+        color: "0EA5E9",
+        description: "PR opened by the agent and waiting for human review",
+    },
+];
+const WORK_TYPE_LABELS = [
+    {
+        name: "triage",
+        color: "EA580C",
+        description: "Production log analysis and bug detection by the agent",
+        isWorkType: true,
+    },
+    {
+        name: "feature",
+        color: "2563EB",
+        description: "Feature implementation by the agent",
+        isWorkType: true,
+    },
+    {
+        name: "optimization",
+        color: "059669",
+        description: "Performance or code optimization by the agent",
+        isWorkType: true,
+    },
+    {
+        name: "research",
+        color: "D97706",
+        description: "Spike, investigation, or report by the agent — exploratory work without a direct code change",
+        isWorkType: true,
+    },
+    {
+        name: "support",
+        color: "0891B2",
+        description: "Work initiated from a support request by the agent",
+        isWorkType: true,
+    },
+    {
+        name: "spec",
+        color: "BE185D",
+        description: "Spec generation — agent converted non-technical input into a structured spec",
+        isWorkType: true,
+    },
+    {
+        name: "task",
+        color: "78716C",
+        description: "Open-ended prompt or generic work by the agent that does not fit another category",
+        isWorkType: true,
+    },
+];
+const AGENT_PARENT = {
+    name: "agent",
+    color: "7C3AED",
+    description: "Parent group — marks all autonomous agent work",
+};
+const BUG_LABEL = {
+    name: "bug",
+    color: "DC2626",
+    description: "A confirmed bug",
+};
+async function linearRequest(apiKey, query, variables) {
+    const res = await fetch(LINEAR_API_URL, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Authorization: apiKey },
+        body: JSON.stringify({ query, variables }),
+    });
+    if (!res.ok)
+        throw new Error(`Linear API error: ${res.status} ${res.statusText}`);
+    const body = (await res.json());
+    if (body.errors?.length)
+        throw new Error(`Linear GraphQL: ${body.errors.map((e) => e.message).join(", ")}`);
+    return body.data;
+}
+async function listLinearLabels(apiKey, teamId) {
+    const data = await linearRequest(apiKey, `query($teamId: String!) {
+      team(id: $teamId) {
+        labels(first: 250) {
+          nodes { id name parent { id } }
+        }
+      }
+    }`, { teamId });
+    return data.team.labels.nodes;
+}
+async function createLinearLabel(apiKey, teamId, def, parentId) {
+    const data = await linearRequest(apiKey, `mutation($input: IssueLabelCreateInput!) {
+      issueLabelCreate(input: $input) {
+        issueLabel { id name }
+        success
+      }
+    }`, {
+        input: {
+            teamId,
+            name: def.name,
+            color: `#${def.color}`,
+            description: def.description,
+            ...(parentId ? { parentId } : {}),
+        },
+    });
+    if (!data.issueLabelCreate.success)
+        throw new Error(`Failed to create Linear label "${def.name}"`);
+    return data.issueLabelCreate.issueLabel;
+}
+export async function setupLinear(apiKey, teamId) {
+    console.log(chalk.dim("\n  Fetching existing labels…\n"));
+    const existing = await listLinearLabels(apiKey, teamId);
+    const byName = new Map(existing.map((l) => [l.name.toLowerCase(), l]));
+    const created = [];
+    const skipped = [];
+    // Helper: find or create
+    async function ensure(def, parentId) {
+        const found = byName.get(def.name.toLowerCase());
+        if (found) {
+            skipped.push(def.name);
+            console.log(`  ${chalk.dim("–")} ${chalk.dim(def.name)} ${chalk.dim("(already exists)")}`);
+            return found;
+        }
+        const label = await createLinearLabel(apiKey, teamId, def, parentId);
+        byName.set(def.name.toLowerCase(), label);
+        created.push(def.name);
+        console.log(`  ${chalk.green("+")} ${chalk.bold(def.name)}`);
+        return label;
+    }
+    // 1. agent group parent
+    const agentLabel = await ensure(AGENT_PARENT);
+    // 2. Work type labels (children of agent)
+    const workTypeIds = {};
+    for (const def of WORK_TYPE_LABELS) {
+        const label = await ensure(def, agentLabel.id);
+        workTypeIds[def.name] = label.id;
+    }
+    // 3. Signal labels (standalone)
+    const signalIds = {};
+    for (const def of SIGNAL_LABELS) {
+        const label = await ensure(def);
+        signalIds[def.name] = label.id;
+    }
+    // 4. Bug label (standalone, may already exist)
+    const bugLabel = byName.get("bug") ?? (await ensure(BUG_LABEL));
+    const bugId = bugLabel.id;
+    // ── Print config snippet ─────────────────────────────────────────────────
+    const triageId = workTypeIds["triage"] ?? byName.get("triage")?.id ?? "";
+    console.log(`
+${chalk.bold("  Done.")} ${created.length} created, ${skipped.length} already existed.
+
+${chalk.bold("  Add these to your .sweny.yml:")}
+
+${chalk.cyan(`  issue-tracker-provider: linear
+  linear-team-id: ${teamId}
+  linear-triage-label-id: ${triageId}
+  linear-bug-label-id: ${bugId}
+  issue-labels: ${agentLabel.id}`)}
+
+${chalk.bold("  Or as environment variables / GitHub Actions secrets:")}
+
+${chalk.cyan(`  LINEAR_TEAM_ID=${teamId}
+  LINEAR_TRIAGE_LABEL_ID=${triageId}
+  LINEAR_BUG_LABEL_ID=${bugId}
+  SWENY_ISSUE_LABELS=${agentLabel.id}`)}
+
+${chalk.dim("  Full label inventory:")}
+${chalk.dim(`  agent               ${agentLabel.id}`)}
+${Object.entries(workTypeIds)
+        .map(([name, id]) => chalk.dim(`  ${name.padEnd(20)}${id}`))
+        .join("\n")}
+${Object.entries(signalIds)
+        .map(([name, id]) => chalk.dim(`  ${name.padEnd(20)}${id}`))
+        .join("\n")}
+${bugId ? chalk.dim(`  bug                 ${bugId}`) : ""}
+`);
+}
+async function githubRequest(token, method, path, body) {
+    const res = await fetch(`${GITHUB_API_URL}${path}`, {
+        method,
+        headers: {
+            Authorization: `Bearer ${token}`,
+            Accept: "application/vnd.github+json",
+            "X-GitHub-Api-Version": "2022-11-28",
+            "Content-Type": "application/json",
+        },
+        ...(body ? { body: JSON.stringify(body) } : {}),
+    });
+    // 201 Created and 200 OK are both success; 422 means label already exists
+    if (!res.ok && res.status !== 422) {
+        throw new Error(`GitHub API error: ${res.status} ${res.statusText}`);
+    }
+    return (await res.json());
+}
+async function listAllGithubLabels(token, repo) {
+    const labels = [];
+    let page = 1;
+    while (true) {
+        const batch = await githubRequest(token, "GET", `/repos/${repo}/labels?per_page=100&page=${page}`);
+        labels.push(...batch);
+        if (batch.length < 100)
+            break;
+        page++;
+    }
+    return labels;
+}
+export async function setupGithub(token, repo) {
+    console.log(chalk.dim("\n  Fetching existing labels…\n"));
+    const existing = await listAllGithubLabels(token, repo);
+    const byName = new Set(existing.map((l) => l.name.toLowerCase()));
+    const allLabels = [AGENT_PARENT, ...WORK_TYPE_LABELS, ...SIGNAL_LABELS, BUG_LABEL];
+    const created = [];
+    const skipped = [];
+    for (const def of allLabels) {
+        if (byName.has(def.name.toLowerCase())) {
+            skipped.push(def.name);
+            console.log(`  ${chalk.dim("–")} ${chalk.dim(def.name)} ${chalk.dim("(already exists)")}`);
+            continue;
+        }
+        await githubRequest(token, "POST", `/repos/${repo}/labels`, {
+            name: def.name,
+            color: def.color,
+            description: def.description,
+        });
+        created.push(def.name);
+        console.log(`  ${chalk.green("+")} ${chalk.bold(def.name)}`);
+    }
+    console.log(`
+${chalk.bold("  Done.")} ${created.length} created, ${skipped.length} already existed.
+
+${chalk.bold("  Add these to your .sweny.yml:")}
+
+${chalk.cyan(`  source-control-provider: github
+  pr-labels: agent,triage,needs-review
+  issue-labels: agent`)}
+
+${chalk.dim("  GitHub labels are referenced by name — no UUIDs needed.")}
+`);
+}
+// ── Command registration ───────────────────────────────────────────────────
+export function registerSetupCommand(program) {
+    const setupCmd = program
+        .command("setup")
+        .description("Create the standard SWEny label set in your issue tracker or source control provider");
+    setupCmd
+        .command("linear")
+        .description("Create SWEny labels in a Linear workspace")
+        .requiredOption("--team-id <id>", "Linear team ID", process.env.LINEAR_TEAM_ID)
+        .action(async (opts) => {
+        const apiKey = process.env.LINEAR_API_KEY;
+        if (!apiKey) {
+            console.error(chalk.red("\n  Missing: LINEAR_API_KEY environment variable\n"));
+            process.exit(1);
+        }
+        if (!opts.teamId) {
+            console.error(chalk.red("\n  Missing: --team-id or LINEAR_TEAM_ID\n"));
+            process.exit(1);
+        }
+        console.log(chalk.bold(`\n  sweny setup linear  (team: ${opts.teamId})\n`));
+        try {
+            await setupLinear(apiKey, opts.teamId);
+        }
+        catch (err) {
+            console.error(chalk.red(`\n  Error: ${err instanceof Error ? err.message : String(err)}\n`));
+            process.exit(1);
+        }
+    });
+    setupCmd
+        .command("github")
+        .description("Create SWEny labels in a GitHub repository")
+        .requiredOption("--repo <owner/repo>", "GitHub repository (e.g. my-org/my-repo)", process.env.GITHUB_REPOSITORY)
+        .action(async (opts) => {
+        const token = process.env.GITHUB_TOKEN || process.env.BOT_TOKEN;
+        if (!token) {
+            console.error(chalk.red("\n  Missing: GITHUB_TOKEN environment variable\n"));
+            process.exit(1);
+        }
+        if (!opts.repo) {
+            console.error(chalk.red("\n  Missing: --repo or GITHUB_REPOSITORY\n"));
+            process.exit(1);
+        }
+        console.log(chalk.bold(`\n  sweny setup github  (repo: ${opts.repo})\n`));
+        try {
+            await setupGithub(token, opts.repo);
+        }
+        catch (err) {
+            console.error(chalk.red(`\n  Error: ${err instanceof Error ? err.message : String(err)}\n`));
+            process.exit(1);
+        }
+    });
+}

package/dist/executor.d.ts

@@ -0,0 +1,29 @@
+/**
+ * DAG Workflow Executor
+ *
+ * Walks a workflow graph node-by-node. At each node, Claude gets
+ * the node's instruction + available skill tools + context from
+ * prior nodes. Claude does the work, then the executor resolves
+ * which edge to follow next.
+ *
+ * This replaces ~8k lines of engine + recipe step code.
+ */
+import type { Workflow, Skill, Claude, Observer, NodeResult, Logger } from "./types.js";
+export interface ExecuteOptions {
+    /** Registered skills (id → Skill) */
+    skills: Map<string, Skill>;
+    /** Config values — env vars + explicit overrides */
+    config?: Record<string, string>;
+    /** Claude client */
+    claude: Claude;
+    /** Event observer for streaming/logging */
+    observer?: Observer;
+    /** Logger */
+    logger?: Logger;
+}
+/**
+ * Execute a workflow from entry to completion.
+ *
+ * Returns a map of node ID → result for every node that ran.
+ */
+export declare function execute(workflow: Workflow, input: unknown, options: ExecuteOptions): Promise<Map<string, NodeResult>>;