@sweny-ai/core 0.1.64 → 0.1.66

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

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

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

@@ -0,0 +1,201 @@
+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 { Command } from "commander";
+import { runWorkflowDiagram } 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("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", () => {
+        it("writes a fenced mermaid block to stdout by default", () => {
+            const stdout = captureStream();
+            const stderr = captureStream();
+            runWorkflowDiagram("any.yml", {}, { loadWorkflowFile, stdout: stdout.stream, stderr: stderr.stream, exit });
+            expect(stdout.text).toMatch(/^```mermaid\n/);
+            expect(stdout.text).toMatch(/\n```\n$/);
+            expect(exit).not.toHaveBeenCalled();
+        });
+        it("writes raw mermaid when --no-block is explicit", () => {
+            const stdout = captureStream();
+            const stderr = captureStream();
+            runWorkflowDiagram("any.yml", { block: false }, { loadWorkflowFile, stdout: stdout.stream, stderr: stderr.stream, exit });
+            expect(stdout.text).not.toMatch(/```mermaid/);
+            expect(stdout.text).toMatch(/graph TB/);
+        });
+        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("honors --title override", () => {
+            const stdout = captureStream();
+            runWorkflowDiagram("any.yml", { title: "Custom Title" }, { loadWorkflowFile, stdout: stdout.stream, stderr: captureStream().stream, exit });
+            expect(stdout.text).toContain("Custom Title");
+        });
+    });
+    describe("-o / --output file", () => {
+        it("writes raw mermaid to .mmd by default (no fence)", () => {
+            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).toMatch(/graph TB/);
+            expect(stderr.text).toMatch(/✓ Wrote diagram to/);
+        });
+        it("writes fenced markdown to .md by default", () => {
+            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("falls back to fenced default for unknown extensions", () => {
+            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).toMatch(/```mermaid/);
+        });
+        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 precedence over extension inference", () => {
+        function cmdWithBlock(block, explicit) {
+            const cmd = new Command();
+            cmd.option("--block", "fenced", true);
+            cmd.option("--no-block", "raw");
+            if (explicit) {
+                // Simulate user typing `--block` or `--no-block` on the CLI — commander
+                // marks the source as "cli" when the flag is seen in argv.
+                cmd.setOptionValueWithSource("block", block, "cli");
+            }
+            return cmd;
+        }
+        it("explicit --block wins over .mmd extension (writes fenced to .mmd)", () => {
+            const out = path.join(tmpdir, "diagram.mmd");
+            runWorkflowDiagram("any.yml", { output: out, block: true }, {
+                loadWorkflowFile,
+                command: cmdWithBlock(true, true),
+                stdout: captureStream().stream,
+                stderr: captureStream().stream,
+                exit,
+            });
+            expect(fs.readFileSync(out, "utf8")).toMatch(/```mermaid/);
+        });
+        it("explicit --no-block wins over .md extension (writes raw to .md)", () => {
+            const out = path.join(tmpdir, "diagram.md");
+            runWorkflowDiagram("any.yml", { output: out, block: false }, {
+                loadWorkflowFile,
+                command: cmdWithBlock(false, true),
+                stdout: captureStream().stream,
+                stderr: captureStream().stream,
+                exit,
+            });
+            expect(fs.readFileSync(out, "utf8")).not.toMatch(/```mermaid/);
+        });
+        it("default --block source does not suppress .mmd extension inference", () => {
+            // Commander always sets `block: true` via the declared default, but its
+            // source is "default" — our inference should still kick in for .mmd.
+            const out = path.join(tmpdir, "diagram.mmd");
+            runWorkflowDiagram("any.yml", { output: out, block: true }, {
+                loadWorkflowFile,
+                command: cmdWithBlock(true, false), // not explicit
+                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(/```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/diagram.d.ts

@@ -0,0 +1,30 @@
+import type { Command } from "commander";
+import type { Workflow } from "../types.js";
+export interface DiagramOptions {
+    direction?: string;
+    title?: string;
+    block?: boolean;
+    output?: string;
+}
+export interface DiagramDeps {
+    /** Load a workflow file (YAML or JSON). Injected so tests can stub. */
+    loadWorkflowFile: (file: string) => Workflow;
+    /** Commander instance used to detect whether --block was set explicitly. */
+    command?: Command;
+    /** Stream for success/error messages. Defaults to process.stderr. */
+    stderr?: NodeJS.WritableStream;
+    /** Stream for diagram output when no --output is set. Defaults to process.stdout. */
+    stdout?: NodeJS.WritableStream;
+    /** Exit handler. Defaults to process.exit. Tests can throw instead. */
+    exit?: (code: number) => void;
+}
+/**
+ * Render a workflow as a Mermaid diagram and write to stdout or a file.
+ *
+ * Block-default rules (in order of precedence):
+ *   1. Explicit `--block` / `--no-block` — always wins (detected via the
+ *      Command's option-value source when provided)
+ *   2. When `-o` is set, infer from extension: `.mmd` → raw, `.md` → fenced
+ *   3. Otherwise default to fenced (matches prior stdout behavior)
+ */
+export declare function runWorkflowDiagram(file: string, options: DiagramOptions, deps: DiagramDeps): void;

package/dist/cli/diagram.js

@@ -0,0 +1,74 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import chalk from "chalk";
+import { toMermaid, toMermaidBlock } from "../mermaid.js";
+import { triageWorkflow, implementWorkflow, seedContentWorkflow } from "../workflows/index.js";
+/**
+ * Render a workflow as a Mermaid diagram and write to stdout or a file.
+ *
+ * Block-default rules (in order of precedence):
+ *   1. Explicit `--block` / `--no-block` — always wins (detected via the
+ *      Command's option-value source when provided)
+ *   2. When `-o` is set, infer from extension: `.mmd` → raw, `.md` → fenced
+ *   3. Otherwise default to fenced (matches prior stdout behavior)
+ */
+export function runWorkflowDiagram(file, options, deps) {
+    const stderr = deps.stderr ?? process.stderr;
+    const stdout = deps.stdout ?? process.stdout;
+    const exit = deps.exit ?? ((code) => process.exit(code));
+    let workflow;
+    // Builtin workflow names
+    if (file === "triage") {
+        workflow = triageWorkflow;
+    }
+    else if (file === "implement") {
+        workflow = implementWorkflow;
+    }
+    else if (file === "seed-content") {
+        workflow = seedContentWorkflow;
+    }
+    else {
+        try {
+            workflow = deps.loadWorkflowFile(file);
+        }
+        catch (err) {
+            stderr.write(chalk.red(`  Error: ${err instanceof Error ? err.message : String(err)}`) + "\n");
+            exit(1);
+            return;
+        }
+    }
+    const direction = (options.direction === "LR" ? "LR" : "TB");
+    const title = options.title ?? workflow.name;
+    // Explicit --block / --no-block always wins. When commander's source is
+    // "cli" or "env" the user (or env var) set it; otherwise we may infer.
+    const blockSource = deps.command?.getOptionValueSource("block");
+    const blockExplicit = blockSource === "cli" || blockSource === "env";
+    let useBlock = options.block !== false;
+    if (!blockExplicit && options.output) {
+        const ext = path.extname(options.output).toLowerCase();
+        if (ext === ".mmd")
+            useBlock = false;
+        else if (ext === ".md")
+            useBlock = true;
+    }
+    const render = useBlock ? toMermaidBlock : toMermaid;
+    const output = render(workflow, { direction, title }) + "\n";
+    if (options.output) {
+        try {
+            // Create parent dirs so `-o some/nested/diagram.mmd` works without a
+            // separate mkdir — matches `pandoc -o`, `tsc --outFile`, etc.
+            const dir = path.dirname(options.output);
+            if (dir && dir !== "." && !fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            fs.writeFileSync(options.output, output, "utf8");
+            stderr.write(chalk.green(`  ✓ Wrote diagram to ${options.output}`) + "\n");
+        }
+        catch (err) {
+            stderr.write(chalk.red(`  Error: ${err instanceof Error ? err.message : String(err)}`) + "\n");
+            exit(1);
+        }
+        return;
+    }
+    stdout.write(output);
+}

package/dist/cli/main.js

@@ -17,7 +17,8 @@ import { loadAdditionalContext } from "../templates.js";
 import { validateWorkflow as validateWorkflowSchema } from "../schema.js";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
 import { buildWorkflow, refineWorkflow } from "../workflow-builder.js";
-import { toMermaid, toMermaidBlock } from "../mermaid.js";
+import { toMermaidBlock } from "../mermaid.js";
+import { runWorkflowDiagram } from "./diagram.js";
 import { DagRenderer } from "./renderer.js";
 import * as readline from "node:readline";
 import { loadDotenv, loadConfigFile } from "./config-file.js";
@@ -800,32 +801,9 @@ workflowCmd
     .option("--title <title>", "Diagram title (defaults to workflow name)")
     .option("--block", "Wrap in ```mermaid fenced code block (default)", true)
     .option("--no-block", "Output raw Mermaid without code fence")
-    .action((file, options) => {
-    let workflow;
-    // Support builtin workflow names
-    if (file === "triage") {
-        workflow = triageWorkflow;
-    }
-    else if (file === "implement") {
-        workflow = implementWorkflow;
-    }
-    else if (file === "seed-content") {
-        workflow = seedContentWorkflow;
-    }
-    else {
-        try {
-            workflow = loadWorkflowFile(file);
-        }
-        catch (err) {
-            console.error(chalk.red(`  Error: ${err instanceof Error ? err.message : String(err)}`));
-            process.exit(1);
-            return;
-        }
-    }
-    const direction = (options.direction === "LR" ? "LR" : "TB");
-    const title = options.title ?? workflow.name;
-    const render = options.block !== false ? toMermaidBlock : toMermaid;
-    process.stdout.write(render(workflow, { direction, title }) + "\n");
+    .option("-o, --output <path>", "Write the diagram to a file instead of stdout")
+    .action(function diagramAction(file, options) {
+    runWorkflowDiagram(file, options, { loadWorkflowFile, command: this });
 });
 workflowCmd
     .command("export <name>")

package/package.json

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