onto-mcp 0.3.2 → 0.4.1

package/dist/core-runtime/onboard/write-review-block.test.js

@@ -1,240 +0,0 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { writeReviewBlock } from "./write-review-block.js";
-// ---------------------------------------------------------------------------
-// writeReviewBlock — Review UX Redesign P4 (2026-04-21)
-// ---------------------------------------------------------------------------
-//
-// These tests cover the four behaviours the onboard prose flow depends on:
-//
-//   (1) Fresh-file creation — onboard on a brand-new project must create
-//       the file + parent directory + write the review block.
-//   (2) Round-trip preservation — existing top-level fields (e.g.
-//       output_language, domains) and their comments must survive the
-//       write.
-//   (3) Replace semantics — a pre-existing `review:` block is REPLACED,
-//       not merged. The caller's config object is the authoritative shape.
-//   (4) Legacy stripping — when stripLegacyPriority=true, the
-//       execution_topology_priority field is removed and reported.
-//
-// Validation failure paths (foreign provider without model_id, etc.) are
-// covered indirectly via validateReviewConfig's own tests — here we spot-
-// check that invalid input blocks the write entirely.
-// ---------------------------------------------------------------------------
-let tmpDir;
-beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "onto-onboard-p4-"));
-});
-afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-});
-function makeConfigPath(name = "config.yml") {
-    return path.join(tmpDir, ".onto", name);
-}
-function read(p) {
-    return fs.readFileSync(p, "utf8");
-}
-describe("writeReviewBlock — fresh file", () => {
-    it("creates the parent directory + file when neither exists", () => {
-        const configPath = makeConfigPath();
-        const review = {
-            teamlead: { model: "main" },
-            subagent: { provider: "main-native" },
-        };
-        const result = writeReviewBlock(configPath, review);
-        expect(result.ok).toBe(true);
-        if (!result.ok)
-            return;
-        expect(result.created).toBe(true);
-        expect(result.replacedExistingBlock).toBe(false);
-        expect(result.strippedLegacyPriority).toBe(false);
-        const written = read(configPath);
-        expect(written).toContain("review:");
-        expect(written).toContain("teamlead:");
-        expect(written).toContain("model: main");
-        expect(written).toContain("provider: main-native");
-    });
-    it("serializes foreign-provider subagent with model_id + effort", () => {
-        const configPath = makeConfigPath();
-        const review = {
-            teamlead: { model: "main" },
-            subagent: { provider: "codex", model_id: "gpt-5.4", effort: "high" },
-            max_concurrent_lenses: 6,
-            lens_deliberation: "synthesizer-only",
-        };
-        const result = writeReviewBlock(configPath, review);
-        expect(result.ok).toBe(true);
-        const written = read(configPath);
-        expect(written).toContain("provider: codex");
-        expect(written).toContain("model_id: gpt-5.4");
-        expect(written).toContain("effort: high");
-        expect(written).toContain("max_concurrent_lenses: 6");
-        expect(written).toContain("lens_deliberation: synthesizer-only");
-    });
-});
-describe("writeReviewBlock — existing file", () => {
-    it("preserves top-level fields + trailing content when adding review", () => {
-        const configPath = makeConfigPath();
-        fs.mkdirSync(path.dirname(configPath), { recursive: true });
-        const original = [
-            "# Project config — hand-written",
-            "output_language: en",
-            "",
-            "domains:",
-            "  - software-engineering",
-            "  - ontology",
-            "",
-        ].join("\n");
-        fs.writeFileSync(configPath, original, "utf8");
-        const review = {
-            teamlead: { model: "main" },
-            subagent: { provider: "main-native" },
-        };
-        const result = writeReviewBlock(configPath, review);
-        expect(result.ok).toBe(true);
-        if (!result.ok)
-            return;
-        expect(result.created).toBe(false);
-        expect(result.replacedExistingBlock).toBe(false);
-        const written = read(configPath);
-        expect(written).toContain("output_language: en");
-        expect(written).toContain("software-engineering");
-        expect(written).toContain("ontology");
-        expect(written).toContain("review:");
-        expect(written).toContain("provider: main-native");
-    });
-    it("replaces (not merges) a pre-existing review block", () => {
-        const configPath = makeConfigPath();
-        fs.mkdirSync(path.dirname(configPath), { recursive: true });
-        const original = [
-            "output_language: en",
-            "review:",
-            "  teamlead:",
-            "    model: main",
-            "  subagent:",
-            "    provider: codex",
-            "    model_id: gpt-5.4",
-            "    effort: high",
-            "  max_concurrent_lenses: 6",
-            "",
-        ].join("\n");
-        fs.writeFileSync(configPath, original, "utf8");
-        // New config chooses main-native — previous codex fields must not leak.
-        const review = {
-            teamlead: { model: "main" },
-            subagent: { provider: "main-native" },
-        };
-        const result = writeReviewBlock(configPath, review);
-        expect(result.ok).toBe(true);
-        if (!result.ok)
-            return;
-        expect(result.replacedExistingBlock).toBe(true);
-        const written = read(configPath);
-        expect(written).toContain("provider: main-native");
-        expect(written).not.toContain("gpt-5.4");
-        expect(written).not.toContain("effort: high");
-        expect(written).not.toMatch(/max_concurrent_lenses:\s*6/);
-    });
-});
-describe("writeReviewBlock — legacy stripping", () => {
-    it("strips execution_topology_priority when stripLegacyPriority=true", () => {
-        const configPath = makeConfigPath();
-        fs.mkdirSync(path.dirname(configPath), { recursive: true });
-        const original = [
-            "output_language: en",
-            "execution_topology_priority:",
-            "  - cc-teams-codex-subprocess",
-            "  - cc-main-agent-subagent",
-            "",
-        ].join("\n");
-        fs.writeFileSync(configPath, original, "utf8");
-        const review = {
-            teamlead: { model: "main" },
-            subagent: { provider: "codex", model_id: "gpt-5.4", effort: "high" },
-        };
-        const result = writeReviewBlock(configPath, review, {
-            stripLegacyPriority: true,
-        });
-        expect(result.ok).toBe(true);
-        if (!result.ok)
-            return;
-        expect(result.strippedLegacyPriority).toBe(true);
-        const written = read(configPath);
-        expect(written).not.toContain("execution_topology_priority");
-        expect(written).not.toContain("cc-teams-codex-subprocess");
-        expect(written).toContain("review:");
-        expect(written).toContain("provider: codex");
-    });
-    it("leaves legacy field alone when stripLegacyPriority is false/absent", () => {
-        const configPath = makeConfigPath();
-        fs.mkdirSync(path.dirname(configPath), { recursive: true });
-        const original = [
-            "output_language: en",
-            "execution_topology_priority:",
-            "  - cc-main-agent-subagent",
-            "",
-        ].join("\n");
-        fs.writeFileSync(configPath, original, "utf8");
-        const review = {
-            teamlead: { model: "main" },
-            subagent: { provider: "main-native" },
-        };
-        const result = writeReviewBlock(configPath, review);
-        expect(result.ok).toBe(true);
-        if (!result.ok)
-            return;
-        expect(result.strippedLegacyPriority).toBe(false);
-        const written = read(configPath);
-        expect(written).toContain("execution_topology_priority");
-        expect(written).toContain("cc-main-agent-subagent");
-    });
-});
-describe("writeReviewBlock — validation failure", () => {
-    it("returns errors without writing when config is invalid", () => {
-        const configPath = makeConfigPath();
-        // provider=codex is a foreign provider, so model_id is required.
-        // The validator catches this; writeReviewBlock must propagate.
-        const invalid = {
-            subagent: { provider: "codex" },
-        };
-        const result = writeReviewBlock(configPath, invalid);
-        expect(result.ok).toBe(false);
-        if (result.ok)
-            return;
-        expect(result.errors.length).toBeGreaterThan(0);
-        expect(result.errors.some((e) => e.path.includes("subagent"))).toBe(true);
-        expect(fs.existsSync(configPath)).toBe(false);
-    });
-    it("rejects mismatched deliberation + teamlead combination", () => {
-        const configPath = makeConfigPath();
-        const invalid = {
-            teamlead: {
-                model: { provider: "codex", model_id: "gpt-5.4" },
-            },
-            lens_deliberation: "sendmessage-a2a",
-        };
-        const result = writeReviewBlock(configPath, invalid);
-        expect(result.ok).toBe(false);
-        if (result.ok)
-            return;
-        expect(result.errors.some((e) => e.path === "review.lens_deliberation")).toBe(true);
-        expect(fs.existsSync(configPath)).toBe(false);
-    });
-});
-describe("writeReviewBlock — pruneUndefined behaviour", () => {
-    it("does not emit null keys for undefined axes", () => {
-        const configPath = makeConfigPath();
-        const review = {
-            teamlead: { model: "main" },
-            // subagent, max_concurrent_lenses, lens_deliberation intentionally absent
-        };
-        const result = writeReviewBlock(configPath, review);
-        expect(result.ok).toBe(true);
-        const written = read(configPath);
-        expect(written).not.toContain("subagent: null");
-        expect(written).not.toContain("max_concurrent_lenses: null");
-        expect(written).not.toContain("lens_deliberation: null");
-    });
-});

package/dist/core-runtime/readers/brownfield-builder.js

@@ -1,150 +0,0 @@
-import { sourceKey } from "./types.js";
-/**
- * Build BrownfieldContext + BrownfieldDetail from scan results.
- *
- * Pure function: no I/O, no side effects.
- *
- * BrownfieldContext contains Tier 1+2 items (for Build Spec Section 7).
- * BrownfieldDetail contains Tier 3 (full scan results with anchors).
- * detail_anchor links Tier 1+2 items to their Tier 3 detail sections.
- */
-export function buildBrownfield(scopeId, scanResults) {
-    const related_files = [];
-    const module_dependencies = [];
-    const api_contracts = [];
-    const db_schemas = [];
-    const config_env = [];
-    const sections = [];
-    for (const result of scanResults) {
-        const srcKey = sourceKey(result.source);
-        const srcLabel = result.source.description ?? srcKey;
-        // ── Files → related_files ──
-        for (const file of result.files) {
-            if (file.category === "source" || file.category === "config" || file.category === "schema" || file.category === "test") {
-                const anchor = makeAnchor(srcKey, file.path);
-                related_files.push({
-                    path: file.path,
-                    role: file.category === "test"
-                        ? `test (${srcLabel})`
-                        : `${file.language ?? file.category} (${srcLabel})`,
-                    detail_anchor: anchor,
-                });
-                sections.push({
-                    anchor,
-                    source: srcLabel,
-                    title: file.path,
-                    content: `- 카테고리: ${file.category}\n- 언어: ${file.language ?? "N/A"}\n- 크기: ${file.size_bytes} bytes`,
-                });
-            }
-        }
-        // ── Dependency graph → module_dependencies ──
-        const seenDeps = new Set();
-        for (const edge of result.dependency_graph) {
-            const depKey = `${edge.from}→${edge.to}`;
-            if (seenDeps.has(depKey))
-                continue;
-            seenDeps.add(depKey);
-            const anchor = makeAnchor(srcKey, `dep-${edge.from}-${edge.to}`);
-            module_dependencies.push({
-                module: edge.from,
-                depends_on: edge.to,
-                detail_anchor: anchor,
-            });
-            sections.push({
-                anchor,
-                source: srcLabel,
-                title: `${edge.from} → ${edge.to}`,
-                content: `- 종류: ${edge.kind}\n- 출처 파일: ${edge.from}`,
-            });
-        }
-        // ── API patterns → api_contracts ──
-        for (const api of result.api_patterns) {
-            const anchor = makeAnchor(srcKey, `api-${api.method}-${api.path}-${api.file}-L${api.line}`);
-            api_contracts.push({
-                endpoint: api.path,
-                method: api.method,
-                description: `${api.file}:${api.line}`,
-                detail_anchor: anchor,
-            });
-            sections.push({
-                anchor,
-                source: srcLabel,
-                title: `${api.method} ${api.path}`,
-                content: `- 파일: ${api.file}\n- 라인: ${api.line}`,
-            });
-        }
-        // ── Schema patterns → db_schemas ──
-        for (const schema of result.schema_patterns) {
-            const anchor = makeAnchor(srcKey, `schema-${schema.table}-${schema.file}-L${schema.line}`);
-            db_schemas.push({
-                table: schema.table,
-                columns: schema.columns,
-                detail_anchor: anchor,
-            });
-            sections.push({
-                anchor,
-                source: srcLabel,
-                title: schema.table,
-                content: `- 파일: ${schema.file}\n- 라인: ${schema.line}\n- 컬럼: ${schema.columns}`,
-            });
-        }
-        // ── Config patterns → config_env ──
-        for (const cfg of result.config_patterns) {
-            const anchor = makeAnchor(srcKey, `config-${cfg.key}-${cfg.file}-L${cfg.line}`);
-            config_env.push({
-                key: cfg.key,
-                description: `${cfg.source_type} (${cfg.file}:${cfg.line})`,
-                detail_anchor: anchor,
-            });
-            sections.push({
-                anchor,
-                source: srcLabel,
-                title: cfg.key,
-                content: `- 타입: ${cfg.source_type}\n- 파일: ${cfg.file}\n- 라인: ${cfg.line}`,
-            });
-        }
-        // ── Doc structures → detail sections only (no BrownfieldContext field) ──
-        for (const doc of result.doc_structure) {
-            const anchor = makeAnchor(srcKey, `doc-${doc.file}`);
-            const parts = [`- 형식: ${doc.format}`];
-            if (doc.headings)
-                parts.push(`- 제목: ${doc.headings.join(", ")}`);
-            if (doc.top_level_keys)
-                parts.push(`- 키: ${doc.top_level_keys.join(", ")}`);
-            if (doc.item_counts) {
-                const counts = Object.entries(doc.item_counts).map(([k, v]) => `${k}: ${v}`).join(", ");
-                parts.push(`- 항목 수: ${counts}`);
-            }
-            sections.push({
-                anchor,
-                source: srcLabel,
-                title: doc.file,
-                content: parts.join("\n"),
-            });
-        }
-    }
-    return {
-        context: {
-            related_files,
-            module_dependencies,
-            api_contracts: api_contracts.length > 0 ? api_contracts : undefined,
-            db_schemas: db_schemas.length > 0 ? db_schemas : undefined,
-            config_env: config_env.length > 0 ? config_env : undefined,
-        },
-        detail: {
-            scope_id: scopeId,
-            sections,
-        },
-    };
-}
-// ─── Anchor generation ───
-function makeAnchor(srcKey, suffix) {
-    return sanitizeAnchor(`${srcKey}-${suffix}`);
-}
-function sanitizeAnchor(raw) {
-    return raw
-        .toLowerCase()
-        .replace(/[^a-z0-9가-힣_-]/g, "-")
-        .replace(/-+/g, "-")
-        .replace(/^-|-$/g, "");
-}

package/dist/core-runtime/readers/brownfield-builder.test.js

@@ -1,136 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { buildBrownfield } from "./brownfield-builder.js";
-function makeScanResult(overrides = {}) {
-    return {
-        source: { type: "add-dir", path: "/test" },
-        scanned_at: "2026-03-09T00:00:00Z",
-        files: [],
-        content_hashes: {},
-        dependency_graph: [],
-        api_patterns: [],
-        schema_patterns: [],
-        config_patterns: [],
-        doc_structure: [],
-        ...overrides,
-    };
-}
-describe("buildBrownfield", () => {
-    it("returns empty context and detail for empty scan results", () => {
-        const { context, detail } = buildBrownfield("SC-TEST", []);
-        expect(context.related_files).toEqual([]);
-        expect(context.module_dependencies).toEqual([]);
-        expect(detail.sections).toEqual([]);
-        expect(detail.scope_id).toBe("SC-TEST");
-    });
-    it("maps files to related_files with detail_anchor", () => {
-        const result = makeScanResult({
-            files: [
-                { path: "src/app.ts", category: "source", language: "typescript", size_bytes: 100 },
-            ],
-        });
-        const { context, detail } = buildBrownfield("SC-TEST", [result]);
-        expect(context.related_files).toHaveLength(1);
-        expect(context.related_files[0].path).toBe("src/app.ts");
-        expect(context.related_files[0].detail_anchor).toBeTruthy();
-        // detail has matching section
-        const anchor = context.related_files[0].detail_anchor;
-        expect(detail.sections.some(s => s.anchor === anchor)).toBe(true);
-    });
-    it("maps dependency_graph to module_dependencies", () => {
-        const result = makeScanResult({
-            dependency_graph: [
-                { from: "app.ts", to: "./utils", kind: "import" },
-            ],
-        });
-        const { context } = buildBrownfield("SC-TEST", [result]);
-        expect(context.module_dependencies).toHaveLength(1);
-        expect(context.module_dependencies[0].module).toBe("app.ts");
-        expect(context.module_dependencies[0].depends_on).toBe("./utils");
-    });
-    it("maps api_patterns to api_contracts", () => {
-        const result = makeScanResult({
-            api_patterns: [
-                { file: "Controller.java", method: "GET", path: "/api/users", line: 10 },
-            ],
-        });
-        const { context } = buildBrownfield("SC-TEST", [result]);
-        expect(context.api_contracts).toHaveLength(1);
-        expect(context.api_contracts[0].endpoint).toBe("/api/users");
-    });
-    it("maps schema_patterns to db_schemas", () => {
-        const result = makeScanResult({
-            schema_patterns: [
-                { file: "V1.sql", table: "users", columns: "id, name", line: 1 },
-            ],
-        });
-        const { context } = buildBrownfield("SC-TEST", [result]);
-        expect(context.db_schemas).toHaveLength(1);
-        expect(context.db_schemas[0].table).toBe("users");
-    });
-    it("maps config_patterns to config_env", () => {
-        const result = makeScanResult({
-            config_patterns: [
-                { file: ".env", key: "DB_URL", source_type: "dotenv", line: 1 },
-            ],
-        });
-        const { context } = buildBrownfield("SC-TEST", [result]);
-        expect(context.config_env).toHaveLength(1);
-        expect(context.config_env[0].key).toBe("DB_URL");
-    });
-    it("deduplicates dependency edges", () => {
-        const result = makeScanResult({
-            dependency_graph: [
-                { from: "a.ts", to: "b", kind: "import" },
-                { from: "a.ts", to: "b", kind: "import" },
-            ],
-        });
-        const { context } = buildBrownfield("SC-TEST", [result]);
-        expect(context.module_dependencies).toHaveLength(1);
-    });
-    it("merges multiple scan results", () => {
-        const r1 = makeScanResult({
-            source: { type: "add-dir", path: "/project1" },
-            files: [{ path: "a.ts", category: "source", language: "typescript", size_bytes: 50 }],
-        });
-        const r2 = makeScanResult({
-            source: { type: "add-dir", path: "/project2" },
-            files: [{ path: "b.java", category: "source", language: "java", size_bytes: 80 }],
-        });
-        const { context, detail } = buildBrownfield("SC-TEST", [r1, r2]);
-        expect(context.related_files).toHaveLength(2);
-        expect(detail.sections.length).toBeGreaterThanOrEqual(2);
-    });
-    it("generates sanitized anchors", () => {
-        const result = makeScanResult({
-            files: [{ path: "src/모듈/컴포넌트.tsx", category: "source", language: "typescript", size_bytes: 100 }],
-        });
-        const { context } = buildBrownfield("SC-TEST", [result]);
-        const anchor = context.related_files[0].detail_anchor;
-        // anchor should not contain special characters that break markdown links
-        expect(anchor).not.toMatch(/[<>[\]{}()|\\^`"']/);
-    });
-    it("omits optional fields when empty", () => {
-        const { context } = buildBrownfield("SC-TEST", [makeScanResult()]);
-        expect(context.api_contracts).toBeUndefined();
-        expect(context.db_schemas).toBeUndefined();
-        expect(context.config_env).toBeUndefined();
-    });
-    it("includes test category files in related_files with test role", () => {
-        const result = makeScanResult({
-            files: [
-                { path: "src/app.ts", category: "source", language: "typescript", size_bytes: 100 },
-                { path: "src/app.test.ts", category: "test", language: "typescript", size_bytes: 80 },
-            ],
-        });
-        const { context, detail } = buildBrownfield("SC-TEST", [result]);
-        expect(context.related_files).toHaveLength(2);
-        const testFile = context.related_files.find(f => f.path === "src/app.test.ts");
-        expect(testFile).toBeDefined();
-        expect(testFile.role).toMatch(/^test \(/);
-        expect(testFile.detail_anchor).toBeTruthy();
-        const sourceFile = context.related_files.find(f => f.path === "src/app.ts");
-        expect(sourceFile.role).not.toMatch(/^test \(/);
-        // detail section exists for the test file
-        expect(detail.sections.some(s => s.anchor === testFile.detail_anchor)).toBe(true);
-    });
-});

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

@@ -1,53 +0,0 @@
-/**
- * 6관점 통합 코드 청크 수집 오케스트레이션.
- *
- * viewpoint-collectors.ts의 6개 수집 함수를 호출하고,
- * 결과를 RelevantCodeChunks 구조로 조합한다.
- */
-import { collectSemantics, collectDependency, collectLogic, collectStructure, collectPragmatics, collectEvolution, } from "./viewpoint-collectors.js";
-// ─── Main ───
-export function collectRelevantChunks(resolved, ontologyResult, scanResult, keywords, options) {
-    const defaultMax = options?.maxChunksPerViewpoint ?? 10;
-    function getMax(vp) {
-        const override = options?.viewpointOverrides?.[vp];
-        if (override?.enabled === false)
-            return 0;
-        return override?.maxChunks ?? defaultMax;
-    }
-    const by_viewpoint = {
-        semantics: collectSemantics(resolved, getMax("semantics")),
-        dependency: collectDependency(resolved, scanResult.dependency_graph, getMax("dependency")),
-        logic: collectLogic(ontologyResult, resolved, getMax("logic")),
-        structure: collectStructure(resolved, scanResult.files, scanResult.schema_patterns, scanResult.config_patterns, getMax("structure")),
-        pragmatics: collectPragmatics(ontologyResult.matched_entities, scanResult.api_patterns, resolved, getMax("pragmatics")),
-        evolution: collectEvolution(resolved, scanResult.files, scanResult.schema_patterns, getMax("evolution")),
-    };
-    // 중복 파일은 토큰 추정에서 1회만 카운트
-    const uniqueFiles = new Set();
-    let totalChunks = 0;
-    const viewpoint_counts = {};
-    for (const [vp, chunks] of Object.entries(by_viewpoint)) {
-        viewpoint_counts[vp] = chunks.length;
-        totalChunks += chunks.length;
-        for (const c of chunks) {
-            if (c.file_path)
-                uniqueFiles.add(c.file_path);
-        }
-    }
-    const unresolvedCount = resolved.filter((r) => r.resolution_method === "unresolved").length;
-    return {
-        by_viewpoint,
-        coverage_gaps: [], // 에이전트가 채움
-        ontology_result: ontologyResult,
-        total_chunks: totalChunks,
-        total_tokens_estimate: uniqueFiles.size * 500, // 파일당 ~500 토큰 추정
-        search_confidence: {
-            method: "ontology",
-            ontology_match_count: ontologyResult.matched_entities.length,
-            unresolved_count: unresolvedCount,
-            keywords_used: keywords,
-            viewpoint_counts,
-            ...(unresolvedCount > 0 ? { warning: `${unresolvedCount}건의 source_code가 파일로 해석되지 않았습니다` } : {}),
-        },
-    };
-}