@sweny-ai/core 0.1.0

package/dist/__tests__/testing.test.js

@@ -0,0 +1,224 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { mkdirSync, writeFileSync, readFileSync, existsSync, rmSync } from "node:fs";
+import * as path from "node:path";
+import { tmpdir } from "node:os";
+import { MockClaude, createFileSkill } from "../testing.js";
+// ─── Fixtures ────────────────────────────────────────────────────
+const tmpBase = path.join(tmpdir(), "sweny-testing-test");
+function freshDir(name) {
+    const dir = path.join(tmpBase, `${name}-${Date.now()}`);
+    rmSync(dir, { recursive: true, force: true });
+    mkdirSync(dir, { recursive: true });
+    return dir;
+}
+const testWorkflow = {
+    id: "test",
+    name: "Test",
+    description: "",
+    entry: "first",
+    nodes: {
+        first: { name: "First", instruction: "Do the first thing", skills: [] },
+        second: { name: "Second", instruction: "Do the second thing", skills: [] },
+        alt: { name: "Alt", instruction: "Alternative path", skills: [] },
+    },
+    edges: [
+        { from: "first", to: "second" },
+        { from: "first", to: "alt", when: "needs alternative" },
+    ],
+};
+// ─── MockClaude tests ────────────────────────────────────────────
+describe("MockClaude", () => {
+    it("returns scripted responses in order", async () => {
+        const claude = new MockClaude({
+            responses: {
+                first: { data: { step: 1 } },
+                second: { data: { step: 2 } },
+            },
+        });
+        const r1 = await claude.run({ instruction: "Do first", context: {}, tools: [] });
+        expect(r1.data.step).toBe(1);
+        const r2 = await claude.run({ instruction: "Do second", context: {}, tools: [] });
+        expect(r2.data.step).toBe(2);
+    });
+    it("matches nodes by instruction when workflow is provided", async () => {
+        const claude = new MockClaude({
+            workflow: testWorkflow,
+            responses: {
+                first: { data: { step: "first" } },
+                alt: { data: { step: "alt" } },
+            },
+        });
+        // Call in non-sequential order using exact instructions
+        const r1 = await claude.run({
+            instruction: "Alternative path",
+            context: {},
+            tools: [],
+        });
+        expect(r1.data.step).toBe("alt");
+        const r2 = await claude.run({
+            instruction: "Do the first thing",
+            context: {},
+            tools: [],
+        });
+        expect(r2.data.step).toBe("first");
+    });
+    it("tracks execution order", async () => {
+        const claude = new MockClaude({
+            responses: {
+                a: { data: {} },
+                b: { data: {} },
+            },
+        });
+        await claude.run({ instruction: "x", context: {}, tools: [] });
+        await claude.run({ instruction: "y", context: {}, tools: [] });
+        expect(claude.executedNodes).toEqual(["a", "b"]);
+    });
+    it("returns default response for unknown nodes", async () => {
+        const claude = new MockClaude({ responses: {} });
+        const result = await claude.run({ instruction: "anything", context: {}, tools: [] });
+        expect(result.status).toBe("success");
+        expect(result.data.summary).toContain("no scripted response");
+    });
+    it("executes scripted tool calls", async () => {
+        const dir = freshDir("mock-tools");
+        const fileSkill = createFileSkill(dir);
+        const claude = new MockClaude({
+            responses: {
+                node1: {
+                    toolCalls: [{ tool: "fs_write_json", input: { path: "test.json", data: { ok: true } } }],
+                    data: { wrote: true },
+                },
+            },
+        });
+        const result = await claude.run({
+            instruction: "Write file",
+            context: {},
+            tools: fileSkill.tools,
+        });
+        expect(result.toolCalls).toHaveLength(1);
+        expect(result.toolCalls[0].tool).toBe("fs_write_json");
+        expect(existsSync(path.join(dir, "test.json"))).toBe(true);
+    });
+    it("records tool not found errors", async () => {
+        const claude = new MockClaude({
+            responses: {
+                node1: {
+                    toolCalls: [{ tool: "nonexistent_tool", input: {} }],
+                    data: {},
+                },
+            },
+        });
+        const result = await claude.run({ instruction: "x", context: {}, tools: [] });
+        expect(result.toolCalls[0].output).toEqual({ error: "tool not found" });
+    });
+    describe("evaluate", () => {
+        it("follows scripted routes", async () => {
+            const claude = new MockClaude({
+                responses: { first: { data: {} } },
+                routes: { first: "alt" },
+            });
+            await claude.run({ instruction: "x", context: {}, tools: [] });
+            const chosen = await claude.evaluate({
+                question: "Which path?",
+                context: {},
+                choices: [
+                    { id: "second", description: "Normal path" },
+                    { id: "alt", description: "Alternative path" },
+                ],
+            });
+            expect(chosen).toBe("alt");
+        });
+        it("defaults to first choice when no route is scripted", async () => {
+            const claude = new MockClaude({ responses: { a: { data: {} } } });
+            await claude.run({ instruction: "x", context: {}, tools: [] });
+            const chosen = await claude.evaluate({
+                question: "Where?",
+                context: {},
+                choices: [
+                    { id: "x", description: "First" },
+                    { id: "y", description: "Second" },
+                ],
+            });
+            expect(chosen).toBe("x");
+        });
+        it("ignores invalid scripted routes", async () => {
+            const claude = new MockClaude({
+                responses: { a: { data: {} } },
+                routes: { a: "nonexistent" },
+            });
+            await claude.run({ instruction: "x", context: {}, tools: [] });
+            const chosen = await claude.evaluate({
+                question: "Where?",
+                context: {},
+                choices: [{ id: "valid", description: "Valid" }],
+            });
+            expect(chosen).toBe("valid"); // falls back to first choice
+        });
+    });
+});
+// ─── File skill tests ────────────────────────────────────────────
+describe("createFileSkill", () => {
+    let dir;
+    beforeEach(() => {
+        dir = freshDir("fileskill");
+    });
+    it("reads and writes JSON", async () => {
+        const skill = createFileSkill(dir);
+        const write = skill.tools.find((t) => t.name === "fs_write_json");
+        const read = skill.tools.find((t) => t.name === "fs_read_json");
+        const ctx = { config: {}, logger: console };
+        await write.handler({ path: "test.json", data: { hello: "world" } }, ctx);
+        const result = await read.handler({ path: "test.json" }, ctx);
+        expect(result).toEqual({ hello: "world" });
+    });
+    it("reads text files", async () => {
+        const skill = createFileSkill(dir);
+        writeFileSync(path.join(dir, "hello.txt"), "hello world");
+        const read = skill.tools.find((t) => t.name === "fs_read_text");
+        const ctx = { config: {}, logger: console };
+        const result = await read.handler({ path: "hello.txt" }, ctx);
+        expect(result).toBe("hello world");
+    });
+    it("writes markdown with nested dirs", async () => {
+        const skill = createFileSkill(dir);
+        const write = skill.tools.find((t) => t.name === "fs_write_markdown");
+        const ctx = { config: {}, logger: console };
+        await write.handler({ path: "issues/ISSUE-1.md", content: "# Bug\n\nBroken" }, ctx);
+        const content = readFileSync(path.join(dir, "issues/ISSUE-1.md"), "utf-8");
+        expect(content).toContain("# Bug");
+    });
+    it("lists directory contents", async () => {
+        const skill = createFileSkill(dir);
+        writeFileSync(path.join(dir, "a.txt"), "a");
+        writeFileSync(path.join(dir, "b.txt"), "b");
+        const list = skill.tools.find((t) => t.name === "fs_list_dir");
+        const ctx = { config: {}, logger: console };
+        const result = await list.handler({}, ctx);
+        expect(result).toContain("a.txt");
+        expect(result).toContain("b.txt");
+    });
+    it("returns error info for non-existent directory", async () => {
+        const skill = createFileSkill(dir);
+        const list = skill.tools.find((t) => t.name === "fs_list_dir");
+        const ctx = { config: {}, logger: console };
+        const result = await list.handler({ path: "nonexistent" }, ctx);
+        expect(result).toHaveProperty("error");
+    });
+    it("creates deeply nested directories for JSON", async () => {
+        const skill = createFileSkill(dir);
+        const write = skill.tools.find((t) => t.name === "fs_write_json");
+        const ctx = { config: {}, logger: console };
+        await write.handler({ path: "deep/nested/dir/file.json", data: { deep: true } }, ctx);
+        expect(existsSync(path.join(dir, "deep/nested/dir/file.json"))).toBe(true);
+    });
+    it("has correct skill metadata", () => {
+        const skill = createFileSkill(dir);
+        expect(skill.id).toBe("filesystem");
+        expect(skill.tools).toHaveLength(5);
+        expect(skill.tools.map((t) => t.name)).toContain("fs_read_json");
+        expect(skill.tools.map((t) => t.name)).toContain("fs_read_text");
+        expect(skill.tools.map((t) => t.name)).toContain("fs_write_json");
+        expect(skill.tools.map((t) => t.name)).toContain("fs_write_markdown");
+        expect(skill.tools.map((t) => t.name)).toContain("fs_list_dir");
+    });
+});

package/dist/browser.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Browser-safe entry point for @sweny-ai/core
+ *
+ * Re-exports everything EXCEPT ClaudeClient (which depends on
+ * @anthropic-ai/claude-agent-sdk, a Node-only package). Use this entry point
+ * in browser environments (Vite, webpack, Astro, etc.).
+ */
+export type { Skill, SkillCategory, Tool, ToolContext, ConfigField, JSONSchema, Workflow, Node, Edge, NodeResult, ToolCall, ExecutionEvent, Observer, Claude, Logger, } from "./types.js";
+export { consoleLogger } from "./types.js";
+export { execute } from "./executor.js";
+export type { ExecuteOptions } from "./executor.js";
+export { github, linear, slack, sentry, datadog, betterstack, notification, builtinSkills, createSkillMap, allSkills, isSkillConfigured, configuredSkills, validateWorkflowSkills, } from "./skills/index.js";
+export type { SkillValidationResult } from "./skills/index.js";
+export { workflowZ, nodeZ, edgeZ, skillZ, parseWorkflow, validateWorkflow, workflowJsonSchema } from "./schema.js";
+export type { WorkflowError } from "./schema.js";
+export { workflowToFlow, flowToWorkflow, applyExecutionEvent, exportAsTypescript, getSkillCatalog } from "./studio.js";
+export type { FlowNode, SkillNodeData, FlowEdge } from "./studio.js";

package/dist/browser.js

@@ -0,0 +1,22 @@
+/**
+ * Browser-safe entry point for @sweny-ai/core
+ *
+ * Re-exports everything EXCEPT ClaudeClient (which depends on
+ * @anthropic-ai/claude-agent-sdk, a Node-only package). Use this entry point
+ * in browser environments (Vite, webpack, Astro, etc.).
+ */
+export { consoleLogger } from "./types.js";
+// Executor
+export { execute } from "./executor.js";
+// Skills
+export { github, linear, slack, sentry, datadog, betterstack, notification, builtinSkills, createSkillMap, allSkills, isSkillConfigured, configuredSkills, validateWorkflowSkills, } from "./skills/index.js";
+// Schema & validation
+export { workflowZ, nodeZ, edgeZ, skillZ, parseWorkflow, validateWorkflow, workflowJsonSchema } from "./schema.js";
+// Studio adapter
+export { workflowToFlow, flowToWorkflow, applyExecutionEvent, exportAsTypescript, getSkillCatalog } from "./studio.js";
+// Workflow builder — NOT included in browser entry.
+// buildWorkflow/refineWorkflow depend on the Claude interface (Node-only).
+// Import from "@sweny-ai/core" in Node environments.
+// Testing utilities — NOT included in browser entry.
+// MockClaude and createFileSkill depend on node:fs.
+// Import from "@sweny-ai/core/testing" in Node environments.

package/dist/claude.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Claude Client — Headless Claude Code backend
+ *
+ * Uses the @anthropic-ai/claude-agent-sdk to run headless Claude Code
+ * as the LLM backend. Tools are exposed via an in-process MCP server
+ * that Claude Code calls during execution.
+ *
+ * This is the ONLY supported LLM backend. The whole point of sweny
+ * is to use headless Claude Code — never the raw Anthropic API.
+ */
+import type { Claude, Tool, ToolContext, NodeResult, JSONSchema, Logger, McpServerConfig } from "./types.js";
+export interface ClaudeClientOptions {
+    /** Model override */
+    model?: string;
+    /** Max turns for tool use loop (default: 20) */
+    maxTurns?: number;
+    /** Working directory for Claude Code (default: process.cwd()) */
+    cwd?: string;
+    /** Logger */
+    logger?: Logger;
+    /** Default tool context for standalone usage (not via executor) */
+    defaultContext?: ToolContext;
+    /** External MCP servers (GitHub, Linear, Sentry, etc.) — merged with core skill tools */
+    mcpServers?: Record<string, McpServerConfig>;
+}
+export declare class ClaudeClient implements Claude {
+    private model;
+    private maxTurns;
+    private cwd;
+    private logger;
+    private defaultContext;
+    private mcpServers;
+    constructor(opts?: ClaudeClientOptions);
+    run(opts: {
+        instruction: string;
+        context: Record<string, unknown>;
+        tools: Tool[];
+        outputSchema?: JSONSchema;
+    }): Promise<NodeResult>;
+    evaluate(opts: {
+        question: string;
+        context: Record<string, unknown>;
+        choices: {
+            id: string;
+            description: string;
+        }[];
+    }): Promise<string>;
+}

package/dist/claude.js

@@ -0,0 +1,293 @@
+/**
+ * Claude Client — Headless Claude Code backend
+ *
+ * Uses the @anthropic-ai/claude-agent-sdk to run headless Claude Code
+ * as the LLM backend. Tools are exposed via an in-process MCP server
+ * that Claude Code calls during execution.
+ *
+ * This is the ONLY supported LLM backend. The whole point of sweny
+ * is to use headless Claude Code — never the raw Anthropic API.
+ */
+import { query, createSdkMcpServer, tool as sdkTool } from "@anthropic-ai/claude-agent-sdk";
+import { z } from "zod";
+import { consoleLogger } from "./types.js";
+const SYSTEM_PROMPT = `You are a step in an automated workflow. Execute the instruction precisely using the tools available to you. Be thorough but concise. When you're done, summarize your findings and results.`;
+export class ClaudeClient {
+    model;
+    maxTurns;
+    cwd;
+    logger;
+    defaultContext;
+    mcpServers;
+    constructor(opts = {}) {
+        this.model = opts.model;
+        this.maxTurns = opts.maxTurns ?? 20;
+        this.cwd = opts.cwd ?? process.cwd();
+        this.logger = opts.logger ?? consoleLogger;
+        this.defaultContext = opts.defaultContext ?? { config: {}, logger: this.logger };
+        this.mcpServers = opts.mcpServers ?? {};
+    }
+    async run(opts) {
+        const { instruction, context, tools, outputSchema } = opts;
+        const toolCalls = [];
+        // Convert core tools to SDK MCP tools
+        const sdkTools = tools.map((t) => coreToolToSdkTool(t, this.defaultContext, toolCalls));
+        // Create in-process MCP server
+        const mcpServer = createSdkMcpServer({
+            name: "sweny-core",
+            tools: sdkTools,
+        });
+        // Build prompt
+        const prompt = [
+            `## Instruction\n\n${instruction}`,
+            `## Context\n\n\`\`\`json\n${JSON.stringify(context, null, 2)}\n\`\`\``,
+            outputSchema
+                ? `## Required Output\n\nYou MUST end with a JSON object matching this schema:\n\`\`\`json\n${JSON.stringify(outputSchema, null, 2)}\n\`\`\``
+                : "",
+        ]
+            .filter(Boolean)
+            .join("\n\n");
+        // Spread process.env so Claude Code inherits PATH, HOME, auth tokens, etc.
+        const env = Object.fromEntries(Object.entries(process.env).filter((e) => e[1] != null));
+        let response = "";
+        try {
+            const allMcpServers = { ...this.mcpServers };
+            if (sdkTools.length > 0)
+                allMcpServers["sweny-core"] = mcpServer;
+            const stream = query({
+                prompt,
+                options: {
+                    maxTurns: this.maxTurns,
+                    systemPrompt: SYSTEM_PROMPT,
+                    cwd: this.cwd,
+                    env,
+                    permissionMode: "bypassPermissions",
+                    ...(this.model ? { model: this.model } : {}),
+                    ...(Object.keys(allMcpServers).length > 0 ? { mcpServers: allMcpServers } : {}),
+                },
+            });
+            for await (const message of stream) {
+                if (message.type === "result") {
+                    const resultMsg = message;
+                    if (resultMsg.subtype === "success" && "result" in resultMsg) {
+                        response = resultMsg.result;
+                    }
+                    else if ("errors" in resultMsg) {
+                        const errors = resultMsg.errors;
+                        return {
+                            status: "failed",
+                            data: { error: errors?.join("\n") ?? "Execution failed" },
+                            toolCalls,
+                        };
+                    }
+                }
+            }
+        }
+        catch (err) {
+            this.logger.error(`Claude Code query failed: ${err.message}`);
+            return {
+                status: "failed",
+                data: { error: err.message },
+                toolCalls,
+            };
+        }
+        return {
+            status: "success",
+            data: { summary: response, ...tryParseJSON(response) },
+            toolCalls,
+        };
+    }
+    async evaluate(opts) {
+        const { question, context, choices } = opts;
+        const choiceList = choices.map((c) => `- "${c.id}": ${c.description}`).join("\n");
+        const prompt = [
+            question,
+            `\nContext:\n\`\`\`json\n${JSON.stringify(context, null, 2)}\n\`\`\``,
+            `\nChoices:\n${choiceList}`,
+            `\nRespond with ONLY the choice ID, nothing else.`,
+        ].join("\n");
+        const env = Object.fromEntries(Object.entries(process.env).filter((e) => e[1] != null));
+        let response = "";
+        try {
+            const stream = query({
+                prompt,
+                options: {
+                    maxTurns: 1,
+                    cwd: this.cwd,
+                    env,
+                    permissionMode: "bypassPermissions",
+                    ...(this.model ? { model: this.model } : {}),
+                },
+            });
+            for await (const message of stream) {
+                if (message.type === "result") {
+                    const resultMsg = message;
+                    if (resultMsg.subtype === "success" && "result" in resultMsg) {
+                        response = resultMsg.result;
+                    }
+                }
+            }
+        }
+        catch (err) {
+            this.logger.warn(`Evaluate query failed: ${err.message}. Falling back to first choice.`);
+            return choices[0].id;
+        }
+        const text = response.trim().replace(/^["']|["']$/g, "");
+        const validIds = choices.map((c) => c.id);
+        // Exact match
+        if (validIds.includes(text))
+            return text;
+        // Fuzzy — look for an ID embedded in the response
+        const match = validIds.find((id) => text.includes(id));
+        if (match)
+            return match;
+        // Fallback
+        this.logger.warn(`Could not parse route choice from: "${text.slice(0, 100)}". Falling back to first choice.`);
+        return validIds[0];
+    }
+}
+// ─── Tool conversion ────────────────────────────────────────────
+/**
+ * Convert a core Tool to an SDK MCP tool definition.
+ * Bridges JSON Schema → Zod and wraps the handler to return CallToolResult.
+ */
+function coreToolToSdkTool(coreTool, defaultCtx, toolCalls) {
+    const zodShape = jsonSchemaToZodShape(coreTool.input_schema);
+    return sdkTool(coreTool.name, coreTool.description, zodShape, async (args) => {
+        try {
+            // The executor wraps handlers to inject ToolContext.
+            // When used standalone, defaultCtx is the fallback.
+            const output = await coreTool.handler(args, defaultCtx);
+            toolCalls.push({ tool: coreTool.name, input: args, output });
+            return {
+                content: [{ type: "text", text: typeof output === "string" ? output : JSON.stringify(output) }],
+            };
+        }
+        catch (err) {
+            toolCalls.push({ tool: coreTool.name, input: args, output: { error: err.message } });
+            return {
+                content: [{ type: "text", text: `Error: ${err.message}` }],
+                isError: true,
+            };
+        }
+    });
+}
+// ─── JSON Schema → Zod conversion ───────────────────────────────
+/**
+ * Convert a JSON Schema object to a Zod raw shape for the agent SDK.
+ * Preserves property names, types, and descriptions so Claude sees
+ * accurate tool parameters through the MCP protocol.
+ */
+function jsonSchemaToZodShape(schema) {
+    const props = schema?.properties ?? {};
+    const required = new Set(schema?.required ?? []);
+    const shape = {};
+    for (const [key, prop] of Object.entries(props)) {
+        let zodType = jsonPropertyToZod(prop);
+        if (!required.has(key)) {
+            zodType = zodType.optional();
+        }
+        shape[key] = zodType;
+    }
+    return shape;
+}
+function jsonPropertyToZod(prop) {
+    if (!prop || typeof prop !== "object")
+        return z.unknown();
+    const desc = typeof prop.description === "string" ? prop.description : undefined;
+    switch (prop.type) {
+        case "string": {
+            if (prop.enum && Array.isArray(prop.enum)) {
+                const e = z.enum(prop.enum);
+                return desc ? e.describe(desc) : e;
+            }
+            const s = z.string();
+            return desc ? s.describe(desc) : s;
+        }
+        case "number":
+        case "integer": {
+            const n = z.number();
+            return desc ? n.describe(desc) : n;
+        }
+        case "boolean": {
+            const b = z.boolean();
+            return desc ? b.describe(desc) : b;
+        }
+        case "array": {
+            const items = prop.items ? jsonPropertyToZod(prop.items) : z.unknown();
+            const a = z.array(items);
+            return desc ? a.describe(desc) : a;
+        }
+        case "object": {
+            if (prop.properties && typeof prop.properties === "object") {
+                const nested = jsonSchemaToZodShape(prop);
+                const o = z.object(nested);
+                return desc ? o.describe(desc) : o;
+            }
+            const r = z.record(z.string(), z.unknown());
+            return desc ? r.describe(desc) : r;
+        }
+        default: {
+            const u = z.unknown();
+            return desc ? u.describe(desc) : u;
+        }
+    }
+}
+// ─── JSON extraction ────────────────────────────────────────────
+/**
+ * Extract a JSON object from Claude's text response.
+ *
+ * Strategy (in order):
+ * 1. ```json code block``` — most reliable, Claude often wraps JSON this way
+ * 2. Last brace-delimited `{...}` block — handles inline JSON at end of text
+ * 3. Full text parse — for responses that are pure JSON
+ * 4. Empty object — safe fallback
+ */
+function tryParseJSON(text) {
+    if (!text)
+        return {};
+    // 1. Code block
+    const codeBlockMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+    if (codeBlockMatch) {
+        try {
+            const parsed = JSON.parse(codeBlockMatch[1].trim());
+            if (typeof parsed === "object" && parsed !== null)
+                return parsed;
+        }
+        catch {
+            /* try next strategy */
+        }
+    }
+    // 2. Last brace-delimited block (scan backwards for matching braces)
+    const lastBrace = text.lastIndexOf("}");
+    if (lastBrace !== -1) {
+        let depth = 0;
+        for (let i = lastBrace; i >= 0; i--) {
+            if (text[i] === "}")
+                depth++;
+            else if (text[i] === "{")
+                depth--;
+            if (depth === 0) {
+                try {
+                    const parsed = JSON.parse(text.slice(i, lastBrace + 1));
+                    if (typeof parsed === "object" && parsed !== null)
+                        return parsed;
+                }
+                catch {
+                    /* try next strategy */
+                }
+                break;
+            }
+        }
+    }
+    // 3. Full text parse
+    try {
+        const parsed = JSON.parse(text.trim());
+        if (typeof parsed === "object" && parsed !== null)
+            return parsed;
+    }
+    catch {
+        /* fall through */
+    }
+    return {};
+}

package/dist/cli/check.d.ts

@@ -0,0 +1,11 @@
+import type { CliConfig } from "./config.js";
+export interface CheckResult {
+    name: string;
+    status: "ok" | "fail" | "skip";
+    detail: string;
+}
+/**
+ * Run lightweight connectivity checks for all configured providers.
+ * Uses raw fetch — does NOT import provider packages.
+ */
+export declare function checkProviderConnectivity(config: CliConfig): Promise<CheckResult[]>;