@sweny-ai/core 0.1.77 → 0.1.78

package/dist/__tests__/integration/datadog.integration.test.d.ts

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

package/dist/__tests__/integration/datadog.integration.test.js

@@ -1,23 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { available } from "./harness.js";
-import { datadog } from "../../skills/datadog.js";
-const ctx = () => ({
-    config: {
-        DD_API_KEY: process.env.DD_API_KEY,
-        DD_APP_KEY: process.env.DD_APP_KEY,
-        DD_SITE: process.env.DD_SITE ?? "",
-    },
-    logger: console,
-});
-describe.runIf(available.datadog)("datadog integration", () => {
-    it("lists monitors", async () => {
-        const tool = datadog.tools.find((t) => t.name === "datadog_list_monitors");
-        const result = await tool.handler({}, ctx());
-        expect(Array.isArray(result)).toBe(true);
-    }, 15_000);
-    it("searches logs", async () => {
-        const tool = datadog.tools.find((t) => t.name === "datadog_search_logs");
-        const result = await tool.handler({ query: "*", from: "now-5m", limit: 5 }, ctx());
-        expect(result).toHaveProperty("data");
-    }, 15_000);
-});

package/dist/__tests__/integration/e2e-workflow.integration.test.d.ts

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

package/dist/__tests__/integration/e2e-workflow.integration.test.js

@@ -1,75 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { available, logAvailability } from "./harness.js";
-import { execute } from "../../executor.js";
-import { ClaudeClient } from "../../claude.js";
-import { createSkillMap } from "../../skills/index.js";
-logAvailability();
-// A minimal 2-node workflow that only uses Claude (no external tools)
-const analysisWorkflow = {
-    id: "e2e-analysis",
-    name: "E2E Analysis",
-    description: "Two-node workflow using real Claude",
-    entry: "analyze",
-    nodes: {
-        analyze: {
-            name: "Analyze Input",
-            instruction: "Analyze the input data and determine if it represents a critical issue. Return JSON with fields: severity (high/medium/low) and summary (one sentence).",
-            skills: [],
-            output: {
-                type: "object",
-                properties: {
-                    severity: { type: "string", enum: ["high", "medium", "low"] },
-                    summary: { type: "string" },
-                },
-                required: ["severity", "summary"],
-            },
-        },
-        report: {
-            name: "Generate Report",
-            instruction: "Based on the analysis, write a brief incident report. Return JSON with fields: title (string) and recommendation (string).",
-            skills: [],
-            output: {
-                type: "object",
-                properties: {
-                    title: { type: "string" },
-                    recommendation: { type: "string" },
-                },
-                required: ["title", "recommendation"],
-            },
-        },
-    },
-    edges: [{ from: "analyze", to: "report" }],
-};
-describe.runIf(available.claude)("e2e workflow with real Claude", () => {
-    it("executes a 2-node analysis workflow", async () => {
-        const claude = new ClaudeClient({
-            model: "claude-haiku-4-5-20251001", // Use Haiku for speed/cost in tests
-            maxTurns: 3,
-        });
-        const events = [];
-        const { results } = await execute(analysisWorkflow, {
-            alert: "CPU usage at 98% for 15 minutes on production server web-03",
-            service: "api-gateway",
-            timestamp: "2025-03-25T08:00:00Z",
-        }, {
-            skills: createSkillMap([]),
-            claude,
-            observer: (e) => events.push(e),
-            config: {},
-        });
-        // Both nodes executed
-        expect(results.size).toBe(2);
-        expect(results.get("analyze")?.status).toBe("success");
-        expect(results.get("report")?.status).toBe("success");
-        // Analysis should have severity
-        const analysis = results.get("analyze").data;
-        expect(analysis).toBeDefined();
-        // Report should have title
-        const report = results.get("report").data;
-        expect(report).toBeDefined();
-        // Events stream should be complete
-        expect(events[0].type).toBe("workflow:start");
-        expect(events[events.length - 1].type).toBe("workflow:end");
-        expect(events.filter((e) => e.type === "node:enter")).toHaveLength(2);
-    }, 60_000); // 60s timeout for real API calls
-});

package/dist/__tests__/integration/github.integration.test.d.ts

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

package/dist/__tests__/integration/github.integration.test.js

@@ -1,37 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { available, logAvailability } from "./harness.js";
-import { github } from "../../skills/github.js";
-logAvailability();
-const ctx = () => ({
-    config: { GITHUB_TOKEN: process.env.GITHUB_TOKEN },
-    logger: console,
-});
-describe.runIf(available.github)("github integration", () => {
-    it("searches code in a public repo", async () => {
-        const tool = github.tools.find((t) => t.name === "github_search_code");
-        const result = await tool.handler({ query: "README", repo: "octocat/Hello-World" }, ctx());
-        expect(result).toHaveProperty("items");
-    }, 15_000);
-    it("gets an issue from a public repo", async () => {
-        const tool = github.tools.find((t) => t.name === "github_get_issue");
-        const result = await tool.handler({ repo: "octocat/Hello-World", number: 1 }, ctx());
-        expect(result).toHaveProperty("title");
-        expect(result).toHaveProperty("state");
-    }, 15_000);
-    it("lists recent commits", async () => {
-        const tool = github.tools.find((t) => t.name === "github_list_recent_commits");
-        const result = await tool.handler({ repo: "octocat/Hello-World", branch: "master", per_page: 3 }, ctx());
-        expect(Array.isArray(result)).toBe(true);
-        expect(result.length).toBeGreaterThan(0);
-    }, 15_000);
-    it("searches issues", async () => {
-        const tool = github.tools.find((t) => t.name === "github_search_issues");
-        const result = await tool.handler({ query: "is:issue", repo: "octocat/Hello-World" }, ctx());
-        expect(result).toHaveProperty("items");
-    }, 15_000);
-    it("gets a file from a public repo", async () => {
-        const tool = github.tools.find((t) => t.name === "github_get_file");
-        const result = await tool.handler({ repo: "octocat/Hello-World", path: "README" }, ctx());
-        expect(result).toHaveProperty("content");
-    }, 15_000);
-});

package/dist/__tests__/integration/harness.d.ts

@@ -1,24 +0,0 @@
-/**
- * Integration Test Harness
- *
- * Detects which external services are available via environment variables.
- * Integration tests use `describe.runIf(available.xxx)` to skip cleanly
- * when credentials aren't present.
- *
- * Usage:
- *   npx vitest run --config vitest.integration.config.ts
- *
- * Or with env vars:
- *   GITHUB_TOKEN=ghp_... npx vitest run --config vitest.integration.config.ts
- */
-export declare const available: {
-    github: boolean;
-    linear: boolean;
-    sentry: boolean;
-    datadog: boolean;
-    slack: boolean;
-    discord: boolean;
-    claude: boolean;
-};
-/** Print which services are available (for CI logs) */
-export declare function logAvailability(): void;

package/dist/__tests__/integration/harness.js

@@ -1,34 +0,0 @@
-/**
- * Integration Test Harness
- *
- * Detects which external services are available via environment variables.
- * Integration tests use `describe.runIf(available.xxx)` to skip cleanly
- * when credentials aren't present.
- *
- * Usage:
- *   npx vitest run --config vitest.integration.config.ts
- *
- * Or with env vars:
- *   GITHUB_TOKEN=ghp_... npx vitest run --config vitest.integration.config.ts
- */
-export const available = {
-    github: !!process.env.GITHUB_TOKEN,
-    linear: !!process.env.LINEAR_API_KEY,
-    sentry: !!(process.env.SENTRY_AUTH_TOKEN && process.env.SENTRY_ORG),
-    datadog: !!(process.env.DD_API_KEY && process.env.DD_APP_KEY),
-    slack: !!(process.env.SLACK_WEBHOOK_URL || process.env.SLACK_BOT_TOKEN),
-    discord: !!process.env.DISCORD_WEBHOOK_URL,
-    claude: !!process.env.ANTHROPIC_API_KEY,
-};
-/** Print which services are available (for CI logs) */
-export function logAvailability() {
-    const entries = Object.entries(available);
-    const on = entries.filter(([, v]) => v).map(([k]) => k);
-    const off = entries.filter(([, v]) => !v).map(([k]) => k);
-    console.log(`\n🔌 Integration test services:`);
-    if (on.length > 0)
-        console.log(`   ✅ Available: ${on.join(", ")}`);
-    if (off.length > 0)
-        console.log(`   ⏭️  Skipped:   ${off.join(", ")}`);
-    console.log();
-}

package/dist/__tests__/integration/linear.integration.test.d.ts

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

package/dist/__tests__/integration/linear.integration.test.js

@@ -1,15 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { available } from "./harness.js";
-import { linear } from "../../skills/linear.js";
-const ctx = () => ({
-    config: { LINEAR_API_KEY: process.env.LINEAR_API_KEY },
-    logger: console,
-});
-describe.runIf(available.linear)("linear integration", () => {
-    it("searches issues", async () => {
-        const tool = linear.tools.find((t) => t.name === "linear_search_issues");
-        const result = await tool.handler({ query: "bug", limit: 3 }, ctx());
-        expect(result).toHaveProperty("searchIssues");
-        expect(result.searchIssues).toHaveProperty("nodes");
-    }, 15_000);
-});

package/dist/__tests__/integration/sentry.integration.test.d.ts

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

package/dist/__tests__/integration/sentry.integration.test.js

@@ -1,20 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { available } from "./harness.js";
-import { sentry } from "../../skills/sentry.js";
-const ctx = () => ({
-    config: {
-        SENTRY_AUTH_TOKEN: process.env.SENTRY_AUTH_TOKEN,
-        SENTRY_ORG: process.env.SENTRY_ORG,
-        SENTRY_BASE_URL: process.env.SENTRY_BASE_URL ?? "",
-    },
-    logger: console,
-});
-describe.runIf(available.sentry)("sentry integration", () => {
-    // These tests require at least one project in the org
-    it("list_issues returns an array", async () => {
-        const tool = sentry.tools.find((t) => t.name === "sentry_list_issues");
-        // Use the first project found, or skip if none
-        const result = await tool.handler({ project: process.env.SENTRY_PROJECT ?? "javascript" }, ctx());
-        expect(Array.isArray(result)).toBe(true);
-    }, 15_000);
-});

package/dist/__tests__/integration/slack.integration.test.d.ts

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

package/dist/__tests__/integration/slack.integration.test.js

@@ -1,22 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { available } from "./harness.js";
-import { slack } from "../../skills/slack.js";
-const ctx = () => ({
-    config: {
-        SLACK_WEBHOOK_URL: process.env.SLACK_WEBHOOK_URL ?? "",
-        SLACK_BOT_TOKEN: process.env.SLACK_BOT_TOKEN ?? "",
-    },
-    logger: console,
-});
-// Only run Slack integration tests when explicitly opted in
-// to avoid spamming channels during routine test runs
-const slackEnabled = available.slack && process.env.SLACK_INTEGRATION_TEST === "1";
-describe.runIf(slackEnabled)("slack integration", () => {
-    it("sends a test message via webhook", async () => {
-        if (!process.env.SLACK_WEBHOOK_URL)
-            return;
-        const tool = slack.tools.find((t) => t.name === "slack_send_message");
-        const result = await tool.handler({ text: `🧪 SWEny integration test — ${new Date().toISOString()}` }, ctx());
-        expect(result).toHaveProperty("ok");
-    }, 15_000);
-});

package/dist/__tests__/integration/sources.integration.test.d.ts

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

package/dist/__tests__/integration/sources.integration.test.js

@@ -1,123 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { mkdirSync, writeFileSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import * as path from "node:path";
-import { randomBytes } from "node:crypto";
-import { execute } from "../../executor.js";
-import { MockClaude } from "../../testing.js";
-import { createSkillMap } from "../../skills/index.js";
-function freshDir(name) {
-    const dir = path.join(tmpdir(), `sweny-sources-int-${name}-${Date.now()}-${randomBytes(4).toString("hex")}`);
-    rmSync(dir, { recursive: true, force: true });
-    mkdirSync(dir, { recursive: true });
-    return dir;
-}
-describe("integration: Source resolution across a workflow", () => {
-    beforeEach(() => {
-        vi.restoreAllMocks();
-    });
-    it("resolves inline, file, and url instructions across three nodes", async () => {
-        const dir = freshDir("three-kinds");
-        writeFileSync(path.join(dir, "b.md"), "Step B instruction from file.");
-        vi.spyOn(globalThis, "fetch").mockImplementation(async () => new Response("Step C instruction from URL.", { status: 200 }));
-        const workflow = {
-            id: "three-kinds",
-            name: "Three Kinds",
-            description: "",
-            entry: "a",
-            nodes: {
-                a: { name: "A", instruction: "Step A inline", skills: [] },
-                b: { name: "B", instruction: { file: path.join(dir, "b.md") }, skills: [] },
-                c: { name: "C", instruction: { url: "https://example.com/c.md" }, skills: [] },
-            },
-            edges: [
-                { from: "a", to: "b" },
-                { from: "b", to: "c" },
-            ],
-        };
-        const skills = createSkillMap([]);
-        const result = await execute(workflow, {}, {
-            skills,
-            claude: new MockClaude({
-                responses: {
-                    a: { data: {} },
-                    b: { data: {} },
-                    c: { data: {} },
-                },
-            }),
-            cwd: dir,
-        });
-        // All three nodes should have executed
-        expect(result.results.size).toBe(3);
-        // Trace should have all sources
-        expect(result.trace.sources["nodes.a.instruction"].kind).toBe("inline");
-        expect(result.trace.sources["nodes.a.instruction"].content).toBe("Step A inline");
-        expect(result.trace.sources["nodes.b.instruction"].kind).toBe("file");
-        expect(result.trace.sources["nodes.b.instruction"].content).toBe("Step B instruction from file.");
-        expect(result.trace.sources["nodes.c.instruction"].kind).toBe("url");
-        expect(result.trace.sources["nodes.c.instruction"].content).toBe("Step C instruction from URL.");
-        expect(result.trace.sources["nodes.c.instruction"].fetchedAt).toBeDefined();
-        // Every source has a hash
-        for (const rs of Object.values(result.trace.sources)) {
-            expect(rs.hash).toMatch(/^[0-9a-f]{16}$/);
-        }
-    });
-    it("fails fast with SOURCE_OFFLINE_REQUIRES_FETCH when offline and URL present", async () => {
-        const workflow = {
-            id: "offline-fail",
-            name: "Offline fail",
-            description: "",
-            entry: "a",
-            nodes: {
-                a: { name: "A", instruction: { url: "https://example.com/x" }, skills: [] },
-            },
-            edges: [],
-        };
-        await expect(execute(workflow, {}, {
-            skills: createSkillMap([]),
-            claude: new MockClaude({ responses: { a: { data: {} } } }),
-            offline: true,
-        })).rejects.toThrow(/SOURCE_OFFLINE_REQUIRES_FETCH/);
-    });
-    it("fails fast with SOURCE_FILE_NOT_FOUND and includes field path", async () => {
-        const dir = freshDir("missing");
-        const workflow = {
-            id: "file-missing",
-            name: "File missing",
-            description: "",
-            entry: "bad",
-            nodes: {
-                bad: { name: "Bad", instruction: { file: "./does-not-exist.md" }, skills: [] },
-            },
-            edges: [],
-        };
-        await expect(execute(workflow, {}, {
-            skills: createSkillMap([]),
-            claude: new MockClaude({ responses: { bad: { data: {} } } }),
-            cwd: dir,
-        })).rejects.toThrow(/SOURCE_FILE_NOT_FOUND.*nodes\.bad\.instruction/);
-    });
-    it("emits workflow:start before sources:resolved (per spec)", async () => {
-        const events = [];
-        const workflow = {
-            id: "evt-test",
-            name: "Event test",
-            description: "",
-            entry: "only",
-            nodes: { only: { name: "Only", instruction: "Go.", skills: [] } },
-            edges: [],
-        };
-        await execute(workflow, {}, {
-            skills: createSkillMap([]),
-            claude: new MockClaude({ responses: { only: { data: {} } } }),
-            observer: (e) => events.push(e),
-        });
-        const srcEvt = events.find((e) => e.type === "sources:resolved");
-        expect(srcEvt).toBeDefined();
-        expect(srcEvt.sources["nodes.only.instruction"].content).toBe("Go.");
-        // workflow:start should come before sources:resolved (per spec)
-        const startIdx = events.findIndex((e) => e.type === "workflow:start");
-        const srcIdx = events.findIndex((e) => e.type === "sources:resolved");
-        expect(startIdx).toBeLessThan(srcIdx);
-    });
-});

package/dist/__tests__/publish.test.d.ts

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

package/dist/__tests__/publish.test.js

@@ -1,180 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from "vitest";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import * as os from "node:os";
-import { validateWorkflowFile, validateSkillDir } from "../cli/publish.js";
-describe("validateWorkflowFile", () => {
-    let tmpDir;
-    beforeAll(() => {
-        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sweny-publish-test-"));
-    });
-    afterAll(() => {
-        fs.rmSync(tmpDir, { recursive: true, force: true });
-    });
-    it("validates a correct workflow file", () => {
-        const file = path.join(tmpDir, "good.yml");
-        fs.writeFileSync(file, `id: test-workflow
-name: Test
-description: A test workflow
-entry: start
-nodes:
-  start:
-    name: Start
-    instruction: Do something.
-    skills: [github]
-edges: []
-`);
-        const result = validateWorkflowFile(file);
-        expect(result.valid).toBe(true);
-        expect(result.id).toBe("test-workflow");
-        expect(result.name).toBe("Test");
-        expect(result.nodeCount).toBe(1);
-        expect(result.edgeCount).toBe(0);
-        expect(result.errors).toEqual([]);
-    });
-    it("rejects a non-existent file", () => {
-        const result = validateWorkflowFile(path.join(tmpDir, "nope.yml"));
-        expect(result.valid).toBe(false);
-        expect(result.errors[0]).toBe("File not found");
-    });
-    it("rejects invalid YAML", () => {
-        const file = path.join(tmpDir, "bad.yml");
-        fs.writeFileSync(file, "{{invalid yaml");
-        const result = validateWorkflowFile(file);
-        expect(result.valid).toBe(false);
-        expect(result.errors[0]).toMatch(/Invalid YAML/);
-    });
-    it("rejects a workflow missing required fields", () => {
-        const file = path.join(tmpDir, "incomplete.yml");
-        fs.writeFileSync(file, "id: test\nname: Test\n");
-        const result = validateWorkflowFile(file);
-        expect(result.valid).toBe(false);
-        expect(result.errors.length).toBeGreaterThan(0);
-    });
-    it("rejects a workflow with unknown skill references", () => {
-        const file = path.join(tmpDir, "unknown-skill.yml");
-        fs.writeFileSync(file, `id: unknown-skill-test
-name: Unknown Skill Test
-description: Test
-entry: start
-nodes:
-  start:
-    name: Start
-    instruction: Do something.
-    skills: [unicorn]
-edges: []
-`);
-        const result = validateWorkflowFile(file);
-        expect(result.valid).toBe(false);
-        expect(result.errors.some((e) => e.includes("unicorn"))).toBe(true);
-    });
-    it("returns config warnings for skills with required env vars", () => {
-        const file = path.join(tmpDir, "with-github.yml");
-        fs.writeFileSync(file, `id: github-test
-name: GitHub Test
-description: Test
-entry: start
-nodes:
-  start:
-    name: Start
-    instruction: Do something.
-    skills: [github]
-edges: []
-`);
-        const result = validateWorkflowFile(file);
-        expect(result.valid).toBe(true);
-        expect(result.warnings.some((w) => w.includes("GITHUB_TOKEN"))).toBe(true);
-    });
-});
-describe("validateSkillDir", () => {
-    let tmpDir;
-    beforeAll(() => {
-        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sweny-skill-test-"));
-    });
-    afterAll(() => {
-        fs.rmSync(tmpDir, { recursive: true, force: true });
-    });
-    it("validates a correct instruction skill", () => {
-        const skillDir = path.join(tmpDir, "my-skill");
-        fs.mkdirSync(skillDir, { recursive: true });
-        fs.writeFileSync(path.join(skillDir, "SKILL.md"), `---
-name: my-skill
-description: A test skill
----
-
-When reviewing code, check for security issues first.
-`);
-        const result = validateSkillDir(skillDir);
-        expect(result.valid).toBe(true);
-        expect(result.id).toBe("my-skill");
-        expect(result.hasInstruction).toBe(true);
-        expect(result.hasMcp).toBe(false);
-    });
-    it("validates a correct MCP skill", () => {
-        const skillDir = path.join(tmpDir, "mcp-skill");
-        fs.mkdirSync(skillDir, { recursive: true });
-        fs.writeFileSync(path.join(skillDir, "SKILL.md"), `---
-name: mcp-skill
-description: A test MCP skill
-mcp:
-  command: npx
-  args: ["-y", "@company/server"]
----
-`);
-        const result = validateSkillDir(skillDir);
-        expect(result.valid).toBe(true);
-        expect(result.hasMcp).toBe(true);
-    });
-    it("rejects a directory without SKILL.md", () => {
-        const emptyDir = path.join(tmpDir, "empty");
-        fs.mkdirSync(emptyDir, { recursive: true });
-        const result = validateSkillDir(emptyDir);
-        expect(result.valid).toBe(false);
-        expect(result.errors[0]).toBe("SKILL.md not found in directory");
-    });
-    it("rejects a skill with no frontmatter", () => {
-        const skillDir = path.join(tmpDir, "no-fm");
-        fs.mkdirSync(skillDir, { recursive: true });
-        fs.writeFileSync(path.join(skillDir, "SKILL.md"), "Just some text");
-        const result = validateSkillDir(skillDir);
-        expect(result.valid).toBe(false);
-        expect(result.errors[0]).toBe("No YAML frontmatter found");
-    });
-    it("rejects an invalid skill ID", () => {
-        const skillDir = path.join(tmpDir, "Bad-Name");
-        fs.mkdirSync(skillDir, { recursive: true });
-        fs.writeFileSync(path.join(skillDir, "SKILL.md"), `---
-name: Bad-Name
----
-
-Some instruction.
-`);
-        const result = validateSkillDir(skillDir);
-        expect(result.valid).toBe(false);
-        expect(result.errors[0]).toMatch(/Invalid skill ID/);
-    });
-    it("rejects a skill with mismatched directory name", () => {
-        const skillDir = path.join(tmpDir, "wrong-dir");
-        fs.mkdirSync(skillDir, { recursive: true });
-        fs.writeFileSync(path.join(skillDir, "SKILL.md"), `---
-name: correct-name
----
-
-Some instruction.
-`);
-        const result = validateSkillDir(skillDir);
-        expect(result.valid).toBe(false);
-        expect(result.errors).toContain(`Directory name "wrong-dir" doesn't match skill name "correct-name"`);
-    });
-    it("rejects a skill with no instruction and no MCP", () => {
-        const skillDir = path.join(tmpDir, "empty-skill");
-        fs.mkdirSync(skillDir, { recursive: true });
-        fs.writeFileSync(path.join(skillDir, "SKILL.md"), `---
-name: empty-skill
----
-`);
-        const result = validateSkillDir(skillDir);
-        expect(result.valid).toBe(false);
-        expect(result.errors).toContain("Skill must have an instruction body or an mcp config");
-    });
-});

package/dist/__tests__/requires.test.d.ts

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