@mawaru/sdk 0.38.0 → 0.40.0

package/_schemas/ai-manifest.test.ts

@@ -145,6 +145,14 @@ describe("aiManifestSchema", () => {
     expect(parsed.inputs.instruction?.resume).toBe(true)
   })
 
+  it("inputs の flexible（推奨型を維持して任意の型を受ける）が読める", () => {
+    const parsed = aiManifestSchema.parse({
+      ...valid,
+      inputs: { in: { schema: { type: "object" }, flexible: true } },
+    })
+    expect(parsed.inputs.in?.flexible).toBe(true)
+  })
+
   it("旧形式（値が素の JSON Schema）は { schema: 値 } として読める", () => {
     const legacy = aiManifestSchema.parse({
       ...valid,

package/_schemas/ai-manifest.ts

@@ -72,6 +72,8 @@ export const agentOfModel = (model: AiModel): AiAgentId =>
 export const aiInputDeclSchema = z.object({
   schema: jsonSchemaSchema,
   resume: z.boolean().optional(),
+  // 推奨型を維持して任意の型を受ける（接続で上書きされず、適合チェックもしない）
+  flexible: z.boolean().optional(),
 })
 export type AiInputDecl = z.infer<typeof aiInputDeclSchema>
 

package/_schemas/graph.test.ts

@@ -174,20 +174,26 @@ describe("humanConfigSchema", () => {
     ).toThrow(/担当/)
   })
 
-  // 承認ビューは不透明なキー（program_dir / ai_dir と同じ）。実在するか・そのテナントが
-  // 選べるかは mawaru 側のカタログ（非公開）と保存 API が見るので、ここは形だけ
-  it("承認ビューを受け付ける", () => {
+  // 実装は nodes/human/ 直下のディレクトリ名（program_dir / ai_dir と同じ）。repo にあるかは保存 API が見る
+  it("実装（human_dir・ref）を受け付ける", () => {
     const parsed = humanConfigSchema.parse({
       assignment: { units: [[uuid()]] },
-      view: "acme/invoice",
+      human_dir: "invoice-review",
+      ref: "try-view",
     })
-    expect(parsed.view).toBe("acme/invoice")
+    expect(parsed.human_dir).toBe("invoice-review")
+    expect(parsed.ref).toBe("try-view")
   })
 
-  it("空のビューキーは拒否する", () => {
-    expect(() =>
-      humanConfigSchema.parse({ assignment: { units: [[uuid()]] }, view: "" }),
-    ).toThrow()
+  it("空・パスの human_dir は拒否する", () => {
+    for (const human_dir of ["", "a/b", "..", "a\\b"]) {
+      expect(() =>
+        humanConfigSchema.parse({
+          assignment: { units: [[uuid()]] },
+          human_dir,
+        }),
+      ).toThrow()
+    }
   })
 
   it("fixed：1ユニット（複数人の and/or）を受け付ける", () => {
@@ -1203,6 +1209,42 @@ describe("saveGraphBodySchema：コンポーネントノード（component kind
     ).not.toThrow()
   })
 
+  it("flexible な in（契約で焼き込まれた component.in・AI の宣言 in）への接続は型が違っても保存できる", () => {
+    const prog = {
+      ...makeNode([
+        port("in", "in"),
+        { ...port("out", "main"), schema: { type: "string" } },
+      ]),
+      kind: "program" as const,
+    }
+    const comp = {
+      ...componentNode({ type: "number" }),
+    }
+    comp.ports = comp.ports.map((p) =>
+      p.io === "in" ? { ...p, flexible: true } : p,
+    )
+    expect(() =>
+      saveGraphBodySchema.parse({
+        nodes: [prog, comp],
+        connections: [connect(prog, comp)],
+      }),
+    ).not.toThrow()
+    // AI の flexible な in：鏡映されず推奨型 {type:"number"} が残るが、型が違う接続を通す
+    const ai = {
+      ...makeNode([
+        { ...port("in", "in"), schema: { type: "number" }, flexible: true },
+        port("out", "main"),
+      ]),
+      kind: "ai" as const,
+    }
+    expect(() =>
+      saveGraphBodySchema.parse({
+        nodes: [prog, ai],
+        connections: [connect(prog, ai)],
+      }),
+    ).not.toThrow()
+  })
+
   it("component の in への接続は契約への適合を検証する（伝播型 ⊆ 契約）", () => {
     // 上流 program の out {type:"string"} → component の in {type:"number"} は不適合
     const prog = {

package/_schemas/graph.ts

@@ -1,4 +1,5 @@
 import { z } from "zod"
+import { humanDeclarationSchema } from "./human-manifest.js"
 import {
   graphPortSchema,
   jsonSchemaSchema,
@@ -6,8 +7,8 @@ import {
   portKeySchema,
 } from "./node.js"
 import {
+  connectionAccepted,
   hasInboundConflict,
-  isSchemaSubset,
   kindPortsViolation,
   resolvePortSchemas,
   UNDECLARED_SCHEMA,
@@ -156,10 +157,23 @@ export type AssignMember = z.infer<typeof assignMemberSchema>
 // メンバーが tenant の membership であることの検証は保存 API 側で行う
 // （docs/tasks/backlog/Human担当者の高度化（複数人承認とラウンドロビン）.md）
 export const humanConfigSchema = z.object({
-  // 承認 UI（承認ビュー）の識別子。program_dir / ai_dir と同じ「不透明なキー」で、
-  // どのキーが実在するか・そのテナントが選べるかは保存時に mawaru 側が検証する
-  // （カタログは非公開。@mawaru/common の approval-view.ts）。省略時は標準ビュー
-  view: z.string().min(1).optional(),
+  // 実装（承認画面と入出力の宣言）の置き場所：実行 repo の nodes/human/ 直下のディレクトリ名。
+  // program_dir / ai_dir と同じ。省略時は mawaru 内蔵の標準の承認画面
+  // （docs/tasks/wip/承認ビューの顧客repo配置.md の「human ノードの実装として置く」）
+  human_dir: z
+    .string()
+    .min(1)
+    .refine(
+      (v) => !v.includes("/") && !v.includes("\\") && v !== "." && v !== "..",
+      "human_dir は nodes/human/ 直下のディレクトリ名で指定してください",
+    )
+    .optional(),
+  // 読むブランチ（省略時はデフォルトブランチ）。publish でその先頭の commit に固定する
+  ref: z.string().min(1).optional(),
+  // 宣言の写し（in / approve / reject の型）。伝播はこれを読む。human_dir を選んだときに
+  // 一覧 API（GET /tenants/:id/github/humans）の宣言を入れる。省略すると保存時に mawaru が repo の
+  // config.json から読む（下書きに同じ human_dir の同じノードがあればその写しを保つ）
+  declaration: humanDeclarationSchema.optional(),
   assignment: z
     .object({
       strategy: z.enum(["fixed", "round_robin"]).default("fixed"),
@@ -293,8 +307,8 @@ export const graphNodeSchema = z.object({
   // 表示アイコン（全 kind 共通の任意設定。human はフロントが担当から導出するので通常設定しない）
   icon: nodeIconSchema.optional(),
   // Slack ビュー（全 kind 共通の任意設定。実行中（human は承認待ち）・完了メッセージの見せ方）。
-  // human の view と同じ「不透明なキー」で、選べる key は GET slack-views が返す。
-  // <slug>/<name> は実行 repo の views/slack/<name>/（@mawaru/sdk/slack-view の契約で書く）。
+  // human の view と同じ「不透明なキー」で、選べる key は GET views/slack が返す。
+  // <slug>/<name> は実行 repo の views/slack/<name>/（@mawaru/sdk/views/slack の契約で書く）。
   // 保存時に mawaru が見るのは common/* の実在と <slug>/* の可視性だけ。
   // 省略＝承認待ちは承認ボタンだけ・完了は ✅ の1行（データは出さない）。
   // ポートの型には一切影響しない
@@ -551,9 +565,10 @@ export const saveGraphBodySchema = z
       // 接続鏡映する口（program / ai の in）とコピー宣言のビューは接続元の型を採用する
       // ので自明に通り、実質の検証対象は宣言で固定された口
       // （component の契約・宣言のあるビューの human.in）になる
+      // flexible な in（AI の宣言 in・契約で焼き込まれた component の in）は型を問わない
       const fromSchema = resolved.get(conn.from_port_id) ?? from.schema
       const toSchema = resolved.get(conn.to_port_id) ?? to.schema
-      if (!isSchemaSubset(fromSchema, toSchema)) {
+      if (!connectionAccepted(fromSchema, { ...to, schema: toSchema })) {
         ctx.addIssue({
           code: "custom",
           path: ["connections", i, "to_port_id"],

package/_schemas/human-manifest.test.ts

@@ -0,0 +1,129 @@
+import { describe, expect, it } from "vitest"
+import {
+  humanDeclarationOfManifest,
+  humanDeclarationSchema,
+  humanManifestSchema,
+  STANDARD_HUMAN_DECLARATION,
+} from "./human-manifest.js"
+import { fileSchema, instructionSchema } from "./port-spec.js"
+
+const pr = {
+  type: "object",
+  properties: {
+    title: { type: "string", description: "PR のタイトル" },
+    gifs: { type: "array", items: fileSchema() },
+    count: { type: "integer" },
+  },
+  required: ["title"],
+}
+
+const issuesOf = (value: unknown) => {
+  const parsed = humanDeclarationSchema.safeParse(value)
+  return parsed.success
+    ? []
+    : parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`)
+}
+
+describe("humanDeclarationSchema（宣言の検査）", () => {
+  it("標準ビューの宣言と具体型の宣言を通す", () => {
+    expect(issuesOf(STANDARD_HUMAN_DECLARATION)).toEqual([])
+    expect(
+      issuesOf({ in: pr, approve: pr, reject: instructionSchema() }),
+    ).toEqual([])
+    // 未宣言（{}）も宣言の1つ（スキーマ未定義）
+    expect(issuesOf({ in: {}, approve: "T", reject: {} })).toEqual([])
+  })
+
+  it("type の配列（nullable）は場所つきで弾く", () => {
+    expect(
+      issuesOf({
+        in: {
+          type: "object",
+          properties: { summary: { type: ["string", "null"] } },
+        },
+        approve: "T",
+        reject: instructionSchema(),
+      }),
+    ).toEqual([
+      "in.properties.summary.type: 配列（nullable）は使えません。任意の値は required から外してください",
+    ])
+  })
+
+  it("知らない type・形の崩れた properties / required / items を弾く", () => {
+    expect(
+      issuesOf({
+        in: { type: "strin" },
+        approve: { type: "object", properties: [] },
+        reject: {
+          type: "object",
+          required: [1],
+          properties: { list: { type: "array", items: "x" } },
+        },
+      }),
+    ).toEqual([
+      "in.type: type は object / array / string / number / integer / boolean のどれかにしてください（strin）",
+      "approve.properties: properties はオブジェクトで書いてください",
+      "reject.properties.list.items: items はスキーマ（オブジェクト）で書いてください",
+      "reject.required: required は文字列の配列で書いてください",
+    ])
+  })
+
+  it("type の無い構造（properties / items だけ）を弾く", () => {
+    expect(
+      issuesOf({
+        in: { properties: { a: { type: "string" } } },
+        approve: "T",
+        reject: instructionSchema(),
+      }),
+    ).toEqual([
+      "in.type: properties / items を書くときは type も書いてください",
+    ])
+  })
+
+  it('reject は上流のコピー（"T"）にできない', () => {
+    expect(issuesOf({ in: "T", approve: "T", reject: "T" })).not.toEqual([])
+  })
+})
+
+describe("humanManifestSchema（nodes/human/<dir>/config.json）", () => {
+  it("省略した口は上流のコピー（in）・in と同型（approve）・標準の差し戻し（reject）になる", () => {
+    const config = humanManifestSchema.parse({})
+    expect(humanDeclarationOfManifest(config)).toEqual(
+      STANDARD_HUMAN_DECLARATION,
+    )
+  })
+
+  it("書いた口の型をそのまま宣言にする", () => {
+    const config = humanManifestSchema.parse({
+      inputs: { in: { schema: pr } },
+      outputs: { approve: { type: "array", items: pr }, reject: pr },
+    })
+    expect(humanDeclarationOfManifest(config)).toEqual({
+      in: pr,
+      approve: { type: "array", items: pr },
+      reject: pr,
+    })
+  })
+
+  it("in / approve / reject 以外の口・知らないキーは弾く", () => {
+    expect(
+      humanManifestSchema.safeParse({ inputs: { instruction: {} } }).success,
+    ).toBe(false)
+    expect(
+      humanManifestSchema.safeParse({ outputs: { notion: {} } }).success,
+    ).toBe(false)
+    expect(humanManifestSchema.safeParse({ name: "x" }).success).toBe(false)
+  })
+
+  it("中の型も宣言の検査を通す", () => {
+    const parsed = humanManifestSchema.safeParse({
+      inputs: { in: { schema: { type: ["string", "null"] } } },
+    })
+    expect(parsed.success).toBe(false)
+    expect(
+      parsed.error?.issues.map((i) => `${i.path.join(".")}: ${i.message}`),
+    ).toEqual([
+      "inputs.in.schema.type: 配列（nullable）は使えません。任意の値は required から外してください",
+    ])
+  })
+})

package/_schemas/human-manifest.ts

@@ -0,0 +1,158 @@
+import { z } from "zod"
+import { type JsonSchema, jsonSchemaSchema } from "./node.js"
+import {
+  COPY_UPSTREAM_SCHEMA,
+  type DeclaredPortSchema,
+  instructionSchema,
+} from "./port-spec.js"
+
+// ---- human ノードの宣言（in / approve / reject の型） ----
+// 正は実装を持つ側（顧客 repo の nodes/human/<dir>/config.json。実装を指さないノードは標準の宣言）。
+// human ノードは実装を選んだ時点の写し（node_humans.declaration）を持ち、伝播はそれを読む
+// （docs/tasks/wip/承認ビューの顧客repo配置.md の「宣言（ポート型）」）。
+// "T"（COPY_UPSTREAM_SCHEMA）は「上流の out をそのまま受ける」（in）／「in と同型」（approve）。
+// reject は具体型だけ（上流のコピーは意味を持たない）
+
+export type HumanDeclaration = {
+  in: DeclaredPortSchema
+  approve: DeclaredPortSchema
+  reject: JsonSchema
+}
+
+// 宣言に書ける type。file は x-mawaru-type マーカー付きの object
+const DECLARED_TYPES = [
+  "object",
+  "array",
+  "string",
+  "number",
+  "integer",
+  "boolean",
+] as const
+
+const isPlainObject = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null && !Array.isArray(value)
+
+// JSON Schema の形の崩れを場所つきで返す。接続の比較（schemaFit）が扱える形だけを通す：
+// 顧客 repo の宣言は mawaru のレビューを通らないので、壊れた型がノードに写る前に止める
+const schemaIssues = (
+  schema: Record<string, unknown>,
+  path: (string | number)[],
+): { path: (string | number)[]; message: string }[] => {
+  const issues: { path: (string | number)[]; message: string }[] = []
+  const { type, properties, required, items } = schema
+  if (Array.isArray(type)) {
+    issues.push({
+      path: [...path, "type"],
+      message:
+        "配列（nullable）は使えません。任意の値は required から外してください",
+    })
+  } else if (
+    type !== undefined &&
+    !DECLARED_TYPES.includes(type as (typeof DECLARED_TYPES)[number])
+  ) {
+    issues.push({
+      path: [...path, "type"],
+      message: `type は ${DECLARED_TYPES.join(" / ")} のどれかにしてください（${String(type)}）`,
+    })
+  } else if (
+    type === undefined &&
+    (properties !== undefined || items !== undefined)
+  ) {
+    issues.push({
+      path: [...path, "type"],
+      message: "properties / items を書くときは type も書いてください",
+    })
+  }
+  if (properties !== undefined) {
+    if (!isPlainObject(properties)) {
+      issues.push({
+        path: [...path, "properties"],
+        message: "properties はオブジェクトで書いてください",
+      })
+    } else {
+      for (const [key, child] of Object.entries(properties)) {
+        if (!isPlainObject(child)) {
+          issues.push({
+            path: [...path, "properties", key],
+            message: "スキーマはオブジェクトで書いてください",
+          })
+          continue
+        }
+        issues.push(...schemaIssues(child, [...path, "properties", key]))
+      }
+    }
+  }
+  if (
+    required !== undefined &&
+    !(Array.isArray(required) && required.every((r) => typeof r === "string"))
+  ) {
+    issues.push({
+      path: [...path, "required"],
+      message: "required は文字列の配列で書いてください",
+    })
+  }
+  if (items !== undefined) {
+    if (!isPlainObject(items)) {
+      issues.push({
+        path: [...path, "items"],
+        message: "items はスキーマ（オブジェクト）で書いてください",
+      })
+    } else {
+      issues.push(...schemaIssues(items, [...path, "items"]))
+    }
+  }
+  return issues
+}
+
+// 宣言に書く1つの型（検査つき）
+const checkedSchema = jsonSchemaSchema.superRefine((schema, ctx) => {
+  for (const issue of schemaIssues(schema, []))
+    ctx.addIssue({ code: "custom", ...issue })
+})
+
+const declaredPortSchema = z.union([
+  z.literal(COPY_UPSTREAM_SCHEMA),
+  checkedSchema,
+])
+
+export const humanDeclarationSchema = z.object({
+  in: declaredPortSchema,
+  approve: declaredPortSchema,
+  reject: checkedSchema,
+}) satisfies z.ZodType<HumanDeclaration>
+
+// 標準ビュー（common/standard）の宣言：上流の型をそのまま受けて出し、差し戻しは標準の指示フォーム
+export const STANDARD_HUMAN_DECLARATION: HumanDeclaration = {
+  in: COPY_UPSTREAM_SCHEMA,
+  approve: COPY_UPSTREAM_SCHEMA,
+  reject: instructionSchema(),
+}
+
+// ---- 顧客 repo の nodes/human/<dir>/config.json ----
+// 形は AI の config.json に揃える（inputs の値は { schema }、outputs の値は素の JSON Schema）。
+// 口は in / approve / reject 固定。省略した口は STANDARD_HUMAN_DECLARATION と同じ扱い
+export const humanManifestSchema = z
+  .object({
+    inputs: z
+      .object({ in: z.object({ schema: checkedSchema }).strict().optional() })
+      .strict()
+      .optional(),
+    outputs: z
+      .object({
+        approve: checkedSchema.optional(),
+        reject: checkedSchema.optional(),
+      })
+      .strict()
+      .optional(),
+  })
+  .strict()
+
+export type HumanManifest = z.infer<typeof humanManifestSchema>
+
+export const humanDeclarationOfManifest = (
+  config: HumanManifest,
+): HumanDeclaration => ({
+  in: config.inputs?.in?.schema ?? COPY_UPSTREAM_SCHEMA,
+  approve: config.outputs?.approve ?? COPY_UPSTREAM_SCHEMA,
+  reject: config.outputs?.reject ?? instructionSchema(),
+})

package/_schemas/node.ts

@@ -54,6 +54,10 @@ export const graphPortSchema = z
     // 再開する（AI ノードで意味を持つ。key ではなくこの属性が再開を決める。
     // ポート型固定の撤去とセッション再開のポート属性化.md）
     resume: z.boolean().optional(),
+    // in ポートの型属性：true なら宣言（推奨型）を維持し、接続元の型による上書き・
+    // 適合チェックをしない（AI の in で設定。start / component へは導出で流れる。
+    // AIノード入力のflexible属性（任意の型で呼べるループ）.md）
+    flexible: z.boolean().optional(),
     side: portSideSchema.optional(),
     offset: z.number().min(0).max(1).optional(),
   })