sonamu 0.8.13 → 0.8.14

package/dist/ui/cdd-service.js

@@ -1,11 +1,10 @@
 import { spawn } from "child_process";
-import crypto from "crypto";
 import fs from "fs";
 import os from "os";
 import path from "path";
 import { Sonamu } from "../api/sonamu.js";
 /** contract/ 디렉터리 절대 경로 반환 (apiRootPath 기준) */ function getContractDir() {
-    return path.join(Sonamu.apiRootPath, "contract");
+    return path.join(Sonamu.apiRootPath, "..", "..", "contract");
 }
 /** 경로가 contract/ 디렉터리 내부인지 검증 */ function assertInsideContractDir(filePath) {
     const contractDir = getContractDir();
@@ -63,12 +62,14 @@ import { Sonamu } from "../api/sonamu.js";
         tree
     };
 }
-/** content 필드를 string으로 변환 (string[] 및 string 모두 지원) */ function contentToString(content) {
-    if (Array.isArray(content)) return content.join("\n");
-    if (typeof content === "string") return content;
-    return "";
+/** schema ID로 schema 파일을 찾아 반환 */ function resolveSchema(schemaId) {
+    const contractDir = getContractDir();
+    const schemaPath = path.join(contractDir, "schemas", `${schemaId}.schema.json`);
+    if (!fs.existsSync(schemaPath)) return null;
+    const raw = fs.readFileSync(schemaPath, "utf-8");
+    return JSON.parse(raw);
 }
-/** JSON 파일의 전체 내용을 읽어 반환 (content는 string으로 변환) */ export function readContent(filePath) {
+/** JSON 파일의 전체 내용을 읽어 schema와 함께 envelope로 반환 */ export function readContent(filePath) {
     assertInsideContractDir(filePath);
     const contractDir = getContractDir();
     const absPath = path.resolve(contractDir, filePath);
@@ -76,13 +77,17 @@ import { Sonamu } from "../api/sonamu.js";
         throw new Error(`파일을 찾을 수 없습니다: ${filePath}`);
     }
     const raw = fs.readFileSync(absPath, "utf-8");
-    const json = JSON.parse(raw);
+    const document = JSON.parse(raw);
+    const fileType = detectFileType(path.basename(filePath));
+    const schemaId = typeof document.schema === "string" ? document.schema : null;
+    const schema = schemaId ? resolveSchema(schemaId) : null;
     return {
-        ...json,
-        content: contentToString(json.content)
+        document,
+        schema,
+        fileType: fileType ?? "contract"
     };
 }
-/** JSON 파일의 content 필드를 외부 에디터로 편집 */ export async function editContent(filePath) {
+/** JSON 파일을 외부 에디터로 직접 편집 */ export async function editContent(filePath) {
     assertInsideContractDir(filePath);
     const contractDir = getContractDir();
     const absPath = path.resolve(contractDir, filePath);
@@ -90,31 +95,11 @@ import { Sonamu } from "../api/sonamu.js";
         throw new Error(`파일을 찾을 수 없습니다: ${filePath}`);
     }
     const editor = resolveEditorCli();
-    const raw = fs.readFileSync(absPath, "utf-8");
-    const json = JSON.parse(raw);
-    const content = contentToString(json.content);
-    const tmpFileName = `cdd-edit-${crypto.randomUUID()}.md`;
-    const tmpFilePath = path.join(os.tmpdir(), tmpFileName);
-    fs.writeFileSync(tmpFilePath, content, "utf-8");
-    try {
-        await runEditor(editor, tmpFilePath);
-        const edited = fs.readFileSync(tmpFilePath, "utf-8");
-        json.content = edited.split("\n");
-        const today = new Date();
-        const yyyy = today.getFullYear();
-        const mm = String(today.getMonth() + 1).padStart(2, "0");
-        const dd = String(today.getDate()).padStart(2, "0");
-        json.lastModified = `${yyyy}-${mm}-${dd}`;
-        fs.writeFileSync(absPath, `${JSON.stringify(json, null, 2)}\n`, "utf-8");
-        return {
-            success: true,
-            filePath
-        };
-    } finally{
-        if (fs.existsSync(tmpFilePath)) {
-            fs.unlinkSync(tmpFilePath);
-        }
-    }
+    await runEditor(editor, absPath);
+    return {
+        success: true,
+        filePath
+    };
 }
 /** 에디터별 앱 번들 내 CLI 경로 + --wait 플래그 매핑 */ const EDITOR_CLI_MAP = {
     "Visual Studio Code": {
@@ -176,6 +161,129 @@ import { Sonamu } from "../api/sonamu.js";
         });
     });
 }
+/* ========================================================================
+ * Schema 관리 API
+ * ======================================================================== */ /** contract/schemas/ 디렉터리 내 .schema.json 파일 경로 목록 반환 */ function scanSchemaFiles() {
+    const schemasDir = path.join(getContractDir(), "schemas");
+    if (!fs.existsSync(schemasDir)) return [];
+    return fs.readdirSync(schemasDir, {
+        withFileTypes: true
+    }).filter((e)=>e.isFile() && e.name.endsWith(".schema.json")).map((e)=>({
+            absPath: path.join(schemasDir, e.name),
+            relPath: `schemas/${e.name}`,
+            fileName: e.name
+        }));
+}
+/** 특정 schemaId를 참조하는 contract/spec 문서들을 재귀 수집 */ function collectSchemaReferences(schemaId, dirPath, relativeTo) {
+    if (!fs.existsSync(dirPath)) return [];
+    const refs = [];
+    const entries = fs.readdirSync(dirPath, {
+        withFileTypes: true
+    });
+    for (const entry of entries){
+        const fullPath = path.join(dirPath, entry.name);
+        if (entry.isDirectory()) {
+            if (entry.name === "schemas") continue;
+            refs.push(...collectSchemaReferences(schemaId, fullPath, relativeTo));
+        } else if (entry.isFile()) {
+            const fileType = detectFileType(entry.name);
+            if (!fileType) continue;
+            try {
+                const raw = fs.readFileSync(fullPath, "utf-8");
+                const doc = JSON.parse(raw);
+                if (doc.schema === schemaId) {
+                    refs.push({
+                        path: path.relative(relativeTo, fullPath),
+                        fileType,
+                        name: entry.name
+                    });
+                }
+            } catch  {
+            // JSON 파싱 실패 시 무시
+            }
+        }
+    }
+    return refs;
+}
+/** schema 파일명에서 기대되는 id 추출 */ function expectedSchemaId(fileName) {
+    return fileName.replace(/\.schema\.json$/, "");
+}
+/** schemas/ 하위 경로가 contract/schemas/ 내부인지 검증 */ function assertInsideSchemaDir(schemaKey) {
+    const schemasDir = path.join(getContractDir(), "schemas");
+    const resolved = path.resolve(schemasDir, `${schemaKey}.schema.json`);
+    if (!resolved.startsWith(schemasDir + path.sep) && resolved !== schemasDir) {
+        throw new Error(`유효하지 않은 스키마 키입니다: ${schemaKey}`);
+    }
+}
+/** schema 목록 반환 */ export function listSchemas() {
+    const contractDir = getContractDir();
+    const files = scanSchemaFiles();
+    const schemas = [];
+    for (const file of files){
+        const key = expectedSchemaId(file.fileName);
+        try {
+            const raw = fs.readFileSync(file.absPath, "utf-8");
+            const schema = JSON.parse(raw);
+            const refs = collectSchemaReferences(schema.id, contractDir, contractDir);
+            schemas.push({
+                key,
+                id: schema.id,
+                path: file.relPath,
+                type: schema.type,
+                fieldCount: schema.fields.length,
+                referenceCount: refs.length,
+                hasIdMismatch: schema.id !== key
+            });
+        } catch (err) {
+            schemas.push({
+                key,
+                id: key,
+                path: file.relPath,
+                type: "contract",
+                fieldCount: 0,
+                referenceCount: 0,
+                hasIdMismatch: false,
+                parseError: err instanceof Error ? err.message : String(err)
+            });
+        }
+    }
+    return {
+        schemas
+    };
+}
+/** schema 상세 반환 (파일명 기반 key로 조회) */ export function readSchema(schemaKey) {
+    assertInsideSchemaDir(schemaKey);
+    const contractDir = getContractDir();
+    const absPath = path.join(contractDir, "schemas", `${schemaKey}.schema.json`);
+    if (!fs.existsSync(absPath)) {
+        throw new Error(`스키마를 찾을 수 없습니다: ${schemaKey}`);
+    }
+    const raw = fs.readFileSync(absPath, "utf-8");
+    const schema = JSON.parse(raw);
+    const relPath = path.relative(contractDir, absPath);
+    const references = collectSchemaReferences(schema.id, contractDir, contractDir);
+    return {
+        key: schemaKey,
+        path: relPath,
+        schema,
+        references,
+        hasIdMismatch: schema.id !== schemaKey
+    };
+}
+/** schema 파일을 외부 에디터로 편집 (파일명 기반 key로 조회) */ export async function editSchema(schemaKey) {
+    assertInsideSchemaDir(schemaKey);
+    const contractDir = getContractDir();
+    const absPath = path.join(contractDir, "schemas", `${schemaKey}.schema.json`);
+    if (!fs.existsSync(absPath)) {
+        throw new Error(`스키마를 찾을 수 없습니다: ${schemaKey}`);
+    }
+    const editor = resolveEditorCli();
+    await runEditor(editor, absPath);
+    return {
+        success: true,
+        schemaKey
+    };
+}
 /** 소스 파일을 외부 에디터로 열기 (대기하지 않음) */ export function openSourceFile(filePath) {
     const absPath = path.isAbsolute(filePath) ? filePath : path.resolve(Sonamu.apiRootPath, filePath);
     if (!fs.existsSync(absPath)) {
@@ -194,4 +302,4 @@ import { Sonamu } from "../api/sonamu.js";
     child.unref();
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/ui/cdd-service.ts"],"sourcesContent":["import { spawn } from \"child_process\";\nimport crypto from \"crypto\";\nimport fs from \"fs\";\nimport os from \"os\";\nimport path from \"path\";\nimport { Sonamu } from \"../api/sonamu\";\n\nexport type CddFileType = \"contract\" | \"spec\";\n\nexport type CddTreeNode = {\n  name: string;\n  /** contract/ 기준 상대 경로 */\n  path: string;\n  type: \"file\" | \"directory\";\n  /** file인 경우만 존재 */\n  fileType?: CddFileType;\n  /** directory인 경우만 존재 */\n  children?: CddTreeNode[];\n};\n\n/** contract/ 디렉터리 절대 경로 반환 (apiRootPath 기준) */\nfunction getContractDir(): string {\n  return path.join(Sonamu.apiRootPath, \"contract\");\n}\n\n/** 경로가 contract/ 디렉터리 내부인지 검증 */\nfunction assertInsideContractDir(filePath: string): void {\n  const contractDir = getContractDir();\n  const resolved = path.resolve(contractDir, filePath);\n  if (!resolved.startsWith(contractDir + path.sep) && resolved !== contractDir) {\n    throw new Error(`경로가 contract/ 디렉터리 밖을 참조합니다: ${filePath}`);\n  }\n}\n\n/** 파일명에서 CddFileType 판별 */\nfunction detectFileType(fileName: string): CddFileType | undefined {\n  if (fileName.endsWith(\".contract.json\")) return \"contract\";\n  if (fileName.endsWith(\".spec.json\")) return \"spec\";\n  return undefined;\n}\n\n/** 디렉터리를 재귀 탐색하여 CddTreeNode 트리를 생성 */\nfunction scanDirectory(dirPath: string, relativeTo: string): CddTreeNode[] {\n  const entries = fs.readdirSync(dirPath, { withFileTypes: true });\n  const nodes: CddTreeNode[] = [];\n\n  for (const entry of entries) {\n    const fullPath = path.join(dirPath, entry.name);\n    const relPath = path.relative(relativeTo, fullPath);\n\n    if (entry.isDirectory()) {\n      const children = scanDirectory(fullPath, relativeTo);\n      nodes.push({\n        name: entry.name,\n        path: relPath,\n        type: \"directory\",\n        children,\n      });\n    } else if (entry.isFile()) {\n      const fileType = detectFileType(entry.name);\n      if (fileType) {\n        nodes.push({\n          name: entry.name,\n          path: relPath,\n          type: \"file\",\n          fileType,\n        });\n      }\n    }\n  }\n\n  return nodes;\n}\n\n/** contract/ 디렉터리의 트리 구조를 반환 */\nexport function getCddTree(): { exists: boolean; tree: CddTreeNode[] } {\n  const contractDir = getContractDir();\n  if (!fs.existsSync(contractDir)) {\n    return { exists: false, tree: [] };\n  }\n  const tree = scanDirectory(contractDir, contractDir);\n  return { exists: true, tree };\n}\n\n/** content 필드를 string으로 변환 (string[] 및 string 모두 지원) */\nfunction contentToString(content: unknown): string {\n  if (Array.isArray(content)) return content.join(\"\\n\");\n  if (typeof content === \"string\") return content;\n  return \"\";\n}\n\n/** JSON 파일의 전체 내용을 읽어 반환 (content는 string으로 변환) */\nexport function readContent(filePath: string): Record<string, unknown> {\n  assertInsideContractDir(filePath);\n\n  const contractDir = getContractDir();\n  const absPath = path.resolve(contractDir, filePath);\n\n  if (!fs.existsSync(absPath)) {\n    throw new Error(`파일을 찾을 수 없습니다: ${filePath}`);\n  }\n\n  const raw = fs.readFileSync(absPath, \"utf-8\");\n  const json = JSON.parse(raw) as Record<string, unknown>;\n  return { ...json, content: contentToString(json.content) };\n}\n\n/** JSON 파일의 content 필드를 외부 에디터로 편집 */\nexport async function editContent(\n  filePath: string,\n): Promise<{ success: boolean; filePath: string }> {\n  assertInsideContractDir(filePath);\n\n  const contractDir = getContractDir();\n  const absPath = path.resolve(contractDir, filePath);\n\n  if (!fs.existsSync(absPath)) {\n    throw new Error(`파일을 찾을 수 없습니다: ${filePath}`);\n  }\n\n  const editor = resolveEditorCli();\n\n  const raw = fs.readFileSync(absPath, \"utf-8\");\n  const json: Record<string, unknown> = JSON.parse(raw);\n\n  const content = contentToString(json.content);\n\n  const tmpFileName = `cdd-edit-${crypto.randomUUID()}.md`;\n  const tmpFilePath = path.join(os.tmpdir(), tmpFileName);\n\n  fs.writeFileSync(tmpFilePath, content, \"utf-8\");\n\n  try {\n    await runEditor(editor, tmpFilePath);\n\n    const edited = fs.readFileSync(tmpFilePath, \"utf-8\");\n    json.content = edited.split(\"\\n\");\n\n    const today = new Date();\n    const yyyy = today.getFullYear();\n    const mm = String(today.getMonth() + 1).padStart(2, \"0\");\n    const dd = String(today.getDate()).padStart(2, \"0\");\n    json.lastModified = `${yyyy}-${mm}-${dd}`;\n\n    fs.writeFileSync(absPath, `${JSON.stringify(json, null, 2)}\\n`, \"utf-8\");\n\n    return { success: true, filePath };\n  } finally {\n    if (fs.existsSync(tmpFilePath)) {\n      fs.unlinkSync(tmpFilePath);\n    }\n  }\n}\n\n/** 에디터별 앱 번들 내 CLI 경로 + --wait 플래그 매핑 */\nconst EDITOR_CLI_MAP: Record<string, { cli: string; waitFlag: string }> = {\n  \"Visual Studio Code\": { cli: \"Contents/Resources/app/bin/code\", waitFlag: \"--wait\" },\n  Zed: { cli: \"Contents/MacOS/cli\", waitFlag: \"--wait\" },\n  Cursor: { cli: \"Contents/Resources/app/bin/cursor\", waitFlag: \"--wait\" },\n};\n\n/** 앱 번들 CLI 경로를 resolve. wait=false이면 --wait 플래그를 생략 */\nfunction resolveEditorCli(options?: { wait?: boolean }): { bin: string; args: string[] } {\n  const wait = options?.wait ?? true;\n  const appName = Sonamu.config.externalEditor ?? \"Visual Studio Code\";\n  const mapping = EDITOR_CLI_MAP[appName];\n  if (!mapping) {\n    throw new Error(\n      `지원되지 않는 에디터입니다: ${appName} (지원: ${Object.keys(EDITOR_CLI_MAP).join(\", \")})`,\n    );\n  }\n\n  const searchPaths = [\n    `/Applications/${appName}.app`,\n    `${os.homedir()}/Applications/${appName}.app`,\n  ];\n  const bundlePath = searchPaths.find((p) => fs.existsSync(p));\n  if (!bundlePath) {\n    throw new Error(`앱 번들을 찾을 수 없습니다: ${appName} (/Applications 확인)`);\n  }\n\n  const cliBin = path.join(bundlePath, mapping.cli);\n  if (!fs.existsSync(cliBin)) {\n    throw new Error(`에디터 CLI를 찾을 수 없습니다: ${cliBin}`);\n  }\n\n  return { bin: cliBin, args: wait ? [mapping.waitFlag] : [] };\n}\n\n/** 에디터 CLI를 실행하고 탭이 닫힐 때까지 대기 */\nfunction runEditor(editor: { bin: string; args: string[] }, filePath: string): Promise<void> {\n  return new Promise((resolve, reject) => {\n    const child = spawn(editor.bin, [...editor.args, filePath], {\n      stdio: \"inherit\",\n    });\n\n    child.on(\"error\", (err) => {\n      reject(new Error(`에디터 실행 실패 (${editor.bin}): ${err.message}`));\n    });\n\n    child.on(\"close\", (code) => {\n      if (code === 0) {\n        resolve();\n      } else {\n        reject(new Error(`에디터가 비정상 종료되었습니다 (exit code: ${code})`));\n      }\n    });\n  });\n}\n\n/** 소스 파일을 외부 에디터로 열기 (대기하지 않음) */\nexport function openSourceFile(filePath: string): void {\n  const absPath = path.isAbsolute(filePath) ? filePath : path.resolve(Sonamu.apiRootPath, filePath);\n\n  if (!fs.existsSync(absPath)) {\n    throw new Error(`파일을 찾을 수 없습니다: ${filePath}`);\n  }\n\n  const editor = resolveEditorCli({ wait: false });\n  const child = spawn(editor.bin, [...editor.args, absPath], {\n    stdio: \"ignore\",\n    detached: true,\n  });\n  child.unref();\n}\n"],"names":["spawn","crypto","fs","os","path","Sonamu","getContractDir","join","apiRootPath","assertInsideContractDir","filePath","contractDir","resolved","resolve","startsWith","sep","Error","detectFileType","fileName","endsWith","undefined","scanDirectory","dirPath","relativeTo","entries","readdirSync","withFileTypes","nodes","entry","fullPath","name","relPath","relative","isDirectory","children","push","type","isFile","fileType","getCddTree","existsSync","exists","tree","contentToString","content","Array","isArray","readContent","absPath","raw","readFileSync","json","JSON","parse","editContent","editor","resolveEditorCli","tmpFileName","randomUUID","tmpFilePath","tmpdir","writeFileSync","runEditor","edited","split","today","Date","yyyy","getFullYear","mm","String","getMonth","padStart","dd","getDate","lastModified","stringify","success","unlinkSync","EDITOR_CLI_MAP","cli","waitFlag","Zed","Cursor","options","wait","appName","config","externalEditor","mapping","Object","keys","searchPaths","homedir","bundlePath","find","p","cliBin","bin","args","Promise","reject","child","stdio","on","err","message","code","openSourceFile","isAbsolute","detached","unref"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/ui/cdd-service.ts"],"sourcesContent":["import { spawn } from \"child_process\";\nimport fs from \"fs\";\nimport os from \"os\";\nimport path from \"path\";\nimport { Sonamu } from \"../api/sonamu\";\nimport type {\n  CddContentEnvelope,\n  CddFileType,\n  CddSchema,\n  CddSchemaDetailEnvelope,\n  CddSchemaReference,\n  CddSchemaSummary,\n  CddTreeNode,\n} from \"./cdd-types\";\n\nexport type {\n  CddContentEnvelope,\n  CddFileType,\n  CddSchema,\n  CddSchemaDetailEnvelope,\n  CddSchemaField,\n  CddSchemaFieldType,\n  CddSchemaReference,\n  CddSchemaSummary,\n  CddTreeNode,\n} from \"./cdd-types\";\n\n/** contract/ 디렉터리 절대 경로 반환 (apiRootPath 기준) */\nfunction getContractDir(): string {\n  return path.join(Sonamu.apiRootPath, \"..\", \"..\", \"contract\");\n}\n\n/** 경로가 contract/ 디렉터리 내부인지 검증 */\nfunction assertInsideContractDir(filePath: string): void {\n  const contractDir = getContractDir();\n  const resolved = path.resolve(contractDir, filePath);\n  if (!resolved.startsWith(contractDir + path.sep) && resolved !== contractDir) {\n    throw new Error(`경로가 contract/ 디렉터리 밖을 참조합니다: ${filePath}`);\n  }\n}\n\n/** 파일명에서 CddFileType 판별 */\nfunction detectFileType(fileName: string): CddFileType | undefined {\n  if (fileName.endsWith(\".contract.json\")) return \"contract\";\n  if (fileName.endsWith(\".spec.json\")) return \"spec\";\n  return undefined;\n}\n\n/** 디렉터리를 재귀 탐색하여 CddTreeNode 트리를 생성 */\nfunction scanDirectory(dirPath: string, relativeTo: string): CddTreeNode[] {\n  const entries = fs.readdirSync(dirPath, { withFileTypes: true });\n  const nodes: CddTreeNode[] = [];\n\n  for (const entry of entries) {\n    const fullPath = path.join(dirPath, entry.name);\n    const relPath = path.relative(relativeTo, fullPath);\n\n    if (entry.isDirectory()) {\n      const children = scanDirectory(fullPath, relativeTo);\n      nodes.push({\n        name: entry.name,\n        path: relPath,\n        type: \"directory\",\n        children,\n      });\n    } else if (entry.isFile()) {\n      const fileType = detectFileType(entry.name);\n      if (fileType) {\n        nodes.push({\n          name: entry.name,\n          path: relPath,\n          type: \"file\",\n          fileType,\n        });\n      }\n    }\n  }\n\n  return nodes;\n}\n\n/** contract/ 디렉터리의 트리 구조를 반환 */\nexport function getCddTree(): { exists: boolean; tree: CddTreeNode[] } {\n  const contractDir = getContractDir();\n  if (!fs.existsSync(contractDir)) {\n    return { exists: false, tree: [] };\n  }\n  const tree = scanDirectory(contractDir, contractDir);\n  return { exists: true, tree };\n}\n\n/** schema ID로 schema 파일을 찾아 반환 */\nfunction resolveSchema(schemaId: string): CddSchema | null {\n  const contractDir = getContractDir();\n  const schemaPath = path.join(contractDir, \"schemas\", `${schemaId}.schema.json`);\n  if (!fs.existsSync(schemaPath)) return null;\n  const raw = fs.readFileSync(schemaPath, \"utf-8\");\n  return JSON.parse(raw) as CddSchema;\n}\n\n/** JSON 파일의 전체 내용을 읽어 schema와 함께 envelope로 반환 */\nexport function readContent(filePath: string): CddContentEnvelope {\n  assertInsideContractDir(filePath);\n\n  const contractDir = getContractDir();\n  const absPath = path.resolve(contractDir, filePath);\n\n  if (!fs.existsSync(absPath)) {\n    throw new Error(`파일을 찾을 수 없습니다: ${filePath}`);\n  }\n\n  const raw = fs.readFileSync(absPath, \"utf-8\");\n  const document = JSON.parse(raw) as Record<string, unknown>;\n  const fileType = detectFileType(path.basename(filePath));\n  const schemaId = typeof document.schema === \"string\" ? document.schema : null;\n  const schema = schemaId ? resolveSchema(schemaId) : null;\n\n  return {\n    document,\n    schema,\n    fileType: fileType ?? \"contract\",\n  };\n}\n\n/** JSON 파일을 외부 에디터로 직접 편집 */\nexport async function editContent(\n  filePath: string,\n): Promise<{ success: boolean; filePath: string }> {\n  assertInsideContractDir(filePath);\n\n  const contractDir = getContractDir();\n  const absPath = path.resolve(contractDir, filePath);\n\n  if (!fs.existsSync(absPath)) {\n    throw new Error(`파일을 찾을 수 없습니다: ${filePath}`);\n  }\n\n  const editor = resolveEditorCli();\n  await runEditor(editor, absPath);\n\n  return { success: true, filePath };\n}\n\n/** 에디터별 앱 번들 내 CLI 경로 + --wait 플래그 매핑 */\nconst EDITOR_CLI_MAP: Record<string, { cli: string; waitFlag: string }> = {\n  \"Visual Studio Code\": { cli: \"Contents/Resources/app/bin/code\", waitFlag: \"--wait\" },\n  Zed: { cli: \"Contents/MacOS/cli\", waitFlag: \"--wait\" },\n  Cursor: { cli: \"Contents/Resources/app/bin/cursor\", waitFlag: \"--wait\" },\n};\n\n/** 앱 번들 CLI 경로를 resolve. wait=false이면 --wait 플래그를 생략 */\nfunction resolveEditorCli(options?: { wait?: boolean }): { bin: string; args: string[] } {\n  const wait = options?.wait ?? true;\n  const appName = Sonamu.config.externalEditor ?? \"Visual Studio Code\";\n  const mapping = EDITOR_CLI_MAP[appName];\n  if (!mapping) {\n    throw new Error(\n      `지원되지 않는 에디터입니다: ${appName} (지원: ${Object.keys(EDITOR_CLI_MAP).join(\", \")})`,\n    );\n  }\n\n  const searchPaths = [\n    `/Applications/${appName}.app`,\n    `${os.homedir()}/Applications/${appName}.app`,\n  ];\n  const bundlePath = searchPaths.find((p) => fs.existsSync(p));\n  if (!bundlePath) {\n    throw new Error(`앱 번들을 찾을 수 없습니다: ${appName} (/Applications 확인)`);\n  }\n\n  const cliBin = path.join(bundlePath, mapping.cli);\n  if (!fs.existsSync(cliBin)) {\n    throw new Error(`에디터 CLI를 찾을 수 없습니다: ${cliBin}`);\n  }\n\n  return { bin: cliBin, args: wait ? [mapping.waitFlag] : [] };\n}\n\n/** 에디터 CLI를 실행하고 탭이 닫힐 때까지 대기 */\nfunction runEditor(editor: { bin: string; args: string[] }, filePath: string): Promise<void> {\n  return new Promise((resolve, reject) => {\n    const child = spawn(editor.bin, [...editor.args, filePath], {\n      stdio: \"inherit\",\n    });\n\n    child.on(\"error\", (err) => {\n      reject(new Error(`에디터 실행 실패 (${editor.bin}): ${err.message}`));\n    });\n\n    child.on(\"close\", (code) => {\n      if (code === 0) {\n        resolve();\n      } else {\n        reject(new Error(`에디터가 비정상 종료되었습니다 (exit code: ${code})`));\n      }\n    });\n  });\n}\n\n/* ========================================================================\n * Schema 관리 API\n * ======================================================================== */\n\n/** contract/schemas/ 디렉터리 내 .schema.json 파일 경로 목록 반환 */\nfunction scanSchemaFiles(): { absPath: string; relPath: string; fileName: string }[] {\n  const schemasDir = path.join(getContractDir(), \"schemas\");\n  if (!fs.existsSync(schemasDir)) return [];\n\n  return fs\n    .readdirSync(schemasDir, { withFileTypes: true })\n    .filter((e) => e.isFile() && e.name.endsWith(\".schema.json\"))\n    .map((e) => ({\n      absPath: path.join(schemasDir, e.name),\n      relPath: `schemas/${e.name}`,\n      fileName: e.name,\n    }));\n}\n\n/** 특정 schemaId를 참조하는 contract/spec 문서들을 재귀 수집 */\nfunction collectSchemaReferences(\n  schemaId: string,\n  dirPath: string,\n  relativeTo: string,\n): CddSchemaReference[] {\n  if (!fs.existsSync(dirPath)) return [];\n  const refs: CddSchemaReference[] = [];\n  const entries = fs.readdirSync(dirPath, { withFileTypes: true });\n\n  for (const entry of entries) {\n    const fullPath = path.join(dirPath, entry.name);\n    if (entry.isDirectory()) {\n      if (entry.name === \"schemas\") continue;\n      refs.push(...collectSchemaReferences(schemaId, fullPath, relativeTo));\n    } else if (entry.isFile()) {\n      const fileType = detectFileType(entry.name);\n      if (!fileType) continue;\n      try {\n        const raw = fs.readFileSync(fullPath, \"utf-8\");\n        const doc = JSON.parse(raw) as Record<string, unknown>;\n        if (doc.schema === schemaId) {\n          refs.push({\n            path: path.relative(relativeTo, fullPath),\n            fileType,\n            name: entry.name,\n          });\n        }\n      } catch {\n        // JSON 파싱 실패 시 무시\n      }\n    }\n  }\n  return refs;\n}\n\n/** schema 파일명에서 기대되는 id 추출 */\nfunction expectedSchemaId(fileName: string): string {\n  return fileName.replace(/\\.schema\\.json$/, \"\");\n}\n\n/** schemas/ 하위 경로가 contract/schemas/ 내부인지 검증 */\nfunction assertInsideSchemaDir(schemaKey: string): void {\n  const schemasDir = path.join(getContractDir(), \"schemas\");\n  const resolved = path.resolve(schemasDir, `${schemaKey}.schema.json`);\n  if (!resolved.startsWith(schemasDir + path.sep) && resolved !== schemasDir) {\n    throw new Error(`유효하지 않은 스키마 키입니다: ${schemaKey}`);\n  }\n}\n\n/** schema 목록 반환 */\nexport function listSchemas(): { schemas: CddSchemaSummary[] } {\n  const contractDir = getContractDir();\n  const files = scanSchemaFiles();\n  const schemas: CddSchemaSummary[] = [];\n\n  for (const file of files) {\n    const key = expectedSchemaId(file.fileName);\n    try {\n      const raw = fs.readFileSync(file.absPath, \"utf-8\");\n      const schema = JSON.parse(raw) as CddSchema;\n      const refs = collectSchemaReferences(schema.id, contractDir, contractDir);\n      schemas.push({\n        key,\n        id: schema.id,\n        path: file.relPath,\n        type: schema.type,\n        fieldCount: schema.fields.length,\n        referenceCount: refs.length,\n        hasIdMismatch: schema.id !== key,\n      });\n    } catch (err) {\n      schemas.push({\n        key,\n        id: key,\n        path: file.relPath,\n        type: \"contract\",\n        fieldCount: 0,\n        referenceCount: 0,\n        hasIdMismatch: false,\n        parseError: err instanceof Error ? err.message : String(err),\n      });\n    }\n  }\n\n  return { schemas };\n}\n\n/** schema 상세 반환 (파일명 기반 key로 조회) */\nexport function readSchema(schemaKey: string): CddSchemaDetailEnvelope {\n  assertInsideSchemaDir(schemaKey);\n\n  const contractDir = getContractDir();\n  const absPath = path.join(contractDir, \"schemas\", `${schemaKey}.schema.json`);\n\n  if (!fs.existsSync(absPath)) {\n    throw new Error(`스키마를 찾을 수 없습니다: ${schemaKey}`);\n  }\n\n  const raw = fs.readFileSync(absPath, \"utf-8\");\n  const schema = JSON.parse(raw) as CddSchema;\n  const relPath = path.relative(contractDir, absPath);\n  const references = collectSchemaReferences(schema.id, contractDir, contractDir);\n\n  return {\n    key: schemaKey,\n    path: relPath,\n    schema,\n    references,\n    hasIdMismatch: schema.id !== schemaKey,\n  };\n}\n\n/** schema 파일을 외부 에디터로 편집 (파일명 기반 key로 조회) */\nexport async function editSchema(\n  schemaKey: string,\n): Promise<{ success: boolean; schemaKey: string }> {\n  assertInsideSchemaDir(schemaKey);\n\n  const contractDir = getContractDir();\n  const absPath = path.join(contractDir, \"schemas\", `${schemaKey}.schema.json`);\n\n  if (!fs.existsSync(absPath)) {\n    throw new Error(`스키마를 찾을 수 없습니다: ${schemaKey}`);\n  }\n\n  const editor = resolveEditorCli();\n  await runEditor(editor, absPath);\n\n  return { success: true, schemaKey };\n}\n\n/** 소스 파일을 외부 에디터로 열기 (대기하지 않음) */\nexport function openSourceFile(filePath: string): void {\n  const absPath = path.isAbsolute(filePath) ? filePath : path.resolve(Sonamu.apiRootPath, filePath);\n\n  if (!fs.existsSync(absPath)) {\n    throw new Error(`파일을 찾을 수 없습니다: ${filePath}`);\n  }\n\n  const editor = resolveEditorCli({ wait: false });\n  const child = spawn(editor.bin, [...editor.args, absPath], {\n    stdio: \"ignore\",\n    detached: true,\n  });\n  child.unref();\n}\n"],"names":["spawn","fs","os","path","Sonamu","getContractDir","join","apiRootPath","assertInsideContractDir","filePath","contractDir","resolved","resolve","startsWith","sep","Error","detectFileType","fileName","endsWith","undefined","scanDirectory","dirPath","relativeTo","entries","readdirSync","withFileTypes","nodes","entry","fullPath","name","relPath","relative","isDirectory","children","push","type","isFile","fileType","getCddTree","existsSync","exists","tree","resolveSchema","schemaId","schemaPath","raw","readFileSync","JSON","parse","readContent","absPath","document","basename","schema","editContent","editor","resolveEditorCli","runEditor","success","EDITOR_CLI_MAP","cli","waitFlag","Zed","Cursor","options","wait","appName","config","externalEditor","mapping","Object","keys","searchPaths","homedir","bundlePath","find","p","cliBin","bin","args","Promise","reject","child","stdio","on","err","message","code","scanSchemaFiles","schemasDir","filter","e","map","collectSchemaReferences","refs","doc","expectedSchemaId","replace","assertInsideSchemaDir","schemaKey","listSchemas","files","schemas","file","key","id","fieldCount","fields","length","referenceCount","hasIdMismatch","parseError","String","readSchema","references","editSchema","openSourceFile","isAbsolute","detached","unref"],"mappings":"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"}

package/dist/ui/cdd-types.d.ts

@@ -0,0 +1,60 @@
+export type CddFileType = "contract" | "spec";
+export type CddSchemaFieldType = "string" | "string[]" | "Record<string, string>" | "Record<string, object>";
+export type CddSchemaField = {
+    name: string;
+    label?: string;
+    type: CddSchemaFieldType;
+    renderer?: string;
+    required: boolean;
+};
+export type CddSchema = {
+    id: string;
+    type: "contract" | "spec";
+    fields: CddSchemaField[];
+};
+export type CddContentEnvelope = {
+    document: Record<string, unknown>;
+    schema: CddSchema | null;
+    fileType: CddFileType;
+};
+export type CddTreeNode = {
+    name: string;
+    path: string;
+    type: "file" | "directory";
+    fileType?: CddFileType;
+    children?: CddTreeNode[];
+};
+export type CddSchemaSummary = {
+    key: string;
+    id: string;
+    path: string;
+    type: "contract" | "spec";
+    fieldCount: number;
+    referenceCount: number;
+    hasIdMismatch: boolean;
+    parseError?: string;
+};
+export type CddSchemaReference = {
+    path: string;
+    fileType: CddFileType;
+    name: string;
+};
+export type CddSchemaDetailEnvelope = {
+    key: string;
+    path: string;
+    schema: CddSchema;
+    references: CddSchemaReference[];
+    hasIdMismatch: boolean;
+};
+/** Acceptance Criterion 테스트 참조 */
+export type AcceptanceCriterionTestRef = {
+    target: string;
+    pattern: string;
+};
+/** 구조화된 Acceptance Criterion */
+export type AcceptanceCriterion = {
+    id: string;
+    condition: string;
+    testRef: AcceptanceCriterionTestRef;
+};
+//# sourceMappingURL=cdd-types.d.ts.map

package/dist/ui/cdd-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cdd-types.d.ts","sourceRoot":"","sources":["../../src/ui/cdd-types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,GAAG,UAAU,GAAG,MAAM,CAAC;AAE9C,MAAM,MAAM,kBAAkB,GAC1B,QAAQ,GACR,UAAU,GACV,wBAAwB,GACxB,wBAAwB,CAAC;AAE7B,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,kBAAkB,CAAC;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,UAAU,GAAG,MAAM,CAAC;IAC1B,MAAM,EAAE,cAAc,EAAE,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,MAAM,EAAE,SAAS,GAAG,IAAI,CAAC;IACzB,QAAQ,EAAE,WAAW,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;IAC3B,QAAQ,CAAC,EAAE,WAAW,CAAC;IACvB,QAAQ,CAAC,EAAE,WAAW,EAAE,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,UAAU,GAAG,MAAM,CAAC;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,OAAO,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,WAAW,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,SAAS,CAAC;IAClB,UAAU,EAAE,kBAAkB,EAAE,CAAC;IACjC,aAAa,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,kCAAkC;AAClC,MAAM,MAAM,0BAA0B,GAAG;IACvC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,gCAAgC;AAChC,MAAM,MAAM,mBAAmB,GAAG;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,0BAA0B,CAAC;CACrC,CAAC"}

package/dist/ui/cdd-types.js

@@ -0,0 +1,3 @@
+/** 구조화된 Acceptance Criterion */ export { };
+
+//# sourceMappingURL=data:application/json;base64,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