@mawaru/sdk 0.5.0 → 0.9.0

package/dist/_schemas/port-spec.js

@@ -2,14 +2,18 @@ import { z } from "zod";
 // ポートの kind 別型システム（docs/tasks/wip/ポートのkind別仕様.md）。
 // 型の決まり方は3分類：宣言（program / AI の in・out）／固定（human reject の
 // content 型）／導出（それ以外。接続元から伝播し、結果は ports.schema にキャッシュする）
-// content 型・未接続の導出ポートは any（{}）で表す。content の意味（エンジンが
-// content に変換して注入する口）はスキーマではなく kind が決める
-export const ANY_SCHEMA = {};
-export const isAnySchema = (schema) => Object.keys(schema).length === 0 || schema.type === undefined;
-// ---- file 型（AI ノードのファイル入力。docs/tasks/wip/AIノードのファイル入力（file型と添付）.md） ----
+// 「まだ型が決まっていない」＝未宣言を {} で表す（未接続・上流が未宣言・fan-in の型割れ）。
+// 「何でも受ける」型は存在しない：AI の in は接続元の具体型を鏡映し、差し戻しの指示は
+// instruction ポートの宣言型を持つ（docs/tasks/wip/ポートスキーマのany撲滅.md）
+export const UNDECLARED_SCHEMA = {};
+export const isUndeclaredSchema = (schema) => Object.keys(schema).length === 0 || schema.type === undefined;
+// ---- file 型（docs/tasks/done/AIノードのファイル入力（file型と添付）.md） ----
 // schema 上の file は x-mawaru-type マーカー付きの object（nominal に識別する）。値はバイト
-// ではなく storage path の参照（url は startAiStep の dispatch 時に発行して client_payload に
-// のみ載せる）。ajv は strict:false で未知キーワードを無視するので検証は素の JSON Schema のまま。
+// ではなく storage path の参照で、署名 URL はどこにも焼き込まない。
+// **file の位置は名前ではなくこのマーカーで決まる**：runner が宣言スキーマと値を並行走査して
+// 入力はワークスペースへ materialize（パスに置換）、出力はアップロード（参照に置換）する
+// （docs/tasks/wip/ポートスキーマ編集でファイル型を選べるようにする.md）。
+// ajv は strict:false で未知キーワードを無視するので検証は素の JSON Schema のまま。
 export const FILE_SCHEMA_MARKER = "x-mawaru-type";
 export const FILE_SCHEMA_TYPE = "file";
 export const fileSchema = () => ({
@@ -24,6 +28,25 @@ export const fileSchema = () => ({
     required: ["path", "name"],
 });
 export const isFileSchema = (schema) => schema[FILE_SCHEMA_MARKER] === FILE_SCHEMA_TYPE;
+// ---- 差し戻しの指示（AI の instruction ポート / human の reject ポート） ----
+// AI 入力の既存エンベロープ { prompt, files } と同じ形にする。配管が効く根拠は
+// files が file 型として宣言されていることであって、キー名ではない
+// （runner がマーカーで位置を見つけて materialize する）。
+// スクリーンショットを添えて差し戻すケースがあるので文章だけにしない
+// （docs/tasks/wip/ポートスキーマのany撲滅.md）
+export const AI_INSTRUCTION_PORT_KEY = "instruction";
+export const instructionSchema = () => ({
+    type: "object",
+    properties: {
+        prompt: { type: "string", description: "差し戻しの理由（AI への指示）" },
+        files: {
+            type: "array",
+            items: fileSchema(),
+            description: "スクリーンショットなどの参考資料",
+        },
+    },
+    required: ["prompt"],
+});
 // ---- データフォーマットカタログ ----
 // human 承認 UI の表示・編集フォームの出し分けに使う（テキスト＝string（markdown）／
 // リスト＝Array<Row>（列定義つき））。バリデーションには使わない（data は任意の型）
@@ -131,8 +154,34 @@ const FIXED_PORT_KEYS = {
     wait: { in: ["in"], out: ["main"] },
     // start は in 1つ（run 入力契約）＋ out main 1つの恒等パススルー
     start: { in: ["in"], out: ["main"] },
+    // component は in（子 loop の start.in 契約）＋ out main（end.out の戻り値）。
+    // スキーマは保存時にサーバが子 loop の契約から焼き込む宣言型
+    // （DERIVED/MIRROR には入れない＝接続で潰さない）
+    component: { in: ["in"], out: ["main"] },
 };
 const FREE_OUT_KINDS = new Set(["program", "ai"]);
+// out は自由（複数出口＝分岐）だが in の構成は固定。ai は上流データを受ける in と、
+// 差し戻しの指示を受ける instruction の2口（意味の違う入力を1つのポートに
+// fan-in させない。docs/tasks/wip/ポートスキーマのany撲滅.md）
+const FIXED_IN_KEYS = {
+    program: ["in"],
+    ai: ["in", AI_INSTRUCTION_PORT_KEY],
+};
+export const fixedInKeysOf = (kind) => FIXED_IN_KEYS[kind] ?? null;
+// config.json（manifest）の inputs 検査（適合なら null）。同じルールを二重に持たないため
+// manifest 側はここを参照する（docs/tasks/wip/manifestのin複数対応（instructionポート）.md）。
+// **必須は "in" だけ**で、kind が固定する他の in（ai の instruction）は任意：スキーマは
+// constSchemaOf が焼き込む固定型なのでエディタ側で補え、in を2口に分ける前に同期された
+// config.json もそのまま読める
+export const manifestInKeysViolation = (kind, keys) => {
+    const allowed = fixedInKeysOf(kind) ?? ["in"];
+    if (!keys.includes("in"))
+        return 'inputs は "in" を宣言してください';
+    const unknown = keys.filter((key) => !allowed.includes(key));
+    return unknown.length > 0
+        ? `inputs に宣言できない key があります: ${unknown.join(" / ")}（${allowed.join(" / ")} のみ）`
+        : null;
+};
 // kind 別のポート構成違反を返す（適合なら null）。in=1/out>=1 の構造ルールは
 // graph.ts 側の既存チェックが担い、ここは key の固定だけ見る
 export const kindPortsViolation = (kind, ports) => {
@@ -150,10 +199,17 @@ export const kindPortsViolation = (kind, ports) => {
     }
     const fixed = FIXED_PORT_KEYS[kind];
     if (!fixed) {
-        // program / ai（自由 out）：in の key だけ "in" 固定
-        if (FREE_OUT_KINDS.has(kind) &&
-            ports.some((p) => p.io === "in" && p.key !== "in"))
-            return `${kind} の in ポートの key は "in" です`;
+        // program / ai（自由 out）：in の構成だけ固定
+        const expectIn = FIXED_IN_KEYS[kind];
+        if (FREE_OUT_KINDS.has(kind) && expectIn) {
+            const inKeys = ports
+                .filter((p) => p.io === "in")
+                .map((p) => p.key)
+                .sort();
+            if (inKeys.join(",") !== [...expectIn].sort().join(",")) {
+                return `${kind} の in ポートは ${expectIn.join(" / ")} です`;
+            }
+        }
         return null;
     }
     const keysOf = (io) => ports
@@ -167,8 +223,32 @@ export const kindPortsViolation = (kind, ports) => {
     }
     return null;
 };
-// end も導出ノード（各 in は上流から、out main は any）。個別処理は
-// resolvePortSchemas 内で行うが、初期スキーマを any にするためここに含める。
+// ---- 型伝播（導出ポートの解決） ----
+// 接続の両端は同じスキーマになる（値入力フォームのSchemaForm統一.md）。
+// wait / human は素通し（パラメトリック）ノード：in は接続元の out、out は in と同型。
+// 例外は human の approve：接続元が AI ノードのときだけ封筒を剥がして data 型になる。
+// human の reject は未宣言のまま（段階2 で instruction エンベロープを宣言する）。
+// 宣言 out（program / ai）は触らない。
+// program / ai の in は接続鏡映（sticky）：接続元 out が具体型のときだけ上書きし、
+// 未接続・型割れ・未宣言は現スキーマ（宣言）を維持する（鏡映結果は repo の config.json
+// へも書き戻される。docs/tasks/wip/ポート編集のrepo書き戻し同期.md）
+// 複数の流入（fan-in）から型を1つに決める：未宣言を除いて具体型が1種類ならその型、
+// 0種類なら未宣言。2種類以上は型が割れているので未宣言に落とす
+// （保存時に graph.ts が 422 で弾く。伝播は止めずに固定点へ収束させる）
+export const mergeInboundSchemas = (schemas) => {
+    const uniq = [
+        ...new Set(schemas
+            .filter((s) => !isUndeclaredSchema(s))
+            .map((s) => JSON.stringify(s))),
+    ];
+    return uniq.length === 1 && uniq[0] !== undefined
+        ? JSON.parse(uniq[0])
+        : UNDECLARED_SCHEMA;
+};
+// 流入の具体型が2種類以上あるか（＝同じポートに違う型を流し込んでいる）
+export const hasInboundConflict = (schemas) => new Set(schemas.filter((s) => !isUndeclaredSchema(s)).map((s) => JSON.stringify(s))).size > 1;
+// end も導出ノード（各 in は上流から、out main は未宣言）。個別処理は
+// resolvePortSchemas 内で行うが、初期スキーマを未宣言にするためここに含める。
 // start も導出ノード：out main は接続先の in から逆向きに転写し、in は out と同型
 // （run 入力契約＝接続先の入力宣言。開始ノードの入力契約を接続先から導出.md）
 const DERIVED_KINDS = new Set(["wait", "human", "end", "start"]);
@@ -179,18 +259,30 @@ const isDerivedPort = (kind, port) => DERIVED_KINDS.has(kind) &&
 // AI の in は nodes/ai/<dir>/config.json の inputs.in 由来の宣言型が初期値で、
 // 接続時は program と同じ鏡映で接続元と同値に同期される（const 扱い廃止。
 // 接続バリデーションの「ai の in は常に許可」は維持）
-const isConstPort = (kind, port) => kind === "human" && port.io === "out" && port.key === "reject";
+// 宣言型で固定されるポート（導出も鏡映もしない）。差し戻しの指示エンベロープを
+// human の出口と AI の入口の両方に焼き込むことで、両端が同じ具体型で一致する
+const constSchemaOf = (kind, port) => {
+    if (kind === "human" && port.io === "out" && port.key === "reject") {
+        return instructionSchema();
+    }
+    if (kind === "ai" &&
+        port.io === "in" &&
+        port.key === AI_INSTRUCTION_PORT_KEY) {
+        return instructionSchema();
+    }
+    return null;
+};
 // port_id → 解決済みスキーマ。導出は接続を遡って固定点まで反復し、
-// 未接続・複数流入・純パラメトリック閉路は any に落とす（MVP の割り切り）
+// 未接続・純パラメトリック閉路・fan-in の型割れは未宣言に落とす
 export const resolvePortSchemas = (nodes, connections) => {
     const resolved = new Map();
     const kindByPortId = new Map();
     for (const node of nodes) {
         for (const port of node.ports) {
             kindByPortId.set(port.id, node.kind);
-            resolved.set(port.id, isDerivedPort(node.kind, port) || isConstPort(node.kind, port)
-                ? ANY_SCHEMA
-                : port.schema);
+            const constSchema = constSchemaOf(node.kind, port);
+            resolved.set(port.id, constSchema ??
+                (isDerivedPort(node.kind, port) ? UNDECLARED_SCHEMA : port.schema));
         }
     }
     // in ポートへの流入（差し戻しの fan-in があり得る。1本のときだけ型を採用）
@@ -215,52 +307,42 @@ export const resolvePortSchemas = (nodes, connections) => {
                 }
             };
             // start：out main は接続先 in の解決値を転写（逆向き導出）。fan-out は
-            // 非 any が1種類（JSON 等値）のときだけ採用し、未接続・型割れは any。
+            // 非未宣言が1種類（JSON 等値）のときだけ採用し、未接続・型割れは未宣言。
             // in は out main と同型（恒等の向きを out→in に逆転。run 入力契約は
             // 接続先の入力宣言から自動で決まる）
             if (node.kind === "start") {
                 const inPort = node.ports.find((p) => p.io === "in");
                 const outMain = node.ports.find((p) => p.io === "out" && p.key === "main");
                 if (inPort && outMain) {
-                    const targets = (outbound.get(outMain.id) ?? [])
-                        .map((id) => resolved.get(id) ?? ANY_SCHEMA)
-                        .filter((s) => !isAnySchema(s))
-                        .map((s) => JSON.stringify(s));
-                    const uniq = [...new Set(targets)];
-                    const schema = uniq.length === 1 && uniq[0] !== undefined
-                        ? JSON.parse(uniq[0])
-                        : ANY_SCHEMA;
+                    const schema = mergeInboundSchemas((outbound.get(outMain.id) ?? []).map((id) => resolved.get(id) ?? UNDECLARED_SCHEMA));
                     assign(outMain.id, schema);
                     assign(inPort.id, schema);
                 }
                 continue;
             }
             // end：各 in を自分の単一上流から導出（複数ルートを別 in で集約）。
-            // out main は any 固定（ルートごとに型が違いうる。Loop-in-Loop で詰める）
+            // out main は未宣言固定（ルートごとに型が違いうる。Loop-in-Loop で詰める）
             if (node.kind === "end") {
                 for (const port of node.ports) {
                     if (port.io !== "in")
                         continue;
                     const srcs = inbound.get(port.id) ?? [];
-                    assign(port.id, srcs.length === 1 && srcs[0] !== undefined
-                        ? (resolved.get(srcs[0]) ?? ANY_SCHEMA)
-                        : ANY_SCHEMA);
+                    assign(port.id, mergeInboundSchemas(srcs.map((id) => resolved.get(id) ?? UNDECLARED_SCHEMA)));
                 }
                 continue;
             }
             const isMirror = MIRROR_KINDS.has(node.kind);
             if (!DERIVED_KINDS.has(node.kind) && !isMirror)
                 continue;
-            const inPort = node.ports.find((p) => p.io === "in");
+            // ai は in が2口あるので、上流データの口（key="in"）だけを鏡映・導出の対象にする
+            const inPort = node.ports.find((p) => p.io === "in" && p.key === "in");
             if (!inPort)
                 continue;
             const sources = inbound.get(inPort.id) ?? [];
-            const inSchema = sources.length === 1 && sources[0] !== undefined
-                ? (resolved.get(sources[0]) ?? ANY_SCHEMA)
-                : ANY_SCHEMA;
-            // 鏡映（program）は具体型が流れてきたときだけ上書き（宣言を any で潰さない）
+            const inSchema = mergeInboundSchemas(sources.map((id) => resolved.get(id) ?? UNDECLARED_SCHEMA));
+            // 鏡映（program / ai）は具体型が流れてきたときだけ上書き（宣言を未宣言で潰さない）
             if (isMirror) {
-                if (!isAnySchema(inSchema))
+                if (!isUndeclaredSchema(inSchema))
                     assign(inPort.id, inSchema);
                 continue;
             }
@@ -273,7 +355,7 @@ export const resolvePortSchemas = (nodes, connections) => {
             for (const port of node.ports) {
                 if (port.io === "out" && isDerivedPort(node.kind, port)) {
                     assign(port.id, node.kind === "human" && port.key === "approve" && fromAiNode
-                        ? (envelopeDataSchemaOf(inSchema) ?? ANY_SCHEMA)
+                        ? (envelopeDataSchemaOf(inSchema) ?? UNDECLARED_SCHEMA)
                         : inSchema);
                 }
             }
@@ -299,18 +381,15 @@ export const propagateDerivedPorts = (nodes, connections) => {
         return touched ? { ...node, ports } : node;
     });
 };
-// ---- 接続バリデーション（伝播型 ⊆ 宣言スキーマ） ----
-// 完全な JSON Schema 包含ではなく実用的な構造チェック：any は素通し、type 一致、
-// object は宣言側 required の存在と型互換、array は items 互換
-export const isSchemaSubset = (sub, sup) => {
-    if (isAnySchema(sup) || isAnySchema(sub))
-        return true;
-    // file は nominal：マーカー一致の file 同士だけ可（file → any は上の any 判定で許可）。
+export const schemaFit = (sub, sup) => {
+    if (isUndeclaredSchema(sup) || isUndeclaredSchema(sub))
+        return "unknown";
+    // file は nominal：マーカー一致の file 同士だけ可。
     // 構造が同じだけの普通の object は file に繋がない／file は普通の object に繋がない
     if (isFileSchema(sub) || isFileSchema(sup))
-        return isFileSchema(sub) && isFileSchema(sup);
+        return isFileSchema(sub) && isFileSchema(sup) ? "ok" : "mismatch";
     if (sub.type !== sup.type)
-        return false;
+        return "mismatch";
     if (sup.type === "object") {
         const subProps = (sub.properties ?? {});
         const subRequired = (sub.required ?? []);
@@ -318,19 +397,22 @@ export const isSchemaSubset = (sub, sup) => {
         for (const key of (sup.required ?? [])) {
             const subProp = subProps[key];
             if (!subProp || !subRequired.includes(key))
-                return false;
+                return "mismatch";
             const supProp = supProps[key];
-            if (supProp && !isSchemaSubset(subProp, supProp))
-                return false;
+            // ネストは「不適合でなければよい」（未宣言のプロパティで親を落とさない）
+            if (supProp && schemaFit(subProp, supProp) === "mismatch")
+                return "mismatch";
         }
-        return true;
+        return "ok";
     }
     if (sup.type === "array") {
         const supItems = sup.items;
         const subItems = sub.items;
         if (!supItems || !subItems)
-            return true;
-        return isSchemaSubset(subItems, supItems);
+            return "ok";
+        return schemaFit(subItems, supItems) === "mismatch" ? "mismatch" : "ok";
     }
-    return true;
+    return "ok";
 };
+// 保存時の接続チェック用：判断できない（未宣言）ものは通す
+export const isSchemaSubset = (sub, sup) => schemaFit(sub, sup) !== "mismatch";

package/dist/_schemas/program-manifest.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { jsonSchemaSchema, portKeySchema } from "./node.js";
+import { manifestInKeysViolation } from "./port-spec.js";
 // nodes/program/<dir>/config.json（リポジトリ規約 v2）。プログラム自身が入出力スキーマを宣言し、
 // エディタが取り込んで ports を自動生成する（実行時の正は ports テーブルのまま。
 // docs/tasks/wip/プログラムのリポジトリ規約v2（ディレクトリ＋config.json）.md）。
@@ -22,14 +23,11 @@ export const programManifestSchema = z
     refs: z.record(portKeySchema, jsonSchemaSchema).default({}),
 })
     .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 が固定する（program は "in" の1口）。ルールの正は
+    // port-spec 側で、ここは参照するだけ
+    const inViolation = manifestInKeysViolation("program", Object.keys(manifest.inputs));
+    if (inViolation) {
+        ctx.addIssue({ code: "custom", path: ["inputs"], message: inViolation });
     }
     if (Object.keys(manifest.outputs).length < 1) {
         ctx.addIssue({

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./_schemas/ai-manifest.js";
+export * from "./_schemas/extract-component.js";
 export * from "./_schemas/graph.js";
 export * from "./_schemas/hook-manifest.js";
 export * from "./_schemas/node.js";

package/dist/index.js

@@ -2,6 +2,7 @@
 // 正はここ（npm 公開）で、@mawaru/common（private）が re-export して
 // backend / frontend が使う。CLI（typegen / validate）の実装は export しない
 export * from "./_schemas/ai-manifest.js";
+export * from "./_schemas/extract-component.js";
 export * from "./_schemas/graph.js";
 export * from "./_schemas/hook-manifest.js";
 export * from "./_schemas/node.js";

package/dist/init.js

@@ -64,6 +64,9 @@ export const runInit = (root) => {
     }
     writeIfAbsent("CLAUDE.md", template("CLAUDE.md"));
     writeIfAbsent("README.md", template("README.md"));
+    // テンプレートのファイル名を .gitignore にすると npm pack 時に無視ルールとして
+    // 作用してしまうため、ドット無しの "gitignore" で持つ
+    writeIfAbsent(".gitignore", template("gitignore"));
     // package.json：@mawaru/sdk を devDependencies に（ポインタ・docs の参照解決と
     // typegen / validate CLI のため）。バージョンはこのパッケージ自身から取る
     const sdkVersion = JSON.parse(readFileSync(join(packageRoot(), "package.json"), "utf-8")).version;

package/dist/typegen.js

@@ -146,7 +146,14 @@ export const renderTypesFile = (manifest, rawConfig) => {
         envelopeUnionType(Object.keys(manifest.outputs)),
         "",
         ...(refEntries.length > 0
-            ? [`export type Refs = {\n${refEntries.join("\n")}\n}`, ""]
+            ? [
+                `export type Refs = {\n${refEntries.join("\n")}\n}`,
+                "",
+                "// run の第2引数：refs＝届いた袋の読み、setRefs＝袋へのパッチの宣言",
+                "// （書いたキーだけが完了時に袋へマージされ、下流のノードから読める）",
+                "export type Ctx = { refs: Refs; setRefs: (patch: Partial<Refs>) => void }",
+                "",
+            ]
             : []),
     ].join("\n");
 };

package/docs/development.md

@@ -26,10 +26,17 @@ skills/<dir>/      # AI ノードが参照する skill（SKILL.md）
 
 - `config.json` — 入出力スキーマ等の宣言。正は `_schemas/program-manifest.ts`
   （`inputs` は `"in"` の1件だけ・`outputs` は1件以上・`env` は必要な secret 名の宣言）
-- `main.ts` — `run(input, ctx)` を export する。`ctx.refs` にループ変数が入る。戻り値：
+- `main.ts` — `run(input, ctx)` を export する。戻り値：
   - `{ <出口ポートのkey>: <データ> }` の**単一キー封筒**（どの出口から出るかを戻り値自身が運ぶ）
   - `"pending"` — 完了保留（外部イベントで後から end が届く）
-- 型生成：`npx mawaru typegen` が config.json から `types.d.ts`（Input / Outputs 型）を生成する
+- `ctx` — ループ変数の袋の読み書き：
+  - `ctx.refs` — 届いた袋（loop に定義された変数の、この step 開始時点の値）
+  - `ctx.setRefs({ key: value })` — 袋へのパッチの宣言。**完了時にだけ**反映され、以降の
+    ノードが `ctx.refs` で読める（動的な値を下流へ渡す唯一の経路）。何度呼んでもトップレベル
+    キー後勝ちで畳まれる。`"pending"` を返す実行では反映されない。loop に定義の無いキーを
+    書くと step は failed になる
+- 型生成：`npx mawaru typegen` が config.json から `types.d.ts`（Input / Outputs / Refs / Ctx 型）を
+  生成する
 - **ノード単位の npm 依存**：`<dir>/package.json` を置けば実行前にそのディレクトリで
   `npm ci` される。`package-lock.json` の commit が必須（無いと明瞭に失敗する）
 - 環境変数：`config.json` の `env` に宣言した secret（repo の Actions secrets）だけが

package/index.ts

@@ -2,6 +2,7 @@
 // 正はここ（npm 公開）で、@mawaru/common（private）が re-export して
 // backend / frontend が使う。CLI（typegen / validate）の実装は export しない
 export * from "./_schemas/ai-manifest.js"
+export * from "./_schemas/extract-component.js"
 export * from "./_schemas/graph.js"
 export * from "./_schemas/hook-manifest.js"
 export * from "./_schemas/node.js"

package/package.json

@@ -1,20 +1,15 @@
 {
   "name": "@mawaru/sdk",
-  "version": "0.5.0",
+  "version": "0.9.0",
   "description": "mawaru 実行 repo の開発 SDK。契約スキーマ（config.json 規約・ループ graph API）の正 ＋ typegen / validate CLI",
   "type": "module",
   "bin": {
     "mawaru": "dist/cli.js"
   },
   "exports": {
-    ".": "./index.ts"
-  },
-  "publishConfig": {
-    "exports": {
-      ".": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
-      }
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
     }
   },
   "files": [
@@ -28,13 +23,6 @@
   "engines": {
     "node": ">=20"
   },
-  "scripts": {
-    "build": "tsc -p tsconfig.build.json",
-    "prepack": "pnpm build",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run",
-    "test:watch": "vitest"
-  },
   "dependencies": {
     "zod": "^4.4.3",
     "zod-from-json-schema": "^0.5.3"
@@ -43,5 +31,11 @@
     "@types/node": "^26.1.0",
     "typescript": "^6.0.3",
     "vitest": "^4.1.9"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
   }
-}
+}

package/templates/gitignore

@@ -0,0 +1,4 @@
+node_modules/
+# mawaru の API キー等（create-loop スキルが生成する。コミット禁止）
+.env
+.DS_Store