sonamu 0.8.26 → 0.9.0

package/dist/ui/cdd-service.js

@@ -1,427 +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");
+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");
 }
-/** 프로젝트 루트 경로 반환 */ function getProjectRoot() {
-    return path.join(Sonamu.apiRootPath, "..", "..");
+/** 프로젝트 루트 경로 반환 */
+function getProjectRoot() {
+	return path.join(Sonamu.apiRootPath, "..", "..");
 }
-/** 경로가 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/ 디렉터리 내부인지 검증 */
+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}`);
+	}
 }
-/** 파일명에서 CddFileType 판별 */ function detectFileType(fileName) {
-    if (fileName.endsWith(".contract.md")) return "contract";
-    if (fileName.endsWith(".rules.json")) return "rules";
-    return undefined;
+/** 파일명에서 CddFileType 판별 */
+function detectFileType(fileName) {
+	if (fileName.endsWith(".contract.md")) return "contract";
+	if (fileName.endsWith(".rules.json")) return "rules";
+	return undefined;
 }
-/** 디렉터리를 재귀 탐색하여 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;
+/** 디렉터리를 재귀 탐색하여 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;
 }
-/** contract/ 디렉터리의 트리 구조를 반환 */ export function getCddTree() {
-    const contractDir = getContractDir();
-    if (!fs.existsSync(contractDir)) {
-        return {
-            exists: false,
-            tree: []
-        };
-    }
-    const tree = scanDirectory(contractDir, contractDir);
-    return {
-        exists: true,
-        tree
-    };
+/** contract/ 디렉터리의 트리 구조를 반환 */
+function getCddTree() {
+	const contractDir = getContractDir();
+	if (!fs.existsSync(contractDir)) {
+		return {
+			exists: false,
+			tree: []
+		};
+	}
+	const tree = scanDirectory(contractDir, contractDir);
+	return {
+		exists: true,
+		tree
+	};
 }
-/** 파일 내용을 읽어 반환 (contract.md → markdown 원문, rules.json → JSON 문자열) */ export 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"
-    };
+/** 파일 내용을 읽어 반환 (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"
+	};
 }
-/** 파일을 외부 에디터로 직접 편집 */ 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
-    };
+/** 파일을 외부 에디터로 직접 편집 */
+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 경로 + --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
-        ] : []
-    };
+/** 앱 번들 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] : []
+	};
 }
-/** 에디터 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를 실행하고 탭이 닫힐 때까지 대기 */
+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})`));
+			}
+		});
+	});
 }
-/** 소스 파일을 외부 에디터로 열기 (대기하지 않음) */ 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();
+/** 소스 파일을 외부 에디터로 열기 (대기하지 않음) */
+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();
 }
-/* ========================================================================
- * Rules API
- * ======================================================================== */ /** contract/rules/ 디렉터리 내 .rules.json 파일 목록 반환 */ export 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
-    };
+/** 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 };
 }
-/** rules 파일 상세 반환 */ export 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 : []
-    };
+/** 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 : []
+	};
 }
-/** rules 파일에 규칙 추가 */ export 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
-    };
+/** 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
+	};
 }
-/** 기존 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")}`;
+/** 기존 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")}`;
 }
-/* ========================================================================
- * AC API (modules/cdd ac-list 파싱 로직 복사)
- * ======================================================================== */ /** 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;
+/** 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;
 }
-/** 프로젝트 내 *.test.ts 파일을 스캔하여 AC 목록 반환 */ export 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
-    };
+/** 프로젝트 내 *.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
+	};
 }
-/** *.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;
+/** *.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  CddAcEntry,\n  CddAcFile,\n  CddAcListResult,\n  CddAddRuleRequest,\n  CddContentResult,\n  CddFileType,\n  CddRuleDetail,\n  CddRuleEntry,\n  CddRuleSummary,\n  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"],"names":["spawn","fs","os","path","Sonamu","getContractDir","join","apiRootPath","getProjectRoot","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","length","push","type","isFile","fileType","getCddTree","existsSync","exists","tree","readContent","absPath","content","readFileSync","basename","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","openSourceFile","isAbsolute","detached","unref","listRules","rulesDir","rules","key","replace","raw","doc","JSON","parse","description","ruleCount","Array","isArray","parseError","String","readRule","ruleKey","addRule","req","nextId","generateNextRuleId","newEntry","id","when","instruction","examples","writeFileSync","stringify","numericPattern","bestPrefix","maxNum","rule","match","exec","prefix","num","Number","parseInt","nextNum","padLen","Math","max","padStart","parseAcEntries","lines","split","currentDescribe","describeDepth","braceDepth","pendingTestAs","testAsBraceDepth","testAsNeedName","line","trimmed","trim","describeMatch","testMatch","describe","test","inlineMatch","ch","nameMatch","getAcList","projectRoot","files","findTestFiles","acFiles","total","reduce","sum","f","dir","results","IGNORE","Set","walk","currentDir","has","sort"],"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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"}