sonamu 0.10.12 → 0.10.13

package/dist/ui/ai-api.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ai-api.d.ts","sourceRoot":"","sources":["../../src/ui/ai-api.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,SAAS,CAAC;AAO/C,wBAAsB,QAAQ,CAAC,MAAM,EAAE,eAAe,iBAsDrD"}
+{"version":3,"file":"ai-api.d.ts","sourceRoot":"","sources":["../../src/ui/ai-api.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,SAAS,CAAC;AAO/C,wBAAsB,QAAQ,CAAC,MAAM,EAAE,eAAe,iBAwDrD"}

package/dist/ui/ai-api.js

@@ -47,4 +47,4 @@ var init_ai_api = __esmMin((() => {
 init_ai_api();
 export { init_ai_api, setAiApi };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/ui/ai-client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ai-client.d.ts","sourceRoot":"","sources":["../../src/ui/ai-client.ts"],"names":[],"mappings":"AAKA,OAAO,EAAsB,KAAK,YAAY,EAAE,KAAK,gBAAgB,EAAE,MAAM,IAAI,CAAC;AAWlF,OAAO,EAAmB,KAAK,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAQrE,cAAM,QAAQ;IACZ,OAAO,CAAC,KAAK,CAA8B;IAC3C,OAAO,CAAC,KAAK,CAIG;IAEV,IAAI;IAcV,aAAa,CACX,QAAQ,EAAE,YAAY,EAAE,EACxB,cAAc,EAAE,aAAa,EAAE,GAC9B,gBAAgB,CAAC,GAAG,EAAE,GAAG,CAAC;IA+M7B,YAAY,CAAC,QAAQ,EAAE,YAAY,EAAE,GAAG,gBAAgB,CAAC,GAAG,EAAE,GAAG,CAAC;CA8QnE;AAiDD,eAAO,MAAM,QAAQ,UAAiB,CAAC"}
+{"version":3,"file":"ai-client.d.ts","sourceRoot":"","sources":["../../src/ui/ai-client.ts"],"names":[],"mappings":"AAKA,OAAO,EAAsB,KAAK,YAAY,EAAE,KAAK,gBAAgB,EAAE,MAAM,IAAI,CAAC;AAWlF,OAAO,EAAmB,KAAK,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAarE,cAAM,QAAQ;IACZ,OAAO,CAAC,KAAK,CAA8B;IAC3C,OAAO,CAAC,KAAK,CAIG;IAEV,IAAI;IAcV,aAAa,CACX,QAAQ,EAAE,YAAY,EAAE,EACxB,cAAc,EAAE,aAAa,EAAE,GAC9B,gBAAgB,CAAC,GAAG,EAAE,GAAG,CAAC;IAyM7B,YAAY,CAAC,QAAQ,EAAE,YAAY,EAAE,GAAG,gBAAgB,CAAC,GAAG,EAAE,GAAG,CAAC;CAoRnE;AAiDD,eAAO,MAAM,QAAQ,UAAiB,CAAC"}

package/dist/ui/ai-client.js

@@ -1,9 +1,9 @@
 import { __esmMin } from "../_virtual/_rolldown/runtime.js";
 import { init_utils, nonNullable } from "../utils/utils.js";
-import { Sonamu, init_sonamu } from "../api/sonamu.js";
 import { TemplateOptions, getEnumDefValues, init_types, isInternalSubsetField, normalizeSubsetField } from "../types/types.js";
+import { Sonamu, init_sonamu } from "../api/sonamu.js";
 import { EntityManager, init_entity_manager } from "../entity/entity-manager.js";
-import { z as z$1 } from "zod";
+import { z } from "zod";
 import assert from "assert";
 import fs from "fs";
 import path from "path";
@@ -38,12 +38,20 @@ function validateEntityJson(input) {
 	});
 	return errors;
 }
-var AIClient, aiClient;
+var fixtureScalarSchema, fixtureColumnValueSchema, fixtureColumnsSchema, AIClient, aiClient;
 var init_ai_client = __esmMin((() => {
 	init_sonamu();
 	init_entity_manager();
 	init_types();
 	init_utils();
+	fixtureScalarSchema = z.union([
+		z.string(),
+		z.number(),
+		z.boolean(),
+		z.null()
+	]);
+	fixtureColumnValueSchema = z.union([fixtureScalarSchema, z.array(fixtureScalarSchema)]);
+	fixtureColumnsSchema = z.record(z.string(), fixtureColumnValueSchema);
 	AIClient = class {
 		model = null;
 		aiSdk = null;
@@ -63,6 +71,7 @@ var init_ai_client = __esmMin((() => {
 		}
 		handleFixture(messages, fixtureRecords) {
 			if (!this.aiSdk || !this.model) throw new Error("AI SDK not initialized. Call init() first.");
+			const model = this.model;
 			const entityStructures = [...new Set(fixtureRecords.map((r) => r.entityId))].map((entityId) => {
 				const entity = EntityManager.get(entityId);
 				return {
@@ -103,15 +112,15 @@ var init_ai_client = __esmMin((() => {
       `;
 			const { streamText, tool } = this.aiSdk;
 			return streamText({
-				model: this.model,
+				model,
 				system: systemMessage,
 				messages,
 				tools: {
 					updateFixtures: tool({
 						description: "픽스쳐 레코드의 값을 수정합니다. 사용자가 특정 컬럼이나 값을 변경해달라고 요청할 때 사용하세요.",
-						inputSchema: z$1.object({ updates: z$1.array(z$1.object({
-							fixtureId: z$1.string().describe("수정할 픽스쳐 ID (형식: EntityId#id)"),
-							updates: z$1.record(z$1.string(), z$1.unknown()).describe("컬럼명을 키로, 새 값을 값으로 하는 객체")
+						inputSchema: z.object({ updates: z.array(z.object({
+							fixtureId: z.string().describe("수정할 픽스쳐 ID (형식: EntityId#id)"),
+							updates: fixtureColumnsSchema.describe("컬럼명을 키로, 새 값을 값으로 하는 객체")
 						})) }),
 						execute: async ({ updates }) => {
 							return {
@@ -129,10 +138,10 @@ var init_ai_client = __esmMin((() => {
 					}),
 					createFixtures: tool({
 						description: "새로운 픽스쳐 레코드를 생성합니다. 사용자가 새로운 데이터를 추가해달라고 요청할 때 사용하세요.",
-						inputSchema: z$1.object({ fixtures: z$1.array(z$1.object({
-							entityId: z$1.string().describe("생성할 엔티티 ID"),
-							id: z$1.number().describe("새 레코드의 ID (음수 권장, 예: -1, -2)"),
-							columns: z$1.record(z$1.string(), z$1.unknown()).describe("컬럼명을 키로, 값을 값으로 하는 객체")
+						inputSchema: z.object({ fixtures: z.array(z.object({
+							entityId: z.string().describe("생성할 엔티티 ID"),
+							id: z.number().describe("새 레코드의 ID (음수 권장, 예: -1, -2)"),
+							columns: fixtureColumnsSchema.describe("컬럼명을 키로, 값을 값으로 하는 객체")
 						})) }),
 						execute: async ({ fixtures }) => {
 							const newRecords = fixtures.map((fixture) => {
@@ -195,6 +204,7 @@ var init_ai_client = __esmMin((() => {
 		}
 		handleEntity(messages) {
 			if (!this.aiSdk || !this.model) throw new Error("AI SDK not initialized. Call init() first.");
+			const model = this.model;
 			const instructionsPath = path.join(import.meta.dirname, "..", "..", "src", "ui", "entity.instructions.md");
 			const instructions = fs.readFileSync(instructionsPath, "utf-8");
 			const existingEntities = EntityManager.getAllIds().map((entityId) => {
@@ -278,14 +288,14 @@ updateEntity({ entityId: "Project", updates: { props: [{ name: "priority", type:
       `;
 			const { streamText, tool, stepCountIs } = this.aiSdk;
 			return streamText({
-				model: this.model,
+				model,
 				system: systemMessage,
 				messages,
 				stopWhen: stepCountIs(2),
 				tools: {
 					createEntity: tool({
 						description: "새로운 Entity를 생성합니다. 사용자가 새로운 엔티티나 테이블 생성을 요청할 때 사용하세요.",
-						inputSchema: TemplateOptions.shape.entity,
+						inputSchema: TemplateOptions["shape"].entity,
 						execute: async (entity) => {
 							try {
 								const validationErrors = validateEntityJson(entity);
@@ -317,10 +327,10 @@ updateEntity({ entityId: "Project", updates: { props: [{ name: "priority", type:
 					}),
 					updateEntity: tool({
 						description: "기존 Entity를 수정합니다. Enum 추가, props 추가/수정, indexes 수정, subsets 수정 등 모든 엔티티 수정 작업에 사용하세요.",
-						inputSchema: z$1.object({
-							entityId: z$1.string().describe("수정할 Entity ID"),
-							updates: TemplateOptions.shape.entity.partial().describe("수정할 필드들"),
-							mode: z$1.enum(["merge", "replace"]).optional().describe("수정 모드: merge(기본값, 기존 값에 병합) 또는 replace(전체 교체)")
+						inputSchema: z.object({
+							entityId: z.string().describe("수정할 Entity ID"),
+							updates: TemplateOptions["shape"].entity.partial().describe("수정할 필드들"),
+							mode: z.enum(["merge", "replace"]).optional().describe("수정 모드: merge(기본값, 기존 값에 병합) 또는 replace(전체 교체)")
 						}),
 						execute: async ({ entityId, updates, mode = "merge" }) => {
 							try {
@@ -396,4 +406,4 @@ updateEntity({ entityId: "Project", updates: { props: [{ name: "priority", type:
 init_ai_client();
 export { aiClient, init_ai_client };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"ai-client.js","names":["z"],"sources":["../../src/ui/ai-client.ts"],"sourcesContent":["import assert from \"assert\";\nimport fs from \"fs\";\nimport path from \"path\";\n\n/* oxlint-disable @typescript-eslint/no-explicit-any */ // AI SDK의 타입이 명확하지 않아 any를 허용함\nimport { type LanguageModel, type ModelMessage, type StreamTextResult } from \"ai\";\nimport { z } from \"zod\";\n\nimport { Sonamu } from \"../api/sonamu\";\nimport { EntityManager } from \"../entity/entity-manager\";\nimport {\n  getEnumDefValues,\n  isInternalSubsetField,\n  normalizeSubsetField,\n  TemplateOptions,\n} from \"../types/types\";\nimport { type EntityProp, type FixtureRecord } from \"../types/types\";\nimport { nonNullable } from \"../utils/utils\";\n\ntype ValidationError = {\n  field: string;\n  message: string;\n};\n\nclass AIClient {\n  private model: LanguageModel | null = null;\n  private aiSdk:\n    | (typeof import(\"ai\") & {\n        anthropic?: typeof import(\"@ai-sdk/anthropic\").anthropic;\n      })\n    | null = null;\n\n  async init() {\n    try {\n      const { anthropic } = await import(\"@ai-sdk/anthropic\");\n      const aiModule = await import(\"ai\");\n      this.aiSdk = { ...aiModule, anthropic };\n      this.model = anthropic(\"claude-sonnet-4-6\");\n    } catch (error) {\n      console.warn(\n        \"AI SDK packages not installed. Install @ai-sdk/anthropic and ai to use AI features.\",\n      );\n      throw error;\n    }\n  }\n\n  handleFixture(\n    messages: ModelMessage[],\n    fixtureRecords: FixtureRecord[],\n  ): StreamTextResult<any, any> {\n    if (!this.aiSdk || !this.model) {\n      throw new Error(\"AI SDK not initialized. Call init() first.\");\n    }\n\n    // 현재 fixtureRecords에서 사용된 엔티티들의 구조 정보 수집\n    const usedEntityIds = [...new Set(fixtureRecords.map((r) => r.entityId))];\n    const entityStructures = usedEntityIds.map((entityId) => {\n      const entity = EntityManager.get(entityId);\n\n      return {\n        entityId: entity.id,\n        table: entity.table,\n        props: entity.props,\n        relations: entity.relations,\n        enumLabels: entity.enumLabels,\n      };\n    });\n\n    const systemMessage = `\n        당신은 픽스쳐 레코드를 수정하고 생성할 수 있는 도우미입니다.\n\n        현재 픽스쳐 레코드:\n        ${JSON.stringify(fixtureRecords, null, 2)}\n\n        엔티티 구조 정보:\n        ${JSON.stringify(entityStructures, null, 2)}\n\n        ## 픽스쳐 수정\n        사용자가 픽스쳐 값 수정을 요청하면 updateFixtures 도구를 사용하여 변경사항을 적용하세요.\n        - fixtureId: 수정할 픽스쳐 ID (형식: \"EntityId#id\")\n        - updates: 컬럼명을 키로, 새 값을 값으로 하는 객체\n\n        예시: \"User#1\" 픽스쳐의 \"name\" 컬럼을 \"홍길동\"으로 변경하려면:\n        updateFixtures({ updates: [{ fixtureId: \"User#1\", updates: { name: \"홍길동\" } }] })\n\n        변경될 컬럼의 type이 relation인 경우, 관련 엔티티에도 반영되어야 할 컬럼이 있는지 확인하세요.\n\n        ## 픽스쳐 생성\n        사용자가 새로운 픽스쳐 생성을 요청하면 createFixtures 도구를 사용하세요.\n        - entityId: 생성할 엔티티 ID\n        - id: 새 레코드의 ID (기존 픽스쳐와 중복되지 않는 음수 사용 권장, 예: -1, -2)\n        - columns: 컬럼명을 키로, 값을 값으로 하는 객체 (엔티티 구조 참고)\n\n        예시: 새로운 User 픽스쳐를 생성하려면:\n        createFixtures({ fixtures: [{ entityId: \"User\", id: -1, columns: { name: \"홍길동\", email: \"hong@example.com\" } }] })\n      `;\n\n    const { streamText, tool } = this.aiSdk;\n\n    return streamText({\n      model: this.model,\n      system: systemMessage,\n      messages,\n      tools: {\n        updateFixtures: tool({\n          description:\n            \"픽스쳐 레코드의 값을 수정합니다. 사용자가 특정 컬럼이나 값을 변경해달라고 요청할 때 사용하세요.\",\n          inputSchema: z.object({\n            updates: z.array(\n              z.object({\n                fixtureId: z.string().describe(\"수정할 픽스쳐 ID (형식: EntityId#id)\"),\n                updates: z\n                  .record(z.string(), z.unknown())\n                  .describe(\"컬럼명을 키로, 새 값을 값으로 하는 객체\"),\n              }),\n            ),\n          }),\n          execute: async ({\n            updates,\n          }: {\n            updates: Array<{ fixtureId: string; updates: Record<string, unknown> }>;\n          }): Promise<{ success: boolean; updatedRecords: FixtureRecord[] }> => {\n            // fixtureRecords를 복사하고 업데이트 적용\n            const updatedRecords: FixtureRecord[] = fixtureRecords.map((record) => {\n              const update = updates.find(\n                (u: { fixtureId: string }) => u.fixtureId === record.fixtureId,\n              );\n              if (update) {\n                // columns의 value를 업데이트\n                for (const [columnName, newValue] of Object.entries(update.updates)) {\n                  record.columns[columnName].value =\n                    newValue as FixtureRecord[\"columns\"][string][\"value\"];\n                }\n                return record;\n              }\n\n              return record;\n            });\n\n            return { success: true, updatedRecords };\n          },\n        }),\n        createFixtures: tool({\n          description:\n            \"새로운 픽스쳐 레코드를 생성합니다. 사용자가 새로운 데이터를 추가해달라고 요청할 때 사용하세요.\",\n          inputSchema: z.object({\n            fixtures: z.array(\n              z.object({\n                entityId: z.string().describe(\"생성할 엔티티 ID\"),\n                id: z.number().describe(\"새 레코드의 ID (음수 권장, 예: -1, -2)\"),\n                columns: z\n                  .record(z.string(), z.unknown())\n                  .describe(\"컬럼명을 키로, 값을 값으로 하는 객체\"),\n              }),\n            ),\n          }),\n          execute: async ({\n            fixtures,\n          }: {\n            fixtures: Array<{ entityId: string; id: number; columns: Record<string, unknown> }>;\n          }): Promise<{ success: boolean; updatedRecords: FixtureRecord[] }> => {\n            const newRecords: FixtureRecord[] = fixtures.map(\n              (fixture: { entityId: string; id: number; columns: Record<string, unknown> }) => {\n                const entity = EntityManager.get(fixture.entityId);\n\n                // 엔티티 props를 기반으로 columns 구성\n                const columns: FixtureRecord[\"columns\"] = {};\n                for (const prop of entity.props) {\n                  if (prop.type === \"virtual\") continue;\n\n                  let value = fixture.columns[prop.name] ?? null;\n\n                  if (prop.name === \"created_at\") {\n                    // 현재 시간으로 설정\n                    value = new Date().toISOString();\n                  } else if (\n                    prop.type === \"relation\" &&\n                    (prop.relationType === \"HasMany\" || prop.relationType === \"ManyToMany\")\n                  ) {\n                    // 배열로 변환\n                    value = Array.isArray(value) ? value : [value].filter(nonNullable);\n                  }\n\n                  columns[prop.name] = {\n                    prop,\n                    value: value as FixtureRecord[\"columns\"][string][\"value\"],\n                  };\n                }\n\n                return {\n                  fixtureId: `${fixture.entityId}#${fixture.id}`,\n                  entityId: fixture.entityId,\n                  id: fixture.id,\n                  columns,\n                  fetchedRecords: [],\n                  belongsRecords: [],\n                  override: false,\n                };\n              },\n            );\n\n            // 새 레코드들의 relation 컬럼을 확인하여 기존 레코드들의 역방향 relation 업데이트\n            for (const newRecord of newRecords) {\n              for (const [_colName, col] of Object.entries(newRecord.columns)) {\n                if (col.prop.type !== \"relation\" || col.value === null) continue;\n\n                const relatedEntityId = col.prop.with;\n                const relatedIds = Array.isArray(col.value) ? col.value : [col.value];\n\n                for (const relatedId of relatedIds) {\n                  const relatedFixtureId = `${relatedEntityId}#${relatedId}`;\n                  const relatedRecord = newRecords.find((r) => r.fixtureId === relatedFixtureId);\n\n                  if (relatedRecord) {\n                    // 역방향 relation 찾기\n                    const reverseCol = Object.entries(relatedRecord.columns).find(\n                      ([, c]) => c.prop.type === \"relation\" && c.prop.with === newRecord.entityId,\n                    );\n\n                    if (reverseCol) {\n                      const [reverseColName, reverseColValue] = reverseCol;\n                      const currentValue = reverseColValue.value;\n\n                      // 역방향이 배열인 경우 (HasMany, ManyToMany)\n                      if (\n                        reverseColValue.prop.type === \"relation\" &&\n                        (reverseColValue.prop.relationType === \"HasMany\" ||\n                          reverseColValue.prop.relationType === \"ManyToMany\")\n                      ) {\n                        assert(Array.isArray(currentValue), \"currentValue must be an array\");\n                        if (!currentValue.includes(newRecord.id)) {\n                          relatedRecord.columns[reverseColName] = {\n                            ...reverseColValue,\n                            value: [...currentValue, newRecord.id],\n                          };\n                        }\n                      } else {\n                        // 역방향이 단일 값인 경우 (BelongsToOne, OneToOne)\n                        relatedRecord.columns[reverseColName] = {\n                          ...reverseColValue,\n                          value: newRecord.id,\n                        };\n                      }\n                    }\n                  }\n                }\n              }\n            }\n\n            return { success: true, updatedRecords: newRecords };\n          },\n        }),\n      },\n    });\n  }\n\n  handleEntity(messages: ModelMessage[]): StreamTextResult<any, any> {\n    if (!this.aiSdk || !this.model) {\n      throw new Error(\"AI SDK not initialized. Call init() first.\");\n    }\n\n    // entity.instructions.md 파일 읽기 (dist/ui 또는 src/ui에서 실행되므로 패키지 루트 기준으로 접근)\n    const instructionsPath = path.join(\n      import.meta.dirname,\n      \"..\",\n      \"..\",\n      \"src\",\n      \"ui\",\n      \"entity.instructions.md\",\n    );\n    const instructions = fs.readFileSync(instructionsPath, \"utf-8\");\n\n    // 현재 등록된 엔티티 정보 수집\n    const entityIds = EntityManager.getAllIds();\n    const existingEntities = entityIds.map((entityId) => {\n      const entity = EntityManager.get(entityId);\n      return {\n        id: entity.id,\n        title: entity.title,\n        table: entity.table,\n        props: entity.props.map((p) => ({\n          name: p.name,\n          type: p.type,\n          desc: p.desc,\n        })),\n      };\n    });\n\n    const systemMessage = `\n당신은 Sonamu 프레임워크에서 Entity와 Enum을 생성하는 도우미입니다.\n\n${instructions}\n\n## 현재 등록된 Entity 목록\n다른 엔티티와 관계(relation)를 맺거나 subset에서 참조할 때 반드시 아래 정보를 확인하세요.\n\n${JSON.stringify(existingEntities, null, 2)}\n\n## Tool 사용 가이드\n\n### Entity 생성 (createEntity)\n사용자가 새로운 Entity 생성을 요청하면 createEntity 도구를 사용하세요.\n- entityId: PascalCase로 된 Entity ID (예: \"User\", \"ProductCategory\")\n- title: 한글 제목 (예: \"사용자\", \"상품 카테고리\")\n- table: snake_case로 된 테이블명 (예: \"users\", \"product_categories\")\n- parentId: 부모 Entity ID (선택사항)\n- props: Entity의 프로퍼티 배열 (위 문서의 Property Types 참고)\n- indexes: 인덱스 배열\n- subsets: 서브셋 정의 (기본값: { A: [\"id\"] })\n- enums: Enum 정의\n\n### Entity 수정 (updateEntity)\n기존 Entity를 수정할 때 updateEntity 도구를 사용하세요. Enum 추가, props 추가/수정, indexes 수정 등 모든 수정 작업에 사용합니다.\n- entityId: 수정할 Entity ID\n- updates: 수정할 필드들 (부분 업데이트)\n  - title: 엔티티 한글 제목\n  - table: 테이블명\n  - props: 추가할 프로퍼티 배열 (기존 props에 추가, 같은 이름이면 교체)\n  - indexes: 추가할 인덱스 배열 (기존 indexes에 추가)\n  - subsets: 서브셋 정의 (기존 subsets에 병합)\n  - enumLabels: Enum 정의 (기존 enumLabels에 병합)\n- mode: \"merge\"(기본값) 또는 \"replace\"\n  - merge: 기존 값에 병합\n  - replace: 해당 필드 전체 교체\n\n예시: Employee에 새 Enum 추가\nupdateEntity({ entityId: \"Employee\", updates: { enumLabels: { \"EmployeeRole\": { \"admin\": \"관리자\", \"user\": \"일반\" } } } })\n\n예시: Project에 새 프로퍼티 추가\nupdateEntity({ entityId: \"Project\", updates: { props: [{ name: \"priority\", type: \"integer\", desc: \"우선순위\" }] } })\n\n## 필수 사항\n- Entity의 props에는 최소한 id(integer, unsigned), created_at(timestamp)가 포함되어야 합니다.\n- relation 필드는 onUpdate, onDelete가 필수입니다. (예외: OneToOne에서 hasJoinColumn이 false인 경우)\n- Enum ID는 보통 EntityId + 속성명 형태입니다 (예: UserStatus, ProductType)\n- subset에서 다른 엔티티의 프로퍼티를 참조할 때는 반드시 해당 엔티티의 실제 프로퍼티명을 사용하세요.\n\n## 검증 오류 처리\n도구 호출 결과로 검증 오류(validationErrors)가 반환되면:\n1. 오류 메시지를 분석하여 문제점을 파악하세요.\n2. 오류를 수정한 데이터로 createEntity를 다시 호출하세요.\n3. 사용자에게 오류를 그대로 전달하지 말고, 수정 후 재시도하세요.\n\n### 일반적인 검증 오류와 수정 방법\n| 오류 메시지 | 수정 방법 |\n|------------|----------|\n| \"id 프로퍼티가 필수\" | props에 { name: \"id\", type: \"integer\", unsigned: true } 추가 |\n| \"created_at 프로퍼티가 필수\" | props에 { name: \"created_at\", type: \"timestamp\", dbDefault: \"CURRENT_TIMESTAMP\" } 추가 |\n| \"XxxOrderBy enum이 필수\" | enums에 { \"XxxOrderBy\": { \"id-desc\": \"ID최신순\" } } 추가 |\n| \"XxxSearchField enum이 필수\" | enums에 { \"XxxSearchField\": { \"id\": \"ID\" } } 추가 |\n| \"string 타입은 length가 필수\" | 해당 prop에 length 추가 (예: 255) |\n| \"text 타입은 textType이 필수\" | 해당 prop에 textType 추가 (\"text\", \"mediumtext\", \"longtext\") |\n| \"onUpdate가 필수\" | 해당 relation prop에 onUpdate, onDelete 추가 (\"CASCADE\") |\n      `;\n\n    const { streamText, tool, stepCountIs } = this.aiSdk;\n\n    return streamText({\n      model: this.model as unknown as LanguageModel,\n      system: systemMessage,\n      messages,\n      stopWhen: stepCountIs(2),\n      tools: {\n        createEntity: tool({\n          description:\n            \"새로운 Entity를 생성합니다. 사용자가 새로운 엔티티나 테이블 생성을 요청할 때 사용하세요.\",\n          inputSchema: TemplateOptions.shape.entity,\n          execute: async (\n            entity: z.infer<typeof TemplateOptions.shape.entity>,\n          ): Promise<{\n            success: boolean;\n            entityId: string;\n            error?: string;\n            validationErrors?: ValidationError[];\n          }> => {\n            try {\n              // 입력 검증\n              const validationErrors = validateEntityJson(entity);\n\n              if (validationErrors.length > 0) {\n                return {\n                  success: false,\n                  entityId: entity.entityId,\n                  error: `검증 오류: ${validationErrors.map((e) => `[${e.field}] ${e.message}`).join(\", \")}`,\n                  validationErrors,\n                };\n              }\n\n              await Sonamu.syncer.createEntity({\n                subsets: { A: [\"id\"] },\n                enums: {},\n                ...entity,\n              });\n\n              // EntityManager 리로드\n              await EntityManager.reload();\n\n              return { success: true, entityId: entity.entityId };\n            } catch (e) {\n              const error = e instanceof Error ? e.message : \"Unknown error\";\n              return { success: false, entityId: entity.entityId, error };\n            }\n          },\n        }),\n        updateEntity: tool({\n          description:\n            \"기존 Entity를 수정합니다. Enum 추가, props 추가/수정, indexes 수정, subsets 수정 등 모든 엔티티 수정 작업에 사용하세요.\",\n          inputSchema: z.object({\n            entityId: z.string().describe(\"수정할 Entity ID\"),\n            updates: TemplateOptions.shape.entity.partial().describe(\"수정할 필드들\"),\n            mode: z\n              .enum([\"merge\", \"replace\"])\n              .optional()\n              .describe(\"수정 모드: merge(기본값, 기존 값에 병합) 또는 replace(전체 교체)\"),\n          }),\n          execute: async ({\n            entityId,\n            updates,\n            mode = \"merge\",\n          }: {\n            entityId: string;\n            updates: Partial<z.infer<typeof TemplateOptions.shape.entity>>;\n            mode?: \"merge\" | \"replace\";\n          }): Promise<{\n            success: boolean;\n            entityId: string;\n            error?: string;\n            validationErrors?: ValidationError[];\n          }> => {\n            try {\n              const entity = EntityManager.get(entityId);\n\n              // Update basic properties\n              if (updates.entityId !== undefined) entity.id = updates.entityId;\n              if (updates.parentId !== undefined) entity.parentId = updates.parentId;\n              if (updates.title !== undefined) entity.title = updates.title;\n              if (updates.table !== undefined) entity.table = updates.table;\n              if (updates.cone !== undefined) entity.cone = updates.cone;\n\n              // props: merge 시 이름 기준 병합, replace 시 교체\n              if (updates.props !== undefined) {\n                if (mode === \"replace\") {\n                  entity.props = updates.props as EntityProp[];\n                } else {\n                  for (const newProp of updates.props) {\n                    const existingIndex = entity.props.findIndex((p) => p.name === newProp.name);\n                    if (existingIndex >= 0) {\n                      entity.props[existingIndex] = newProp as EntityProp;\n                    } else {\n                      entity.props.push(newProp as EntityProp);\n                    }\n                  }\n                }\n              }\n\n              // indexes: merge 시 추가, replace 시 교체\n              if (updates.indexes !== undefined) {\n                entity.indexes =\n                  mode === \"replace\" ? updates.indexes : [...entity.indexes, ...updates.indexes];\n              }\n\n              // subsets, subsetsInternal: assign으로 병합 또는 교체\n              if (updates.subsets !== undefined) {\n                // Normalize subset fields: separate into subsets (normal) and subsetsInternal (internal)\n                const normalizedSubsets: { [key: string]: string[] } = {};\n                const normalizedSubsetsInternal: { [key: string]: string[] } = {};\n\n                for (const [key, fields] of Object.entries(updates.subsets)) {\n                  const fieldArray = fields as string[];\n                  normalizedSubsets[key] = fieldArray\n                    .filter((f: string) => !isInternalSubsetField(f))\n                    .map(normalizeSubsetField);\n                  normalizedSubsetsInternal[key] = fieldArray\n                    .filter(isInternalSubsetField)\n                    .map(normalizeSubsetField);\n                }\n\n                entity.subsets =\n                  mode === \"replace\"\n                    ? normalizedSubsets\n                    : { ...entity.subsets, ...normalizedSubsets };\n                entity.subsetsInternal =\n                  mode === \"replace\"\n                    ? normalizedSubsetsInternal\n                    : { ...entity.subsetsInternal, ...normalizedSubsetsInternal };\n              }\n\n              if (updates.enums !== undefined) {\n                const convertedEnums = Object.fromEntries(\n                  Object.entries(updates.enums).map(([key, enumDef]) => [\n                    key,\n                    getEnumDefValues(enumDef),\n                  ]),\n                );\n                entity.enumLabels =\n                  mode === \"replace\" ? convertedEnums : { ...entity.enumLabels, ...convertedEnums };\n              }\n\n              // 저장 전 검증\n              const validationErrors = validateEntityJson({\n                ...entity,\n                entityId: entity.id,\n                enums: entity.enumLabels,\n              });\n\n              if (validationErrors.length > 0) {\n                return {\n                  success: false,\n                  entityId,\n                  error: `검증 오류: ${validationErrors.map((e) => `[${e.field}] ${e.message}`).join(\", \")}`,\n                  validationErrors,\n                };\n              }\n\n              await entity.save();\n\n              return { success: true, entityId };\n            } catch (e) {\n              const error = e instanceof Error ? e.message : \"Unknown error\";\n              return { success: false, entityId, error };\n            }\n          },\n        }),\n      },\n    });\n  }\n}\n\n/**\n * Entity JSON이 entity.instructions.md의 규칙을 따르는지 검증합니다.\n */\nfunction validateEntityJson(input: TemplateOptions[\"entity\"]): ValidationError[] {\n  const errors: ValidationError[] = [];\n  const { entityId, props, enums } = input;\n\n  // 1. id, created_at prop 필수\n  const hasIdProp = props?.some((p) => p.name === \"id\");\n  if (!hasIdProp) {\n    errors.push({ field: \"props\", message: \"id 프로퍼티가 필수입니다.\" });\n  }\n  const hasCreatedAtProp = props?.some((p) => p.name === \"created_at\");\n  if (!hasCreatedAtProp) {\n    errors.push({ field: \"props\", message: \"created_at 프로퍼티가 필수입니다.\" });\n  }\n\n  // 2. 필수 enum 검증: EntityNameOrderBy, EntityNameSearchField\n  const orderByEnumId = `${entityId}OrderBy`;\n  const searchFieldEnumId = `${entityId}SearchField`;\n\n  if (!enums?.[orderByEnumId]) {\n    errors.push({\n      field: \"enums\",\n      message: `${orderByEnumId} enum이 필수입니다. (예: { \"id-desc\": \"ID최신순\" })`,\n    });\n  }\n  if (!enums?.[searchFieldEnumId]) {\n    errors.push({\n      field: \"enums\",\n      message: `${searchFieldEnumId} enum이 필수입니다. (예: { \"id\": \"ID\" })`,\n    });\n  }\n\n  // 3. enum prop의 id가 enums에 정의되어 있는지 확인 (cross-field 검증)\n  for (const prop of props ?? []) {\n    if (prop.type === \"enum\" && !enums?.[prop.id]) {\n      errors.push({\n        field: `props.${prop.name}`,\n        message: `enum id \"${prop.id}\"가 enums에 정의되어 있지 않습니다.`,\n      });\n    }\n  }\n\n  return errors;\n}\n\nexport const aiClient = new AIClient();\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"ai-client.js","names":[],"sources":["../../src/ui/ai-client.ts"],"sourcesContent":["import assert from \"assert\";\nimport fs from \"fs\";\nimport path from \"path\";\n\n/* oxlint-disable @typescript-eslint/no-explicit-any */ // AI SDK의 타입이 명확하지 않아 any를 허용함\nimport { type LanguageModel, type ModelMessage, type StreamTextResult } from \"ai\";\nimport { z } from \"zod\";\n\nimport { Sonamu } from \"../api/sonamu\";\nimport { EntityManager } from \"../entity/entity-manager\";\nimport {\n  getEnumDefValues,\n  isInternalSubsetField,\n  normalizeSubsetField,\n  TemplateOptions,\n} from \"../types/types\";\nimport { type EntityProp, type FixtureRecord } from \"../types/types\";\nimport { nonNullable } from \"../utils/utils\";\n\ntype ValidationError = {\n  field: string;\n  message: string;\n};\n\nconst fixtureScalarSchema = z.union([z.string(), z.number(), z.boolean(), z.null()]);\nconst fixtureColumnValueSchema = z.union([fixtureScalarSchema, z.array(fixtureScalarSchema)]);\nconst fixtureColumnsSchema = z.record(z.string(), fixtureColumnValueSchema);\ntype FixtureToolColumns = z.infer<typeof fixtureColumnsSchema>;\n\nclass AIClient {\n  private model: LanguageModel | null = null;\n  private aiSdk:\n    | (typeof import(\"ai\") & {\n        anthropic?: typeof import(\"@ai-sdk/anthropic\").anthropic;\n      })\n    | null = null;\n\n  async init() {\n    try {\n      const { anthropic } = await import(\"@ai-sdk/anthropic\");\n      const aiModule = await import(\"ai\");\n      this.aiSdk = { ...aiModule, anthropic };\n      this.model = anthropic(\"claude-sonnet-4-6\");\n    } catch (error) {\n      console.warn(\n        \"AI SDK packages not installed. Install @ai-sdk/anthropic and ai to use AI features.\",\n      );\n      throw error;\n    }\n  }\n\n  handleFixture(\n    messages: ModelMessage[],\n    fixtureRecords: FixtureRecord[],\n  ): StreamTextResult<any, any> {\n    if (!this.aiSdk || !this.model) {\n      throw new Error(\"AI SDK not initialized. Call init() first.\");\n    }\n    const model = this.model;\n\n    // 현재 fixtureRecords에서 사용된 엔티티들의 구조 정보 수집\n    const usedEntityIds = [...new Set(fixtureRecords.map((r) => r.entityId))];\n    const entityStructures = usedEntityIds.map((entityId) => {\n      const entity = EntityManager.get(entityId);\n\n      return {\n        entityId: entity.id,\n        table: entity.table,\n        props: entity.props,\n        relations: entity.relations,\n        enumLabels: entity.enumLabels,\n      };\n    });\n\n    const systemMessage = `\n        당신은 픽스쳐 레코드를 수정하고 생성할 수 있는 도우미입니다.\n\n        현재 픽스쳐 레코드:\n        ${JSON.stringify(fixtureRecords, null, 2)}\n\n        엔티티 구조 정보:\n        ${JSON.stringify(entityStructures, null, 2)}\n\n        ## 픽스쳐 수정\n        사용자가 픽스쳐 값 수정을 요청하면 updateFixtures 도구를 사용하여 변경사항을 적용하세요.\n        - fixtureId: 수정할 픽스쳐 ID (형식: \"EntityId#id\")\n        - updates: 컬럼명을 키로, 새 값을 값으로 하는 객체\n\n        예시: \"User#1\" 픽스쳐의 \"name\" 컬럼을 \"홍길동\"으로 변경하려면:\n        updateFixtures({ updates: [{ fixtureId: \"User#1\", updates: { name: \"홍길동\" } }] })\n\n        변경될 컬럼의 type이 relation인 경우, 관련 엔티티에도 반영되어야 할 컬럼이 있는지 확인하세요.\n\n        ## 픽스쳐 생성\n        사용자가 새로운 픽스쳐 생성을 요청하면 createFixtures 도구를 사용하세요.\n        - entityId: 생성할 엔티티 ID\n        - id: 새 레코드의 ID (기존 픽스쳐와 중복되지 않는 음수 사용 권장, 예: -1, -2)\n        - columns: 컬럼명을 키로, 값을 값으로 하는 객체 (엔티티 구조 참고)\n\n        예시: 새로운 User 픽스쳐를 생성하려면:\n        createFixtures({ fixtures: [{ entityId: \"User\", id: -1, columns: { name: \"홍길동\", email: \"hong@example.com\" } }] })\n      `;\n\n    const { streamText, tool } = this.aiSdk;\n\n    return streamText({\n      model,\n      system: systemMessage,\n      messages,\n      tools: {\n        updateFixtures: tool({\n          description:\n            \"픽스쳐 레코드의 값을 수정합니다. 사용자가 특정 컬럼이나 값을 변경해달라고 요청할 때 사용하세요.\",\n          inputSchema: z.object({\n            updates: z.array(\n              z.object({\n                fixtureId: z.string().describe(\"수정할 픽스쳐 ID (형식: EntityId#id)\"),\n                updates: fixtureColumnsSchema.describe(\"컬럼명을 키로, 새 값을 값으로 하는 객체\"),\n              }),\n            ),\n          }),\n          execute: async ({\n            updates,\n          }: {\n            updates: Array<{ fixtureId: string; updates: FixtureToolColumns }>;\n          }): Promise<{ success: boolean; updatedRecords: FixtureRecord[] }> => {\n            // fixtureRecords를 복사하고 업데이트 적용\n            const updatedRecords: FixtureRecord[] = fixtureRecords.map((record) => {\n              const update = updates.find(\n                (u: { fixtureId: string }) => u.fixtureId === record.fixtureId,\n              );\n              if (update) {\n                // columns의 value를 업데이트\n                for (const [columnName, newValue] of Object.entries(update.updates)) {\n                  record.columns[columnName].value = newValue;\n                }\n                return record;\n              }\n\n              return record;\n            });\n\n            return { success: true, updatedRecords };\n          },\n        }),\n        createFixtures: tool({\n          description:\n            \"새로운 픽스쳐 레코드를 생성합니다. 사용자가 새로운 데이터를 추가해달라고 요청할 때 사용하세요.\",\n          inputSchema: z.object({\n            fixtures: z.array(\n              z.object({\n                entityId: z.string().describe(\"생성할 엔티티 ID\"),\n                id: z.number().describe(\"새 레코드의 ID (음수 권장, 예: -1, -2)\"),\n                columns: fixtureColumnsSchema.describe(\"컬럼명을 키로, 값을 값으로 하는 객체\"),\n              }),\n            ),\n          }),\n          execute: async ({\n            fixtures,\n          }: {\n            fixtures: Array<{ entityId: string; id: number; columns: FixtureToolColumns }>;\n          }): Promise<{ success: boolean; updatedRecords: FixtureRecord[] }> => {\n            const newRecords: FixtureRecord[] = fixtures.map((fixture) => {\n              const entity = EntityManager.get(fixture.entityId);\n\n              // 엔티티 props를 기반으로 columns 구성\n              const columns: FixtureRecord[\"columns\"] = {};\n              for (const prop of entity.props) {\n                if (prop.type === \"virtual\") continue;\n\n                let value = fixture.columns[prop.name] ?? null;\n\n                if (prop.name === \"created_at\") {\n                  // 현재 시간으로 설정\n                  value = new Date().toISOString();\n                } else if (\n                  prop.type === \"relation\" &&\n                  (prop.relationType === \"HasMany\" || prop.relationType === \"ManyToMany\")\n                ) {\n                  // 배열로 변환\n                  value = Array.isArray(value) ? value : [value].filter(nonNullable);\n                }\n\n                columns[prop.name] = {\n                  prop,\n                  value,\n                };\n              }\n\n              return {\n                fixtureId: `${fixture.entityId}#${fixture.id}`,\n                entityId: fixture.entityId,\n                id: fixture.id,\n                columns,\n                fetchedRecords: [],\n                belongsRecords: [],\n                override: false,\n              };\n            });\n\n            // 새 레코드들의 relation 컬럼을 확인하여 기존 레코드들의 역방향 relation 업데이트\n            for (const newRecord of newRecords) {\n              for (const [_colName, col] of Object.entries(newRecord.columns)) {\n                if (col.prop.type !== \"relation\" || col.value === null) continue;\n\n                const relatedEntityId = col.prop.with;\n                const relatedIds = Array.isArray(col.value) ? col.value : [col.value];\n\n                for (const relatedId of relatedIds) {\n                  const relatedFixtureId = `${relatedEntityId}#${relatedId}`;\n                  const relatedRecord = newRecords.find((r) => r.fixtureId === relatedFixtureId);\n\n                  if (relatedRecord) {\n                    // 역방향 relation 찾기\n                    const reverseCol = Object.entries(relatedRecord.columns).find(\n                      ([, c]) => c.prop.type === \"relation\" && c.prop.with === newRecord.entityId,\n                    );\n\n                    if (reverseCol) {\n                      const [reverseColName, reverseColValue] = reverseCol;\n                      const currentValue = reverseColValue.value;\n\n                      // 역방향이 배열인 경우 (HasMany, ManyToMany)\n                      if (\n                        reverseColValue.prop.type === \"relation\" &&\n                        (reverseColValue.prop.relationType === \"HasMany\" ||\n                          reverseColValue.prop.relationType === \"ManyToMany\")\n                      ) {\n                        assert(Array.isArray(currentValue), \"currentValue must be an array\");\n                        if (!currentValue.includes(newRecord.id)) {\n                          relatedRecord.columns[reverseColName] = {\n                            ...reverseColValue,\n                            value: [...currentValue, newRecord.id],\n                          };\n                        }\n                      } else {\n                        // 역방향이 단일 값인 경우 (BelongsToOne, OneToOne)\n                        relatedRecord.columns[reverseColName] = {\n                          ...reverseColValue,\n                          value: newRecord.id,\n                        };\n                      }\n                    }\n                  }\n                }\n              }\n            }\n\n            return { success: true, updatedRecords: newRecords };\n          },\n        }),\n      },\n    });\n  }\n\n  handleEntity(messages: ModelMessage[]): StreamTextResult<any, any> {\n    if (!this.aiSdk || !this.model) {\n      throw new Error(\"AI SDK not initialized. Call init() first.\");\n    }\n    const model = this.model;\n\n    // entity.instructions.md 파일 읽기 (dist/ui 또는 src/ui에서 실행되므로 패키지 루트 기준으로 접근)\n    const instructionsPath = path.join(\n      import.meta.dirname,\n      \"..\",\n      \"..\",\n      \"src\",\n      \"ui\",\n      \"entity.instructions.md\",\n    );\n    const instructions = fs.readFileSync(instructionsPath, \"utf-8\");\n\n    // 현재 등록된 엔티티 정보 수집\n    const entityIds = EntityManager.getAllIds();\n    const existingEntities = entityIds.map((entityId) => {\n      const entity = EntityManager.get(entityId);\n      return {\n        id: entity.id,\n        title: entity.title,\n        table: entity.table,\n        props: entity.props.map((p) => ({\n          name: p.name,\n          type: p.type,\n          desc: p.desc,\n        })),\n      };\n    });\n\n    const systemMessage = `\n당신은 Sonamu 프레임워크에서 Entity와 Enum을 생성하는 도우미입니다.\n\n${instructions}\n\n## 현재 등록된 Entity 목록\n다른 엔티티와 관계(relation)를 맺거나 subset에서 참조할 때 반드시 아래 정보를 확인하세요.\n\n${JSON.stringify(existingEntities, null, 2)}\n\n## Tool 사용 가이드\n\n### Entity 생성 (createEntity)\n사용자가 새로운 Entity 생성을 요청하면 createEntity 도구를 사용하세요.\n- entityId: PascalCase로 된 Entity ID (예: \"User\", \"ProductCategory\")\n- title: 한글 제목 (예: \"사용자\", \"상품 카테고리\")\n- table: snake_case로 된 테이블명 (예: \"users\", \"product_categories\")\n- parentId: 부모 Entity ID (선택사항)\n- props: Entity의 프로퍼티 배열 (위 문서의 Property Types 참고)\n- indexes: 인덱스 배열\n- subsets: 서브셋 정의 (기본값: { A: [\"id\"] })\n- enums: Enum 정의\n\n### Entity 수정 (updateEntity)\n기존 Entity를 수정할 때 updateEntity 도구를 사용하세요. Enum 추가, props 추가/수정, indexes 수정 등 모든 수정 작업에 사용합니다.\n- entityId: 수정할 Entity ID\n- updates: 수정할 필드들 (부분 업데이트)\n  - title: 엔티티 한글 제목\n  - table: 테이블명\n  - props: 추가할 프로퍼티 배열 (기존 props에 추가, 같은 이름이면 교체)\n  - indexes: 추가할 인덱스 배열 (기존 indexes에 추가)\n  - subsets: 서브셋 정의 (기존 subsets에 병합)\n  - enumLabels: Enum 정의 (기존 enumLabels에 병합)\n- mode: \"merge\"(기본값) 또는 \"replace\"\n  - merge: 기존 값에 병합\n  - replace: 해당 필드 전체 교체\n\n예시: Employee에 새 Enum 추가\nupdateEntity({ entityId: \"Employee\", updates: { enumLabels: { \"EmployeeRole\": { \"admin\": \"관리자\", \"user\": \"일반\" } } } })\n\n예시: Project에 새 프로퍼티 추가\nupdateEntity({ entityId: \"Project\", updates: { props: [{ name: \"priority\", type: \"integer\", desc: \"우선순위\" }] } })\n\n## 필수 사항\n- Entity의 props에는 최소한 id(integer, unsigned), created_at(timestamp)가 포함되어야 합니다.\n- relation 필드는 onUpdate, onDelete가 필수입니다. (예외: OneToOne에서 hasJoinColumn이 false인 경우)\n- Enum ID는 보통 EntityId + 속성명 형태입니다 (예: UserStatus, ProductType)\n- subset에서 다른 엔티티의 프로퍼티를 참조할 때는 반드시 해당 엔티티의 실제 프로퍼티명을 사용하세요.\n\n## 검증 오류 처리\n도구 호출 결과로 검증 오류(validationErrors)가 반환되면:\n1. 오류 메시지를 분석하여 문제점을 파악하세요.\n2. 오류를 수정한 데이터로 createEntity를 다시 호출하세요.\n3. 사용자에게 오류를 그대로 전달하지 말고, 수정 후 재시도하세요.\n\n### 일반적인 검증 오류와 수정 방법\n| 오류 메시지 | 수정 방법 |\n|------------|----------|\n| \"id 프로퍼티가 필수\" | props에 { name: \"id\", type: \"integer\", unsigned: true } 추가 |\n| \"created_at 프로퍼티가 필수\" | props에 { name: \"created_at\", type: \"timestamp\", dbDefault: \"CURRENT_TIMESTAMP\" } 추가 |\n| \"XxxOrderBy enum이 필수\" | enums에 { \"XxxOrderBy\": { \"id-desc\": \"ID최신순\" } } 추가 |\n| \"XxxSearchField enum이 필수\" | enums에 { \"XxxSearchField\": { \"id\": \"ID\" } } 추가 |\n| \"string 타입은 length가 필수\" | 해당 prop에 length 추가 (예: 255) |\n| \"text 타입은 textType이 필수\" | 해당 prop에 textType 추가 (\"text\", \"mediumtext\", \"longtext\") |\n| \"onUpdate가 필수\" | 해당 relation prop에 onUpdate, onDelete 추가 (\"CASCADE\") |\n      `;\n\n    const { streamText, tool, stepCountIs } = this.aiSdk;\n\n    return streamText({\n      model,\n      system: systemMessage,\n      messages,\n      stopWhen: stepCountIs(2),\n      tools: {\n        createEntity: tool({\n          description:\n            \"새로운 Entity를 생성합니다. 사용자가 새로운 엔티티나 테이블 생성을 요청할 때 사용하세요.\",\n          inputSchema: TemplateOptions[\"shape\"].entity,\n          execute: async (\n            entity: z.infer<(typeof TemplateOptions)[\"shape\"][\"entity\"]>,\n          ): Promise<{\n            success: boolean;\n            entityId: string;\n            error?: string;\n            validationErrors?: ValidationError[];\n          }> => {\n            try {\n              // 입력 검증\n              const validationErrors = validateEntityJson(entity);\n\n              if (validationErrors.length > 0) {\n                return {\n                  success: false,\n                  entityId: entity.entityId,\n                  error: `검증 오류: ${validationErrors.map((e) => `[${e.field}] ${e.message}`).join(\", \")}`,\n                  validationErrors,\n                };\n              }\n\n              await Sonamu.syncer.createEntity({\n                subsets: { A: [\"id\"] },\n                enums: {},\n                ...entity,\n              });\n\n              // EntityManager 리로드\n              await EntityManager.reload();\n\n              return { success: true, entityId: entity.entityId };\n            } catch (e) {\n              const error = e instanceof Error ? e.message : \"Unknown error\";\n              return { success: false, entityId: entity.entityId, error };\n            }\n          },\n        }),\n        updateEntity: tool({\n          description:\n            \"기존 Entity를 수정합니다. Enum 추가, props 추가/수정, indexes 수정, subsets 수정 등 모든 엔티티 수정 작업에 사용하세요.\",\n          inputSchema: z.object({\n            entityId: z.string().describe(\"수정할 Entity ID\"),\n            updates: TemplateOptions[\"shape\"].entity.partial().describe(\"수정할 필드들\"),\n            mode: z\n              .enum([\"merge\", \"replace\"])\n              .optional()\n              .describe(\"수정 모드: merge(기본값, 기존 값에 병합) 또는 replace(전체 교체)\"),\n          }),\n          execute: async ({\n            entityId,\n            updates,\n            mode = \"merge\",\n          }: {\n            entityId: string;\n            updates: Partial<z.infer<(typeof TemplateOptions)[\"shape\"][\"entity\"]>>;\n            mode?: \"merge\" | \"replace\";\n          }): Promise<{\n            success: boolean;\n            entityId: string;\n            error?: string;\n            validationErrors?: ValidationError[];\n          }> => {\n            try {\n              const entity = EntityManager.get(entityId);\n\n              // Update basic properties\n              if (updates.entityId !== undefined) entity.id = updates.entityId;\n              if (updates.parentId !== undefined) entity.parentId = updates.parentId;\n              if (updates.title !== undefined) entity.title = updates.title;\n              if (updates.table !== undefined) entity.table = updates.table;\n              if (updates.cone !== undefined) entity.cone = updates.cone;\n\n              // props: merge 시 이름 기준 병합, replace 시 교체\n              if (updates.props !== undefined) {\n                if (mode === \"replace\") {\n                  entity.props =\n                    /* SAFETY: UI 도구의 Zod 입력 스키마가 이 값의 타입을 보장한다. */ updates.props as EntityProp[];\n                } else {\n                  for (const newProp of updates.props) {\n                    const existingIndex = entity.props.findIndex((p) => p.name === newProp.name);\n                    if (existingIndex >= 0) {\n                      entity.props[existingIndex] =\n                        /* SAFETY: UI 도구의 Zod 입력 스키마가 이 값의 타입을 보장한다. */ newProp as EntityProp;\n                    } else {\n                      entity.props.push(\n                        /* SAFETY: UI 도구의 Zod 입력 스키마가 이 값의 타입을 보장한다. */ newProp as EntityProp,\n                      );\n                    }\n                  }\n                }\n              }\n\n              // indexes: merge 시 추가, replace 시 교체\n              if (updates.indexes !== undefined) {\n                entity.indexes =\n                  mode === \"replace\" ? updates.indexes : [...entity.indexes, ...updates.indexes];\n              }\n\n              // subsets, subsetsInternal: assign으로 병합 또는 교체\n              if (updates.subsets !== undefined) {\n                // Normalize subset fields: separate into subsets (normal) and subsetsInternal (internal)\n                const normalizedSubsets: { [key: string]: string[] } = {};\n                const normalizedSubsetsInternal: { [key: string]: string[] } = {};\n\n                for (const [key, fields] of Object.entries(updates.subsets)) {\n                  const fieldArray =\n                    /* SAFETY: UI 도구의 Zod 입력 스키마가 이 값의 타입을 보장한다. */ fields as string[];\n                  normalizedSubsets[key] = fieldArray\n                    .filter((f: string) => !isInternalSubsetField(f))\n                    .map(normalizeSubsetField);\n                  normalizedSubsetsInternal[key] = fieldArray\n                    .filter(isInternalSubsetField)\n                    .map(normalizeSubsetField);\n                }\n\n                entity.subsets =\n                  mode === \"replace\"\n                    ? normalizedSubsets\n                    : { ...entity.subsets, ...normalizedSubsets };\n                entity.subsetsInternal =\n                  mode === \"replace\"\n                    ? normalizedSubsetsInternal\n                    : { ...entity.subsetsInternal, ...normalizedSubsetsInternal };\n              }\n\n              if (updates.enums !== undefined) {\n                const convertedEnums = Object.fromEntries(\n                  Object.entries(updates.enums).map(([key, enumDef]) => [\n                    key,\n                    getEnumDefValues(enumDef),\n                  ]),\n                );\n                entity.enumLabels =\n                  mode === \"replace\" ? convertedEnums : { ...entity.enumLabels, ...convertedEnums };\n              }\n\n              // 저장 전 검증\n              const validationErrors = validateEntityJson({\n                ...entity,\n                entityId: entity.id,\n                enums: entity.enumLabels,\n              });\n\n              if (validationErrors.length > 0) {\n                return {\n                  success: false,\n                  entityId,\n                  error: `검증 오류: ${validationErrors.map((e) => `[${e.field}] ${e.message}`).join(\", \")}`,\n                  validationErrors,\n                };\n              }\n\n              await entity.save();\n\n              return { success: true, entityId };\n            } catch (e) {\n              const error = e instanceof Error ? e.message : \"Unknown error\";\n              return { success: false, entityId, error };\n            }\n          },\n        }),\n      },\n    });\n  }\n}\n\n/**\n * Entity JSON이 entity.instructions.md의 규칙을 따르는지 검증합니다.\n */\nfunction validateEntityJson(input: TemplateOptions[\"entity\"]): ValidationError[] {\n  const errors: ValidationError[] = [];\n  const { entityId, props, enums } = input;\n\n  // 1. id, created_at prop 필수\n  const hasIdProp = props?.some((p) => p.name === \"id\");\n  if (!hasIdProp) {\n    errors.push({ field: \"props\", message: \"id 프로퍼티가 필수입니다.\" });\n  }\n  const hasCreatedAtProp = props?.some((p) => p.name === \"created_at\");\n  if (!hasCreatedAtProp) {\n    errors.push({ field: \"props\", message: \"created_at 프로퍼티가 필수입니다.\" });\n  }\n\n  // 2. 필수 enum 검증: EntityNameOrderBy, EntityNameSearchField\n  const orderByEnumId = `${entityId}OrderBy`;\n  const searchFieldEnumId = `${entityId}SearchField`;\n\n  if (!enums?.[orderByEnumId]) {\n    errors.push({\n      field: \"enums\",\n      message: `${orderByEnumId} enum이 필수입니다. (예: { \"id-desc\": \"ID최신순\" })`,\n    });\n  }\n  if (!enums?.[searchFieldEnumId]) {\n    errors.push({\n      field: \"enums\",\n      message: `${searchFieldEnumId} enum이 필수입니다. (예: { \"id\": \"ID\" })`,\n    });\n  }\n\n  // 3. enum prop의 id가 enums에 정의되어 있는지 확인 (cross-field 검증)\n  for (const prop of props ?? []) {\n    if (prop.type === \"enum\" && !enums?.[prop.id]) {\n      errors.push({\n        field: `props.${prop.name}`,\n        message: `enum id \"${prop.id}\"가 enums에 정의되어 있지 않습니다.`,\n      });\n    }\n  }\n\n  return errors;\n}\n\nexport const aiClient = new AIClient();\n"],"mappings":"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"}

package/dist/ui/api.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../src/ui/api.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,SAAS,CAAC;AAgD/C,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,eAAe,iBAyvC/D"}
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../src/ui/api.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,SAAS,CAAC;AAkF/C,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,eAAe,iBAs0C/D"}