@mawaru/sdk 0.35.0 → 0.36.0

package/_schemas/extract-component.test.ts

@@ -417,3 +417,78 @@ describe("buildExtractPlan（子グラフと親置換の生成）", () => {
     })
   })
 })
+
+// forで配列を要素ごとに処理する（繰り返しの枠）.md：繰り返しは結果を配列で返すので出口はちょうど1つ
+describe("buildExtractPlan（singleExit：繰り返しの出口は1つ）", () => {
+  const childEndNode = (): GraphNode => ({
+    id: uuid(),
+    kind: "end",
+    name: "終了",
+    ports: [port("in", "in", {}), port("out", "main", {})],
+    hooks: [],
+    position_x: 560,
+    position_y: 200,
+  })
+  const plan = (
+    nodes: GraphNode[],
+    connections: { from_port_id: string; to_port_id: string }[],
+    selectedIds: string[],
+    childEnd = childEndNode(),
+  ) =>
+    buildExtractPlan({
+      nodes,
+      connections,
+      selectedIds,
+      name: "繰り返し",
+      componentLoopId: uuid(),
+      childStartOutPortId: uuid(),
+      childEnd,
+      newId: uuid,
+      singleExit: true,
+    })
+
+  it("外へ出る線が無ければ、線の出ていない唯一の出力を出口にする（結果を返す）", () => {
+    const { d, nodes, connections } = chain()
+    const childEnd = childEndNode()
+
+    const result = plan(nodes, connections, [d.id], childEnd)
+
+    if (!result.ok) throw new Error(result.reason)
+    const [nd] = result.childNodes
+    if (!nd) throw new Error("コピーがない")
+    expect(result.childConnections).toContainEqual({
+      from_port_id: outOf(nd).id,
+      to_port_id: inOf(childEnd).id,
+    })
+    expect(result.groupNode.ports.filter((p) => p.io === "out")).toHaveLength(1)
+  })
+
+  it("外へ出る線があればそれが出口（ふだんの抽出と同じ）", () => {
+    const { b, c, nodes, connections } = chain()
+
+    const result = plan(nodes, connections, [b.id, c.id])
+
+    if (!result.ok) throw new Error(result.reason)
+    expect(result.childEnd.ports.filter((p) => p.io === "in")).toHaveLength(1)
+  })
+
+  it("出口が2つ以上・出口にできる出力が決まらない選択は拒否する", () => {
+    const a = makeNode("program", "A")
+    const b = makeNode("program", "B")
+    const c = makeNode("program", "C")
+    const d = makeNode("program", "D")
+    // B と C を選ぶ：B → D、C → D の2つの出口
+    const twoExits = plan(
+      [a, b, c, d],
+      [connect(a, b), connect(a, c), connect(b, d), connect(c, d)],
+      [b.id, c.id],
+    )
+    expect(twoExits.ok).toBe(false)
+    if (twoExits.ok) return
+    expect(twoExits.reason).toContain("出口を1つ")
+
+    // 外へ出る線が無く、線の出ていない出力が2つ（B と C）
+    const ambiguous = plan([b, c], [], [b.id, c.id])
+    expect(ambiguous.ok).toBe(false)
+  })
+})

package/_schemas/extract-component.ts

@@ -118,6 +118,10 @@ export const buildExtractPlan = (params: {
   childStartOutPortId: string
   childEnd: GraphNode
   newId: () => string
+  // 繰り返し（for）：結果を配列で返すので出口はちょうど1つ。外へ出る線が無ければ、
+  // 選択の中で線の出ていない唯一の出力を出口にする
+  // （forで配列を要素ごとに処理する（繰り返しの枠）.md）
+  singleExit?: boolean
 }): { ok: false; reason: string } | ({ ok: true } & ExtractPlan) => {
   const {
     nodes,
@@ -128,11 +132,30 @@ export const buildExtractPlan = (params: {
     childStartOutPortId,
     childEnd,
     newId,
+    singleExit = false,
   } = params
   const analysis = analyzeExtractSelection(nodes, connections, selectedIds)
   if (!analysis.ok) return analysis
 
   const selected = new Set(selectedIds)
+  let exitPortIds = analysis.exitPortIds
+  if (singleExit) {
+    if (exitPortIds.length === 0) {
+      const wiredOut = new Set(analysis.internal.map((c) => c.from_port_id))
+      const free = nodes
+        .filter((n) => selected.has(n.id))
+        .flatMap((n) =>
+          n.ports
+            .filter((p) => p.io === "out" && !wiredOut.has(p.id))
+            .map((p) => p.id),
+        )
+      exitPortIds = free.length === 1 ? free : []
+    }
+    if (exitPortIds.length !== 1) {
+      return { ok: false, reason: "繰り返しの出口を1つにしてください" }
+    }
+  }
+
   // ノード・ポートとも新 id を採番してコピー（kind 別設定・hooks は共有参照で問題ない
   // ＝この後 JSON 化して保存 API に渡すだけで、エディタ状態には子側を持たない）。
   // node_key は親の版の行との突き合わせ用なので子へは持ち込まない（子 loop の draft に
@@ -185,7 +208,7 @@ export const buildExtractPlan = (params: {
       }
     }
   }
-  const exits = analysis.exitPortIds.map((exitPortId, i) => {
+  const exits = exitPortIds.map((exitPortId, i) => {
     const exitName = portById.get(exitPortId)?.name ?? "出力"
     const seeded = i === 0 ? seededEndIns[0] : undefined
     const endIn: GraphPort = seeded

package/_schemas/graph.test.ts

@@ -997,22 +997,69 @@ describe("saveGraphBodySchema：開始/終了ノード（start/end kind）", ()
     ).toThrow(/in ポートはちょうど1つ/)
   })
 
-  it("start への接続・end からの接続を拒否する", () => {
-    const s = startNode()
+  it("end からの接続を拒否する", () => {
     const e = endNode()
     const other = makeNode()
+    expect(() =>
+      saveGraphBodySchema.parse({
+        nodes: [e, other],
+        connections: [connect(e, other)],
+      }),
+    ).toThrow(/終了ノード/)
+  })
+
+  // start の入口へ戻すと次の周回になる
+  // （docs/tasks/wip/startノードに入力をつないで周回する（runの周回）.md）
+  it("start の入口へ1本つなげる（周回の最後から戻す）", () => {
+    const s = startNode()
+    const other = { ...makeNode(simplePorts()), kind: "wait" }
     expect(() =>
       saveGraphBodySchema.parse({
         nodes: [s, other],
-        connections: [connect(other, s)],
+        connections: [connect(s, other), connect(other, s)],
       }),
-    ).toThrow(/開始ノード/)
+    ).not.toThrow()
+  })
+
+  it("start の入口につなげる線は1本だけ", () => {
+    const s = startNode()
+    const a = makeNode()
+    const b = makeNode()
     expect(() =>
       saveGraphBodySchema.parse({
-        nodes: [e, other],
-        connections: [connect(e, other)],
+        nodes: [s, a, b],
+        connections: [connect(a, s), connect(b, s)],
       }),
-    ).toThrow(/終了ノード/)
+    ).toThrow(/開始ノードの入口につなげる線は1本だけです/)
+  })
+
+  it("start の入口の型（直後のノードが受ける型）に合わない線を拒否する", () => {
+    const s = startNode()
+    const objectIn = {
+      type: "object",
+      properties: { title: { type: "string" } },
+      required: ["title"],
+    }
+    const next = {
+      ...makeNode([
+        { ...port("in", "in"), schema: objectIn },
+        port("out", "main"),
+      ]),
+      kind: "program",
+    }
+    const last = {
+      ...makeNode([
+        port("in", "in"),
+        { ...port("out", "main"), schema: { type: "string" } },
+      ]),
+      kind: "program",
+    }
+    expect(() =>
+      saveGraphBodySchema.parse({
+        nodes: [s, next, last],
+        connections: [connect(s, next), connect(next, last), connect(last, s)],
+      }),
+    ).toThrow(/入力スキーマに適合しません/)
   })
 })
 

package/_schemas/graph.ts

@@ -521,12 +521,16 @@ export const saveGraphBodySchema = z
       const toNode = nodeByPortId.get(conn.to_port_id)
       if (!from || !to || !fromNode || !toNode) return // 構造違反は検出済み
 
-      // start には引き込めない（run payload だけが入口）、end からは引き出せない（終端）
-      if (toNode.kind === "start") {
+      // end からは引き出せない（終端）。start の入口へは戻せる（次の周回になる）が、
+      // 線は1本だけ（2本あると両方が着いたときに周回が2本並んで走る）
+      if (
+        toNode.kind === "start" &&
+        (inboundByPort.get(conn.to_port_id)?.length ?? 0) > 1
+      ) {
         ctx.addIssue({
           code: "custom",
           path: ["connections", i, "to_port_id"],
-          message: "開始ノードには接続できません",
+          message: "開始ノードの入口につなげる線は1本だけです",
         })
       }
       if (fromNode.kind === "end") {

package/_schemas/port-spec.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, it } from "vitest"
 import type { GraphPort, JsonSchema } from "./node.js"
 import {
+  arrayOf,
   dataFormatOf,
   dataSchemaOf,
   fileSchema,
@@ -1116,3 +1117,30 @@ describe("schemaTypeKey（型としての同一性）", () => {
     ).not.toBe(schemaTypeKey({ type: "array", items: [{ type: "number" }] }))
   })
 })
+
+describe("arrayOf（for の配置ポート：1件分の型を配列に包む）", () => {
+  it("宣言された型は items に入れた配列になる", () => {
+    const error = { type: "object", properties: { id: { type: "string" } } }
+    expect(arrayOf(error)).toEqual({ type: "array", items: error })
+  })
+
+  it("未宣言の型は items を持たない配列になる（要素の型は判断できないまま）", () => {
+    expect(arrayOf(UNDECLARED_SCHEMA)).toEqual({ type: "array" })
+  })
+
+  it("配列にした型同士は要素の型で適合を判定する", () => {
+    const narrow = {
+      type: "object",
+      properties: { id: { type: "string" }, title: { type: "string" } },
+      required: ["id", "title"],
+    }
+    const wide = {
+      type: "object",
+      properties: { id: { type: "string" } },
+      required: ["id"],
+    }
+    expect(schemaFit(arrayOf(narrow), arrayOf(wide))).toBe("ok")
+    expect(schemaFit(arrayOf(wide), arrayOf(narrow))).toBe("mismatch")
+    expect(schemaFit(wide, arrayOf(wide))).toBe("mismatch")
+  })
+})

package/_schemas/port-spec.ts

@@ -15,6 +15,14 @@ export const UNDECLARED_SCHEMA: JsonSchema = {}
 export const isUndeclaredSchema = (schema: JsonSchema): boolean =>
   Object.keys(schema).length === 0 || schema.type === undefined
 
+// 1件分の型を配列に包む（for の配置ポート：in ＝ 中身の start.in の配列、out ＝ 中身の
+// end の in の配列。docs/tasks/done/forで配列を要素ごとに処理する（繰り返しの枠）.md）。
+// 未宣言は items を持たせない（要素の型は判断できないまま）
+export const arrayOf = (schema: JsonSchema): JsonSchema =>
+  isUndeclaredSchema(schema)
+    ? { type: "array" }
+    : { type: "array", items: schema }
+
 // ---- file 型（docs/tasks/done/AIノードのファイル入力（file型と添付）.md） ----
 // schema 上の file は x-mawaru-type マーカー付きの object（nominal に識別する）。値はバイト
 // ではなく storage path の参照で、署名 URL はどこにも焼き込まない。

package/dist/_schemas/extract-component.d.ts

@@ -28,6 +28,7 @@ export declare const buildExtractPlan: (params: {
     childStartOutPortId: string;
     childEnd: GraphNode;
     newId: () => string;
+    singleExit?: boolean;
 }) => {
     ok: false;
     reason: string;

package/dist/_schemas/extract-component.js

@@ -55,11 +55,26 @@ export const analyzeExtractSelection = (nodes, connections, selectedIds) => {
 // end の in が1つの loop は out main の1口として振る舞う）
 const SINGLE_OUT_KEY = "main";
 export const buildExtractPlan = (params) => {
-    const { nodes, connections, selectedIds, name, componentLoopId, childStartOutPortId, childEnd, newId, } = params;
+    const { nodes, connections, selectedIds, name, componentLoopId, childStartOutPortId, childEnd, newId, singleExit = false, } = params;
     const analysis = analyzeExtractSelection(nodes, connections, selectedIds);
     if (!analysis.ok)
         return analysis;
     const selected = new Set(selectedIds);
+    let exitPortIds = analysis.exitPortIds;
+    if (singleExit) {
+        if (exitPortIds.length === 0) {
+            const wiredOut = new Set(analysis.internal.map((c) => c.from_port_id));
+            const free = nodes
+                .filter((n) => selected.has(n.id))
+                .flatMap((n) => n.ports
+                .filter((p) => p.io === "out" && !wiredOut.has(p.id))
+                .map((p) => p.id));
+            exitPortIds = free.length === 1 ? free : [];
+        }
+        if (exitPortIds.length !== 1) {
+            return { ok: false, reason: "繰り返しの出口を1つにしてください" };
+        }
+    }
     // ノード・ポートとも新 id を採番してコピー（kind 別設定・hooks は共有参照で問題ない
     // ＝この後 JSON 化して保存 API に渡すだけで、エディタ状態には子側を持たない）。
     // node_key は親の版の行との突き合わせ用なので子へは持ち込まない（子 loop の draft に
@@ -108,7 +123,7 @@ export const buildExtractPlan = (params) => {
             }
         }
     };
-    const exits = analysis.exitPortIds.map((exitPortId, i) => {
+    const exits = exitPortIds.map((exitPortId, i) => {
         const exitName = portById.get(exitPortId)?.name ?? "出力";
         const seeded = i === 0 ? seededEndIns[0] : undefined;
         const endIn = seeded

package/dist/_schemas/graph.js

@@ -447,12 +447,14 @@ export const saveGraphBodySchema = z
         const toNode = nodeByPortId.get(conn.to_port_id);
         if (!from || !to || !fromNode || !toNode)
             return; // 構造違反は検出済み
-        // start には引き込めない（run payload だけが入口）、end からは引き出せない（終端）
-        if (toNode.kind === "start") {
+        // end からは引き出せない（終端）。start の入口へは戻せる（次の周回になる）が、
+        // 線は1本だけ（2本あると両方が着いたときに周回が2本並んで走る）
+        if (toNode.kind === "start" &&
+            (inboundByPort.get(conn.to_port_id)?.length ?? 0) > 1) {
             ctx.addIssue({
                 code: "custom",
                 path: ["connections", i, "to_port_id"],
-                message: "開始ノードには接続できません",
+                message: "開始ノードの入口につなげる線は1本だけです",
             });
         }
         if (fromNode.kind === "end") {

package/dist/_schemas/port-spec.d.ts

@@ -2,6 +2,7 @@ import { z } from "zod";
 import type { GraphPort, JsonSchema } from "./node.js";
 export declare const UNDECLARED_SCHEMA: JsonSchema;
 export declare const isUndeclaredSchema: (schema: JsonSchema) => boolean;
+export declare const arrayOf: (schema: JsonSchema) => JsonSchema;
 export declare const FILE_SCHEMA_MARKER = "x-mawaru-type";
 export declare const FILE_SCHEMA_TYPE = "file";
 export declare const fileSchema: () => JsonSchema;

package/dist/_schemas/port-spec.js

@@ -9,6 +9,12 @@ import { z } from "zod";
 // （docs/tasks/done/ポートスキーマのany撲滅.md）
 export const UNDECLARED_SCHEMA = {};
 export const isUndeclaredSchema = (schema) => Object.keys(schema).length === 0 || schema.type === undefined;
+// 1件分の型を配列に包む（for の配置ポート：in ＝ 中身の start.in の配列、out ＝ 中身の
+// end の in の配列。docs/tasks/done/forで配列を要素ごとに処理する（繰り返しの枠）.md）。
+// 未宣言は items を持たせない（要素の型は判断できないまま）
+export const arrayOf = (schema) => isUndeclaredSchema(schema)
+    ? { type: "array" }
+    : { type: "array", items: schema };
 // ---- file 型（docs/tasks/done/AIノードのファイル入力（file型と添付）.md） ----
 // schema 上の file は x-mawaru-type マーカー付きの object（nominal に識別する）。値はバイト
 // ではなく storage path の参照で、署名 URL はどこにも焼き込まない。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mawaru/sdk",
-  "version": "0.35.0",
+  "version": "0.36.0",
   "description": "mawaru 実行 repo の開発 SDK。契約スキーマ（config.json 規約・ループ graph API）の正 ＋ typegen / validate CLI",
   "type": "module",
   "bin": {

package/skills/create-loop/SKILL.md

@@ -77,6 +77,12 @@ repo との矛盾・使用中ノードの削除は 409。**graph PUT は冪等
    1つの出口から複数の線を引くと枝が並行に走る（fan-out）。枝の結果を待ち合わせるときは
    合流（`join`）を置く：線のつながった入口が全部揃うまで待ち、`{ [入口の key]: 値 }` にまとめて
    `main` から流す。並行した枝を合流させずに同じノード（待機など）へ戻すと、枝の数だけ走り続ける。
+   配列の要素ごとに同じ手順や別ループを回すときは繰り返し（for）にする：`POST loops` に
+   `kind: "for"` と `owner_loop_id`（このループ）を渡して中身の loop を作り、その graph
+   （start → 1件分の処理 → end）を保存してから、このループに component ノード
+   （`component.component_loop_id`＝作った for）を置く。配置ノードの in / out は中身の型の配列に
+   自動で焼き込まれ、全件そろうと入力と同じ順の配列で `main` から流れる（1件ずつは同時に走る）。
+   中身の出口（end につないだ in）は1つにする。
 2. **repo 側の準備**：足りない program / ai は `nodes/program/<dir>/` / `nodes/ai/<dir>/` に作る
    （config.json → `npx mawaru typegen` → main.ts 実装 → `npx mawaru validate`）。
    **AI ノードの決定論的な処理は prompt ではなく `setup.sh` に書く**（下記）。