onto-mcp 0.3.2 → 0.4.1

package/dist/core-runtime/readers/code-chunk-collector.test.js

@@ -1,136 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { collectRelevantChunks } from "./code-chunk-collector.js";
-// ─── Fixtures ───
-const RESOLVED = [
-    { reference: "TrialLectureCommandServiceImpl.create()", resolved_files: ["src/TrialLectureCommandServiceImpl.java"], resolution_method: "filename" },
-    { reference: "UnknownService.call()", resolved_files: [], resolution_method: "unresolved" },
-];
-const ONTOLOGY_RESULT = {
-    matched_entities: ["TrialLesson", "Ticket"],
-    code_locations: [{ reference: "TrialLectureCommandServiceImpl.create()", context: "Action TRIAL-1", entity: "TrialLesson" }],
-    db_tables: ["GT_CLASS"],
-    related_actions: [{ id: "TRIAL-1", display_name: "체험 수업 생성", source_code: "TrialLectureCommandServiceImpl.create()" }],
-    related_transitions: [],
-    value_filters: [{ entity: "TrialLesson", column: "CITY", value: "PODO_TRIAL", description: "체험 수업" }],
-    total_glossary_count: 2,
-};
-const SCAN_RESULT = {
-    source: { type: "add-dir", path: "./src" },
-    scanned_at: new Date().toISOString(),
-    files: [
-        { path: "src/TrialLectureCommandServiceImpl.java", category: "source", language: "java", size_bytes: 2000 },
-        { path: "src/LectureController.java", category: "source", language: "java", size_bytes: 1500 },
-        { path: "test/TrialLectureTest.java", category: "test", language: "java", size_bytes: 1000 },
-        { path: "schema/GT_CLASS.sql", category: "schema", language: "sql", size_bytes: 500 },
-    ],
-    content_hashes: {},
-    dependency_graph: [
-        { from: "src/LectureController.java", to: "src/TrialLectureCommandServiceImpl.java", kind: "import" },
-    ],
-    api_patterns: [
-        { file: "src/LectureController.java", method: "GET", path: "/trial/list", line: 30 },
-    ],
-    schema_patterns: [
-        { file: "schema/GT_CLASS.sql", table: "GT_CLASS", columns: "id, city, status", line: 1 },
-    ],
-    config_patterns: [],
-    doc_structure: [],
-};
-// ─── Tests ───
-describe("collectRelevantChunks", () => {
-    it("6관점 모두에서 결과를 생성한다", () => {
-        const result = collectRelevantChunks(RESOLVED, ONTOLOGY_RESULT, SCAN_RESULT, ["체험", "수업"]);
-        expect(result.by_viewpoint.semantics.length).toBeGreaterThan(0);
-        expect(result.by_viewpoint.dependency.length).toBeGreaterThan(0);
-        expect(result.coverage_gaps).toEqual([]); // 에이전트가 채움
-        expect(result.search_confidence.method).toBe("ontology");
-    });
-    it("total_chunks는 6관점 합계이다", () => {
-        const result = collectRelevantChunks(RESOLVED, ONTOLOGY_RESULT, SCAN_RESULT, ["체험"]);
-        const sum = Object.values(result.by_viewpoint).reduce((acc, chunks) => acc + chunks.length, 0);
-        expect(result.total_chunks).toBe(sum);
-    });
-    it("unresolved_count를 정확히 기록한다", () => {
-        const result = collectRelevantChunks(RESOLVED, ONTOLOGY_RESULT, SCAN_RESULT, ["체험"]);
-        expect(result.search_confidence.unresolved_count).toBe(1); // UnknownService
-    });
-    it("viewpoint_counts가 관점별 청크 수를 기록한다", () => {
-        const result = collectRelevantChunks(RESOLVED, ONTOLOGY_RESULT, SCAN_RESULT, ["체험"]);
-        for (const [vp, count] of Object.entries(result.search_confidence.viewpoint_counts)) {
-            expect(count).toBe(result.by_viewpoint[vp].length);
-        }
-    });
-    it("viewpointOverrides로 특정 관점을 비활성화할 수 있다", () => {
-        const result = collectRelevantChunks(RESOLVED, ONTOLOGY_RESULT, SCAN_RESULT, ["체험"], {
-            viewpointOverrides: { evolution: { enabled: false } },
-        });
-        expect(result.by_viewpoint.evolution).toEqual([]);
-    });
-    it("maxChunksPerViewpoint로 관점당 상한을 제어한다", () => {
-        const result = collectRelevantChunks(RESOLVED, ONTOLOGY_RESULT, SCAN_RESULT, ["체험"], {
-            maxChunksPerViewpoint: 1,
-        });
-        for (const chunks of Object.values(result.by_viewpoint)) {
-            expect(chunks.length).toBeLessThanOrEqual(1);
-        }
-    });
-    it("value_filters가 logic 관점에 반영된다", () => {
-        const result = collectRelevantChunks(RESOLVED, ONTOLOGY_RESULT, SCAN_RESULT, ["체험"]);
-        const logicContexts = result.by_viewpoint.logic.map((c) => c.context);
-        expect(logicContexts.some((ctx) => ctx.includes("PODO_TRIAL"))).toBe(true);
-    });
-    it("keywords_used가 기록된다", () => {
-        const result = collectRelevantChunks(RESOLVED, ONTOLOGY_RESULT, SCAN_RESULT, ["체험", "수업"]);
-        expect(result.search_confidence.keywords_used).toEqual(["체험", "수업"]);
-    });
-    it("guard_note가 있는 action이 logic 관점에 반영된다", () => {
-        const withGuard = {
-            ...ONTOLOGY_RESULT,
-            related_actions: [{
-                    id: "TRIAL-1",
-                    display_name: "체험 수업 생성",
-                    source_code: "TrialLectureCommandServiceImpl.create()",
-                    guard_note: "체험 수업은 1회만 가능",
-                }],
-        };
-        const result = collectRelevantChunks(RESOLVED, withGuard, SCAN_RESULT, ["체험"]);
-        const logicChunks = result.by_viewpoint.logic;
-        expect(logicChunks.some((c) => c.context.includes("체험 수업은 1회만 가능"))).toBe(true);
-        // guard_note가 있는 청크는 실제 파일 경로를 가져야 함
-        const guardChunk = logicChunks.find((c) => c.context.includes("체험 수업은 1회만 가능"));
-        expect(guardChunk?.file_path).toBe("src/TrialLectureCommandServiceImpl.java");
-    });
-    it("preconditions가 있는 action이 logic 관점에 반영된다", () => {
-        const withPreconditions = {
-            ...ONTOLOGY_RESULT,
-            related_actions: [{
-                    id: "TRIAL-1",
-                    display_name: "체험 수업 생성",
-                    source_code: "TrialLectureCommandServiceImpl.create()",
-                    preconditions: [{ check: "학생이 체험 수업을 받은 적 없음" }],
-                }],
-        };
-        const result = collectRelevantChunks(RESOLVED, withPreconditions, SCAN_RESULT, ["체험"]);
-        const logicChunks = result.by_viewpoint.logic;
-        expect(logicChunks.some((c) => c.context.includes("학생이 체험 수업을 받은 적 없음"))).toBe(true);
-    });
-    it("value_filters의 search_hint가 file_path가 아닌 별도 필드에 저장된다", () => {
-        const result = collectRelevantChunks(RESOLVED, ONTOLOGY_RESULT, SCAN_RESULT, ["체험"]);
-        const vfChunks = result.by_viewpoint.logic.filter((c) => c.search_hint);
-        expect(vfChunks.length).toBeGreaterThan(0);
-        for (const c of vfChunks) {
-            expect(c.file_path).toBeUndefined(); // file_path 없이 search_hint만 사용
-            expect(c.search_hint).toMatch(/^grep:/);
-        }
-    });
-    it("search_hint만 있는 청크는 토큰 추정에서 제외된다", () => {
-        const result = collectRelevantChunks(RESOLVED, ONTOLOGY_RESULT, SCAN_RESULT, ["체험"]);
-        // 빈 file_path는 uniqueFiles에 포함되지 않으므로 토큰 추정에 영향 없음
-        const allFilePaths = Object.values(result.by_viewpoint)
-            .flat()
-            .map((c) => c.file_path)
-            .filter((fp) => fp !== undefined);
-        const uniqueFiles = new Set(allFilePaths);
-        expect(result.total_tokens_estimate).toBe(uniqueFiles.size * 500);
-    });
-});

package/dist/core-runtime/readers/file-utils.js

@@ -1,240 +0,0 @@
-import { readdirSync, statSync, readFileSync, existsSync } from "node:fs";
-import { join, resolve, relative, extname } from "node:path";
-import { contentHash } from "../scope-runtime/hash.js";
-import { getLogger } from "../logger.js";
-// ─── File Filtering ───
-const ALWAYS_EXCLUDE_DIRS = new Set([".git", "node_modules", ".obsidian"]);
-const BINARY_EXTENSIONS = new Set([
-    ".png", ".jpg", ".jpeg", ".gif", ".bmp", ".ico", ".svg", ".webp",
-    ".woff", ".woff2", ".ttf", ".otf", ".eot",
-    ".zip", ".tar", ".gz", ".bz2", ".7z", ".rar",
-    ".pdf", ".doc", ".docx", ".xls", ".xlsx", ".ppt", ".pptx",
-    ".exe", ".dll", ".so", ".dylib", ".class", ".jar", ".war",
-    ".o", ".obj", ".pyc", ".pyo",
-    ".mp3", ".mp4", ".avi", ".mov", ".flv", ".wav",
-    ".sqlite", ".db",
-]);
-export function isBinaryFile(filePath) {
-    if (BINARY_EXTENSIONS.has(extname(filePath).toLowerCase())) {
-        return true;
-    }
-    try {
-        const buf = Buffer.alloc(512);
-        const fd = require("node:fs").openSync(filePath, "r");
-        const bytesRead = require("node:fs").readSync(fd, buf, 0, 512, 0);
-        require("node:fs").closeSync(fd);
-        for (let i = 0; i < bytesRead; i++) {
-            if (buf[i] === 0)
-                return true; // NULL byte = binary
-        }
-        return false;
-    }
-    catch {
-        return false;
-    }
-}
-// ─── .gitignore parsing (simplified) ───
-export function loadGitignorePatterns(dirPath) {
-    const gitignorePath = join(dirPath, ".gitignore");
-    if (!existsSync(gitignorePath))
-        return [];
-    try {
-        return readFileSync(gitignorePath, "utf-8")
-            .split("\n")
-            .map(line => line.trim())
-            .filter(line => line.length > 0 && !line.startsWith("#"));
-    }
-    catch {
-        return [];
-    }
-}
-function matchesGitignore(relativePath, patterns) {
-    let excluded = false;
-    for (const pattern of patterns) {
-        // Negation pattern: ! prefix → force include (cancel previous exclusion)
-        const isNegation = pattern.startsWith("!");
-        const rawPattern = isNegation ? pattern.slice(1) : pattern;
-        const cleanPattern = rawPattern.endsWith("/") ? rawPattern.slice(0, -1) : rawPattern;
-        let matched = false;
-        // Simple matching: exact segment match
-        const segments = relativePath.split("/");
-        for (const seg of segments) {
-            if (seg === cleanPattern) {
-                matched = true;
-                break;
-            }
-        }
-        // Wildcard patterns: *.ext
-        if (!matched && cleanPattern.startsWith("*.")) {
-            const ext = cleanPattern.slice(1);
-            if (relativePath.endsWith(ext)) {
-                matched = true;
-            }
-        }
-        // Path prefix match (e.g. "dist/keep.js" matches pattern "dist/keep.js")
-        if (!matched && cleanPattern.includes("/")) {
-            if (relativePath === cleanPattern || relativePath.startsWith(cleanPattern + "/")) {
-                matched = true;
-            }
-        }
-        if (matched) {
-            excluded = isNegation ? false : true;
-        }
-    }
-    return excluded;
-}
-/**
- * Check if any negation pattern references a path under the given directory.
- * Used to decide whether to recurse into an otherwise-excluded directory.
- */
-function hasNegationUnder(dirRelPath, patterns) {
-    for (const pattern of patterns) {
-        if (!pattern.startsWith("!"))
-            continue;
-        const rawPattern = pattern.slice(1);
-        const cleanPattern = rawPattern.endsWith("/") ? rawPattern.slice(0, -1) : rawPattern;
-        if (cleanPattern.startsWith(dirRelPath + "/")) {
-            return true;
-        }
-    }
-    return false;
-}
-// ─── Path normalization (NFC) ───
-export function normalizePath(p) {
-    return resolve(p).normalize("NFC");
-}
-export function walkDirectory(rootPath, options = {}) {
-    const root = normalizePath(rootPath);
-    const results = [];
-    const extraExclude = options.extraExcludeDirs ?? new Set();
-    const gitignore = options.gitignorePatterns ?? loadGitignorePatterns(root);
-    function walk(dirPath) {
-        let entries;
-        try {
-            entries = readdirSync(dirPath);
-        }
-        catch (error) {
-            getLogger().debug("walkDirectory: failed to read directory", { path: dirPath, error });
-            return;
-        }
-        for (const name of entries) {
-            const fullPath = join(dirPath, name);
-            const relPath = relative(root, fullPath).normalize("NFC");
-            // Skip excluded directories
-            if (ALWAYS_EXCLUDE_DIRS.has(name) || extraExclude.has(name)) {
-                continue;
-            }
-            const excluded = matchesGitignore(relPath, gitignore);
-            let stat;
-            try {
-                stat = statSync(fullPath);
-            }
-            catch (error) {
-                getLogger().debug("walkDirectory: failed to stat file", { path: fullPath, error });
-                continue; // broken symlink etc.
-            }
-            if (stat.isDirectory()) {
-                // Even if the directory is excluded, recurse if negation patterns
-                // reference paths under it — individual files will be checked.
-                if (excluded && !hasNegationUnder(relPath, gitignore)) {
-                    continue;
-                }
-                walk(fullPath);
-            }
-            else if (excluded) {
-                // File is excluded by gitignore
-                continue;
-            }
-            else if (stat.isFile()) {
-                // Skip binary files
-                if (isBinaryFile(fullPath))
-                    continue;
-                results.push({
-                    path: relPath,
-                    category: categorizeFile(relPath),
-                    language: detectLanguage(relPath),
-                    size_bytes: stat.size,
-                });
-            }
-            // Symlinks: statSync follows them by default. Circular symlinks
-            // will fail with ELOOP and be caught by the try/catch.
-        }
-    }
-    walk(root);
-    return results;
-}
-// ─── Sorted concat hash ───
-/**
- * Core hash logic: sorted path-hash pairs → single directory hash.
- * Both computeDirectoryHash and computeDirectoryHashFromMap delegate to this.
- * Changing this function changes all directory hashes (source_hashes in events).
- */
-export function computeHashFromEntries(entries) {
-    const sorted = [...entries].sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0));
-    return contentHash(sorted.map(e => e[1]).join(""));
-}
-export function computeDirectoryHash(rootPath, files) {
-    const root = normalizePath(rootPath);
-    const entries = [];
-    for (const file of files) {
-        const fullPath = join(root, file.path);
-        try {
-            const content = readFileSync(fullPath, "utf-8");
-            entries.push([file.path, contentHash(content)]);
-        }
-        catch {
-            entries.push([file.path, "unreadable"]);
-        }
-    }
-    return computeHashFromEntries(entries);
-}
-/**
- * Compute directory hash from pre-computed content hashes.
- * Avoids re-reading files when hashes are already available.
- * Results are identical to computeDirectoryHash for the same file set.
- */
-export function computeDirectoryHashFromMap(contentMap) {
-    const entries = [...contentMap.entries()];
-    return computeHashFromEntries(entries);
-}
-// ─── File categorization ───
-const LANGUAGE_MAP = {
-    ".ts": "typescript", ".tsx": "typescript", ".mts": "typescript", ".cts": "typescript",
-    ".js": "javascript", ".jsx": "javascript", ".mjs": "javascript", ".cjs": "javascript",
-    ".java": "java", ".kt": "kotlin", ".kts": "kotlin",
-    ".py": "python", ".go": "go", ".rs": "rust", ".rb": "ruby",
-    ".sql": "sql",
-    ".yaml": "yaml", ".yml": "yaml",
-    ".json": "json",
-    ".md": "markdown",
-    ".html": "html", ".css": "css", ".scss": "scss",
-    ".sh": "shell", ".bash": "shell",
-    ".xml": "xml",
-    ".toml": "toml",
-    ".gradle": "gradle",
-};
-function detectLanguage(filePath) {
-    const ext = extname(filePath).toLowerCase();
-    return LANGUAGE_MAP[ext];
-}
-const TEST_PATTERNS = [/\.test\.[^.]+$/, /\.spec\.[^.]+$/, /\/__tests__\//, /\/test\//];
-const CONFIG_PATTERNS = [
-    /\.env/, /\.config\.[^.]+$/, /tsconfig/, /package\.json$/, /\.eslintrc/,
-    /application\.ya?ml$/, /application\.properties$/,
-];
-const SCHEMA_PATTERNS = [/\.sql$/, /migration/, /schema/, /\.dbml$/];
-const DOC_PATTERNS = [/\.md$/, /\.mdx$/, /README/, /CHANGELOG/];
-function categorizeFile(relPath) {
-    if (TEST_PATTERNS.some(p => p.test(relPath)))
-        return "test";
-    if (CONFIG_PATTERNS.some(p => p.test(relPath)))
-        return "config";
-    if (SCHEMA_PATTERNS.some(p => p.test(relPath)))
-        return "schema";
-    if (DOC_PATTERNS.some(p => p.test(relPath)))
-        return "doc";
-    const lang = detectLanguage(relPath);
-    if (lang && !["yaml", "json", "markdown", "xml", "toml"].includes(lang))
-        return "source";
-    return "other";
-}

package/dist/core-runtime/readers/file-utils.test.js

@@ -1,146 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { mkdirSync, writeFileSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { walkDirectory, computeDirectoryHash, normalizePath, isBinaryFile } from "./file-utils.js";
-const TMP = join(import.meta.dirname ?? ".", ".tmp-fileutils-test");
-beforeEach(() => mkdirSync(TMP, { recursive: true }));
-afterEach(() => rmSync(TMP, { recursive: true, force: true }));
-describe("walkDirectory", () => {
-    it("lists files recursively", () => {
-        mkdirSync(join(TMP, "sub"), { recursive: true });
-        writeFileSync(join(TMP, "a.ts"), "const a = 1;");
-        writeFileSync(join(TMP, "sub", "b.ts"), "const b = 2;");
-        const files = walkDirectory(TMP);
-        const paths = files.map(f => f.path).sort();
-        expect(paths).toEqual(["a.ts", "sub/b.ts"]);
-    });
-    it("excludes .git directory", () => {
-        mkdirSync(join(TMP, ".git", "objects"), { recursive: true });
-        writeFileSync(join(TMP, ".git", "config"), "gitconfig");
-        writeFileSync(join(TMP, "app.ts"), "code");
-        const files = walkDirectory(TMP);
-        expect(files.map(f => f.path)).toEqual(["app.ts"]);
-    });
-    it("excludes node_modules", () => {
-        mkdirSync(join(TMP, "node_modules", "pkg"), { recursive: true });
-        writeFileSync(join(TMP, "node_modules", "pkg", "index.js"), "code");
-        writeFileSync(join(TMP, "app.ts"), "code");
-        const files = walkDirectory(TMP);
-        expect(files.map(f => f.path)).toEqual(["app.ts"]);
-    });
-    it("respects .gitignore", () => {
-        writeFileSync(join(TMP, ".gitignore"), "dist\n*.log\n");
-        mkdirSync(join(TMP, "dist"), { recursive: true });
-        writeFileSync(join(TMP, "dist", "bundle.js"), "bundled");
-        writeFileSync(join(TMP, "app.log"), "log");
-        writeFileSync(join(TMP, "app.ts"), "code");
-        const files = walkDirectory(TMP);
-        const paths = files.map(f => f.path).filter(p => p !== ".gitignore");
-        expect(paths).toEqual(["app.ts"]);
-    });
-    it("skips binary files", () => {
-        writeFileSync(join(TMP, "app.ts"), "code");
-        writeFileSync(join(TMP, "image.png"), Buffer.from([0x89, 0x50, 0x4e, 0x47]));
-        const files = walkDirectory(TMP);
-        expect(files.map(f => f.path)).toEqual(["app.ts"]);
-    });
-    it("categorizes files", () => {
-        writeFileSync(join(TMP, "app.ts"), "code");
-        writeFileSync(join(TMP, "app.test.ts"), "test");
-        writeFileSync(join(TMP, "README.md"), "docs");
-        writeFileSync(join(TMP, ".env"), "KEY=val");
-        const files = walkDirectory(TMP);
-        const cats = Object.fromEntries(files.map(f => [f.path, f.category]));
-        expect(cats["app.ts"]).toBe("source");
-        expect(cats["app.test.ts"]).toBe("test");
-        expect(cats["README.md"]).toBe("doc");
-        expect(cats[".env"]).toBe("config");
-    });
-    it("handles empty directory", () => {
-        expect(walkDirectory(TMP)).toEqual([]);
-    });
-    it("excludes extra dirs", () => {
-        mkdirSync(join(TMP, ".obsidian"), { recursive: true });
-        writeFileSync(join(TMP, ".obsidian", "config.json"), "{}");
-        writeFileSync(join(TMP, "note.md"), "# Note");
-        const files = walkDirectory(TMP);
-        expect(files.map(f => f.path)).toEqual(["note.md"]);
-    });
-    it("respects .gitignore negation pattern (! prefix)", () => {
-        writeFileSync(join(TMP, ".gitignore"), "*.log\n!important.log\n");
-        writeFileSync(join(TMP, "debug.log"), "debug info");
-        writeFileSync(join(TMP, "important.log"), "important info");
-        writeFileSync(join(TMP, "app.ts"), "code");
-        const files = walkDirectory(TMP);
-        const paths = files.map(f => f.path).filter(p => p !== ".gitignore").sort();
-        expect(paths).toContain("important.log");
-        expect(paths).toContain("app.ts");
-        expect(paths).not.toContain("debug.log");
-    });
-    it("respects .gitignore negation for directory paths", () => {
-        writeFileSync(join(TMP, ".gitignore"), "dist\n!dist/keep.js\n");
-        mkdirSync(join(TMP, "dist"), { recursive: true });
-        writeFileSync(join(TMP, "dist", "bundle.js"), "bundled");
-        writeFileSync(join(TMP, "dist", "keep.js"), "kept");
-        writeFileSync(join(TMP, "app.ts"), "code");
-        const files = walkDirectory(TMP);
-        const paths = files.map(f => f.path).filter(p => p !== ".gitignore").sort();
-        expect(paths).toContain("dist/keep.js");
-        expect(paths).toContain("app.ts");
-        expect(paths).not.toContain("dist/bundle.js");
-    });
-    it("handles Korean filenames with NFC normalization", () => {
-        writeFileSync(join(TMP, "컴포넌트.tsx"), "export default {}");
-        const files = walkDirectory(TMP);
-        expect(files).toHaveLength(1);
-        expect(files[0].path).toBe("컴포넌트.tsx");
-        expect(files[0].language).toBe("typescript");
-    });
-});
-describe("computeDirectoryHash", () => {
-    it("produces consistent hash for same content", () => {
-        writeFileSync(join(TMP, "a.ts"), "const a = 1;");
-        writeFileSync(join(TMP, "b.ts"), "const b = 2;");
-        const files = walkDirectory(TMP);
-        const h1 = computeDirectoryHash(TMP, files);
-        const h2 = computeDirectoryHash(TMP, files);
-        expect(h1).toBe(h2);
-    });
-    it("changes when file content changes", () => {
-        writeFileSync(join(TMP, "a.ts"), "const a = 1;");
-        const files1 = walkDirectory(TMP);
-        const h1 = computeDirectoryHash(TMP, files1);
-        writeFileSync(join(TMP, "a.ts"), "const a = 2;");
-        const h2 = computeDirectoryHash(TMP, files1); // same file list
-        expect(h1).not.toBe(h2);
-    });
-    it("changes when file is added", () => {
-        writeFileSync(join(TMP, "a.ts"), "code");
-        const files1 = walkDirectory(TMP);
-        const h1 = computeDirectoryHash(TMP, files1);
-        writeFileSync(join(TMP, "b.ts"), "code2");
-        const files2 = walkDirectory(TMP);
-        const h2 = computeDirectoryHash(TMP, files2);
-        expect(h1).not.toBe(h2);
-    });
-});
-describe("normalizePath", () => {
-    it("resolves relative paths", () => {
-        const p = normalizePath("./src/../src/app.ts");
-        expect(p).not.toContain("..");
-    });
-});
-describe("isBinaryFile", () => {
-    it("detects by extension", () => {
-        writeFileSync(join(TMP, "test.png"), "fakepng");
-        expect(isBinaryFile(join(TMP, "test.png"))).toBe(true);
-    });
-    it("detects by null byte", () => {
-        writeFileSync(join(TMP, "test.dat"), Buffer.from([0x48, 0x65, 0x00, 0x6c]));
-        expect(isBinaryFile(join(TMP, "test.dat"))).toBe(true);
-    });
-    it("text files are not binary", () => {
-        writeFileSync(join(TMP, "test.ts"), "const x = 1;");
-        expect(isBinaryFile(join(TMP, "test.ts"))).toBe(false);
-    });
-});

package/dist/core-runtime/readers/lexicon-citation-check.js

@@ -1,93 +0,0 @@
-/**
- * Provisional term 인용 금지 검증 도구 (W-D-02, D0 Bootstrap).
- *
- * core-lexicon.yaml 의 provisional_lifecycle 규칙에 따라,
- * lifecycle_status 가 seed/candidate/provisional 인 term 을
- * authority file 이외의 문서·코드에서 인용하면 warn 또는 reject 한다.
- *
- * authority file (core-lexicon.yaml 자체) 내 참조는 예외 (bypass).
- */
-import { readFileSync } from "node:fs";
-import { resolve, basename } from "node:path";
-import { parse as yamlParse } from "yaml";
-// lifecycle_status 값 중 인용이 금지되는 상태
-const CITATION_BLOCKED_STATUSES = new Set(["seed", "candidate", "provisional"]);
-// authority file — 이 파일 내 참조는 예외
-const AUTHORITY_FILE = "core-lexicon.yaml";
-// ─── Lexicon 읽기 ───
-/**
- * core-lexicon.yaml 에서 provisional_terms section 의 term 목록을 읽는다.
- * provisional_terms section 이 없으면 빈 배열을 반환한다.
- */
-export function loadProvisionalTerms(lexiconPath) {
-    const content = readFileSync(resolve(lexiconPath), "utf-8");
-    const data = yamlParse(content);
-    const provisionalTerms = data["provisional_terms"];
-    if (!provisionalTerms || typeof provisionalTerms !== "object") {
-        return [];
-    }
-    return Object.entries(provisionalTerms)
-        .filter(([_, entry]) => entry && typeof entry === "object" && entry.lifecycle_status)
-        .map(([termId, entry]) => ({
-        term_id: termId,
-        lifecycle_status: entry.lifecycle_status,
-    }));
-}
-// ─── 검증 ───
-/**
- * 단일 파일의 내용에서 provisional term 인용을 검사한다.
- *
- * @param filePath - 검사 대상 파일 경로
- * @param fileContent - 파일 내용 문자열
- * @param terms - provisional term 목록
- * @param options - severity 설정 (기본 warn)
- * @returns 발견된 위반 목록
- */
-export function checkFileCitations(filePath, fileContent, terms, options = {}) {
-    const severity = options.severity ?? "warn";
-    // authority file bypass
-    if (basename(filePath) === AUTHORITY_FILE) {
-        return [];
-    }
-    const violations = [];
-    const lines = fileContent.split("\n");
-    for (const term of terms) {
-        if (!CITATION_BLOCKED_STATUSES.has(term.lifecycle_status)) {
-            continue;
-        }
-        // term_id를 단어 경계로 검색 (부분 매칭 방지)
-        const pattern = new RegExp(`\\b${escapeRegex(term.term_id)}\\b`, "g");
-        for (let i = 0; i < lines.length; i++) {
-            if (pattern.test(lines[i])) {
-                violations.push({
-                    file: filePath,
-                    line: i + 1,
-                    term_id: term.term_id,
-                    lifecycle_status: term.lifecycle_status,
-                    severity,
-                    message: `provisional term "${term.term_id}" (status: ${term.lifecycle_status}) 인용 금지 — promoted 전이 후 사용 가능`,
-                });
-            }
-            // reset regex lastIndex for next line
-            pattern.lastIndex = 0;
-        }
-    }
-    return violations;
-}
-/**
- * 복수 파일을 검사하고 전체 위반 목록을 반환한다.
- */
-export function checkMultipleFiles(files, terms, options = {}) {
-    return files.flatMap((f) => checkFileCitations(f.path, f.content, terms, options));
-}
-/**
- * 위반 목록에 reject severity 가 1건 이상 있으면 true.
- * pre-commit hook 에서 exit code 결정에 사용.
- */
-export function hasRejectViolations(violations) {
-    return violations.some((v) => v.severity === "reject");
-}
-// ─── Helpers ───
-function escapeRegex(str) {
-    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}