@mawaru/sdk 0.5.0 → 0.9.0

package/_schemas/ai-manifest.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest"
 import { aiManifestSchema } from "./ai-manifest.js"
-import { envelopeSchemaOf } from "./port-spec.js"
+import { envelopeSchemaOf, instructionSchema } from "./port-spec.js"
 
 const envelope = envelopeSchemaOf({ type: "string" })
 
@@ -49,11 +49,26 @@ describe("aiManifestSchema", () => {
     ).toThrow()
   })
 
-  it('inputs は "in" の1件だけ', () => {
+  it('inputs は "in" 必須・instruction は任意（kind が固定する2口）', () => {
+    // in は必須
     expect(() => aiManifestSchema.parse({ ...valid, inputs: {} })).toThrow()
     expect(() =>
       aiManifestSchema.parse({ ...valid, inputs: { data: {} } }),
     ).toThrow()
+    // 固定ポートの instruction も宣言に載る（ノードの現在の姿を書き出すため）
+    expect(
+      aiManifestSchema.parse({
+        ...valid,
+        inputs: { in: {}, instruction: instructionSchema() },
+      }).inputs.instruction,
+    ).toEqual(instructionSchema())
+    // in を2口に分ける前に同期された config.json（in だけ）もそのまま読める
+    expect(
+      Object.keys(
+        aiManifestSchema.parse({ ...valid, inputs: { in: {} } }).inputs,
+      ),
+    ).toEqual(["in"])
+    // kind が固定しない key は宣言できない
     expect(() =>
       aiManifestSchema.parse({ ...valid, inputs: { in: {}, extra: {} } }),
     ).toThrow()

package/_schemas/ai-manifest.ts

@@ -1,6 +1,6 @@
 import { z } from "zod"
 import { jsonSchemaSchema } from "./node.js"
-import { isAiEnvelopeSchema } from "./port-spec.js"
+import { isAiEnvelopeSchema, manifestInKeysViolation } from "./port-spec.js"
 
 // AI ノードのモデル選択肢（既定は Opus：下書き品質が価値の中心。費用はユーザー持ち）
 export const AI_MODELS = [
@@ -43,14 +43,14 @@ export const aiManifestSchema = z
     outputs: z.record(z.string(), jsonSchemaSchema),
   })
   .superRefine((manifest, ctx) => {
-    // グラフ側の既存制約（in ちょうど1つ・key "in"）に整合させる
-    const inKeys = Object.keys(manifest.inputs)
-    if (inKeys.length !== 1 || inKeys[0] !== "in") {
-      ctx.addIssue({
-        code: "custom",
-        path: ["inputs"],
-        message: 'inputs は "in" の1件だけ宣言してください（join 導入まで）',
-      })
+    // in の構成は kind が固定する（ai は上流データの in ＋ 差し戻しの instruction の2口）。
+    // ルールの正は port-spec 側で、ここは参照するだけ
+    const inViolation = manifestInKeysViolation(
+      "ai",
+      Object.keys(manifest.inputs),
+    )
+    if (inViolation) {
+      ctx.addIssue({ code: "custom", path: ["inputs"], message: inViolation })
     }
     // outputs は1件以上・key 自由（複数出口＝分岐。AIノードの複数出口（分岐）.md）
     if (Object.keys(manifest.outputs).length < 1) {

package/_schemas/extract-component.test.ts

@@ -0,0 +1,220 @@
+import { describe, expect, it } from "vitest"
+import {
+  analyzeExtractSelection,
+  buildExtractPlan,
+} from "./extract-component.js"
+import type { GraphNode } from "./graph.js"
+import type { GraphPort } from "./node.js"
+
+// テスト用の決定的な uuid（graph.test.ts と同じ流儀）
+let seq = 0
+const uuid = () => `00000000-0000-4000-8000-${String(++seq).padStart(12, "0")}`
+
+const port = (io: "in" | "out", key: string): GraphPort => ({
+  id: uuid(),
+  io,
+  key,
+  name: key,
+  schema: { type: "object" },
+})
+
+const makeNode = (
+  kind: GraphNode["kind"],
+  name: string,
+  x = 0,
+  y = 0,
+): GraphNode => ({
+  id: uuid(),
+  kind,
+  name,
+  ports: [port("in", "in"), port("out", "main")],
+  hooks: [],
+  position_x: x,
+  position_y: y,
+  ...(kind === "wait"
+    ? { wait: { wait_type: "duration" as const, duration_seconds: 90 } }
+    : {}),
+})
+
+const inOf = (n: GraphNode) => {
+  const p = n.ports.find((p) => p.io === "in")
+  if (!p) throw new Error("in がない")
+  return p
+}
+const outOf = (n: GraphNode, key = "main") => {
+  const p = n.ports.find((p) => p.io === "out" && p.key === key)
+  if (!p) throw new Error("out がない")
+  return p
+}
+const connect = (from: GraphNode, to: GraphNode) => ({
+  from_port_id: outOf(from).id,
+  to_port_id: inOf(to).id,
+})
+
+// 直列 A → B → C → D（B, C を選択するのが基本ケース）
+const chain = () => {
+  const a = makeNode("program", "A", 0, 0)
+  const b = makeNode("wait", "B", 100, 0)
+  const c = makeNode("program", "C", 200, 100)
+  const d = makeNode("program", "D", 300, 0)
+  const nodes = [a, b, c, d]
+  const connections = [connect(a, b), connect(b, c), connect(c, d)]
+  return { a, b, c, d, nodes, connections }
+}
+
+describe("analyzeExtractSelection（境界の分類と V1 制約）", () => {
+  it("直列の中間2ノード：入口・出口と内部/入口/出口線を分類する", () => {
+    const { a, b, c, d, nodes, connections } = chain()
+    const result = analyzeExtractSelection(nodes, connections, [b.id, c.id])
+    if (!result.ok) throw new Error(result.reason)
+    expect(result.entryNodeId).toBe(b.id)
+    expect(result.exitPortId).toBe(outOf(c).id)
+    expect(result.internal).toEqual([connect(b, c)])
+    expect(result.inbound).toEqual([connect(a, b)])
+    expect(result.outbound).toEqual([connect(c, d)])
+  })
+
+  it("孤立した島（入出力なし）も抽出できる（entry/exit は null）", () => {
+    const { b, c, nodes } = chain()
+    const internalOnly = [connect(b, c)]
+    const result = analyzeExtractSelection(nodes, internalOnly, [b.id, c.id])
+    if (!result.ok) throw new Error(result.reason)
+    expect(result.entryNodeId).toBeNull()
+    expect(result.exitPortId).toBeNull()
+  })
+
+  it("入口が2ノードになる選択は拒否する", () => {
+    const { a, b, c, d, nodes, connections } = chain()
+    // A→B と D→C を追加：選択 {B, C} への外部入力が B と C の2ノードに入る
+    const withSecondEntry = [...connections, connect(d, c)]
+    const result = analyzeExtractSelection(nodes, withSecondEntry, [b.id, c.id])
+    expect(result.ok).toBe(false)
+    if (!result.ok) expect(result.reason).toContain("入口")
+    void a
+  })
+
+  it("出口が2ポートになる選択は拒否する（同一ポートからの fan-out は許す）", () => {
+    const { a, b, c, d, nodes, connections } = chain()
+    // B→D を追加：選択 {B, C} から外への出力が B.main と C.main の2ポート
+    const twoExits = [...connections, connect(b, d)]
+    const result = analyzeExtractSelection(nodes, twoExits, [b.id, c.id])
+    expect(result.ok).toBe(false)
+    if (!result.ok) expect(result.reason).toContain("出口")
+
+    // C.main → D に加えて C.main → A（同一ポートの fan-out）は出口1つ扱い
+    const fanOut = [
+      ...connections,
+      { from_port_id: outOf(c).id, to_port_id: inOf(a).id },
+    ]
+    const ok = analyzeExtractSelection(nodes, fanOut, [b.id, c.id])
+    expect(ok.ok).toBe(true)
+  })
+
+  it("空・1ノードのみ・start/end 含みは拒否する", () => {
+    const { b, nodes, connections } = chain()
+    expect(analyzeExtractSelection(nodes, connections, []).ok).toBe(false)
+    expect(analyzeExtractSelection(nodes, connections, [b.id]).ok).toBe(false)
+
+    const start = makeNode("start", "開始")
+    const withStart = [...nodes, start]
+    const result = analyzeExtractSelection(withStart, connections, [
+      b.id,
+      start.id,
+    ])
+    expect(result.ok).toBe(false)
+    if (!result.ok) expect(result.reason).toContain("開始")
+  })
+})
+
+describe("buildExtractPlan（子グラフと親置換の生成）", () => {
+  const build = () => {
+    const { a, b, c, d, nodes, connections } = chain()
+    const childStartOutPortId = uuid()
+    const childEndInPortId = uuid()
+    const componentLoopId = uuid()
+    const plan = buildExtractPlan({
+      nodes,
+      connections,
+      selectedIds: [b.id, c.id],
+      name: "PRレビュー",
+      componentLoopId,
+      childStartOutPortId,
+      childEndInPortId,
+      newId: uuid,
+    })
+    if (!plan.ok) throw new Error(plan.reason)
+    return {
+      a,
+      b,
+      c,
+      d,
+      nodes,
+      connections,
+      plan,
+      childStartOutPortId,
+      childEndInPortId,
+      componentLoopId,
+    }
+  }
+
+  it("子：ノードは新 id でコピーされ、kind 設定を引き継ぎ、内部接続の両端が新 id に揃う", () => {
+    const { b, plan } = build()
+    expect(plan.childNodes).toHaveLength(2)
+    const [nb, nc] = plan.childNodes
+    if (!nb || !nc) throw new Error("コピーがない")
+    // 新 id（元と重複しない）・名前と kind 設定のコピー
+    expect(nb.id).not.toBe(b.id)
+    expect(nb.name).toBe("B")
+    expect(nb.wait).toEqual({ wait_type: "duration", duration_seconds: 90 })
+    expect(nc.name).toBe("C")
+    // 内部接続はコピー後のポート id を指す
+    const internal = plan.childConnections.find(
+      (conn) =>
+        conn.from_port_id === outOf(nb).id && conn.to_port_id === inOf(nc).id,
+    )
+    expect(internal).toBeDefined()
+  })
+
+  it("子：start.main → 入口ノード、出口ポート → end.in が配線される", () => {
+    const { plan, childStartOutPortId, childEndInPortId } = build()
+    const [nb, nc] = plan.childNodes
+    if (!nb || !nc) throw new Error("コピーがない")
+    expect(plan.childConnections).toContainEqual({
+      from_port_id: childStartOutPortId,
+      to_port_id: inOf(nb).id,
+    })
+    expect(plan.childConnections).toContainEqual({
+      from_port_id: outOf(nc).id,
+      to_port_id: childEndInPortId,
+    })
+  })
+
+  it("親：選択が groupNode に置き換わり、外部との線が in/main へ繋ぎ直される", () => {
+    const { a, b, c, d, plan, componentLoopId } = build()
+    // groupNode：component 参照・in/main・選択ノードの重心
+    expect(plan.groupNode.kind).toBe("component")
+    expect(plan.groupNode.component).toEqual({
+      component_loop_id: componentLoopId,
+    })
+    expect(plan.groupNode.name).toBe("PRレビュー")
+    expect(plan.groupNode.position_x).toBe(150) // (100+200)/2
+    expect(plan.groupNode.position_y).toBe(50) // (0+100)/2
+
+    // 親 nodes：A, D, groupNode（B, C は消える）
+    expect(plan.parentNodes.map((n) => n.id).sort()).toEqual(
+      [a.id, d.id, plan.groupNode.id].sort(),
+    )
+    // 親 connections：A.main → group.in／group.main → D.in の2本だけ
+    expect(plan.parentConnections).toHaveLength(2)
+    expect(plan.parentConnections).toContainEqual({
+      from_port_id: outOf(a).id,
+      to_port_id: inOf(plan.groupNode).id,
+    })
+    expect(plan.parentConnections).toContainEqual({
+      from_port_id: outOf(plan.groupNode).id,
+      to_port_id: inOf(d).id,
+    })
+    void b
+    void c
+  })
+})

package/_schemas/extract-component.ts

@@ -0,0 +1,224 @@
+import type { GraphConnection, GraphNode } from "./graph.js"
+
+// 矩形選択からのグループ化・コンポーネント化（ノードのグループ化・コンポーネント化.md）。
+// 選択境界を分類・検証し（analyze）、「子（部品）loop の graph」と「親の置換後グラフ」を
+// 生成する（build）。純関数（id 採番は newId で注入）。エディタとテストの両方から使う。
+//
+// V1 制約：component の口は in 1つ・out main 1つなので、
+// 入口（外→選択内の線の到達先ノード）は1つ・出口（選択内→外の線の出発ポート）は1つまで。
+
+export type ExtractAnalysis =
+  | { ok: false; reason: string }
+  | {
+      ok: true
+      // 外部からの入力を受けるノード（入出力の無い孤立した島は null）
+      entryNodeId: string | null
+      // 外部への出力の出発ポート（同一ポートからの fan-out は1出口扱い）
+      exitPortId: string | null
+      internal: GraphConnection[]
+      inbound: GraphConnection[]
+      outbound: GraphConnection[]
+    }
+
+export const analyzeExtractSelection = (
+  nodes: GraphNode[],
+  connections: GraphConnection[],
+  selectedIds: readonly string[],
+): ExtractAnalysis => {
+  const selected = new Set(selectedIds)
+  if (selected.size < 2) {
+    return { ok: false, reason: "2つ以上のノードを選択してください" }
+  }
+  const selectedNodes = nodes.filter((n) => selected.has(n.id))
+  const flow = selectedNodes.find((n) => n.kind === "start" || n.kind === "end")
+  if (flow) {
+    return {
+      ok: false,
+      reason: "開始・終了ノードはグループ化できません",
+    }
+  }
+
+  const nodeIdByPortId = new Map(
+    nodes.flatMap((n) => n.ports.map((p) => [p.id, n.id] as const)),
+  )
+  const internal: GraphConnection[] = []
+  const inbound: GraphConnection[] = []
+  const outbound: GraphConnection[] = []
+  for (const conn of connections) {
+    const fromIn = selected.has(nodeIdByPortId.get(conn.from_port_id) ?? "")
+    const toIn = selected.has(nodeIdByPortId.get(conn.to_port_id) ?? "")
+    if (fromIn && toIn) internal.push(conn)
+    else if (!fromIn && toIn) inbound.push(conn)
+    else if (fromIn && !toIn) outbound.push(conn)
+  }
+
+  const entryNodeIds = new Set(
+    inbound.map((c) => nodeIdByPortId.get(c.to_port_id) ?? ""),
+  )
+  if (entryNodeIds.size > 1) {
+    return {
+      ok: false,
+      reason:
+        "外部からの入力が複数のノードに入っています（入口は1つにしてください）",
+    }
+  }
+  const exitPortIds = new Set(outbound.map((c) => c.from_port_id))
+  if (exitPortIds.size > 1) {
+    return {
+      ok: false,
+      reason:
+        "外部への出力が複数のポートから出ています（出口は1つにしてください）",
+    }
+  }
+
+  return {
+    ok: true,
+    entryNodeId: [...entryNodeIds][0] ?? null,
+    exitPortId: [...exitPortIds][0] ?? null,
+    internal,
+    inbound,
+    outbound,
+  }
+}
+
+export type ExtractPlan = {
+  // 子 loop に入るノード（新 id でコピー。seed 済み start/end は含まない＝呼び出し側が足す）
+  childNodes: GraphNode[]
+  // 内部接続（新 id）＋ start.main → 入口／出口 → end.in
+  childConnections: GraphConnection[]
+  // 親に置く GROUP / COMPONENT ノード（in/main・参照＝componentLoopId・選択の重心）
+  groupNode: GraphNode
+  // 置換後の親グラフ（選択ノードを除き groupNode を足した全量。線は繋ぎ直し済み）
+  parentNodes: GraphNode[]
+  parentConnections: GraphConnection[]
+}
+
+export const buildExtractPlan = (params: {
+  nodes: GraphNode[]
+  connections: GraphConnection[]
+  selectedIds: string[]
+  name: string
+  componentLoopId: string
+  // 子 loop（作成済み・seed 済み）の構造ノードのポート
+  childStartOutPortId: string
+  childEndInPortId: string
+  newId: () => string
+}): { ok: false; reason: string } | ({ ok: true } & ExtractPlan) => {
+  const {
+    nodes,
+    connections,
+    selectedIds,
+    name,
+    componentLoopId,
+    childStartOutPortId,
+    childEndInPortId,
+    newId,
+  } = params
+  const analysis = analyzeExtractSelection(nodes, connections, selectedIds)
+  if (!analysis.ok) return analysis
+
+  const selected = new Set(selectedIds)
+  // ノード・ポートとも新 id を採番してコピー（kind 別設定・hooks は共有参照で問題ない
+  // ＝この後 JSON 化して保存 API に渡すだけで、エディタ状態には子側を持たない）
+  const nodeIdMap = new Map<string, string>()
+  const portIdMap = new Map<string, string>()
+  const childNodes = nodes
+    .filter((n) => selected.has(n.id))
+    .map((n) => {
+      const id = newId()
+      nodeIdMap.set(n.id, id)
+      return {
+        ...n,
+        id,
+        ports: n.ports.map((p) => {
+          const portId = newId()
+          portIdMap.set(p.id, portId)
+          return { ...p, id: portId }
+        }),
+      }
+    })
+
+  const mapConn = (conn: GraphConnection): GraphConnection => ({
+    from_port_id: portIdMap.get(conn.from_port_id) ?? conn.from_port_id,
+    to_port_id: portIdMap.get(conn.to_port_id) ?? conn.to_port_id,
+  })
+  const childConnections = analysis.internal.map(mapConn)
+  // 境界の配線：start.main → 入口ノードの in／出口ポート → end.in
+  if (analysis.entryNodeId !== null) {
+    const entry = childNodes.find(
+      (n) => n.id === nodeIdMap.get(analysis.entryNodeId ?? ""),
+    )
+    const entryIn = entry?.ports.find((p) => p.io === "in")
+    if (entryIn) {
+      childConnections.push({
+        from_port_id: childStartOutPortId,
+        to_port_id: entryIn.id,
+      })
+    }
+  }
+  if (analysis.exitPortId !== null) {
+    childConnections.push({
+      from_port_id: portIdMap.get(analysis.exitPortId) ?? analysis.exitPortId,
+      to_port_id: childEndInPortId,
+    })
+  }
+
+  // 親に置くノード（位置は選択の重心。ポートスキーマは保存時にサーバが契約から焼き込む）
+  const selectedNodes = nodes.filter((n) => selected.has(n.id))
+  const centroid = {
+    x:
+      selectedNodes.reduce((sum, n) => sum + n.position_x, 0) /
+      selectedNodes.length,
+    y:
+      selectedNodes.reduce((sum, n) => sum + n.position_y, 0) /
+      selectedNodes.length,
+  }
+  const groupNode: GraphNode = {
+    id: newId(),
+    kind: "component",
+    name,
+    ports: [
+      { id: newId(), io: "in", key: "in", name: "入力", schema: {} },
+      { id: newId(), io: "out", key: "main", name: "出力", schema: {} },
+    ],
+    hooks: [],
+    position_x: centroid.x,
+    position_y: centroid.y,
+    component: { component_loop_id: componentLoopId },
+  }
+  const groupIn = groupNode.ports.find((p) => p.io === "in")
+  const groupMain = groupNode.ports.find((p) => p.io === "out")
+  if (!groupIn || !groupMain) {
+    return { ok: false, reason: "groupNode のポート生成に失敗しました" }
+  }
+
+  // 親の置換：選択関連の線（内部・境界）を除き、境界を group の in/main へ繋ぎ直す
+  const removed = new Set(
+    [...analysis.internal, ...analysis.inbound, ...analysis.outbound].map(
+      (c) => `${c.from_port_id}→${c.to_port_id}`,
+    ),
+  )
+  const parentConnections = [
+    ...connections.filter(
+      (c) => !removed.has(`${c.from_port_id}→${c.to_port_id}`),
+    ),
+    ...analysis.inbound.map((c) => ({
+      from_port_id: c.from_port_id,
+      to_port_id: groupIn.id,
+    })),
+    ...analysis.outbound.map((c) => ({
+      from_port_id: groupMain.id,
+      to_port_id: c.to_port_id,
+    })),
+  ]
+  const parentNodes = [...nodes.filter((n) => !selected.has(n.id)), groupNode]
+
+  return {
+    ok: true,
+    childNodes,
+    childConnections,
+    groupNode,
+    parentNodes,
+    parentConnections,
+  }
+}