sonamu 0.8.25 → 0.9.0

package/dist/ui/cdd-service.js

@@ -1,403 +1,426 @@
-import { spawn } from "child_process";
-import fs from "fs";
-import os from "os";
+import { __esmMin } from "../_virtual/rolldown_runtime.js";
+import { Sonamu, init_sonamu } from "../api/sonamu.js";
 import path from "path";
-import { Sonamu } from "../api/sonamu.js";
-/** contract/ 디렉터리 절대 경로 반환 (apiRootPath 기준) */ function getContractDir() {
-    return path.join(Sonamu.apiRootPath, "..", "..", "contract");
-}
-/** 경로가 contract/ 디렉터리 내부인지 검증 */ function assertInsideContractDir(filePath) {
-    const contractDir = getContractDir();
-    const resolved = path.resolve(contractDir, filePath);
-    if (!resolved.startsWith(contractDir + path.sep) && resolved !== contractDir) {
-        throw new Error(`경로가 contract/ 디렉터리 밖을 참조합니다: ${filePath}`);
-    }
+import os from "os";
+import fs from "fs";
+import { spawn } from "child_process";
+
+//#region src/ui/cdd-service.ts
+/** contract/ 디렉터리 절대 경로 반환 (apiRootPath 기준) */
+function getContractDir() {
+	return path.join(Sonamu.apiRootPath, "..", "..", "contract");
 }
-/** 파일명에서 CddFileType 판별 */ function detectFileType(fileName) {
-    if (fileName.endsWith(".contract.json")) return "contract";
-    if (fileName.endsWith(".spec.json")) return "spec";
-    return undefined;
+/** 프로젝트 루트 경로 반환 */
+function getProjectRoot() {
+	return path.join(Sonamu.apiRootPath, "..", "..");
 }
-/** 디렉터리를 재귀 탐색하여 CddTreeNode 트리를 생성 */ function scanDirectory(dirPath, relativeTo) {
-    const entries = fs.readdirSync(dirPath, {
-        withFileTypes: true
-    });
-    const nodes = [];
-    for (const entry of entries){
-        const fullPath = path.join(dirPath, entry.name);
-        const relPath = path.relative(relativeTo, fullPath);
-        if (entry.isDirectory()) {
-            const children = scanDirectory(fullPath, relativeTo);
-            nodes.push({
-                name: entry.name,
-                path: relPath,
-                type: "directory",
-                children
-            });
-        } else if (entry.isFile()) {
-            const fileType = detectFileType(entry.name);
-            if (fileType) {
-                nodes.push({
-                    name: entry.name,
-                    path: relPath,
-                    type: "file",
-                    fileType
-                });
-            }
-        }
-    }
-    return nodes;
+/** 경로가 contract/ 디렉터리 내부인지 검증 */
+function assertInsideContractDir(filePath) {
+	const contractDir = getContractDir();
+	const resolved = path.resolve(contractDir, filePath);
+	if (!resolved.startsWith(contractDir + path.sep) && resolved !== contractDir) {
+		throw new Error(`경로가 contract/ 디렉터리 밖을 참조합니다: ${filePath}`);
+	}
 }
-/** contract/ 디렉터리의 트리 구조를 반환 */ export function getCddTree() {
-    const contractDir = getContractDir();
-    if (!fs.existsSync(contractDir)) {
-        return {
-            exists: false,
-            tree: []
-        };
-    }
-    const tree = scanDirectory(contractDir, contractDir);
-    return {
-        exists: true,
-        tree
-    };
+/** 파일명에서 CddFileType 판별 */
+function detectFileType(fileName) {
+	if (fileName.endsWith(".contract.md")) return "contract";
+	if (fileName.endsWith(".rules.json")) return "rules";
+	return undefined;
 }
-/** 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);
+/** 디렉터리를 재귀 탐색하여 CddTreeNode 트리를 생성 */
+function scanDirectory(dirPath, relativeTo) {
+	const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+	const nodes = [];
+	for (const entry of entries) {
+		const fullPath = path.join(dirPath, entry.name);
+		const relPath = path.relative(relativeTo, fullPath);
+		if (entry.isDirectory()) {
+			if (entry.name === "rules") continue;
+			const children = scanDirectory(fullPath, relativeTo);
+			if (children.length > 0) {
+				nodes.push({
+					name: entry.name,
+					path: relPath,
+					type: "directory",
+					children
+				});
+			}
+		} else if (entry.isFile()) {
+			const fileType = detectFileType(entry.name);
+			if (fileType && fileType !== "rules") {
+				nodes.push({
+					name: entry.name,
+					path: relPath,
+					type: "file",
+					fileType
+				});
+			}
+		}
+	}
+	return nodes;
 }
-/** JSON 파일의 전체 내용을 읽어 schema와 함께 envelope로 반환 */ export function readContent(filePath) {
-    assertInsideContractDir(filePath);
-    const contractDir = getContractDir();
-    const absPath = path.resolve(contractDir, filePath);
-    if (!fs.existsSync(absPath)) {
-        throw new Error(`파일을 찾을 수 없습니다: ${filePath}`);
-    }
-    const raw = fs.readFileSync(absPath, "utf-8");
-    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 {
-        document,
-        schema,
-        fileType: fileType ?? "contract"
-    };
+/** contract/ 디렉터리의 트리 구조를 반환 */
+function getCddTree() {
+	const contractDir = getContractDir();
+	if (!fs.existsSync(contractDir)) {
+		return {
+			exists: false,
+			tree: []
+		};
+	}
+	const tree = scanDirectory(contractDir, contractDir);
+	return {
+		exists: true,
+		tree
+	};
 }
-/** JSON 파일을 외부 에디터로 직접 편집 */ export async function editContent(filePath) {
-    assertInsideContractDir(filePath);
-    const contractDir = getContractDir();
-    const absPath = path.resolve(contractDir, filePath);
-    if (!fs.existsSync(absPath)) {
-        throw new Error(`파일을 찾을 수 없습니다: ${filePath}`);
-    }
-    const editor = resolveEditorCli();
-    await runEditor(editor, absPath);
-    return {
-        success: true,
-        filePath
-    };
+/** 파일 내용을 읽어 반환 (contract.md → markdown 원문, rules.json → JSON 문자열) */
+function readContent(filePath) {
+	assertInsideContractDir(filePath);
+	const contractDir = getContractDir();
+	const absPath = path.resolve(contractDir, filePath);
+	if (!fs.existsSync(absPath)) {
+		throw new Error(`파일을 찾을 수 없습니다: ${filePath}`);
+	}
+	const content = fs.readFileSync(absPath, "utf-8");
+	const fileType = detectFileType(path.basename(filePath));
+	return {
+		content,
+		fileType: fileType ?? "contract"
+	};
 }
-/** 에디터별 앱 번들 내 CLI 경로 + --wait 플래그 매핑 */ const EDITOR_CLI_MAP = {
-    "Visual Studio Code": {
-        cli: "Contents/Resources/app/bin/code",
-        waitFlag: "--wait"
-    },
-    Zed: {
-        cli: "Contents/MacOS/cli",
-        waitFlag: "--wait"
-    },
-    Cursor: {
-        cli: "Contents/Resources/app/bin/cursor",
-        waitFlag: "--wait"
-    }
-};
-/** 앱 번들 CLI 경로를 resolve. wait=false이면 --wait 플래그를 생략 */ function resolveEditorCli(options) {
-    const wait = options?.wait ?? true;
-    const appName = Sonamu.config.externalEditor ?? "Visual Studio Code";
-    const mapping = EDITOR_CLI_MAP[appName];
-    if (!mapping) {
-        throw new Error(`지원되지 않는 에디터입니다: ${appName} (지원: ${Object.keys(EDITOR_CLI_MAP).join(", ")})`);
-    }
-    const searchPaths = [
-        `/Applications/${appName}.app`,
-        `${os.homedir()}/Applications/${appName}.app`
-    ];
-    const bundlePath = searchPaths.find((p)=>fs.existsSync(p));
-    if (!bundlePath) {
-        throw new Error(`앱 번들을 찾을 수 없습니다: ${appName} (/Applications 확인)`);
-    }
-    const cliBin = path.join(bundlePath, mapping.cli);
-    if (!fs.existsSync(cliBin)) {
-        throw new Error(`에디터 CLI를 찾을 수 없습니다: ${cliBin}`);
-    }
-    return {
-        bin: cliBin,
-        args: wait ? [
-            mapping.waitFlag
-        ] : []
-    };
+/** 파일을 외부 에디터로 직접 편집 */
+async function editContent(filePath) {
+	assertInsideContractDir(filePath);
+	const contractDir = getContractDir();
+	const absPath = path.resolve(contractDir, filePath);
+	if (!fs.existsSync(absPath)) {
+		throw new Error(`파일을 찾을 수 없습니다: ${filePath}`);
+	}
+	const editor = resolveEditorCli();
+	await runEditor(editor, absPath);
+	return {
+		success: true,
+		filePath
+	};
 }
-/** 에디터 CLI를 실행하고 탭이 닫힐 때까지 대기 */ function runEditor(editor, filePath) {
-    return new Promise((resolve, reject)=>{
-        const child = spawn(editor.bin, [
-            ...editor.args,
-            filePath
-        ], {
-            stdio: "inherit"
-        });
-        child.on("error", (err)=>{
-            reject(new Error(`에디터 실행 실패 (${editor.bin}): ${err.message}`));
-        });
-        child.on("close", (code)=>{
-            if (code === 0) {
-                resolve();
-            } else {
-                reject(new Error(`에디터가 비정상 종료되었습니다 (exit code: ${code})`));
-            }
-        });
-    });
+/** 앱 번들 CLI 경로를 resolve. wait=false이면 --wait 플래그를 생략 */
+function resolveEditorCli(options) {
+	const wait = options?.wait ?? true;
+	const appName = Sonamu.config.externalEditor ?? "Visual Studio Code";
+	const mapping = EDITOR_CLI_MAP[appName];
+	if (!mapping) {
+		throw new Error(`지원되지 않는 에디터입니다: ${appName} (지원: ${Object.keys(EDITOR_CLI_MAP).join(", ")})`);
+	}
+	const searchPaths = [`/Applications/${appName}.app`, `${os.homedir()}/Applications/${appName}.app`];
+	const bundlePath = searchPaths.find((p) => fs.existsSync(p));
+	if (!bundlePath) {
+		throw new Error(`앱 번들을 찾을 수 없습니다: ${appName} (/Applications 확인)`);
+	}
+	const cliBin = path.join(bundlePath, mapping.cli);
+	if (!fs.existsSync(cliBin)) {
+		throw new Error(`에디터 CLI를 찾을 수 없습니다: ${cliBin}`);
+	}
+	return {
+		bin: cliBin,
+		args: wait ? [mapping.waitFlag] : []
+	};
 }
-/* ========================================================================
- * 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
-        }));
+/** 에디터 CLI를 실행하고 탭이 닫힐 때까지 대기 */
+function runEditor(editor, filePath) {
+	return new Promise((resolve, reject) => {
+		const child = spawn(editor.bin, [...editor.args, filePath], { stdio: "inherit" });
+		child.on("error", (err) => {
+			reject(new Error(`에디터 실행 실패 (${editor.bin}): ${err.message}`));
+		});
+		child.on("close", (code) => {
+			if (code === 0) {
+				resolve();
+			} else {
+				reject(new Error(`에디터가 비정상 종료되었습니다 (exit code: ${code})`));
+			}
+		});
+	});
 }
-/** 특정 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;
+/** 소스 파일을 외부 에디터로 열기 (대기하지 않음) */
+function openSourceFile(filePath) {
+	const absPath = path.isAbsolute(filePath) ? filePath : path.resolve(Sonamu.apiRootPath, filePath);
+	if (!fs.existsSync(absPath)) {
+		throw new Error(`파일을 찾을 수 없습니다: ${filePath}`);
+	}
+	const editor = resolveEditorCli({ wait: false });
+	const child = spawn(editor.bin, [...editor.args, absPath], {
+		stdio: "ignore",
+		detached: true
+	});
+	child.unref();
 }
-/** schema 파일명에서 기대되는 id 추출 */ function expectedSchemaId(fileName) {
-    return fileName.replace(/\.schema\.json$/, "");
+/** contract/rules/ 디렉터리 내 .rules.json 파일 목록 반환 */
+function listRules() {
+	const contractDir = getContractDir();
+	const rulesDir = path.join(contractDir, "rules");
+	if (!fs.existsSync(rulesDir)) return { rules: [] };
+	const entries = fs.readdirSync(rulesDir, { withFileTypes: true });
+	const rules = [];
+	for (const entry of entries) {
+		if (!entry.isFile() || !entry.name.endsWith(".rules.json")) continue;
+		const key = entry.name.replace(/\.rules\.json$/, "");
+		const relPath = `rules/${entry.name}`;
+		const absPath = path.join(rulesDir, entry.name);
+		try {
+			const raw = fs.readFileSync(absPath, "utf-8");
+			const doc = JSON.parse(raw);
+			rules.push({
+				key,
+				path: relPath,
+				description: typeof doc.description === "string" ? doc.description : "",
+				ruleCount: Array.isArray(doc.rules) ? doc.rules.length : 0
+			});
+		} catch (err) {
+			rules.push({
+				key,
+				path: relPath,
+				description: "",
+				ruleCount: 0,
+				parseError: err instanceof Error ? err.message : String(err)
+			});
+		}
+	}
+	return { rules };
 }
-/** 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}`);
-    }
+/** rules 파일 상세 반환 */
+function readRule(ruleKey) {
+	const contractDir = getContractDir();
+	const absPath = path.join(contractDir, "rules", `${ruleKey}.rules.json`);
+	if (!fs.existsSync(absPath)) {
+		throw new Error(`Rules 파일을 찾을 수 없습니다: ${ruleKey}`);
+	}
+	const raw = fs.readFileSync(absPath, "utf-8");
+	const doc = JSON.parse(raw);
+	return {
+		key: ruleKey,
+		path: `rules/${ruleKey}.rules.json`,
+		description: typeof doc.description === "string" ? doc.description : "",
+		rules: Array.isArray(doc.rules) ? doc.rules : []
+	};
 }
-/** 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
-    };
+/** rules 파일에 규칙 추가 */
+function addRule(req) {
+	const contractDir = getContractDir();
+	const rulesDir = path.join(contractDir, "rules");
+	const absPath = path.join(rulesDir, `${req.ruleKey}.rules.json`);
+	if (!fs.existsSync(absPath)) {
+		throw new Error(`Rules 파일을 찾을 수 없습니다: ${req.ruleKey}`);
+	}
+	const raw = fs.readFileSync(absPath, "utf-8");
+	const doc = JSON.parse(raw);
+	const rules = Array.isArray(doc.rules) ? doc.rules : [];
+	const nextId = generateNextRuleId(rules);
+	const newEntry = {
+		id: nextId,
+		when: req.when,
+		instruction: req.instruction
+	};
+	if (req.examples && req.examples.length > 0) {
+		newEntry.examples = req.examples;
+	}
+	rules.push(newEntry);
+	doc.rules = rules;
+	fs.writeFileSync(absPath, `${JSON.stringify(doc, null, 2)}\n`, "utf-8");
+	return {
+		key: req.ruleKey,
+		path: `rules/${req.ruleKey}.rules.json`,
+		description: typeof doc.description === "string" ? doc.description : "",
+		rules
+	};
 }
-/** 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
-    };
+/** 기존 id 패턴을 분석하여 다음 순번 id 생성 */
+function generateNextRuleId(rules) {
+	if (rules.length === 0) return "R-001";
+	const numericPattern = /^(.+?)(\d+)$/;
+	let bestPrefix = "R-";
+	let maxNum = 0;
+	for (const rule of rules) {
+		const match = numericPattern.exec(rule.id);
+		if (match) {
+			const prefix = match[1];
+			const num = Number.parseInt(match[2], 10);
+			if (num > maxNum) {
+				bestPrefix = prefix;
+				maxNum = num;
+			}
+		}
+	}
+	const nextNum = maxNum + 1;
+	const padLen = Math.max(3, String(maxNum).length);
+	return `${bestPrefix}${String(nextNum).padStart(padLen, "0")}`;
 }
-/** 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
-    };
+/** describe/test 패턴 파싱 */
+function parseAcEntries(content) {
+	const entries = [];
+	const lines = content.split("\n");
+	let currentDescribe = null;
+	let describeDepth = 0;
+	let braceDepth = 0;
+	let pendingTestAs = false;
+	let testAsBraceDepth = 0;
+	let testAsNeedName = false;
+	for (const line of lines) {
+		const trimmed = line.trim();
+		const describeMatch = trimmed.match(/^describe\(["'`](.+?)["'`]/);
+		if (describeMatch) {
+			currentDescribe = describeMatch[1];
+			describeDepth = braceDepth;
+		}
+		const testMatch = trimmed.match(/^(?:test|it)\(["'`](.+?)["'`]/);
+		if (testMatch) {
+			entries.push({
+				describe: currentDescribe,
+				test: testMatch[1]
+			});
+		}
+		if (!pendingTestAs && trimmed.match(/^testAs\s*\(/)) {
+			const inlineMatch = trimmed.match(/^testAs\s*\(\s*\{[^}]*\}\s*,\s*["'`](.+?)["'`]/);
+			if (inlineMatch) {
+				entries.push({
+					describe: currentDescribe,
+					test: inlineMatch[1]
+				});
+			} else {
+				pendingTestAs = true;
+				testAsBraceDepth = 0;
+				testAsNeedName = false;
+				for (const ch of trimmed) {
+					if (ch === "{") testAsBraceDepth++;
+					if (ch === "}") testAsBraceDepth--;
+				}
+				if (testAsBraceDepth <= 0) {
+					testAsNeedName = true;
+					const nameMatch = trimmed.match(/}\s*,\s*["'`](.+?)["'`]/);
+					if (nameMatch) {
+						entries.push({
+							describe: currentDescribe,
+							test: nameMatch[1]
+						});
+						pendingTestAs = false;
+						testAsNeedName = false;
+					}
+				}
+			}
+		} else if (pendingTestAs) {
+			if (!testAsNeedName) {
+				for (const ch of trimmed) {
+					if (ch === "{") testAsBraceDepth++;
+					if (ch === "}") testAsBraceDepth--;
+				}
+				if (testAsBraceDepth <= 0) {
+					testAsNeedName = true;
+					const nameMatch = trimmed.match(/}\s*,\s*["'`](.+?)["'`]/);
+					if (nameMatch) {
+						entries.push({
+							describe: currentDescribe,
+							test: nameMatch[1]
+						});
+						pendingTestAs = false;
+						testAsNeedName = false;
+					}
+				}
+			} else {
+				const nameMatch = trimmed.match(/^["'`](.+?)["'`]/);
+				if (nameMatch) {
+					entries.push({
+						describe: currentDescribe,
+						test: nameMatch[1]
+					});
+					pendingTestAs = false;
+					testAsNeedName = false;
+				}
+			}
+		}
+		for (const ch of trimmed) {
+			if (ch === "{") braceDepth++;
+			if (ch === "}") {
+				braceDepth--;
+				if (currentDescribe && braceDepth <= describeDepth) {
+					currentDescribe = null;
+				}
+			}
+		}
+	}
+	return entries;
 }
-const VALID_SPEC_STATUSES = new Set([
-    "draft",
-    "specifying",
-    "implementing",
-    "validating",
-    "done"
-]);
-/** 모든 contract/spec 문서를 스캔하여 대시보드 통계를 반환 */ export function getDashboard() {
-    const contractDir = getContractDir();
-    if (!fs.existsSync(contractDir)) {
-        return {
-            exists: false,
-            stats: {
-                totalContracts: 0,
-                totalSpecs: 0,
-                statusDistribution: {
-                    draft: 0,
-                    specifying: 0,
-                    implementing: 0,
-                    validating: 0,
-                    done: 0
-                }
-            },
-            documents: []
-        };
-    }
-    const documents = [];
-    const statusDistribution = {
-        draft: 0,
-        specifying: 0,
-        implementing: 0,
-        validating: 0,
-        done: 0
-    };
-    function scanForDashboard(dirPath) {
-        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;
-                scanForDashboard(fullPath);
-            } else if (entry.isFile()) {
-                const fileType = detectFileType(entry.name);
-                if (!fileType) continue;
-                const relPath = path.relative(contractDir, fullPath);
-                try {
-                    const raw = fs.readFileSync(fullPath, "utf-8");
-                    const doc = JSON.parse(raw);
-                    const summary = {
-                        path: relPath,
-                        name: entry.name,
-                        fileType,
-                        schemaId: typeof doc.schema === "string" ? doc.schema : undefined,
-                        lastModified: typeof doc.lastModified === "string" ? doc.lastModified : undefined
-                    };
-                    if (fileType === "contract") {
-                        const features = doc.features;
-                        if (features && typeof features === "object" && !Array.isArray(features)) {
-                            summary.featureCount = Object.keys(features).length;
-                        }
-                    } else {
-                        const status = typeof doc.status === "string" ? doc.status : "draft";
-                        summary.status = VALID_SPEC_STATUSES.has(status) ? status : "draft";
-                        statusDistribution[summary.status]++;
-                        if (Array.isArray(doc.acceptanceCriteria)) {
-                            summary.acceptanceCriteriaCount = doc.acceptanceCriteria.length;
-                        }
-                        if (Array.isArray(doc.sources)) {
-                            summary.sourceCount = doc.sources.length;
-                        }
-                    }
-                    documents.push(summary);
-                } catch (err) {
-                    documents.push({
-                        path: relPath,
-                        name: entry.name,
-                        fileType,
-                        parseError: err instanceof Error ? err.message : String(err)
-                    });
-                }
-            }
-        }
-    }
-    scanForDashboard(contractDir);
-    const totalContracts = documents.filter((d)=>d.fileType === "contract" && !d.parseError).length;
-    const totalSpecs = documents.filter((d)=>d.fileType === "spec" && !d.parseError).length;
-    return {
-        exists: true,
-        stats: {
-            totalContracts,
-            totalSpecs,
-            statusDistribution
-        },
-        documents
-    };
+/** 프로젝트 내 *.test.ts 파일을 스캔하여 AC 목록 반환 */
+function getAcList() {
+	const projectRoot = getProjectRoot();
+	const files = findTestFiles(projectRoot);
+	const acFiles = [];
+	for (const absPath of files) {
+		const content = fs.readFileSync(absPath, "utf-8");
+		const entries = parseAcEntries(content);
+		if (entries.length > 0) {
+			acFiles.push({
+				path: path.relative(projectRoot, absPath),
+				entries
+			});
+		}
+	}
+	const total = acFiles.reduce((sum, f) => sum + f.entries.length, 0);
+	return {
+		files: acFiles,
+		total
+	};
 }
-/** 소스 파일을 외부 에디터로 열기 (대기하지 않음) */ export function openSourceFile(filePath) {
-    const absPath = path.isAbsolute(filePath) ? filePath : path.resolve(Sonamu.apiRootPath, filePath);
-    if (!fs.existsSync(absPath)) {
-        throw new Error(`파일을 찾을 수 없습니다: ${filePath}`);
-    }
-    const editor = resolveEditorCli({
-        wait: false
-    });
-    const child = spawn(editor.bin, [
-        ...editor.args,
-        absPath
-    ], {
-        stdio: "ignore",
-        detached: true
-    });
-    child.unref();
+/** *.test.ts 파일을 재귀 탐색 (node_modules, dist 제외) */
+function findTestFiles(dir) {
+	const results = [];
+	const IGNORE = new Set([
+		"node_modules",
+		"dist",
+		".git",
+		"contract"
+	]);
+	function walk(currentDir) {
+		let entries;
+		try {
+			entries = fs.readdirSync(currentDir, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			if (IGNORE.has(entry.name)) continue;
+			const fullPath = path.join(currentDir, entry.name);
+			if (entry.isDirectory()) {
+				walk(fullPath);
+			} else if (entry.isFile() && entry.name.endsWith(".test.ts")) {
+				results.push(fullPath);
+			}
+		}
+	}
+	walk(dir);
+	results.sort();
+	return results;
 }
+var EDITOR_CLI_MAP;
+var init_cdd_service = __esmMin((() => {
+	init_sonamu();
+	EDITOR_CLI_MAP = {
+		"Visual Studio Code": {
+			cli: "Contents/Resources/app/bin/code",
+			waitFlag: "--wait"
+		},
+		Zed: {
+			cli: "Contents/MacOS/cli",
+			waitFlag: "--wait"
+		},
+		Cursor: {
+			cli: "Contents/Resources/app/bin/cursor",
+			waitFlag: "--wait"
+		}
+	};
+}));
 
-//# 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  CddDashboardData,\n  CddDocumentSummary,\n  CddFileType,\n  CddSchema,\n  CddSchemaDetailEnvelope,\n  CddSchemaReference,\n  CddSchemaSummary,\n  CddSpecStatus,\n  CddTreeNode,\n} from \"./cdd-types\";\n\nexport type {\n  CddContentEnvelope,\n  CddDashboardData,\n  CddDocumentSummary,\n  CddFileType,\n  CddSchema,\n  CddSchemaDetailEnvelope,\n  CddSchemaField,\n  CddSchemaFieldType,\n  CddSchemaReference,\n  CddSchemaSummary,\n  CddSpecStatus,\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\nconst VALID_SPEC_STATUSES = new Set<CddSpecStatus>([\n  \"draft\",\n  \"specifying\",\n  \"implementing\",\n  \"validating\",\n  \"done\",\n]);\n\n/** 모든 contract/spec 문서를 스캔하여 대시보드 통계를 반환 */\nexport function getDashboard(): CddDashboardData {\n  const contractDir = getContractDir();\n  if (!fs.existsSync(contractDir)) {\n    return {\n      exists: false,\n      stats: {\n        totalContracts: 0,\n        totalSpecs: 0,\n        statusDistribution: { draft: 0, specifying: 0, implementing: 0, validating: 0, done: 0 },\n      },\n      documents: [],\n    };\n  }\n\n  const documents: CddDocumentSummary[] = [];\n  const statusDistribution: Record<CddSpecStatus, number> = {\n    draft: 0,\n    specifying: 0,\n    implementing: 0,\n    validating: 0,\n    done: 0,\n  };\n\n  function scanForDashboard(dirPath: string): void {\n    const entries = fs.readdirSync(dirPath, { withFileTypes: true });\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        scanForDashboard(fullPath);\n      } else if (entry.isFile()) {\n        const fileType = detectFileType(entry.name);\n        if (!fileType) continue;\n        const relPath = path.relative(contractDir, fullPath);\n        try {\n          const raw = fs.readFileSync(fullPath, \"utf-8\");\n          const doc = JSON.parse(raw) as Record<string, unknown>;\n\n          const summary: CddDocumentSummary = {\n            path: relPath,\n            name: entry.name,\n            fileType,\n            schemaId: typeof doc.schema === \"string\" ? doc.schema : undefined,\n            lastModified: typeof doc.lastModified === \"string\" ? doc.lastModified : undefined,\n          };\n\n          if (fileType === \"contract\") {\n            const features = doc.features;\n            if (features && typeof features === \"object\" && !Array.isArray(features)) {\n              summary.featureCount = Object.keys(features).length;\n            }\n          } else {\n            const status = typeof doc.status === \"string\" ? doc.status : \"draft\";\n            summary.status = VALID_SPEC_STATUSES.has(status as CddSpecStatus)\n              ? (status as CddSpecStatus)\n              : \"draft\";\n            statusDistribution[summary.status]++;\n\n            if (Array.isArray(doc.acceptanceCriteria)) {\n              summary.acceptanceCriteriaCount = doc.acceptanceCriteria.length;\n            }\n            if (Array.isArray(doc.sources)) {\n              summary.sourceCount = doc.sources.length;\n            }\n          }\n\n          documents.push(summary);\n        } catch (err) {\n          documents.push({\n            path: relPath,\n            name: entry.name,\n            fileType,\n            parseError: err instanceof Error ? err.message : String(err),\n          });\n        }\n      }\n    }\n  }\n\n  scanForDashboard(contractDir);\n\n  const totalContracts = documents.filter((d) => d.fileType === \"contract\" && !d.parseError).length;\n  const totalSpecs = documents.filter((d) => d.fileType === \"spec\" && !d.parseError).length;\n\n  return {\n    exists: true,\n    stats: { totalContracts, totalSpecs, statusDistribution },\n    documents,\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","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","VALID_SPEC_STATUSES","Set","getDashboard","stats","totalContracts","totalSpecs","statusDistribution","draft","specifying","implementing","validating","done","documents","scanForDashboard","summary","lastModified","features","Array","isArray","featureCount","status","has","acceptanceCriteria","acceptanceCriteriaCount","sources","sourceCount","d","openSourceFile","isAbsolute","detached","unref"],"mappings":"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"}
+//#endregion
+init_cdd_service();
+export { addRule, editContent, getAcList, getCddTree, init_cdd_service, listRules, openSourceFile, readContent, readRule };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"cdd-service.js","names":["nodes: CddTreeNode[]","rules: CddRuleSummary[]","rules: CddRuleEntry[]","newEntry: CddRuleEntry","entries: CddAcEntry[]","currentDescribe: string | null","acFiles: CddAcFile[]","results: string[]","entries: fs.Dirent[]","EDITOR_CLI_MAP: Record<string, { cli: string; waitFlag: string }>"],"sources":["../../src/ui/cdd-service.ts"],"sourcesContent":["import { spawn } from \"child_process\";\nimport fs from \"fs\";\nimport os from \"os\";\nimport path from \"path\";\n\nimport { Sonamu } from \"../api/sonamu\";\nimport {\n  type CddAcEntry,\n  type CddAcFile,\n  type CddAcListResult,\n  type CddAddRuleRequest,\n  type CddContentResult,\n  type CddFileType,\n  type CddRuleDetail,\n  type CddRuleEntry,\n  type CddRuleSummary,\n  type CddTreeNode,\n} from \"./cdd-types\";\n\nexport type {\n  CddAcEntry,\n  CddAcFile,\n  CddAcListResult,\n  CddAddRuleRequest,\n  CddContentResult,\n  CddFileType,\n  CddRuleDetail,\n  CddRuleEntry,\n  CddRuleSummary,\n  CddTreeNode,\n} from \"./cdd-types\";\n\n/** contract/ 디렉터리 절대 경로 반환 (apiRootPath 기준) */\nfunction getContractDir(): string {\n  return path.join(Sonamu.apiRootPath, \"..\", \"..\", \"contract\");\n}\n\n/** 프로젝트 루트 경로 반환 */\nfunction getProjectRoot(): string {\n  return path.join(Sonamu.apiRootPath, \"..\", \"..\");\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.md\")) return \"contract\";\n  if (fileName.endsWith(\".rules.json\")) return \"rules\";\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      if (entry.name === \"rules\") continue;\n      const children = scanDirectory(fullPath, relativeTo);\n      if (children.length > 0) {\n        nodes.push({\n          name: entry.name,\n          path: relPath,\n          type: \"directory\",\n          children,\n        });\n      }\n    } else if (entry.isFile()) {\n      const fileType = detectFileType(entry.name);\n      if (fileType && fileType !== \"rules\") {\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/** 파일 내용을 읽어 반환 (contract.md → markdown 원문, rules.json → JSON 문자열) */\nexport function readContent(filePath: string): CddContentResult {\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 content = fs.readFileSync(absPath, \"utf-8\");\n  const fileType = detectFileType(path.basename(filePath));\n\n  return {\n    content,\n    fileType: fileType ?? \"contract\",\n  };\n}\n\n/** 파일을 외부 에디터로 직접 편집 */\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/** 소스 파일을 외부 에디터로 열기 (대기하지 않음) */\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\n/* ========================================================================\n * Rules API\n * ======================================================================== */\n\n/** contract/rules/ 디렉터리 내 .rules.json 파일 목록 반환 */\nexport function listRules(): { rules: CddRuleSummary[] } {\n  const contractDir = getContractDir();\n  const rulesDir = path.join(contractDir, \"rules\");\n  if (!fs.existsSync(rulesDir)) return { rules: [] };\n\n  const entries = fs.readdirSync(rulesDir, { withFileTypes: true });\n  const rules: CddRuleSummary[] = [];\n\n  for (const entry of entries) {\n    if (!entry.isFile() || !entry.name.endsWith(\".rules.json\")) continue;\n\n    const key = entry.name.replace(/\\.rules\\.json$/, \"\");\n    const relPath = `rules/${entry.name}`;\n    const absPath = path.join(rulesDir, entry.name);\n\n    try {\n      const raw = fs.readFileSync(absPath, \"utf-8\");\n      const doc = JSON.parse(raw) as { description?: string; rules?: unknown[] };\n      rules.push({\n        key,\n        path: relPath,\n        description: typeof doc.description === \"string\" ? doc.description : \"\",\n        ruleCount: Array.isArray(doc.rules) ? doc.rules.length : 0,\n      });\n    } catch (err) {\n      rules.push({\n        key,\n        path: relPath,\n        description: \"\",\n        ruleCount: 0,\n        parseError: err instanceof Error ? err.message : String(err),\n      });\n    }\n  }\n\n  return { rules };\n}\n\n/** rules 파일 상세 반환 */\nexport function readRule(ruleKey: string): CddRuleDetail {\n  const contractDir = getContractDir();\n  const absPath = path.join(contractDir, \"rules\", `${ruleKey}.rules.json`);\n\n  if (!fs.existsSync(absPath)) {\n    throw new Error(`Rules 파일을 찾을 수 없습니다: ${ruleKey}`);\n  }\n\n  const raw = fs.readFileSync(absPath, \"utf-8\");\n  const doc = JSON.parse(raw) as { description?: string; rules?: CddRuleEntry[] };\n\n  return {\n    key: ruleKey,\n    path: `rules/${ruleKey}.rules.json`,\n    description: typeof doc.description === \"string\" ? doc.description : \"\",\n    rules: Array.isArray(doc.rules) ? doc.rules : [],\n  };\n}\n\n/** rules 파일에 규칙 추가 */\nexport function addRule(req: CddAddRuleRequest): CddRuleDetail {\n  const contractDir = getContractDir();\n  const rulesDir = path.join(contractDir, \"rules\");\n  const absPath = path.join(rulesDir, `${req.ruleKey}.rules.json`);\n\n  if (!fs.existsSync(absPath)) {\n    throw new Error(`Rules 파일을 찾을 수 없습니다: ${req.ruleKey}`);\n  }\n\n  const raw = fs.readFileSync(absPath, \"utf-8\");\n  const doc = JSON.parse(raw) as { description?: string; rules?: CddRuleEntry[] };\n  const rules: CddRuleEntry[] = Array.isArray(doc.rules) ? doc.rules : [];\n\n  const nextId = generateNextRuleId(rules);\n  const newEntry: CddRuleEntry = {\n    id: nextId,\n    when: req.when,\n    instruction: req.instruction,\n  };\n  if (req.examples && req.examples.length > 0) {\n    newEntry.examples = req.examples;\n  }\n\n  rules.push(newEntry);\n  doc.rules = rules;\n\n  fs.writeFileSync(absPath, `${JSON.stringify(doc, null, 2)}\\n`, \"utf-8\");\n\n  return {\n    key: req.ruleKey,\n    path: `rules/${req.ruleKey}.rules.json`,\n    description: typeof doc.description === \"string\" ? doc.description : \"\",\n    rules,\n  };\n}\n\n/** 기존 id 패턴을 분석하여 다음 순번 id 생성 */\nfunction generateNextRuleId(rules: CddRuleEntry[]): string {\n  if (rules.length === 0) return \"R-001\";\n\n  const numericPattern = /^(.+?)(\\d+)$/;\n  let bestPrefix = \"R-\";\n  let maxNum = 0;\n\n  for (const rule of rules) {\n    const match = numericPattern.exec(rule.id);\n    if (match) {\n      const prefix = match[1];\n      const num = Number.parseInt(match[2], 10);\n      if (num > maxNum) {\n        bestPrefix = prefix;\n        maxNum = num;\n      }\n    }\n  }\n\n  const nextNum = maxNum + 1;\n  const padLen = Math.max(3, String(maxNum).length);\n  return `${bestPrefix}${String(nextNum).padStart(padLen, \"0\")}`;\n}\n\n/* ========================================================================\n * AC API (modules/cdd ac-list 파싱 로직 복사)\n * ======================================================================== */\n\n/** describe/test 패턴 파싱 */\nfunction parseAcEntries(content: string): CddAcEntry[] {\n  const entries: CddAcEntry[] = [];\n  const lines = content.split(\"\\n\");\n\n  let currentDescribe: string | null = null;\n  let describeDepth = 0;\n  let braceDepth = 0;\n  let pendingTestAs = false;\n  let testAsBraceDepth = 0;\n  let testAsNeedName = false;\n\n  for (const line of lines) {\n    const trimmed = line.trim();\n\n    const describeMatch = trimmed.match(/^describe\\([\"'`](.+?)[\"'`]/);\n    if (describeMatch) {\n      currentDescribe = describeMatch[1];\n      describeDepth = braceDepth;\n    }\n\n    const testMatch = trimmed.match(/^(?:test|it)\\([\"'`](.+?)[\"'`]/);\n    if (testMatch) {\n      entries.push({\n        describe: currentDescribe,\n        test: testMatch[1],\n      });\n    }\n\n    if (!pendingTestAs && trimmed.match(/^testAs\\s*\\(/)) {\n      const inlineMatch = trimmed.match(/^testAs\\s*\\(\\s*\\{[^}]*\\}\\s*,\\s*[\"'`](.+?)[\"'`]/);\n      if (inlineMatch) {\n        entries.push({ describe: currentDescribe, test: inlineMatch[1] });\n      } else {\n        pendingTestAs = true;\n        testAsBraceDepth = 0;\n        testAsNeedName = false;\n        for (const ch of trimmed) {\n          if (ch === \"{\") testAsBraceDepth++;\n          if (ch === \"}\") testAsBraceDepth--;\n        }\n        if (testAsBraceDepth <= 0) {\n          testAsNeedName = true;\n          const nameMatch = trimmed.match(/}\\s*,\\s*[\"'`](.+?)[\"'`]/);\n          if (nameMatch) {\n            entries.push({ describe: currentDescribe, test: nameMatch[1] });\n            pendingTestAs = false;\n            testAsNeedName = false;\n          }\n        }\n      }\n    } else if (pendingTestAs) {\n      if (!testAsNeedName) {\n        for (const ch of trimmed) {\n          if (ch === \"{\") testAsBraceDepth++;\n          if (ch === \"}\") testAsBraceDepth--;\n        }\n        if (testAsBraceDepth <= 0) {\n          testAsNeedName = true;\n          const nameMatch = trimmed.match(/}\\s*,\\s*[\"'`](.+?)[\"'`]/);\n          if (nameMatch) {\n            entries.push({ describe: currentDescribe, test: nameMatch[1] });\n            pendingTestAs = false;\n            testAsNeedName = false;\n          }\n        }\n      } else {\n        const nameMatch = trimmed.match(/^[\"'`](.+?)[\"'`]/);\n        if (nameMatch) {\n          entries.push({ describe: currentDescribe, test: nameMatch[1] });\n          pendingTestAs = false;\n          testAsNeedName = false;\n        }\n      }\n    }\n\n    for (const ch of trimmed) {\n      if (ch === \"{\") braceDepth++;\n      if (ch === \"}\") {\n        braceDepth--;\n        if (currentDescribe && braceDepth <= describeDepth) {\n          currentDescribe = null;\n        }\n      }\n    }\n  }\n\n  return entries;\n}\n\n/** 프로젝트 내 *.test.ts 파일을 스캔하여 AC 목록 반환 */\nexport function getAcList(): CddAcListResult {\n  const projectRoot = getProjectRoot();\n  const files = findTestFiles(projectRoot);\n\n  const acFiles: CddAcFile[] = [];\n  for (const absPath of files) {\n    const content = fs.readFileSync(absPath, \"utf-8\");\n    const entries = parseAcEntries(content);\n    if (entries.length > 0) {\n      acFiles.push({\n        path: path.relative(projectRoot, absPath),\n        entries,\n      });\n    }\n  }\n\n  const total = acFiles.reduce((sum, f) => sum + f.entries.length, 0);\n  return { files: acFiles, total };\n}\n\n/** *.test.ts 파일을 재귀 탐색 (node_modules, dist 제외) */\nfunction findTestFiles(dir: string): string[] {\n  const results: string[] = [];\n  const IGNORE = new Set([\"node_modules\", \"dist\", \".git\", \"contract\"]);\n\n  function walk(currentDir: string): void {\n    let entries: fs.Dirent[];\n    try {\n      entries = fs.readdirSync(currentDir, { withFileTypes: true });\n    } catch {\n      return;\n    }\n    for (const entry of entries) {\n      if (IGNORE.has(entry.name)) continue;\n      const fullPath = path.join(currentDir, entry.name);\n      if (entry.isDirectory()) {\n        walk(fullPath);\n      } else if (entry.isFile() && entry.name.endsWith(\".test.ts\")) {\n        results.push(fullPath);\n      }\n    }\n  }\n\n  walk(dir);\n  results.sort();\n  return results;\n}\n"],"mappings":"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"}