@sweny-ai/core 0.1.0

package/dist/skills/notification.js

@@ -0,0 +1,142 @@
+/**
+ * Notification Skill — generic webhook / multi-channel
+ *
+ * Replaces: notification/webhook.ts + notification/discord-webhook.ts +
+ *           notification/email.ts + notification/teams-webhook.ts
+ *
+ * For Slack-specific notifications, use the Slack skill instead.
+ * This skill handles generic webhooks, Discord, Teams, and email.
+ */
+export const notification = {
+    id: "notification",
+    name: "Notification",
+    description: "Send notifications via webhook, Discord, Teams, or email",
+    category: "notification",
+    config: {
+        NOTIFICATION_WEBHOOK_URL: {
+            description: "Generic webhook URL for notifications",
+            required: false,
+            env: "NOTIFICATION_WEBHOOK_URL",
+        },
+        DISCORD_WEBHOOK_URL: {
+            description: "Discord webhook URL",
+            required: false,
+            env: "DISCORD_WEBHOOK_URL",
+        },
+        TEAMS_WEBHOOK_URL: {
+            description: "Microsoft Teams webhook URL",
+            required: false,
+            env: "TEAMS_WEBHOOK_URL",
+        },
+        SMTP_URL: {
+            description: "SMTP connection URL for email notifications",
+            required: false,
+            env: "SMTP_URL",
+        },
+    },
+    tools: [
+        {
+            name: "notify_webhook",
+            description: "Send a JSON payload to a webhook URL",
+            input_schema: {
+                type: "object",
+                properties: {
+                    url: { type: "string", description: "Webhook URL (overrides NOTIFICATION_WEBHOOK_URL)" },
+                    payload: { type: "object", description: "JSON payload to send" },
+                },
+                required: ["payload"],
+            },
+            handler: async (input, ctx) => {
+                const url = input.url ?? ctx.config.NOTIFICATION_WEBHOOK_URL;
+                if (!url)
+                    throw new Error("No webhook URL provided or configured");
+                const res = await fetch(url, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify(input.payload),
+                    signal: AbortSignal.timeout(30_000),
+                });
+                if (!res.ok)
+                    throw new Error(`[Notification] webhook failed (HTTP ${res.status}): ${await res.text()}`);
+                return { ok: true, status: res.status };
+            },
+        },
+        {
+            name: "notify_discord",
+            description: "Send a message to Discord via webhook",
+            input_schema: {
+                type: "object",
+                properties: {
+                    content: { type: "string", description: "Message text" },
+                    embeds: {
+                        type: "array",
+                        description: "Discord embed objects for rich formatting",
+                        items: {
+                            type: "object",
+                            properties: {
+                                title: { type: "string" },
+                                description: { type: "string" },
+                                color: { type: "number", description: "Embed color (decimal)" },
+                                fields: {
+                                    type: "array",
+                                    items: {
+                                        type: "object",
+                                        properties: {
+                                            name: { type: "string" },
+                                            value: { type: "string" },
+                                            inline: { type: "boolean" },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+            handler: async (input, ctx) => {
+                if (!ctx.config.DISCORD_WEBHOOK_URL)
+                    throw new Error("[Notification] DISCORD_WEBHOOK_URL not configured");
+                const res = await fetch(ctx.config.DISCORD_WEBHOOK_URL, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({ content: input.content, embeds: input.embeds }),
+                    signal: AbortSignal.timeout(30_000),
+                });
+                if (!res.ok)
+                    throw new Error(`[Notification] Discord webhook failed (HTTP ${res.status}): ${await res.text()}`);
+                return { ok: true };
+            },
+        },
+        {
+            name: "notify_teams",
+            description: "Send a message to Microsoft Teams via webhook",
+            input_schema: {
+                type: "object",
+                properties: {
+                    title: { type: "string", description: "Card title" },
+                    text: { type: "string", description: "Card body (markdown)" },
+                    themeColor: { type: "string", description: "Hex color for the card accent" },
+                },
+                required: ["text"],
+            },
+            handler: async (input, ctx) => {
+                if (!ctx.config.TEAMS_WEBHOOK_URL)
+                    throw new Error("[Notification] TEAMS_WEBHOOK_URL not configured");
+                const res = await fetch(ctx.config.TEAMS_WEBHOOK_URL, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({
+                        "@type": "MessageCard",
+                        themeColor: input.themeColor ?? "0076D7",
+                        title: input.title,
+                        text: input.text,
+                    }),
+                    signal: AbortSignal.timeout(30_000),
+                });
+                if (!res.ok)
+                    throw new Error(`[Notification] Teams webhook failed (HTTP ${res.status}): ${await res.text()}`);
+                return { ok: true };
+            },
+        },
+    ],
+};

package/dist/skills/sentry.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Sentry Skill
+ *
+ * Replaces: observability/sentry.ts
+ */
+import type { Skill } from "../types.js";
+export declare const sentry: Skill;

package/dist/skills/sentry.js

@@ -0,0 +1,105 @@
+/**
+ * Sentry Skill
+ *
+ * Replaces: observability/sentry.ts
+ */
+async function sentryApi(path, ctx) {
+    const base = ctx.config.SENTRY_BASE_URL || "https://sentry.io";
+    const res = await fetch(`${base}/api/0${path}`, {
+        headers: { Authorization: `Bearer ${ctx.config.SENTRY_AUTH_TOKEN}` },
+        signal: AbortSignal.timeout(30_000),
+    });
+    if (!res.ok)
+        throw new Error(`[Sentry] API request failed (HTTP ${res.status}): ${await res.text()}`);
+    return res.json();
+}
+export const sentry = {
+    id: "sentry",
+    name: "Sentry",
+    description: "Query errors, issues, and performance data from Sentry",
+    category: "observability",
+    config: {
+        SENTRY_AUTH_TOKEN: {
+            description: "Sentry authentication token",
+            required: true,
+            env: "SENTRY_AUTH_TOKEN",
+        },
+        SENTRY_ORG: {
+            description: "Sentry organization slug",
+            required: true,
+            env: "SENTRY_ORG",
+        },
+        SENTRY_BASE_URL: {
+            description: "Sentry base URL (default: https://sentry.io)",
+            required: false,
+            env: "SENTRY_BASE_URL",
+        },
+    },
+    tools: [
+        {
+            name: "sentry_list_issues",
+            description: "List recent issues for a Sentry project",
+            input_schema: {
+                type: "object",
+                properties: {
+                    project: { type: "string", description: "Sentry project slug" },
+                    query: { type: "string", description: "Search query (e.g., 'is:unresolved level:error')" },
+                },
+                required: ["project"],
+            },
+            handler: async (input, ctx) => {
+                const q = encodeURIComponent(input.query ?? "is:unresolved");
+                return sentryApi(`/projects/${ctx.config.SENTRY_ORG}/${input.project}/issues/?query=${q}`, ctx);
+            },
+        },
+        {
+            name: "sentry_get_issue",
+            description: "Get detailed information about a Sentry issue",
+            input_schema: {
+                type: "object",
+                properties: {
+                    issueId: { type: "string", description: "Sentry issue ID" },
+                },
+                required: ["issueId"],
+            },
+            handler: async (input, ctx) => sentryApi(`/issues/${input.issueId}/`, ctx),
+        },
+        {
+            name: "sentry_get_issue_events",
+            description: "Get recent events (occurrences) for a Sentry issue",
+            input_schema: {
+                type: "object",
+                properties: {
+                    issueId: { type: "string", description: "Sentry issue ID" },
+                },
+                required: ["issueId"],
+            },
+            handler: async (input, ctx) => sentryApi(`/issues/${input.issueId}/events/?full=true`, ctx),
+        },
+        {
+            name: "sentry_search_events",
+            description: "Search events across a project using Discover query syntax",
+            input_schema: {
+                type: "object",
+                properties: {
+                    project: { type: "string", description: "Sentry project slug" },
+                    query: { type: "string", description: "Discover query" },
+                    fields: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Fields to return (e.g., ['title', 'count()', 'last_seen()'])",
+                    },
+                },
+                required: ["project", "fields"],
+            },
+            handler: async (input, ctx) => {
+                const params = new URLSearchParams();
+                if (input.query)
+                    params.set("query", input.query);
+                for (const f of input.fields)
+                    params.append("field", f);
+                return sentryApi(`/organizations/${ctx.config.SENTRY_ORG}/events/?project=${input.project}&${params}`, ctx);
+            },
+        },
+    ],
+};

package/dist/skills/slack.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Slack Skill
+ *
+ * Replaces: notification/slack-webhook.ts + messaging/slack.ts
+ * Two separate provider modules → one skill with simple tools
+ */
+import type { Skill } from "../types.js";
+export declare const slack: Skill;

package/dist/skills/slack.js

@@ -0,0 +1,115 @@
+/**
+ * Slack Skill
+ *
+ * Replaces: notification/slack-webhook.ts + messaging/slack.ts
+ * Two separate provider modules → one skill with simple tools
+ */
+export const slack = {
+    id: "slack",
+    name: "Slack",
+    description: "Send messages and notifications to Slack channels",
+    category: "notification",
+    config: {
+        SLACK_WEBHOOK_URL: {
+            description: "Slack incoming webhook URL",
+            required: false,
+            env: "SLACK_WEBHOOK_URL",
+        },
+        SLACK_BOT_TOKEN: {
+            description: "Slack bot token (for API calls)",
+            required: false,
+            env: "SLACK_BOT_TOKEN",
+        },
+    },
+    tools: [
+        {
+            name: "slack_send_message",
+            description: "Send a message to a Slack channel via webhook or API",
+            input_schema: {
+                type: "object",
+                properties: {
+                    text: { type: "string", description: "Message text (Slack mrkdwn supported)" },
+                    channel: { type: "string", description: "Channel ID or name (required for API, ignored for webhook)" },
+                    blocks: {
+                        type: "array",
+                        description: "Optional Block Kit blocks for rich formatting",
+                        items: { type: "object" },
+                    },
+                },
+                required: ["text"],
+            },
+            handler: async (input, ctx) => {
+                // Prefer bot token API for channel targeting; fall back to webhook
+                if (ctx.config.SLACK_BOT_TOKEN && input.channel) {
+                    const res = await fetch("https://slack.com/api/chat.postMessage", {
+                        method: "POST",
+                        headers: {
+                            Authorization: `Bearer ${ctx.config.SLACK_BOT_TOKEN}`,
+                            "Content-Type": "application/json",
+                        },
+                        body: JSON.stringify({
+                            channel: input.channel,
+                            text: input.text,
+                            blocks: input.blocks,
+                        }),
+                        signal: AbortSignal.timeout(30_000),
+                    });
+                    if (!res.ok)
+                        throw new Error(`[Slack] send_message failed (HTTP ${res.status}): ${await res.text()}`);
+                    const data = await res.json();
+                    if (!data.ok)
+                        throw new Error(`[Slack] send_message failed: ${data.error ?? "unknown error"}`);
+                    return data;
+                }
+                if (ctx.config.SLACK_WEBHOOK_URL) {
+                    const res = await fetch(ctx.config.SLACK_WEBHOOK_URL, {
+                        method: "POST",
+                        headers: { "Content-Type": "application/json" },
+                        body: JSON.stringify({ text: input.text, blocks: input.blocks }),
+                        signal: AbortSignal.timeout(30_000),
+                    });
+                    if (!res.ok)
+                        throw new Error(`[Slack] webhook failed (HTTP ${res.status}): ${await res.text()}`);
+                    return { ok: true };
+                }
+                throw new Error("No Slack credentials configured (need SLACK_WEBHOOK_URL or SLACK_BOT_TOKEN)");
+            },
+        },
+        {
+            name: "slack_send_thread_reply",
+            description: "Reply to an existing Slack message thread",
+            input_schema: {
+                type: "object",
+                properties: {
+                    channel: { type: "string", description: "Channel ID" },
+                    thread_ts: { type: "string", description: "Parent message timestamp" },
+                    text: { type: "string" },
+                },
+                required: ["channel", "thread_ts", "text"],
+            },
+            handler: async (input, ctx) => {
+                if (!ctx.config.SLACK_BOT_TOKEN)
+                    throw new Error("[Slack] thread replies require SLACK_BOT_TOKEN");
+                const res = await fetch("https://slack.com/api/chat.postMessage", {
+                    method: "POST",
+                    headers: {
+                        Authorization: `Bearer ${ctx.config.SLACK_BOT_TOKEN}`,
+                        "Content-Type": "application/json",
+                    },
+                    body: JSON.stringify({
+                        channel: input.channel,
+                        thread_ts: input.thread_ts,
+                        text: input.text,
+                    }),
+                    signal: AbortSignal.timeout(30_000),
+                });
+                if (!res.ok)
+                    throw new Error(`[Slack] thread_reply failed (HTTP ${res.status}): ${await res.text()}`);
+                const data = await res.json();
+                if (!data.ok)
+                    throw new Error(`[Slack] thread_reply failed: ${data.error ?? "unknown error"}`);
+                return data;
+            },
+        },
+    ],
+};

package/dist/studio.d.ts

@@ -0,0 +1,124 @@
+/**
+ * Studio Adapter
+ *
+ * Converts between @sweny-ai/core Workflow types and React Flow
+ * graph structures. This replaces definition-to-flow.ts in the
+ * old Studio — and it's dramatically simpler because our Workflow
+ * type already uses explicit nodes + edges (not next/on routing).
+ *
+ * Old Studio flow:
+ *   WorkflowDefinition → extractTransitions() → build nodes → build edges → ELK
+ *   (94 lines of conversion code)
+ *
+ * New Studio flow:
+ *   Workflow → workflowToFlow()
+ *   (direct mapping — edges are already explicit)
+ *
+ * The big wins for Studio in the new model:
+ *
+ * 1. NO CONVERSION LAYER — Workflow.nodes → React Flow nodes,
+ *    Workflow.edges → React Flow edges. It's a 1:1 map.
+ *
+ * 2. SKILL CATALOG in the properties panel — instead of picking
+ *    from "phase" and "uses" (provider roles), users browse a
+ *    skill catalog and toggle which skills are available at each node.
+ *
+ * 3. INSTRUCTION EDITOR — each node has a rich-text instruction
+ *    instead of a one-line description. This is what Claude actually
+ *    reads, so WYSIWYG.
+ *
+ * 4. NATURAL LANGUAGE EDGE CONDITIONS — instead of "outcome → target"
+ *    with magic string outcomes, edges have human-readable `when`
+ *    clauses like "severity is high or critical".
+ *
+ * 5. OUTPUT SCHEMA EDITOR — optional JSON schema per node for
+ *    structured output. Studio could render this as a form builder.
+ *
+ * 6. LIVE EXECUTION OVERLAY — the event stream from execute() maps
+ *    directly to node highlights. node:enter → glow blue,
+ *    tool:call → show tool name, node:exit → green/red.
+ */
+import type { Workflow, Node, ExecutionEvent, NodeResult, Skill } from "./types.js";
+export interface FlowNode {
+    id: string;
+    type: "skillNode";
+    position: {
+        x: number;
+        y: number;
+    };
+    data: SkillNodeData;
+}
+export interface SkillNodeData {
+    nodeId: string;
+    node: Node;
+    isEntry: boolean;
+    isTerminal: boolean;
+    /** Resolved skill metadata for the node's skill IDs */
+    skills: {
+        id: string;
+        name: string;
+        toolCount: number;
+    }[];
+    /** Execution state (for live/simulate mode) */
+    exec: {
+        status: "pending" | "running" | "success" | "failed" | "skipped";
+        result?: NodeResult;
+        currentTool?: string;
+    };
+}
+export interface FlowEdge {
+    id: string;
+    source: string;
+    target: string;
+    type: "conditionEdge";
+    data: {
+        when?: string;
+        isConditional: boolean;
+    };
+}
+/**
+ * Convert a Workflow to React Flow nodes + edges.
+ *
+ * This is the entire conversion layer — compare to the old
+ * definitionToFlow() which had to parse next/on routing into edges.
+ */
+export declare function workflowToFlow(workflow: Workflow, skillCatalog?: Skill[]): {
+    nodes: FlowNode[];
+    edges: FlowEdge[];
+};
+/**
+ * Apply an execution event to the flow state.
+ * Returns a function that mutates SkillNodeData in place (for Zustand/immer).
+ */
+export declare function applyExecutionEvent(event: ExecutionEvent, nodeDataMap: Map<string, SkillNodeData>): void;
+/**
+ * Convert React Flow state back to a Workflow.
+ * This is what "Export" / "Save" does in Studio.
+ */
+export declare function flowToWorkflow(meta: {
+    id: string;
+    name: string;
+    description: string;
+    entry: string;
+}, nodes: FlowNode[], edges: FlowEdge[]): Workflow;
+/**
+ * Generate a TypeScript file from a Workflow definition.
+ *
+ * Compare to the old exportAsTypescript() which generated step
+ * implementation stubs. The new export is just the workflow
+ * definition — Claude does the implementation.
+ */
+export declare function exportAsTypescript(workflow: Workflow): string;
+/**
+ * Skill catalog for the Studio properties panel.
+ * Returns all available skills with their tool lists.
+ */
+export declare function getSkillCatalog(extraSkills?: Skill[]): {
+    id: string;
+    name: string;
+    description: string;
+    tools: {
+        name: string;
+        description: string;
+    }[];
+}[];

package/dist/studio.js

@@ -0,0 +1,174 @@
+/**
+ * Studio Adapter
+ *
+ * Converts between @sweny-ai/core Workflow types and React Flow
+ * graph structures. This replaces definition-to-flow.ts in the
+ * old Studio — and it's dramatically simpler because our Workflow
+ * type already uses explicit nodes + edges (not next/on routing).
+ *
+ * Old Studio flow:
+ *   WorkflowDefinition → extractTransitions() → build nodes → build edges → ELK
+ *   (94 lines of conversion code)
+ *
+ * New Studio flow:
+ *   Workflow → workflowToFlow()
+ *   (direct mapping — edges are already explicit)
+ *
+ * The big wins for Studio in the new model:
+ *
+ * 1. NO CONVERSION LAYER — Workflow.nodes → React Flow nodes,
+ *    Workflow.edges → React Flow edges. It's a 1:1 map.
+ *
+ * 2. SKILL CATALOG in the properties panel — instead of picking
+ *    from "phase" and "uses" (provider roles), users browse a
+ *    skill catalog and toggle which skills are available at each node.
+ *
+ * 3. INSTRUCTION EDITOR — each node has a rich-text instruction
+ *    instead of a one-line description. This is what Claude actually
+ *    reads, so WYSIWYG.
+ *
+ * 4. NATURAL LANGUAGE EDGE CONDITIONS — instead of "outcome → target"
+ *    with magic string outcomes, edges have human-readable `when`
+ *    clauses like "severity is high or critical".
+ *
+ * 5. OUTPUT SCHEMA EDITOR — optional JSON schema per node for
+ *    structured output. Studio could render this as a form builder.
+ *
+ * 6. LIVE EXECUTION OVERLAY — the event stream from execute() maps
+ *    directly to node highlights. node:enter → glow blue,
+ *    tool:call → show tool name, node:exit → green/red.
+ */
+import { builtinSkills } from "./skills/index.js";
+// ─── Conversion ──────────────────────────────────────────────────
+/**
+ * Convert a Workflow to React Flow nodes + edges.
+ *
+ * This is the entire conversion layer — compare to the old
+ * definitionToFlow() which had to parse next/on routing into edges.
+ */
+export function workflowToFlow(workflow, skillCatalog = builtinSkills) {
+    const skillMap = new Map(skillCatalog.map((s) => [s.id, s]));
+    const terminalIds = findTerminals(workflow);
+    const nodes = Object.entries(workflow.nodes).map(([id, node]) => ({
+        id,
+        type: "skillNode",
+        position: { x: 0, y: 0 }, // ELK will compute real positions
+        data: {
+            nodeId: id,
+            node,
+            isEntry: id === workflow.entry,
+            isTerminal: terminalIds.has(id),
+            skills: node.skills.map((sid) => {
+                const skill = skillMap.get(sid);
+                return {
+                    id: sid,
+                    name: skill?.name ?? sid,
+                    toolCount: skill?.tools.length ?? 0,
+                };
+            }),
+            exec: { status: "pending" },
+        },
+    }));
+    const edges = workflow.edges.map((edge) => ({
+        id: `${edge.from}--${edge.to}`,
+        source: edge.from,
+        target: edge.to,
+        type: "conditionEdge",
+        data: {
+            when: edge.when,
+            isConditional: !!edge.when,
+        },
+    }));
+    return { nodes, edges };
+}
+/**
+ * Apply an execution event to the flow state.
+ * Returns a function that mutates SkillNodeData in place (for Zustand/immer).
+ */
+export function applyExecutionEvent(event, nodeDataMap) {
+    switch (event.type) {
+        case "workflow:start":
+            for (const data of nodeDataMap.values()) {
+                data.exec = { status: "pending" };
+            }
+            break;
+        case "node:enter": {
+            const data = nodeDataMap.get(event.node);
+            if (data)
+                data.exec = { status: "running" };
+            break;
+        }
+        case "tool:call": {
+            const data = nodeDataMap.get(event.node);
+            if (data)
+                data.exec.currentTool = event.tool;
+            break;
+        }
+        case "tool:result": {
+            const data = nodeDataMap.get(event.node);
+            if (data)
+                data.exec.currentTool = undefined;
+            break;
+        }
+        case "node:exit": {
+            const data = nodeDataMap.get(event.node);
+            if (data) {
+                data.exec = {
+                    status: event.result.status === "success" ? "success" : "failed",
+                    result: event.result,
+                };
+            }
+            break;
+        }
+    }
+}
+// ─── Reverse conversion (Studio → Workflow) ──────────────────────
+/**
+ * Convert React Flow state back to a Workflow.
+ * This is what "Export" / "Save" does in Studio.
+ */
+export function flowToWorkflow(meta, nodes, edges) {
+    return {
+        id: meta.id,
+        name: meta.name,
+        description: meta.description,
+        entry: meta.entry,
+        nodes: Object.fromEntries(nodes.map((n) => [n.id, n.data.node])),
+        edges: edges.map((e) => ({
+            from: e.source,
+            to: e.target,
+            ...(e.data.when ? { when: e.data.when } : {}),
+        })),
+    };
+}
+// ─── Helpers ─────────────────────────────────────────────────────
+function findTerminals(workflow) {
+    const hasOutgoing = new Set(workflow.edges.map((e) => e.from));
+    return new Set(Object.keys(workflow.nodes).filter((id) => !hasOutgoing.has(id)));
+}
+/**
+ * Generate a TypeScript file from a Workflow definition.
+ *
+ * Compare to the old exportAsTypescript() which generated step
+ * implementation stubs. The new export is just the workflow
+ * definition — Claude does the implementation.
+ */
+export function exportAsTypescript(workflow) {
+    const varName = workflow.id.replace(/[^a-zA-Z0-9]/g, "_");
+    return `import type { Workflow } from "@sweny-ai/core";
+
+export const ${varName}: Workflow = ${JSON.stringify(workflow, null, 2)};
+`;
+}
+/**
+ * Skill catalog for the Studio properties panel.
+ * Returns all available skills with their tool lists.
+ */
+export function getSkillCatalog(extraSkills = []) {
+    return [...builtinSkills, ...extraSkills].map((s) => ({
+        id: s.id,
+        name: s.name,
+        description: s.description,
+        tools: s.tools.map((t) => ({ name: t.name, description: t.description })),
+    }));
+}