@sweny-ai/core 0.1.0

package/dist/skills/datadog.js

@@ -0,0 +1,107 @@
+/**
+ * Datadog Skill
+ *
+ * Replaces: observability/datadog.ts
+ */
+async function ddApi(path, ctx, init) {
+    const base = ctx.config.DD_SITE ? `https://api.${ctx.config.DD_SITE}` : "https://api.datadoghq.com";
+    const version = init?.v2 ? "v2" : "v1";
+    const res = await fetch(`${base}/api/${version}${path}`, {
+        ...init,
+        headers: {
+            "DD-API-KEY": ctx.config.DD_API_KEY,
+            "DD-APPLICATION-KEY": ctx.config.DD_APP_KEY,
+            "Content-Type": "application/json",
+            ...init?.headers,
+        },
+        signal: AbortSignal.timeout(30_000),
+    });
+    if (!res.ok)
+        throw new Error(`[Datadog] API request failed (HTTP ${res.status}): ${await res.text()}`);
+    return res.json();
+}
+export const datadog = {
+    id: "datadog",
+    name: "Datadog",
+    description: "Query logs, metrics, and monitors from Datadog",
+    category: "observability",
+    config: {
+        DD_API_KEY: {
+            description: "Datadog API key",
+            required: true,
+            env: "DD_API_KEY",
+        },
+        DD_APP_KEY: {
+            description: "Datadog application key",
+            required: true,
+            env: "DD_APP_KEY",
+        },
+        DD_SITE: {
+            description: "Datadog site (e.g., datadoghq.eu). Default: datadoghq.com",
+            required: false,
+            env: "DD_SITE",
+        },
+    },
+    tools: [
+        {
+            name: "datadog_search_logs",
+            description: "Search logs in Datadog",
+            input_schema: {
+                type: "object",
+                properties: {
+                    query: { type: "string", description: "Log search query (Datadog syntax)" },
+                    from: { type: "string", description: "Start time (ISO 8601 or relative like 'now-1h')" },
+                    to: { type: "string", description: "End time (default: now)" },
+                    limit: { type: "number", description: "Max results (default: 50)" },
+                },
+                required: ["query"],
+            },
+            handler: async (input, ctx) => ddApi("/logs/events/search", ctx, {
+                method: "POST",
+                v2: true,
+                body: JSON.stringify({
+                    filter: {
+                        query: input.query,
+                        from: input.from ?? "now-1h",
+                        to: input.to ?? "now",
+                    },
+                    page: { limit: input.limit ?? 50 },
+                    sort: "-timestamp",
+                }),
+            }),
+        },
+        {
+            name: "datadog_query_metrics",
+            description: "Query time-series metrics from Datadog",
+            input_schema: {
+                type: "object",
+                properties: {
+                    query: { type: "string", description: "Metrics query (e.g., 'avg:system.cpu.user{*}')" },
+                    from: { type: "number", description: "Start time (UNIX epoch seconds)" },
+                    to: { type: "number", description: "End time (UNIX epoch seconds)" },
+                },
+                required: ["query", "from", "to"],
+            },
+            handler: async (input, ctx) => ddApi(`/query?query=${encodeURIComponent(input.query)}&from=${input.from}&to=${input.to}`, ctx),
+        },
+        {
+            name: "datadog_list_monitors",
+            description: "List Datadog monitors, optionally filtered by tag or name",
+            input_schema: {
+                type: "object",
+                properties: {
+                    name: { type: "string", description: "Filter by monitor name (substring match)" },
+                    tags: { type: "string", description: "Comma-separated tags to filter by" },
+                },
+            },
+            handler: async (input, ctx) => {
+                const params = new URLSearchParams();
+                if (input.name)
+                    params.set("name", input.name);
+                if (input.tags)
+                    params.set("monitor_tags", input.tags);
+                return ddApi(`/monitor?${params}`, ctx);
+            },
+        },
+    ],
+};

package/dist/skills/github.d.ts

@@ -0,0 +1,8 @@
+/**
+ * GitHub Skill
+ *
+ * Replaces: source-control/github.ts + issue-tracking/github-issues.ts
+ * ~800 lines → ~120 lines
+ */
+import type { Skill } from "../types.js";
+export declare const github: Skill;

package/dist/skills/github.js

@@ -0,0 +1,155 @@
+/**
+ * GitHub Skill
+ *
+ * Replaces: source-control/github.ts + issue-tracking/github-issues.ts
+ * ~800 lines → ~120 lines
+ */
+async function gh(path, ctx, init) {
+    const res = await fetch(`https://api.github.com${path}`, {
+        ...init,
+        headers: {
+            Authorization: `token ${ctx.config.GITHUB_TOKEN}`,
+            Accept: "application/vnd.github.v3+json",
+            "Content-Type": "application/json",
+            ...init?.headers,
+        },
+        signal: AbortSignal.timeout(30_000),
+    });
+    if (!res.ok)
+        throw new Error(`[GitHub] API request failed (HTTP ${res.status}): ${await res.text()}`);
+    return res.json();
+}
+export const github = {
+    id: "github",
+    name: "GitHub",
+    description: "Search code, manage issues and pull requests on GitHub",
+    category: "git",
+    config: {
+        GITHUB_TOKEN: {
+            description: "GitHub personal access token or app installation token",
+            required: true,
+            env: "GITHUB_TOKEN",
+        },
+    },
+    tools: [
+        {
+            name: "github_search_code",
+            description: "Search for code in a GitHub repository",
+            input_schema: {
+                type: "object",
+                properties: {
+                    query: { type: "string", description: "Search query (GitHub code search syntax)" },
+                    repo: { type: "string", description: "Repository in owner/repo format" },
+                },
+                required: ["query", "repo"],
+            },
+            handler: async (input, ctx) => gh(`/search/code?q=${encodeURIComponent(`${input.query} repo:${input.repo}`)}&per_page=20`, ctx),
+        },
+        {
+            name: "github_get_issue",
+            description: "Get details of a GitHub issue",
+            input_schema: {
+                type: "object",
+                properties: {
+                    repo: { type: "string", description: "owner/repo" },
+                    number: { type: "number", description: "Issue number" },
+                },
+                required: ["repo", "number"],
+            },
+            handler: async (input, ctx) => gh(`/repos/${input.repo}/issues/${input.number}`, ctx),
+        },
+        {
+            name: "github_search_issues",
+            description: "Search issues and pull requests",
+            input_schema: {
+                type: "object",
+                properties: {
+                    query: { type: "string", description: "Search query (GitHub issues search syntax)" },
+                    repo: { type: "string", description: "owner/repo — optional, scope to a repo" },
+                },
+                required: ["query"],
+            },
+            handler: async (input, ctx) => {
+                const q = input.repo ? `${input.query} repo:${input.repo}` : input.query;
+                return gh(`/search/issues?q=${encodeURIComponent(q)}&per_page=20`, ctx);
+            },
+        },
+        {
+            name: "github_create_issue",
+            description: "Create a new GitHub issue",
+            input_schema: {
+                type: "object",
+                properties: {
+                    repo: { type: "string", description: "owner/repo" },
+                    title: { type: "string" },
+                    body: { type: "string" },
+                    labels: { type: "array", items: { type: "string" } },
+                },
+                required: ["repo", "title"],
+            },
+            handler: async (input, ctx) => gh(`/repos/${input.repo}/issues`, ctx, {
+                method: "POST",
+                body: JSON.stringify({ title: input.title, body: input.body, labels: input.labels }),
+            }),
+        },
+        {
+            name: "github_create_pr",
+            description: "Create a pull request",
+            input_schema: {
+                type: "object",
+                properties: {
+                    repo: { type: "string", description: "owner/repo" },
+                    title: { type: "string" },
+                    body: { type: "string" },
+                    head: { type: "string", description: "Branch with changes" },
+                    base: { type: "string", description: "Target branch (default: main)" },
+                },
+                required: ["repo", "title", "head"],
+            },
+            handler: async (input, ctx) => gh(`/repos/${input.repo}/pulls`, ctx, {
+                method: "POST",
+                body: JSON.stringify({
+                    title: input.title,
+                    body: input.body,
+                    head: input.head,
+                    base: input.base ?? "main",
+                }),
+            }),
+        },
+        {
+            name: "github_list_recent_commits",
+            description: "List recent commits on a branch",
+            input_schema: {
+                type: "object",
+                properties: {
+                    repo: { type: "string", description: "owner/repo" },
+                    branch: { type: "string", description: "Branch name (default: main)" },
+                    per_page: { type: "number", description: "Number of commits (default: 10)" },
+                },
+                required: ["repo"],
+            },
+            handler: async (input, ctx) => gh(`/repos/${input.repo}/commits?sha=${input.branch ?? "main"}&per_page=${input.per_page ?? 10}`, ctx),
+        },
+        {
+            name: "github_get_file",
+            description: "Get a file's contents from a repository",
+            input_schema: {
+                type: "object",
+                properties: {
+                    repo: { type: "string", description: "owner/repo" },
+                    path: { type: "string", description: "File path in the repo" },
+                    ref: { type: "string", description: "Branch or commit SHA (default: main)" },
+                },
+                required: ["repo", "path"],
+            },
+            handler: async (input, ctx) => {
+                const ref = input.ref ? `?ref=${input.ref}` : "";
+                const data = await gh(`/repos/${input.repo}/contents/${input.path}${ref}`, ctx);
+                if (data.content && data.encoding === "base64") {
+                    return { ...data, decoded_content: Buffer.from(data.content, "base64").toString("utf-8") };
+                }
+                return data;
+            },
+        },
+    ],
+};

package/dist/skills/index.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Skill Registry
+ *
+ * All built-in skills + helpers to build a skill map from config.
+ */
+import type { Skill, SkillCategory } from "../types.js";
+import { github } from "./github.js";
+import { linear } from "./linear.js";
+import { slack } from "./slack.js";
+import { sentry } from "./sentry.js";
+import { datadog } from "./datadog.js";
+import { betterstack } from "./betterstack.js";
+import { notification } from "./notification.js";
+export declare const builtinSkills: Skill[];
+export { github, linear, slack, sentry, datadog, betterstack, notification };
+/**
+ * Build a skill map from an array of skills.
+ * Pass to `execute()` as the `skills` option.
+ *
+ * @example
+ * ```ts
+ * const skills = createSkillMap([github, sentry, slack])
+ * await execute(workflow, input, { skills, claude })
+ * ```
+ */
+export declare function createSkillMap(skills: Skill[]): Map<string, Skill>;
+/**
+ * Create a skill map from all built-in skills.
+ */
+export declare function allSkills(): Map<string, Skill>;
+/**
+ * Check if a skill is usable given the available environment.
+ *
+ * - All required config fields must have values.
+ * - If a skill has env-backed config fields (even optional ones),
+ *   at least one must be set — otherwise the skill has zero credentials.
+ * - Skills with no env-backed config are always considered configured.
+ */
+export declare function isSkillConfigured(skill: Skill, env?: Record<string, string | undefined>): boolean;
+/**
+ * From all builtins, return only the skills that have their required env vars set.
+ */
+export declare function configuredSkills(env?: Record<string, string | undefined>): Skill[];
+/**
+ * Validate that a workflow's skill requirements are satisfiable.
+ *
+ * Groups each node's skills by category and checks that at least one
+ * skill per category is available. Returns a report of what's configured,
+ * what's missing, and any hard errors (required category with zero providers).
+ */
+export interface SkillValidationResult {
+    /** All skills referenced by the workflow, grouped by availability */
+    configured: Skill[];
+    missing: {
+        id: string;
+        category: SkillCategory | "unknown";
+        missingEnv: string[];
+    }[];
+    /** Nodes where an entire non-notification category has zero configured skills */
+    errors: string[];
+    /** Nodes where notification category has zero configured skills (non-fatal) */
+    warnings: string[];
+}
+export declare function validateWorkflowSkills(workflow: {
+    nodes: Record<string, {
+        skills: string[];
+    }>;
+}, available: Map<string, Skill>): SkillValidationResult;

package/dist/skills/index.js

@@ -0,0 +1,134 @@
+/**
+ * Skill Registry
+ *
+ * All built-in skills + helpers to build a skill map from config.
+ */
+import { github } from "./github.js";
+import { linear } from "./linear.js";
+import { slack } from "./slack.js";
+import { sentry } from "./sentry.js";
+import { datadog } from "./datadog.js";
+import { betterstack } from "./betterstack.js";
+import { notification } from "./notification.js";
+// ─── Built-in skill catalog ─────────────────────────────────────
+export const builtinSkills = [github, linear, slack, sentry, datadog, betterstack, notification];
+export { github, linear, slack, sentry, datadog, betterstack, notification };
+// ─── Registry helpers ───────────────────────────────────────────
+/**
+ * Build a skill map from an array of skills.
+ * Pass to `execute()` as the `skills` option.
+ *
+ * @example
+ * ```ts
+ * const skills = createSkillMap([github, sentry, slack])
+ * await execute(workflow, input, { skills, claude })
+ * ```
+ */
+export function createSkillMap(skills) {
+    const map = new Map();
+    for (const skill of skills) {
+        if (map.has(skill.id)) {
+            throw new Error(`Duplicate skill ID: "${skill.id}"`);
+        }
+        map.set(skill.id, skill);
+    }
+    return map;
+}
+/**
+ * Create a skill map from all built-in skills.
+ */
+export function allSkills() {
+    return createSkillMap(builtinSkills);
+}
+/**
+ * Check if a skill is usable given the available environment.
+ *
+ * - All required config fields must have values.
+ * - If a skill has env-backed config fields (even optional ones),
+ *   at least one must be set — otherwise the skill has zero credentials.
+ * - Skills with no env-backed config are always considered configured.
+ */
+export function isSkillConfigured(skill, env = process.env) {
+    const envFields = Object.values(skill.config).filter((f) => f.env);
+    if (envFields.length === 0)
+        return true; // no env needed
+    // All required fields must be set
+    for (const field of envFields) {
+        if (field.required && !env[field.env])
+            return false;
+    }
+    // At least one env-backed field must be set (handles all-optional skills like slack)
+    return envFields.some((f) => env[f.env]);
+}
+/**
+ * From all builtins, return only the skills that have their required env vars set.
+ */
+export function configuredSkills(env = process.env) {
+    return builtinSkills.filter((s) => isSkillConfigured(s, env));
+}
+export function validateWorkflowSkills(workflow, available) {
+    const configured = [];
+    const configuredIds = new Set();
+    const missing = [];
+    const missingIds = new Set();
+    const errors = [];
+    const warnings = [];
+    // Collect all referenced skill IDs
+    const allReferencedIds = new Set();
+    for (const node of Object.values(workflow.nodes)) {
+        for (const id of node.skills)
+            allReferencedIds.add(id);
+    }
+    // Classify each referenced skill
+    for (const id of allReferencedIds) {
+        const skill = available.get(id);
+        if (skill) {
+            if (!configuredIds.has(id)) {
+                configured.push(skill);
+                configuredIds.add(id);
+            }
+        }
+        else {
+            if (!missingIds.has(id)) {
+                // Try to find it in builtins to get its category and required env vars
+                const builtin = builtinSkills.find((s) => s.id === id);
+                const category = builtin?.category ?? "unknown";
+                // Show required env vars first, then optional ones (for all-optional skills like slack)
+                const envFields = builtin ? Object.entries(builtin.config).filter(([, f]) => f.env) : [];
+                const requiredEnv = envFields.filter(([, f]) => f.required).map(([, f]) => f.env);
+                const missingEnv = requiredEnv.length > 0 ? requiredEnv : envFields.map(([, f]) => f.env); // show all options for all-optional skills
+                missing.push({ id, category, missingEnv });
+                missingIds.add(id);
+            }
+        }
+    }
+    // Per-node validation: check that each node has at least one skill per category
+    for (const [nodeId, node] of Object.entries(workflow.nodes)) {
+        if (node.skills.length === 0)
+            continue;
+        // Group this node's skills by category
+        const categoriesNeeded = new Map();
+        for (const id of node.skills) {
+            const skill = available.get(id);
+            const builtin = builtinSkills.find((s) => s.id === id);
+            const cat = skill?.category ?? builtin?.category ?? "unknown";
+            if (!categoriesNeeded.has(cat))
+                categoriesNeeded.set(cat, []);
+            categoriesNeeded.get(cat).push(id);
+        }
+        // Check each category has at least one configured skill
+        for (const [cat, skillIds] of categoriesNeeded) {
+            const hasAny = skillIds.some((id) => available.has(id));
+            if (!hasAny) {
+                const msg = `Node "${nodeId}" has no configured ${cat} providers (needs one of: ${skillIds.join(", ")})`;
+                if (cat === "notification") {
+                    warnings.push(msg);
+                }
+                else {
+                    errors.push(msg);
+                }
+            }
+        }
+    }
+    return { configured, missing, errors, warnings };
+}

package/dist/skills/linear.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Linear Skill
+ *
+ * Replaces: issue-tracking/linear.ts (~400 lines → ~80 lines)
+ */
+import type { Skill } from "../types.js";
+export declare const linear: Skill;

package/dist/skills/linear.js

@@ -0,0 +1,89 @@
+/**
+ * Linear Skill
+ *
+ * Replaces: issue-tracking/linear.ts (~400 lines → ~80 lines)
+ */
+async function linearGql(query, variables, ctx) {
+    const res = await fetch("https://api.linear.app/graphql", {
+        method: "POST",
+        headers: {
+            Authorization: ctx.config.LINEAR_API_KEY,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ query, variables }),
+        signal: AbortSignal.timeout(30_000),
+    });
+    if (!res.ok)
+        throw new Error(`[Linear] API request failed (HTTP ${res.status}): ${await res.text()}`);
+    const json = await res.json();
+    if (json.errors?.length)
+        throw new Error(`[Linear] GraphQL error: ${json.errors[0].message}`);
+    return json.data;
+}
+export const linear = {
+    id: "linear",
+    name: "Linear",
+    description: "Create, search, and update issues in Linear",
+    category: "tasks",
+    config: {
+        LINEAR_API_KEY: {
+            description: "Linear API key",
+            required: true,
+            env: "LINEAR_API_KEY",
+        },
+    },
+    tools: [
+        {
+            name: "linear_create_issue",
+            description: "Create a new Linear issue",
+            input_schema: {
+                type: "object",
+                properties: {
+                    teamId: { type: "string", description: "Linear team ID" },
+                    title: { type: "string" },
+                    description: { type: "string", description: "Markdown description" },
+                    priority: { type: "number", description: "0=none, 1=urgent, 2=high, 3=medium, 4=low" },
+                    labelIds: { type: "array", items: { type: "string" } },
+                },
+                required: ["teamId", "title"],
+            },
+            handler: async (input, ctx) => linearGql(`mutation($input: IssueCreateInput!) { issueCreate(input: $input) { success issue { id identifier url title } } }`, { input }, ctx),
+        },
+        {
+            name: "linear_search_issues",
+            description: "Search Linear issues by text query",
+            input_schema: {
+                type: "object",
+                properties: {
+                    query: { type: "string", description: "Search text" },
+                    limit: { type: "number", description: "Max results (default: 10)" },
+                },
+                required: ["query"],
+            },
+            handler: async (input, ctx) => linearGql(`query($query: String!, $first: Int) {
+            searchIssues(term: $query, first: $first) {
+              nodes { id identifier title state { name } priority url }
+            }
+          }`, { query: input.query, first: input.limit ?? 10 }, ctx),
+        },
+        {
+            name: "linear_update_issue",
+            description: "Update an existing Linear issue",
+            input_schema: {
+                type: "object",
+                properties: {
+                    issueId: { type: "string", description: "Linear issue ID" },
+                    title: { type: "string" },
+                    description: { type: "string" },
+                    stateId: { type: "string", description: "State/status ID" },
+                    priority: { type: "number" },
+                },
+                required: ["issueId"],
+            },
+            handler: async (input, ctx) => {
+                const { issueId, ...updates } = input;
+                return linearGql(`mutation($id: String!, $input: IssueUpdateInput!) { issueUpdate(id: $id, input: $input) { success issue { id identifier url title state { name } } } }`, { id: issueId, input: updates }, ctx);
+            },
+        },
+    ],
+};

package/dist/skills/notification.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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.
+ */
+import type { Skill } from "../types.js";
+export declare const notification: Skill;