@sweny-ai/core 0.1.49 → 0.1.50

package/dist/__tests__/executor.test.js

@@ -28,6 +28,17 @@ const linearWorkflow = {
         { from: "b", to: "c" },
     ],
 };
+/** Same shape as linearWorkflow but with no skill requirements — for tests that
+ *  don't exercise tool usage and just need a 3-node DAG. */
+const skilllessWorkflow = {
+    ...linearWorkflow,
+    id: "linear-no-skills",
+    nodes: {
+        a: { name: "A", instruction: "Do A", skills: [] },
+        b: { name: "B", instruction: "Do B", skills: [] },
+        c: { name: "C", instruction: "Do C", skills: [] },
+    },
+};
 const branchingWorkflow = {
     id: "branching",
     name: "Branching",
@@ -154,7 +165,7 @@ describe("executor", () => {
                 c: { data: {} },
             },
         });
-        const { results } = await execute(linearWorkflow, {}, {
+        const { results } = await execute(skilllessWorkflow, {}, {
             skills: createSkillMap([]),
             claude,
             observer: () => {
@@ -246,13 +257,13 @@ describe("executor", () => {
         const claude = new MockClaude({
             responses: { a: { data: {} }, b: { data: {} }, c: { data: {} } },
         });
-        // Should throw without config
-        await expect(execute(linearWorkflow, {}, {
+        // Should throw without config (uses skilllessWorkflow — no skill requirements on nodes)
+        await expect(execute(skilllessWorkflow, {}, {
             skills: createSkillMap([skillWithConfig]),
             claude,
         })).rejects.toThrow("Missing required config");
         // Should succeed with override
-        const { results } = await execute(linearWorkflow, {}, {
+        const { results } = await execute(skilllessWorkflow, {}, {
             skills: createSkillMap([skillWithConfig]),
             claude,
             config: { MY_KEY: "provided" },
@@ -267,7 +278,7 @@ describe("executor", () => {
                 c: { data: {} },
             },
         });
-        const { results } = await execute(linearWorkflow, {}, {
+        const { results } = await execute(skilllessWorkflow, {}, {
             skills: createSkillMap([]),
             claude,
             config: {},
@@ -368,6 +379,56 @@ describe("executor", () => {
         expect(aCount).toBe(2);
         expect(results.has("end")).toBe(true);
     });
+    it("throws when a node with required skills is reached but none are configured", async () => {
+        const workflowWithSkills = {
+            id: "needs-linear",
+            name: "Needs Linear",
+            description: "A→B where B needs linear skill",
+            entry: "a",
+            nodes: {
+                a: { name: "A", instruction: "Do A", skills: [] },
+                b: { name: "B", instruction: "Create a Linear issue", skills: ["linear"] },
+            },
+            edges: [{ from: "a", to: "b" }],
+        };
+        const claude = new MockClaude({
+            responses: {
+                a: { data: { done: true } },
+                b: { data: {} },
+            },
+        });
+        // No linear skill in the map — should throw when node B is reached
+        await expect(execute(workflowWithSkills, {}, { skills: createSkillMap([]), claude, config: {} })).rejects.toThrow('Node "b" requires skills [linear] but none are configured');
+    });
+    it("does not throw for unreachable nodes with missing skills", async () => {
+        const workflowWithUnreachable = {
+            id: "unreachable-skill",
+            name: "Unreachable Skill",
+            description: "A→C, B needs linear but is never reached",
+            entry: "a",
+            nodes: {
+                a: { name: "A", instruction: "Do A", skills: [] },
+                b: { name: "B", instruction: "Create issue", skills: ["linear"] },
+                c: { name: "C", instruction: "Do C", skills: [] },
+            },
+            edges: [
+                { from: "a", to: "c" },
+                { from: "a", to: "b", when: "needs escalation" },
+            ],
+        };
+        const claude = new MockClaude({
+            responses: {
+                a: { data: {} },
+                c: { data: {} },
+            },
+            routes: { a: "c" },
+        });
+        // Node B is never reached, so missing linear skill should not cause a throw
+        const { results } = await execute(workflowWithUnreachable, {}, { skills: createSkillMap([]), claude, config: {} });
+        expect(results.has("a")).toBe(true);
+        expect(results.has("c")).toBe(true);
+        expect(results.has("b")).toBe(false);
+    });
     it("validates route choice falls back on invalid Claude response", async () => {
         // Create a claude mock that returns an invalid route
         const badRouteClaude = {

package/dist/executor.js

@@ -41,6 +41,14 @@ export async function execute(workflow, input, options) {
         logger.info(`→ ${node.name}`, { node: currentId });
         // Gather tools from the node's skills
         const tools = resolveTools(node.skills, skills);
+        // Runtime guard: if this node declares skills but none resolved, the node
+        // cannot do its job (e.g. "create a Linear issue" with no linear skill).
+        // The startup validate() warns about this possibility, but only throw when
+        // the node is actually reached — unreachable nodes with missing skills are fine.
+        if (node.skills.length > 0 && tools.length === 0) {
+            throw new Error(`Node "${currentId}" requires skills [${node.skills.join(", ")}] but none are configured. ` +
+                `Set the required environment variables and try again.`);
+        }
         // Build context: input + all prior node results
         const context = {
             input,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sweny-ai/core",
-  "version": "0.1.49",
+  "version": "0.1.50",
   "type": "module",
   "bin": {
     "sweny": "./dist/cli/main.js"