@sweny-ai/core 0.1.58 → 0.1.60

package/dist/__tests__/studio.test.js

@@ -139,6 +139,157 @@ describe("workflowToFlow", () => {
         });
     });
 });
+describe("edge IDs and edgeIndex", () => {
+    it("generates unique edge IDs using array index", () => {
+        const { edges } = workflowToFlow(testWorkflow);
+        const ids = edges.map((e) => e.id);
+        expect(ids[0]).toBe("edge-0");
+        expect(ids[1]).toBe("edge-1");
+        // All IDs are unique
+        expect(new Set(ids).size).toBe(ids.length);
+    });
+    it("assigns correct edgeIndex matching array position", () => {
+        const { edges } = workflowToFlow(testWorkflow);
+        edges.forEach((edge, i) => {
+            expect(edge.edgeIndex).toBe(i);
+        });
+    });
+    it("produces unique IDs for multiple edges between the same node pair", () => {
+        const wf = {
+            id: "multi-edge",
+            name: "Multi-Edge",
+            description: "",
+            entry: "a",
+            nodes: {
+                a: { name: "A", instruction: "A", skills: [] },
+                b: { name: "B", instruction: "B", skills: [] },
+            },
+            edges: [
+                { from: "a", to: "b" },
+                { from: "a", to: "b", when: "error detected" },
+                { from: "a", to: "b", when: "retry needed" },
+            ],
+        };
+        const { edges } = workflowToFlow(wf);
+        expect(edges).toHaveLength(3);
+        const ids = edges.map((e) => e.id);
+        expect(new Set(ids).size).toBe(3);
+        expect(ids).toEqual(["edge-0", "edge-1", "edge-2"]);
+    });
+    it("produces stable IDs across multiple conversions", () => {
+        const first = workflowToFlow(testWorkflow).edges.map((e) => e.id);
+        const second = workflowToFlow(testWorkflow).edges.map((e) => e.id);
+        expect(first).toEqual(second);
+    });
+});
+describe("max_iterations in conversion", () => {
+    const wfWithMaxIter = {
+        id: "retry-loop",
+        name: "Retry Loop",
+        description: "",
+        entry: "check",
+        nodes: {
+            check: { name: "Check", instruction: "Check it", skills: [] },
+            fix: { name: "Fix", instruction: "Fix it", skills: [] },
+        },
+        edges: [
+            { from: "check", to: "fix", when: "issue found" },
+            { from: "fix", to: "check", when: "needs re-check", max_iterations: 3 },
+        ],
+    };
+    it("includes max_iterations in flow edge data", () => {
+        const { edges } = workflowToFlow(wfWithMaxIter);
+        const retryEdge = edges.find((e) => e.source === "fix" && e.target === "check");
+        expect(retryEdge?.data.max_iterations).toBe(3);
+    });
+    it("omits max_iterations when not set", () => {
+        const { edges } = workflowToFlow(wfWithMaxIter);
+        const firstEdge = edges.find((e) => e.source === "check" && e.target === "fix");
+        expect(firstEdge?.data.max_iterations).toBeUndefined();
+    });
+    it("round-trips max_iterations through flowToWorkflow", () => {
+        const { nodes, edges } = workflowToFlow(wfWithMaxIter);
+        const rebuilt = flowToWorkflow({
+            id: wfWithMaxIter.id,
+            name: wfWithMaxIter.name,
+            description: wfWithMaxIter.description,
+            entry: wfWithMaxIter.entry,
+        }, nodes, edges);
+        const retryEdge = rebuilt.edges.find((e) => e.from === "fix" && e.to === "check");
+        expect(retryEdge?.max_iterations).toBe(3);
+        // Non-retry edge should not have max_iterations
+        const normalEdge = rebuilt.edges.find((e) => e.from === "check" && e.to === "fix");
+        expect(normalEdge).not.toHaveProperty("max_iterations");
+    });
+});
+describe("Source type preservation", () => {
+    it("preserves inline string instructions through round-trip", () => {
+        const { nodes, edges } = workflowToFlow(testWorkflow);
+        const rebuilt = flowToWorkflow({ id: "x", name: "X", description: "", entry: "a" }, nodes, edges);
+        expect(rebuilt.nodes.a.instruction).toBe("Do A");
+    });
+    it("preserves {file:} Source through round-trip", () => {
+        const wf = {
+            id: "file-src",
+            name: "File Source",
+            description: "",
+            entry: "a",
+            nodes: {
+                a: { name: "A", instruction: { file: "./instructions/step-a.md" }, skills: [] },
+            },
+            edges: [],
+        };
+        const { nodes, edges } = workflowToFlow(wf);
+        const rebuilt = flowToWorkflow({ id: wf.id, name: wf.name, description: "", entry: "a" }, nodes, edges);
+        expect(rebuilt.nodes.a.instruction).toEqual({ file: "./instructions/step-a.md" });
+    });
+    it("preserves {url:} Source through round-trip", () => {
+        const wf = {
+            id: "url-src",
+            name: "URL Source",
+            description: "",
+            entry: "a",
+            nodes: {
+                a: { name: "A", instruction: { url: "https://example.com/instruction.md" }, skills: [] },
+            },
+            edges: [],
+        };
+        const { nodes, edges } = workflowToFlow(wf);
+        const rebuilt = flowToWorkflow({ id: wf.id, name: wf.name, description: "", entry: "a" }, nodes, edges);
+        expect(rebuilt.nodes.a.instruction).toEqual({ url: "https://example.com/instruction.md" });
+    });
+    it("preserves {inline:} Source through round-trip", () => {
+        const wf = {
+            id: "inline-src",
+            name: "Inline Source",
+            description: "",
+            entry: "a",
+            nodes: {
+                a: { name: "A", instruction: { inline: "Explicit inline text" }, skills: [] },
+            },
+            edges: [],
+        };
+        const { nodes, edges } = workflowToFlow(wf);
+        const rebuilt = flowToWorkflow({ id: wf.id, name: wf.name, description: "", entry: "a" }, nodes, edges);
+        expect(rebuilt.nodes.a.instruction).toEqual({ inline: "Explicit inline text" });
+    });
+    it("preserves {url:, type:} Source through round-trip", () => {
+        const wf = {
+            id: "url-type-src",
+            name: "URL Type Source",
+            description: "",
+            entry: "a",
+            nodes: {
+                a: { name: "A", instruction: { url: "https://example.com/data", type: "fetch" }, skills: [] },
+            },
+            edges: [],
+        };
+        const { nodes, edges } = workflowToFlow(wf);
+        const rebuilt = flowToWorkflow({ id: wf.id, name: wf.name, description: "", entry: "a" }, nodes, edges);
+        const src = rebuilt.nodes.a.instruction;
+        expect(src).toEqual({ url: "https://example.com/data", type: "fetch" });
+    });
+});
 describe("flowToWorkflow", () => {
     it("round-trips correctly", () => {
         const { nodes, edges } = workflowToFlow(testWorkflow);
@@ -160,6 +311,13 @@ describe("flowToWorkflow", () => {
         const unconditional = rebuilt.edges.find((e) => e.from === "a" && e.to === "b");
         expect(unconditional).not.toHaveProperty("when");
     });
+    it("omits max_iterations when not set", () => {
+        const { nodes, edges } = workflowToFlow(testWorkflow);
+        const rebuilt = flowToWorkflow({ id: "x", name: "X", description: "", entry: "a" }, nodes, edges);
+        for (const edge of rebuilt.edges) {
+            expect(edge).not.toHaveProperty("max_iterations");
+        }
+    });
 });
 describe("applyExecutionEvent", () => {
     function makeNodeDataMap() {

package/dist/schema.d.ts

@@ -697,9 +697,9 @@ export interface WorkflowError {
 export declare function validateWorkflow(workflow: Workflow | z.infer<typeof workflowZ>, knownSkills?: Set<string>): WorkflowError[];
 export declare const workflowJsonSchema: {
     readonly $schema: "https://json-schema.org/draft/2020-12/schema";
-    readonly $id: "https://sweny.ai/schemas/workflow.json";
+    readonly $id: "https://spec.sweny.ai/schemas/workflow.json";
     readonly title: "SWEny Workflow";
-    readonly description: "A workflow definition for skill-based orchestration (supports controlled cycles via max_iterations)";
+    readonly description: "A declarative YAML format for AI agent orchestration as a directed graph with natural language routing.";
     readonly type: "object";
     readonly required: readonly ["id", "name", "nodes", "edges", "entry"];
     readonly additionalProperties: false;
@@ -774,7 +774,7 @@ export declare const workflowJsonSchema: {
                     };
                     readonly instruction: {
                         readonly $ref: "#/$defs/Source";
-                        readonly description: "What Claude should do at this node";
+                        readonly description: "Natural language instruction for the AI model.";
                     };
                     readonly skills: {
                         readonly type: "array";

package/dist/schema.js

@@ -262,9 +262,9 @@ const sourceJsonSchema = {
 };
 export const workflowJsonSchema = {
     $schema: "https://json-schema.org/draft/2020-12/schema",
-    $id: "https://sweny.ai/schemas/workflow.json",
+    $id: "https://spec.sweny.ai/schemas/workflow.json",
     title: "SWEny Workflow",
-    description: "A workflow definition for skill-based orchestration (supports controlled cycles via max_iterations)",
+    description: "A declarative YAML format for AI agent orchestration as a directed graph with natural language routing.",
     type: "object",
     required: ["id", "name", "nodes", "edges", "entry"],
     additionalProperties: false,
@@ -282,7 +282,7 @@ export const workflowJsonSchema = {
                 additionalProperties: false,
                 properties: {
                     name: { type: "string", minLength: 1 },
-                    instruction: { $ref: "#/$defs/Source", description: "What Claude should do at this node" },
+                    instruction: { $ref: "#/$defs/Source", description: "Natural language instruction for the AI model." },
                     skills: {
                         type: "array",
                         items: { type: "string" },

package/dist/studio.d.ts

@@ -71,8 +71,11 @@ export interface FlowEdge {
     source: string;
     target: string;
     type: "conditionEdge";
+    /** Array index of this edge in workflow.edges — used for stable lookups. */
+    edgeIndex: number;
     data: {
         when?: string;
+        max_iterations?: number;
         isConditional: boolean;
     };
 }

package/dist/studio.js

@@ -77,13 +77,15 @@ export function workflowToFlow(workflow, skillCatalog = builtinSkills) {
             exec: { status: "pending" },
         },
     }));
-    const edges = workflowEdges.map((edge) => ({
-        id: `${edge.from}--${edge.to}`,
+    const edges = workflowEdges.map((edge, i) => ({
+        id: `edge-${i}`,
         source: edge.from,
         target: edge.to,
         type: "conditionEdge",
+        edgeIndex: i,
         data: {
             when: edge.when,
+            max_iterations: edge.max_iterations,
             isConditional: !!edge.when,
         },
     }));
@@ -146,6 +148,7 @@ export function flowToWorkflow(meta, nodes, edges) {
             from: e.source,
             to: e.target,
             ...(e.data.when ? { when: e.data.when } : {}),
+            ...(e.data.max_iterations ? { max_iterations: e.data.max_iterations } : {}),
         })),
     };
 }

package/package.json

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