@sweny-ai/core 0.1.76 → 0.1.78

package/dist/mermaid.test.d.ts

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

package/dist/mermaid.test.js

@@ -1,256 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { toMermaid, toMermaidBlock } from "./mermaid.js";
-import { triageWorkflow, implementWorkflow } from "./workflows/index.js";
-// ─── Fixtures ──────────────────────────────────────────────────────
-const simple = {
-    id: "simple",
-    name: "Simple",
-    description: "A→B→C",
-    entry: "a",
-    nodes: {
-        a: { name: "Triage", instruction: "Triage the alert", skills: ["github"] },
-        b: { name: "Investigate", instruction: "Investigate the issue", skills: ["sentry"] },
-        c: { name: "Report", instruction: "Write report", skills: ["slack"] },
-    },
-    edges: [
-        { from: "a", to: "b" },
-        { from: "b", to: "c" },
-    ],
-};
-const branching = {
-    id: "branching",
-    name: "Branching",
-    description: "Conditional routing",
-    entry: "triage",
-    nodes: {
-        triage: { name: "Triage", instruction: "Classify severity", skills: [] },
-        investigate: { name: "Investigate", instruction: "Deep dive", skills: [] },
-        notify: { name: "Notify", instruction: "Send alert", skills: [] },
-        close: { name: "Close", instruction: "Close ticket", skills: [] },
-    },
-    edges: [
-        { from: "triage", to: "investigate", when: "severity is high or critical" },
-        { from: "triage", to: "notify", when: "severity is low" },
-        { from: "investigate", to: "close" },
-        { from: "notify", to: "close" },
-    ],
-};
-const withLoop = {
-    id: "loop",
-    name: "Loop",
-    description: "Retry loop",
-    entry: "a",
-    nodes: {
-        a: { name: "Try", instruction: "Attempt fix", skills: [] },
-        b: { name: "Done", instruction: "Wrap up", skills: [] },
-    },
-    edges: [
-        { from: "a", to: "a", when: "needs retry", max_iterations: 3 },
-        { from: "a", to: "b" },
-    ],
-};
-// ─── Tests ─────────────────────────────────────────────────────────
-describe("toMermaid", () => {
-    it("renders a simple linear workflow", () => {
-        const result = toMermaid(simple);
-        expect(result).toContain("graph TB");
-        // Entry node gets stadium shape
-        expect(result).toContain("a([Triage \u25B6])");
-        // Non-entry nodes get default shape
-        expect(result).toContain("b[Investigate]");
-        expect(result).toContain("c[Report]");
-        // Edges
-        expect(result).toContain("a --> b");
-        expect(result).toContain("b --> c");
-    });
-    it("renders conditional edges with labels", () => {
-        const result = toMermaid(branching);
-        expect(result).toContain('triage -->|"severity is high or critical"| investigate');
-        expect(result).toContain('triage -->|"severity is low"| notify');
-        expect(result).toContain("investigate --> close");
-        expect(result).toContain("notify --> close");
-    });
-    it("renders max_iterations on edges", () => {
-        const result = toMermaid(withLoop);
-        expect(result).toContain('a -->|"needs retry · max 3x"| a');
-        expect(result).toContain("a --> b");
-    });
-    it("renders max_iterations without condition", () => {
-        const wf = {
-            ...simple,
-            edges: [
-                { from: "a", to: "b", max_iterations: 5 },
-                { from: "b", to: "c" },
-            ],
-        };
-        const result = toMermaid(wf);
-        expect(result).toContain('a -->|"max 5x"| b');
-    });
-    it("applies execution state styling", () => {
-        const result = toMermaid(simple, {
-            state: {
-                a: "success",
-                b: "current",
-            },
-        });
-        expect(result).toContain("classDef current fill:#3b82f6");
-        expect(result).toContain("classDef success fill:#22c55e");
-        expect(result).toContain("class a success");
-        expect(result).toContain("class b current");
-        // c has no state — no class applied
-        expect(result).not.toContain("class c");
-    });
-    it("applies failed and skipped styling", () => {
-        const result = toMermaid(simple, {
-            state: {
-                a: "success",
-                b: "failed",
-                c: "skipped",
-            },
-        });
-        expect(result).toContain("classDef failed fill:#ef4444");
-        expect(result).toContain("classDef skipped fill:#6b7280");
-        expect(result).toContain("class b failed");
-        expect(result).toContain("class c skipped");
-    });
-    it("omits style block when no state provided", () => {
-        const result = toMermaid(simple);
-        expect(result).not.toContain("classDef");
-        expect(result).not.toContain("class ");
-    });
-    it("supports LR direction", () => {
-        const result = toMermaid(simple, { direction: "LR" });
-        expect(result).toContain("graph LR");
-    });
-    it("supports title", () => {
-        const result = toMermaid(simple, { title: "My Workflow" });
-        expect(result).toContain("---");
-        expect(result).toContain("title: My Workflow");
-    });
-    it("sanitizes node IDs with special characters", () => {
-        const wf = {
-            id: "special",
-            name: "Special",
-            description: "",
-            entry: "step.one",
-            nodes: {
-                "step.one": { name: "Step One", instruction: "Do it", skills: [] },
-                "step two": { name: "Step Two", instruction: "Do it", skills: [] },
-            },
-            edges: [{ from: "step.one", to: "step two" }],
-        };
-        const result = toMermaid(wf);
-        expect(result).toContain("step_one");
-        expect(result).toContain("step_two");
-        expect(result).not.toContain("step.one");
-        expect(result).not.toContain("step two");
-    });
-    it("escapes special characters in labels", () => {
-        const wf = {
-            id: "escape",
-            name: "Escape",
-            description: "",
-            entry: "a",
-            nodes: {
-                a: { name: 'Say "hello"', instruction: "x", skills: [] },
-                b: { name: "Done", instruction: "x", skills: [] },
-            },
-            edges: [{ from: "a", to: "b" }],
-        };
-        const result = toMermaid(wf);
-        expect(result).toContain(""");
-        expect(result).not.toContain('Say "hello"');
-    });
-    it("groups multiple nodes with same status", () => {
-        const result = toMermaid(simple, {
-            state: { a: "success", b: "success", c: "current" },
-        });
-        expect(result).toContain("class a,b success");
-        expect(result).toContain("class c current");
-    });
-    it("highlights taken edges and dims not-taken edges with trace", () => {
-        const trace = {
-            steps: [
-                { node: "triage", status: "success", iteration: 1 },
-                { node: "investigate", status: "success", iteration: 1 },
-                { node: "close", status: "success", iteration: 1 },
-            ],
-            edges: [
-                { from: "triage", to: "investigate", reason: "severity is high or critical" },
-                { from: "investigate", to: "close", reason: "only path" },
-            ],
-            sources: {},
-        };
-        const result = toMermaid(branching, { trace });
-        // Taken edges get green bold styling (edges 0 and 2 in the workflow)
-        expect(result).toContain("linkStyle");
-        expect(result).toContain("stroke:#22c55e,stroke-width:3px");
-        // Not-taken edges get dashed gray
-        expect(result).toContain("stroke:#6b7280,stroke-width:1px,stroke-dasharray:5 5");
-    });
-    it("shows iteration count on nodes and edges from trace", () => {
-        const trace = {
-            steps: [
-                { node: "a", status: "success", iteration: 1 },
-                { node: "a", status: "success", iteration: 2 },
-                { node: "b", status: "success", iteration: 1 },
-            ],
-            edges: [
-                { from: "a", to: "a", reason: "needs retry" },
-                { from: "a", to: "b", reason: "only path" },
-            ],
-            sources: {},
-        };
-        const result = toMermaid(withLoop, { trace });
-        // Node a ran twice — should show ×2
-        expect(result).toContain("×2");
-        // Node b ran once — no iteration tag
-        expect(result).not.toContain("Done ×");
-    });
-});
-describe("builtin workflows", () => {
-    it("renders triage workflow", () => {
-        const result = toMermaid(triageWorkflow);
-        expect(result).toContain("graph TB");
-        // Every node should appear
-        for (const [id, node] of Object.entries(triageWorkflow.nodes)) {
-            expect(result).toContain(node.name);
-        }
-        // Every edge should appear
-        for (const edge of triageWorkflow.edges) {
-            expect(result).toContain(edge.from);
-            expect(result).toContain(edge.to);
-        }
-    });
-    it("renders implement workflow", () => {
-        const result = toMermaid(implementWorkflow);
-        expect(result).toContain("graph TB");
-        for (const node of Object.values(implementWorkflow.nodes)) {
-            expect(result).toContain(node.name);
-        }
-    });
-    it("renders triage with execution state", () => {
-        const ids = Object.keys(triageWorkflow.nodes);
-        const state = {};
-        state[ids[0]] = "success";
-        if (ids[1])
-            state[ids[1]] = "current";
-        const result = toMermaid(triageWorkflow, { state, title: triageWorkflow.name });
-        expect(result).toContain("classDef success");
-        expect(result).toContain("classDef current");
-        expect(result).toContain(`class ${ids[0]} success`);
-    });
-});
-describe("toMermaidBlock", () => {
-    it("wraps in fenced code block", () => {
-        const result = toMermaidBlock(simple);
-        expect(result).toMatch(/^```mermaid\n/);
-        expect(result).toMatch(/\n```$/);
-        expect(result).toContain("graph TB");
-    });
-    it("passes options through", () => {
-        const result = toMermaidBlock(simple, { direction: "LR", state: { a: "success" } });
-        expect(result).toContain("graph LR");
-        expect(result).toContain("class a success");
-    });
-});

package/dist/sources.test.d.ts

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

package/dist/sources.test.js

@@ -1,265 +0,0 @@
-import { mkdirSync, writeFileSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import * as path from "node:path";
-import { describe, it, expect, beforeEach, vi } from "vitest";
-import { classifySource, sourceZ } from "./sources.js";
-import { hashContent, resolveSource, resolveSources } from "./source-resolver.js";
-const fileTmp = path.join(tmpdir(), "sweny-sources-file-test");
-const baseCtx = () => ({
-    cwd: "/tmp",
-    env: {},
-    authConfig: {},
-    offline: false,
-    logger: { info: () => { }, warn: () => { }, error: () => { }, debug: () => { } },
-});
-describe("classifySource", () => {
-    it("classifies http(s) URLs as url", () => {
-        expect(classifySource("http://example.com/x.md")).toBe("url");
-        expect(classifySource("https://example.com/x.md")).toBe("url");
-    });
-    it("classifies ./ ../ and / paths as file", () => {
-        expect(classifySource("./local.md")).toBe("file");
-        expect(classifySource("../sibling.md")).toBe("file");
-        expect(classifySource("/abs/path.md")).toBe("file");
-    });
-    it("classifies anything else as inline", () => {
-        expect(classifySource("Just be helpful.")).toBe("inline");
-        expect(classifySource("foo bar baz")).toBe("inline");
-    });
-    it("rejects empty strings", () => {
-        expect(() => classifySource("")).toThrow(/empty/i);
-        expect(() => classifySource("   ")).toThrow(/empty/i);
-    });
-});
-describe("sourceZ", () => {
-    it("accepts non-empty string", () => {
-        expect(sourceZ.parse("hello")).toBe("hello");
-        expect(sourceZ.parse("./x.md")).toBe("./x.md");
-        expect(sourceZ.parse("https://x/y")).toBe("https://x/y");
-    });
-    it("rejects empty string", () => {
-        expect(() => sourceZ.parse("")).toThrow();
-    });
-    it("accepts tagged inline form", () => {
-        expect(sourceZ.parse({ inline: "text" })).toEqual({ inline: "text" });
-    });
-    it("accepts tagged file form", () => {
-        expect(sourceZ.parse({ file: "./x.md" })).toEqual({ file: "./x.md" });
-    });
-    it("accepts tagged url form with and without type", () => {
-        expect(sourceZ.parse({ url: "https://x" })).toEqual({ url: "https://x" });
-        expect(sourceZ.parse({ url: "https://x", type: "fetch" })).toEqual({
-            url: "https://x",
-            type: "fetch",
-        });
-    });
-    it("rejects objects with multiple tag keys", () => {
-        expect(() => sourceZ.parse({ inline: "x", file: "./y" })).toThrow();
-        expect(() => sourceZ.parse({ file: "./x", url: "https://y" })).toThrow();
-    });
-    it("rejects objects with no tag keys", () => {
-        expect(() => sourceZ.parse({})).toThrow();
-        expect(() => sourceZ.parse({ foo: "bar" })).toThrow();
-    });
-    it("rejects extra keys on tagged forms", () => {
-        expect(() => sourceZ.parse({ inline: "x", extra: true })).toThrow();
-    });
-});
-describe("hashContent", () => {
-    it("produces stable 16-char hex for same content", () => {
-        const a = hashContent("hello world");
-        const b = hashContent("hello world");
-        expect(a).toBe(b);
-        expect(a).toMatch(/^[0-9a-f]{16}$/);
-    });
-    it("produces different hashes for different content", () => {
-        expect(hashContent("a")).not.toBe(hashContent("b"));
-    });
-});
-describe("resolveSource (inline)", () => {
-    it("returns the plain string for inline-classified strings", async () => {
-        const resolved = await resolveSource("Just do it.", "test.field", baseCtx());
-        expect(resolved.content).toBe("Just do it.");
-        expect(resolved.kind).toBe("inline");
-        expect(resolved.resolver).toBe("inline");
-        expect(resolved.origin).toBe("Just do it.");
-        expect(resolved.hash).toMatch(/^[0-9a-f]{16}$/);
-        expect(resolved.fetchedAt).toBeUndefined();
-        expect(resolved.sourcePath).toBeUndefined();
-    });
-    it("returns the inline text from tagged {inline} form", async () => {
-        const resolved = await resolveSource({ inline: "Tagged body" }, "test.field", baseCtx());
-        expect(resolved.content).toBe("Tagged body");
-        expect(resolved.kind).toBe("inline");
-        expect(resolved.resolver).toBe("inline");
-    });
-});
-describe("resolveSource (file)", () => {
-    beforeEach(() => {
-        rmSync(fileTmp, { recursive: true, force: true });
-        mkdirSync(fileTmp, { recursive: true });
-    });
-    it("reads a file by relative path (cwd-based)", async () => {
-        writeFileSync(path.join(fileTmp, "rules.md"), "# Rules\n\nBe kind.");
-        const resolved = await resolveSource("./rules.md", "rules[0]", {
-            ...baseCtx(),
-            cwd: fileTmp,
-        });
-        expect(resolved.content).toBe("# Rules\n\nBe kind.");
-        expect(resolved.kind).toBe("file");
-        expect(resolved.resolver).toBe("file");
-        expect(resolved.sourcePath).toBe(path.resolve(fileTmp, "rules.md"));
-    });
-    it("reads a file via tagged {file} form", async () => {
-        writeFileSync(path.join(fileTmp, "a.txt"), "alpha");
-        const resolved = await resolveSource({ file: "./a.txt" }, "x", {
-            ...baseCtx(),
-            cwd: fileTmp,
-        });
-        expect(resolved.content).toBe("alpha");
-        expect(resolved.origin).toEqual({ file: "./a.txt" });
-    });
-    it("reads an absolute path", async () => {
-        const abs = path.join(fileTmp, "abs.md");
-        writeFileSync(abs, "absolute body");
-        const resolved = await resolveSource(abs, "x", baseCtx());
-        expect(resolved.content).toBe("absolute body");
-    });
-    it("throws SOURCE_FILE_NOT_FOUND with field path on missing file", async () => {
-        await expect(resolveSource("./missing.md", "nodes.investigate.instruction", {
-            ...baseCtx(),
-            cwd: fileTmp,
-        })).rejects.toThrow(/SOURCE_FILE_NOT_FOUND.*nodes\.investigate\.instruction/);
-    });
-});
-describe("resolveSource (fetch)", () => {
-    beforeEach(() => {
-        vi.restoreAllMocks();
-    });
-    it("fetches URL content via plain string", async () => {
-        const fetchMock = vi.spyOn(globalThis, "fetch").mockImplementation(async () => {
-            return new Response("# Shared rules\n\nBe careful.", {
-                status: 200,
-                headers: { "content-type": "text/markdown" },
-            });
-        });
-        const resolved = await resolveSource("https://example.com/rules.md", "rules[0]", baseCtx());
-        expect(resolved.content).toBe("# Shared rules\n\nBe careful.");
-        expect(resolved.kind).toBe("url");
-        expect(resolved.resolver).toBe("fetch");
-        expect(resolved.fetchedAt).toMatch(/^\d{4}-\d{2}-\d{2}T/);
-        expect(fetchMock).toHaveBeenCalledOnce();
-    });
-    it("fetches via tagged {url} form", async () => {
-        vi.spyOn(globalThis, "fetch").mockImplementation(async () => new Response("body", { status: 200 }));
-        const resolved = await resolveSource({ url: "https://x.test/y", type: "fetch" }, "x", baseCtx());
-        expect(resolved.content).toBe("body");
-    });
-    it("throws SOURCE_URL_HTTP_ERROR on 4xx", async () => {
-        vi.spyOn(globalThis, "fetch").mockImplementation(async () => new Response("nope", { status: 404 }));
-        await expect(resolveSource("https://x.test/missing", "nodes.n.instruction", baseCtx())).rejects.toThrow(/SOURCE_URL_HTTP_ERROR.*404.*nodes\.n\.instruction/);
-    });
-    it("throws SOURCE_URL_AUTH_REQUIRED on 401", async () => {
-        vi.spyOn(globalThis, "fetch").mockImplementation(async () => new Response("denied", { status: 401 }));
-        await expect(resolveSource("https://x.test/auth", "x", baseCtx())).rejects.toThrow(/SOURCE_URL_AUTH_REQUIRED/);
-    });
-});
-describe("fetch auth headers", () => {
-    beforeEach(() => {
-        vi.restoreAllMocks();
-    });
-    it("sets Authorization from per-host fetch.auth config", async () => {
-        const fetchMock = vi.spyOn(globalThis, "fetch").mockImplementation(async () => new Response("ok", { status: 200 }));
-        await resolveSource("https://raw.githubusercontent.com/x/y/main/z.md", "f", {
-            ...baseCtx(),
-            env: { GITHUB_TOKEN: "ghp_abc" },
-            authConfig: { "raw.githubusercontent.com": "GITHUB_TOKEN" },
-        });
-        const [, init] = fetchMock.mock.calls[0];
-        expect(init.headers).toMatchObject({
-            Authorization: "Bearer ghp_abc",
-        });
-    });
-    it("falls back to SWENY_FETCH_TOKEN when no per-host match", async () => {
-        const fetchMock = vi.spyOn(globalThis, "fetch").mockImplementation(async () => new Response("ok", { status: 200 }));
-        await resolveSource("https://other.example/x", "f", {
-            ...baseCtx(),
-            env: { SWENY_FETCH_TOKEN: "global_token" },
-            authConfig: { "raw.githubusercontent.com": "GITHUB_TOKEN" },
-        });
-        const [, init] = fetchMock.mock.calls[0];
-        expect(init.headers).toMatchObject({
-            Authorization: "Bearer global_token",
-        });
-    });
-    it("omits Authorization when env var is unset", async () => {
-        const fetchMock = vi.spyOn(globalThis, "fetch").mockImplementation(async () => new Response("ok", { status: 200 }));
-        await resolveSource("https://raw.githubusercontent.com/x", "f", {
-            ...baseCtx(),
-            env: {},
-            authConfig: { "raw.githubusercontent.com": "GITHUB_TOKEN" },
-        });
-        const [, init] = fetchMock.mock.calls[0];
-        const headers = init.headers;
-        expect(headers.Authorization).toBeUndefined();
-    });
-});
-describe("offline mode", () => {
-    beforeEach(() => {
-        vi.restoreAllMocks();
-        rmSync(fileTmp, { recursive: true, force: true });
-        mkdirSync(fileTmp, { recursive: true });
-    });
-    it("file resolution still works when offline", async () => {
-        writeFileSync(path.join(fileTmp, "local.md"), "hi");
-        const resolved = await resolveSource("./local.md", "f", {
-            ...baseCtx(),
-            cwd: fileTmp,
-            offline: true,
-        });
-        expect(resolved.content).toBe("hi");
-    });
-    it("url resolution fails with SOURCE_OFFLINE_REQUIRES_FETCH when offline", async () => {
-        await expect(resolveSource("https://example.com/x", "rules[0]", {
-            ...baseCtx(),
-            offline: true,
-        })).rejects.toThrow(/SOURCE_OFFLINE_REQUIRES_FETCH.*https:\/\/example\.com\/x.*rules\[0\]/);
-    });
-});
-describe("resolveSources (orchestrator)", () => {
-    beforeEach(() => {
-        vi.restoreAllMocks();
-        rmSync(fileTmp, { recursive: true, force: true });
-        mkdirSync(fileTmp, { recursive: true });
-    });
-    it("resolves a map of Sources and returns a parallel ResolvedSource map", async () => {
-        writeFileSync(path.join(fileTmp, "a.md"), "alpha");
-        const fetchMock = vi
-            .spyOn(globalThis, "fetch")
-            .mockImplementation(async () => new Response("beta", { status: 200 }));
-        const out = await resolveSources({
-            "nodes.n.instruction": "Inline thing.",
-            "rules[0]": "./a.md",
-            "context[0]": "https://x.test/doc",
-        }, { ...baseCtx(), cwd: fileTmp });
-        expect(out["nodes.n.instruction"].content).toBe("Inline thing.");
-        expect(out["rules[0]"].content).toBe("alpha");
-        expect(out["context[0]"].content).toBe("beta");
-        expect(fetchMock).toHaveBeenCalledTimes(1);
-    });
-    it("caches by canonical key: same URL referenced twice fetches once", async () => {
-        const fetchMock = vi
-            .spyOn(globalThis, "fetch")
-            .mockImplementation(async () => new Response("shared", { status: 200 }));
-        const out = await resolveSources({
-            "rules[0]": "https://x.test/shared.md",
-            "context[0]": "https://x.test/shared.md",
-        }, baseCtx());
-        expect(out["rules[0]"].content).toBe("shared");
-        expect(out["context[0]"].content).toBe("shared");
-        expect(fetchMock).toHaveBeenCalledTimes(1);
-    });
-    it("reports the first failure's field path", async () => {
-        await expect(resolveSources({ "nodes.bad.instruction": "./does-not-exist.md" }, { ...baseCtx(), cwd: fileTmp })).rejects.toThrow(/SOURCE_FILE_NOT_FOUND.*nodes\.bad\.instruction/);
-    });
-});

package/dist/sources.validation.test.d.ts

@@ -1,12 +0,0 @@
-/**
- * Comprehensive validation tests for the unified Source type.
- *
- * These tests verify correctness, completeness, and best practices
- * beyond the unit tests in sources.test.ts. They cover:
- *   - Review fix features: retry on 5xx, BOM stripping, SOURCE_INVALID_TYPE, tagged trimming
- *   - Edge cases: whitespace, unicode, large content, concurrent resolution
- *   - Schema validation: sourceZ boundary cases
- *   - Error message quality: field paths, remediation hints
- *   - Security: no auth token leakage, URL validation
- */
-export {};