@sweny-ai/core 0.1.0

package/dist/workflow-builder.test.js

@@ -0,0 +1,117 @@
+import { describe, it, expect } from "vitest";
+import { buildWorkflow, refineWorkflow } from "./workflow-builder.js";
+import { MockClaude } from "./testing.js";
+// ─── Test fixtures ────────────────────────────────────────────────
+const mockSkill = {
+    id: "github",
+    name: "GitHub",
+    description: "Interact with GitHub repositories and pull requests",
+    category: "git",
+    config: {},
+    tools: [],
+};
+const validWorkflow = {
+    id: "triage-errors",
+    name: "Triage Errors",
+    description: "Queries Sentry for errors and creates a ticket",
+    entry: "gather",
+    nodes: {
+        gather: {
+            name: "Gather Errors",
+            instruction: "Query Sentry for unresolved errors from the last 24 hours. Group by fingerprint. Return top 10 by frequency.",
+            skills: ["github"],
+        },
+        report: {
+            name: "Report",
+            instruction: "Summarize the gathered errors and output a final report.",
+            skills: [],
+        },
+    },
+    edges: [{ from: "gather", to: "report" }],
+};
+// ─── buildWorkflow ────────────────────────────────────────────────
+describe("buildWorkflow", () => {
+    it("returns a validated Workflow when Claude produces valid output", async () => {
+        const claude = new MockClaude({
+            responses: {
+                build: { data: { ...validWorkflow } },
+            },
+        });
+        const opts = { claude, skills: [mockSkill] };
+        const result = await buildWorkflow("Triage Sentry errors", opts);
+        expect(result.id).toBe("triage-errors");
+        expect(result.entry).toBe("gather");
+        expect(Object.keys(result.nodes)).toHaveLength(2);
+        expect(result.edges).toHaveLength(1);
+    });
+    it("throws when Claude produces invalid output (missing entry)", async () => {
+        const badWorkflow = { ...validWorkflow, entry: "nonexistent-node" };
+        const claude = new MockClaude({
+            responses: {
+                build: { data: { ...badWorkflow } },
+            },
+        });
+        const opts = { claude, skills: [mockSkill] };
+        await expect(buildWorkflow("Triage Sentry errors", opts)).rejects.toThrow();
+    });
+    it("throws when Claude returns empty data", async () => {
+        const claude = new MockClaude({
+            responses: {
+                build: { data: {} },
+            },
+        });
+        const opts = { claude, skills: [mockSkill] };
+        await expect(buildWorkflow("Triage Sentry errors", opts)).rejects.toThrow();
+    });
+    it("includes skill descriptions in the prompt context", async () => {
+        let capturedInstruction = "";
+        const capturingClaude = {
+            async run(opts) {
+                capturedInstruction = opts.instruction;
+                return { status: "success", data: { ...validWorkflow }, toolCalls: [] };
+            },
+            async evaluate() {
+                return "";
+            },
+        };
+        const opts = { claude: capturingClaude, skills: [mockSkill] };
+        await buildWorkflow("Triage Sentry errors", opts);
+        expect(capturedInstruction).toContain("github");
+        expect(capturedInstruction).toContain("Interact with GitHub repositories");
+    });
+});
+// ─── refineWorkflow ───────────────────────────────────────────────
+describe("refineWorkflow", () => {
+    it("returns a modified workflow", async () => {
+        const refinedWorkflow = {
+            ...validWorkflow,
+            id: "triage-errors-refined",
+            name: "Triage Errors (Refined)",
+        };
+        const claude = new MockClaude({
+            responses: {
+                refine: { data: { ...refinedWorkflow } },
+            },
+        });
+        const opts = { claude, skills: [mockSkill] };
+        const result = await refineWorkflow(validWorkflow, "Add a node that creates a Linear ticket", opts);
+        expect(result.id).toBe("triage-errors-refined");
+        expect(result.name).toBe("Triage Errors (Refined)");
+    });
+    it("includes the current workflow in the prompt", async () => {
+        let capturedInstruction = "";
+        const capturingClaude = {
+            async run(opts) {
+                capturedInstruction = opts.instruction;
+                return { status: "success", data: { ...validWorkflow }, toolCalls: [] };
+            },
+            async evaluate() {
+                return "";
+            },
+        };
+        const opts = { claude: capturingClaude, skills: [mockSkill] };
+        await refineWorkflow(validWorkflow, "Add a notification node", opts);
+        expect(capturedInstruction).toContain("triage-errors");
+        expect(capturedInstruction).toContain("gather");
+    });
+});

package/dist/workflows/implement.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Implement Workflow
+ *
+ * Given an issue, implement a fix and open a pull request.
+ *
+ * Compare: the previous version was 8 files, ~2000 lines.
+ * This version is a DAG definition — Claude does the implementation
+ * work at each node using the available skill tools.
+ */
+import type { Workflow } from "../types.js";
+export declare const implementWorkflow: Workflow;

package/dist/workflows/implement.js

@@ -0,0 +1,83 @@
+/**
+ * Implement Workflow
+ *
+ * Given an issue, implement a fix and open a pull request.
+ *
+ * Compare: the previous version was 8 files, ~2000 lines.
+ * This version is a DAG definition — Claude does the implementation
+ * work at each node using the available skill tools.
+ */
+export const implementWorkflow = {
+    id: "implement",
+    name: "Implement Fix",
+    description: "Implement a code fix for an issue and open a pull request",
+    entry: "analyze",
+    nodes: {
+        analyze: {
+            name: "Analyze Issue",
+            instruction: `Read the issue details and understand what needs to be fixed:
+
+1. Fetch the issue from the tracker (GitHub or Linear).
+2. Read the relevant source files to understand the current code.
+3. Identify the exact files and lines that need to change.
+4. Plan the fix approach.
+
+Output a clear analysis of what needs to change and why.`,
+            skills: ["github", "linear"],
+            output: {
+                type: "object",
+                properties: {
+                    issue_summary: { type: "string" },
+                    files_to_change: { type: "array", items: { type: "string" } },
+                    fix_plan: { type: "string" },
+                    risk_level: { type: "string", enum: ["low", "medium", "high"] },
+                },
+                required: ["issue_summary", "fix_plan"],
+            },
+        },
+        implement: {
+            name: "Implement Fix",
+            instruction: `Implement the planned fix:
+
+1. Create a feature branch.
+2. Make the necessary code changes.
+3. Ensure changes are minimal and focused — fix the bug, nothing more.
+4. Stage and commit with a clear commit message referencing the issue.
+
+If the fix is too risky or complex, explain why and skip.`,
+            skills: ["github"],
+        },
+        create_pr: {
+            name: "Open Pull Request",
+            instruction: `Open a pull request for the fix:
+
+1. Push the branch to the remote.
+2. Create a PR with a clear title and description.
+3. Reference the original issue in the PR body.
+4. Add appropriate reviewers or labels if possible.
+
+Return the PR URL.`,
+            skills: ["github"],
+        },
+        notify: {
+            name: "Notify",
+            instruction: `Send a notification about the implementation result:
+
+1. Include: issue reference, PR link, brief summary of changes.
+2. Keep it concise — one message, not a wall of text.`,
+            skills: ["slack", "notification"],
+        },
+        skip: {
+            name: "Skip — Too Complex",
+            instruction: `The fix was determined to be too complex or risky for automated implementation.
+Add a comment to the issue explaining what was found and why it needs manual attention.`,
+            skills: ["github", "linear"],
+        },
+    },
+    edges: [
+        { from: "analyze", to: "implement", when: "Fix risk level is low or medium and a clear plan exists" },
+        { from: "analyze", to: "skip", when: "Fix is too complex, risky, or unclear" },
+        { from: "implement", to: "create_pr" },
+        { from: "create_pr", to: "notify" },
+    ],
+};

package/dist/workflows/index.d.ts

@@ -0,0 +1,2 @@
+export { triageWorkflow } from "./triage.js";
+export { implementWorkflow } from "./implement.js";

package/dist/workflows/index.js

@@ -0,0 +1,2 @@
+export { triageWorkflow } from "./triage.js";
+export { implementWorkflow } from "./implement.js";

package/dist/workflows/triage.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Triage Workflow
+ *
+ * Investigate a production alert → gather context from available
+ * providers → determine root cause → create issue → notify team.
+ *
+ * Provider-agnostic: nodes list all compatible skills per category.
+ * The executor uses whichever skills are configured. Pre-execution
+ * validation ensures required categories have at least one provider.
+ *
+ * Categories used:
+ *   git:            github (+ bitbucket, gitlab in future)
+ *   observability:  sentry, datadog, betterstack (+ aws, pagerduty in future)
+ *   tasks:          linear, github (issues) (+ jira in future)
+ *   notification:   slack, notification (discord/teams/webhook)
+ */
+import type { Workflow } from "../types.js";
+export declare const triageWorkflow: Workflow;

package/dist/workflows/triage.js

@@ -0,0 +1,108 @@
+/**
+ * Triage Workflow
+ *
+ * Investigate a production alert → gather context from available
+ * providers → determine root cause → create issue → notify team.
+ *
+ * Provider-agnostic: nodes list all compatible skills per category.
+ * The executor uses whichever skills are configured. Pre-execution
+ * validation ensures required categories have at least one provider.
+ *
+ * Categories used:
+ *   git:            github (+ bitbucket, gitlab in future)
+ *   observability:  sentry, datadog, betterstack (+ aws, pagerduty in future)
+ *   tasks:          linear, github (issues) (+ jira in future)
+ *   notification:   slack, notification (discord/teams/webhook)
+ */
+export const triageWorkflow = {
+    id: "triage",
+    name: "Alert Triage",
+    description: "Investigate a production alert, determine root cause, create an issue, and notify the team",
+    entry: "gather",
+    nodes: {
+        gather: {
+            name: "Gather Context",
+            instruction: `You are investigating a production alert. Gather all relevant context using the available tools:
+
+1. **Observability**: Pull error details, stack traces, recent logs, metrics, and active incidents around the time of the alert. Use whichever observability tools are available to you.
+2. **Source control**: Check recent commits, pull requests, and deploys that might be related.
+3. **Issue tracker**: Search for similar past issues or known problems.
+
+Be thorough — the investigation step depends on complete context. Use every tool available to you.`,
+            skills: ["github", "sentry", "datadog", "betterstack", "linear"],
+        },
+        investigate: {
+            name: "Root Cause Analysis",
+            instruction: `Based on the gathered context, perform a root cause analysis:
+
+1. Correlate the error with recent code changes, deploys, or config changes.
+2. Identify the most likely root cause.
+3. Assess severity: critical (service down), high (major feature broken), medium (degraded), low (cosmetic/minor).
+4. Determine affected services and users.
+5. Recommend a fix approach.
+
+If this is a known issue that already has a ticket, mark it as duplicate.`,
+            skills: ["github"],
+            output: {
+                type: "object",
+                properties: {
+                    root_cause: { type: "string" },
+                    severity: { type: "string", enum: ["critical", "high", "medium", "low"] },
+                    affected_services: { type: "array", items: { type: "string" } },
+                    is_duplicate: { type: "boolean" },
+                    duplicate_of: { type: "string", description: "Issue ID if duplicate" },
+                    recommendation: { type: "string" },
+                    fix_approach: { type: "string" },
+                },
+                required: ["root_cause", "severity", "recommendation"],
+            },
+        },
+        create_issue: {
+            name: "Create Issue",
+            instruction: `Create an issue documenting the investigation findings:
+
+1. Use a clear, actionable title.
+2. Include: root cause, severity, affected services, reproduction steps, and recommended fix.
+3. Add appropriate labels (bug, severity level, affected service).
+4. Link to relevant commits, PRs, or existing issues.
+
+Create the issue in whichever tracker is available to you.`,
+            skills: ["linear", "github"],
+        },
+        notify: {
+            name: "Notify Team",
+            instruction: `Send a notification summarizing the triage result:
+
+1. Include: alert summary, severity, root cause (1-2 sentences), and a link to the created issue.
+2. For critical/high severity, make the notification urgent.
+3. For medium/low, a standard notification is fine.
+
+Use whichever notification channel is available to you.`,
+            skills: ["slack", "notification"],
+        },
+        skip: {
+            name: "Skip — Duplicate or Low Priority",
+            instruction: `This alert was determined to be a duplicate or low-priority.
+Log a brief note about why it was skipped. No further action needed.`,
+            skills: [],
+        },
+    },
+    edges: [
+        // gather → investigate (always)
+        { from: "gather", to: "investigate" },
+        // investigate → create_issue (if novel and actionable)
+        {
+            from: "investigate",
+            to: "create_issue",
+            when: "The issue is novel (not a duplicate) and severity is medium or higher",
+        },
+        // investigate → skip (if duplicate or low priority)
+        {
+            from: "investigate",
+            to: "skip",
+            when: "The issue is a duplicate of an existing ticket, or severity is low",
+        },
+        // create_issue → notify (always)
+        { from: "create_issue", to: "notify" },
+    ],
+};

package/package.json

@@ -0,0 +1,83 @@
+{
+  "name": "@sweny-ai/core",
+  "version": "0.1.0",
+  "type": "module",
+  "bin": {
+    "sweny": "./dist/cli/main.js"
+  },
+  "description": "Skill library + DAG workflow orchestration powered by Claude",
+  "license": "MIT",
+  "exports": {
+    ".": "./dist/index.js",
+    "./browser": "./dist/browser.js",
+    "./studio": "./dist/studio.js",
+    "./skills": "./dist/skills/index.js",
+    "./workflows": "./dist/workflows/index.js",
+    "./testing": "./dist/testing.js",
+    "./schema": "./dist/schema.js"
+  },
+  "typesVersions": {
+    "*": {
+      "browser": [
+        "dist/browser.d.ts"
+      ],
+      "studio": [
+        "dist/studio.d.ts"
+      ],
+      "skills": [
+        "dist/skills/index.d.ts"
+      ],
+      "workflows": [
+        "dist/workflows/index.d.ts"
+      ],
+      "testing": [
+        "dist/testing.d.ts"
+      ],
+      "schema": [
+        "dist/schema.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --exclude 'src/__tests__/integration/**'",
+    "test:integration": "vitest run --config vitest.integration.config.ts"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.2.84",
+    "chalk": "^5",
+    "commander": "^13",
+    "yaml": "^2",
+    "zod": "^4.0.0"
+  },
+  "devDependencies": {
+    "@anthropic-ai/claude-code": "^2.1.84",
+    "vitest": "^3.2.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "homepage": "https://sweny.ai",
+  "bugs": {
+    "url": "https://github.com/swenyai/sweny/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/swenyai/sweny.git",
+    "directory": "packages/core"
+  },
+  "keywords": [
+    "workflow",
+    "dag",
+    "skills",
+    "claude",
+    "ai",
+    "automation",
+    "devops",
+    "sweny"
+  ]
+}