onto-mcp 0.3.0

package/dist/core-runtime/evolve/commands/reconstruct.test.js

@@ -0,0 +1,278 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdirSync, rmSync, readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { executeReconstructStart, executeReconstructExplore, executeReconstructComplete, executeReconstructConfirm, } from "./reconstruct.js";
+let tmpRoot;
+beforeEach(() => {
+    tmpRoot = join(tmpdir(), `reconstruct-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(tmpRoot, { recursive: true });
+});
+afterEach(() => {
+    try {
+        rmSync(tmpRoot, { recursive: true, force: true });
+    }
+    catch { }
+});
+function readStateFile(sessionRoot) {
+    return JSON.parse(readFileSync(join(sessionRoot, "reconstruct-state.json"), "utf-8"));
+}
+describe("executeReconstructStart", () => {
+    it("session 초기화: gathering_context 상태로 시작", () => {
+        const result = executeReconstructStart({
+            source: "./src",
+            intent: "recover domain ontology",
+            sessionsDir: tmpRoot,
+            sessionId: "test-001",
+        });
+        expect(result.success).toBe(true);
+        expect(result.session_id).toBe("test-001");
+        expect(result.state.current_state).toBe("gathering_context");
+        expect(result.state.source).toBe("./src");
+        expect(result.state.intent).toBe("recover domain ontology");
+        expect(result.state.explore_invocations).toBe(0);
+        expect(result.state.ontology_draft_path).toBeNull();
+        expect(result.state.principal_review_status).toBe("pending");
+    });
+    it("state 파일이 session root 에 저장된다", () => {
+        const result = executeReconstructStart({
+            source: "./src",
+            intent: "test",
+            sessionsDir: tmpRoot,
+            sessionId: "test-002",
+        });
+        const persisted = readStateFile(result.session_root);
+        expect(persisted.session_id).toBe("test-002");
+        expect(persisted.current_state).toBe("gathering_context");
+    });
+    it("중복 session id 는 에러", () => {
+        executeReconstructStart({
+            source: "./src",
+            intent: "first",
+            sessionsDir: tmpRoot,
+            sessionId: "dup",
+        });
+        expect(() => executeReconstructStart({
+            source: "./src",
+            intent: "second",
+            sessionsDir: tmpRoot,
+            sessionId: "dup",
+        })).toThrow(/session already exists/);
+    });
+    it("source 가 비어있으면 에러", () => {
+        expect(() => executeReconstructStart({
+            source: "   ",
+            intent: "x",
+            sessionsDir: tmpRoot,
+        })).toThrow(/source is required/);
+    });
+    it("intent 가 비어있으면 에러", () => {
+        expect(() => executeReconstructStart({
+            source: "./src",
+            intent: "",
+            sessionsDir: tmpRoot,
+        })).toThrow(/intent is required/);
+    });
+    it("session-id 미지정 시 date-hex 형식으로 자동 생성", () => {
+        const result = executeReconstructStart({
+            source: "./src",
+            intent: "auto",
+            sessionsDir: tmpRoot,
+        });
+        expect(result.session_id).toMatch(/^\d{8}-[0-9a-f]+$/);
+    });
+});
+describe("executeReconstructExplore", () => {
+    function startFixture(id = "x1") {
+        return executeReconstructStart({
+            source: "./src",
+            intent: "t",
+            sessionsDir: tmpRoot,
+            sessionId: id,
+        });
+    }
+    it("gathering_context → exploring 전이 + invocation 증가", () => {
+        startFixture("e1");
+        const result = executeReconstructExplore({
+            sessionsDir: tmpRoot,
+            sessionId: "e1",
+        });
+        expect(result.success).toBe(true);
+        expect(result.state.current_state).toBe("exploring");
+        expect(result.state.explore_invocations).toBe(1);
+    });
+    it("여러 번 호출 시 invocations 누적", () => {
+        startFixture("e2");
+        executeReconstructExplore({ sessionsDir: tmpRoot, sessionId: "e2" });
+        executeReconstructExplore({ sessionsDir: tmpRoot, sessionId: "e2" });
+        const result = executeReconstructExplore({ sessionsDir: tmpRoot, sessionId: "e2" });
+        expect(result.state.explore_invocations).toBe(3);
+    });
+    it("존재하지 않는 session id 는 에러", () => {
+        expect(() => executeReconstructExplore({ sessionsDir: tmpRoot, sessionId: "nope" })).toThrow(/session not found/);
+    });
+    it("converted 이후 explore 는 에러", () => {
+        startFixture("e3");
+        executeReconstructExplore({ sessionsDir: tmpRoot, sessionId: "e3" });
+        executeReconstructComplete({ sessionsDir: tmpRoot, sessionId: "e3" });
+        expect(() => executeReconstructExplore({ sessionsDir: tmpRoot, sessionId: "e3" })).toThrow(/already converted/);
+    });
+});
+describe("executeReconstructComplete", () => {
+    function startAndExplore(id) {
+        executeReconstructStart({
+            source: "./src",
+            intent: "t",
+            sessionsDir: tmpRoot,
+            sessionId: id,
+        });
+        executeReconstructExplore({ sessionsDir: tmpRoot, sessionId: id });
+    }
+    it("exploring → converted 전이 + ontology-draft.md 생성", () => {
+        startAndExplore("c1");
+        const result = executeReconstructComplete({
+            sessionsDir: tmpRoot,
+            sessionId: "c1",
+        });
+        expect(result.success).toBe(true);
+        expect(result.state.current_state).toBe("converted");
+        expect(result.state.ontology_draft_path).toBe(join(tmpRoot, "c1", "ontology-draft.md"));
+        expect(existsSync(result.state.ontology_draft_path)).toBe(true);
+    });
+    it("draft 파일에 source/intent/invocations 가 포함된다", () => {
+        startAndExplore("c2");
+        executeReconstructExplore({ sessionsDir: tmpRoot, sessionId: "c2" });
+        executeReconstructComplete({ sessionsDir: tmpRoot, sessionId: "c2" });
+        const draft = readFileSync(join(tmpRoot, "c2", "ontology-draft.md"), "utf-8");
+        expect(draft).toContain("source: ./src");
+        expect(draft).toContain("intent: t");
+        expect(draft).toContain("explore invocations: 2");
+    });
+    it("Principal 검증 경로: complete 는 principal_review_status = requested", () => {
+        startAndExplore("c3");
+        const result = executeReconstructComplete({
+            sessionsDir: tmpRoot,
+            sessionId: "c3",
+        });
+        expect(result.state.principal_review_status).toBe("requested");
+    });
+    it("explore 없이 complete 는 에러 (gathering_context 에서 직접 complete 금지)", () => {
+        executeReconstructStart({
+            source: "./src",
+            intent: "t",
+            sessionsDir: tmpRoot,
+            sessionId: "c4",
+        });
+        expect(() => executeReconstructComplete({ sessionsDir: tmpRoot, sessionId: "c4" })).toThrow(/requires at least one explore/);
+    });
+    it("이미 converted 된 session 재 complete 는 에러", () => {
+        startAndExplore("c5");
+        executeReconstructComplete({ sessionsDir: tmpRoot, sessionId: "c5" });
+        expect(() => executeReconstructComplete({ sessionsDir: tmpRoot, sessionId: "c5" })).toThrow(/already converted/);
+    });
+    it("존재하지 않는 session id 는 에러", () => {
+        expect(() => executeReconstructComplete({ sessionsDir: tmpRoot, sessionId: "nope" })).toThrow(/session not found/);
+    });
+});
+describe("confirm (W-B-07: principal confirmation seat)", () => {
+    function startExploreComplete(id) {
+        executeReconstructStart({
+            source: "./src",
+            intent: "t",
+            sessionsDir: tmpRoot,
+            sessionId: id,
+        });
+        executeReconstructExplore({ sessionsDir: tmpRoot, sessionId: id });
+        return executeReconstructComplete({ sessionsDir: tmpRoot, sessionId: id });
+    }
+    it("confirm --verdict passed 는 principal_review_status = passed", () => {
+        startExploreComplete("cf1");
+        const result = executeReconstructConfirm({
+            sessionsDir: tmpRoot,
+            sessionId: "cf1",
+            verdict: "passed",
+        });
+        expect(result.state.principal_review_status).toBe("passed");
+        expect(result.state.current_state).toBe("converted");
+    });
+    it("confirm --verdict rejected 는 principal_review_status = rejected", () => {
+        startExploreComplete("cf2");
+        const result = executeReconstructConfirm({
+            sessionsDir: tmpRoot,
+            sessionId: "cf2",
+            verdict: "rejected",
+        });
+        expect(result.state.principal_review_status).toBe("rejected");
+    });
+    it("exploring 상태에서 confirm 은 에러", () => {
+        executeReconstructStart({
+            source: "./src",
+            intent: "t",
+            sessionsDir: tmpRoot,
+            sessionId: "cf3",
+        });
+        executeReconstructExplore({ sessionsDir: tmpRoot, sessionId: "cf3" });
+        expect(() => executeReconstructConfirm({
+            sessionsDir: tmpRoot,
+            sessionId: "cf3",
+            verdict: "passed",
+        })).toThrow(/expected "converted"/);
+    });
+    it("이미 confirm 된 session 재 confirm 은 에러", () => {
+        startExploreComplete("cf4");
+        executeReconstructConfirm({
+            sessionsDir: tmpRoot,
+            sessionId: "cf4",
+            verdict: "passed",
+        });
+        expect(() => executeReconstructConfirm({
+            sessionsDir: tmpRoot,
+            sessionId: "cf4",
+            verdict: "rejected",
+        })).toThrow(/expected "requested"/);
+    });
+    it("confirm 결과가 state 파일에 persist", () => {
+        const completed = startExploreComplete("cf5");
+        executeReconstructConfirm({
+            sessionsDir: tmpRoot,
+            sessionId: "cf5",
+            verdict: "passed",
+        });
+        const root = join(tmpRoot, "cf5");
+        const persisted = readStateFile(root);
+        expect(persisted.principal_review_status).toBe("passed");
+    });
+});
+describe("end-to-end bounded path (review 4-step: start→explore→complete→confirm)", () => {
+    it("start → explore → complete → confirm 전체 작동", () => {
+        const started = executeReconstructStart({
+            source: "./src",
+            intent: "E2E",
+            sessionsDir: tmpRoot,
+            sessionId: "e2e",
+        });
+        expect(started.state.current_state).toBe("gathering_context");
+        const explored = executeReconstructExplore({
+            sessionsDir: tmpRoot,
+            sessionId: "e2e",
+        });
+        expect(explored.state.current_state).toBe("exploring");
+        const completed = executeReconstructComplete({
+            sessionsDir: tmpRoot,
+            sessionId: "e2e",
+        });
+        expect(completed.state.current_state).toBe("converted");
+        expect(completed.state.principal_review_status).toBe("requested");
+        const confirmed = executeReconstructConfirm({
+            sessionsDir: tmpRoot,
+            sessionId: "e2e",
+            verdict: "passed",
+        });
+        expect(confirmed.state.principal_review_status).toBe("passed");
+        const persisted = readStateFile(started.session_root);
+        expect(persisted.current_state).toBe("converted");
+        expect(persisted.principal_review_status).toBe("passed");
+        expect(persisted.explore_invocations).toBe(1);
+        expect(persisted.ontology_draft_path).not.toBeNull();
+    });
+});

package/dist/core-runtime/evolve/commands/shared.js

@@ -0,0 +1,22 @@
+/**
+ * Shared command utilities.
+ *
+ * Consolidates patterns duplicated across command modules
+ * (UF-CONCISENESS-SCOPE-MD-DUPLICATION).
+ */
+import { writeFileSync } from "node:fs";
+import { readEvents } from "../../scope-runtime/event-store.js";
+import { reduce } from "../../scope-runtime/reducer.js";
+import { renderScopeMd } from "../renderers/scope-md.js";
+/**
+ * Refresh scope.md from the current event stream.
+ *
+ * If `state` is already available (e.g., from a pipeline result),
+ * pass it to avoid a redundant readEvents+reduce cycle.
+ * Otherwise the function reads events and derives state itself.
+ */
+export function refreshScopeMd(paths, state) {
+    const s = state ?? reduce(readEvents(paths.events));
+    const md = renderScopeMd(s);
+    writeFileSync(paths.scopeMd, md, "utf-8");
+}

package/dist/core-runtime/evolve/commands/stale-check.js

@@ -0,0 +1,103 @@
+/**
+ * Stale detection: compare current source hashes with recorded source_hashes.
+ *
+ * Called before gate transitions (mandatory) and at command start (lightweight).
+ * If stale sources are found, records snapshot.marked_stale event.
+ *
+ * This module does NOT re-scan sources. It only computes current hashes
+ * and compares with the hashes recorded in grounding.completed.
+ */
+import { readFileSync, statSync, existsSync } from "node:fs";
+import { readEvents } from "../../scope-runtime/event-store.js";
+import { reduce } from "../../scope-runtime/reducer.js";
+import { appendScopeEvent } from "../../scope-runtime/event-pipeline.js";
+import { renderScopeMd } from "../renderers/scope-md.js";
+import { writeFileSync } from "node:fs";
+import { computeDirectoryHash, walkDirectory, normalizePath } from "../../readers/file-utils.js";
+import { contentHash } from "../../scope-runtime/hash.js";
+import { readSourcesYaml } from "../config/project-config.js";
+import { sourceKey } from "../../readers/types.js";
+// ─── Main ───
+/**
+ * Check if any sources have changed since last grounding.
+ * Compares current file hashes with source_hashes from grounding.completed.
+ *
+ * Only checks local sources (add-dir, obsidian-vault).
+ * github-tarball requires network access (not checked here).
+ * figma-mcp requires MCP calls (not checked here).
+ */
+export function checkStale(paths) {
+    const events = readEvents(paths.events);
+    const state = reduce(events);
+    // Find grounding.completed event to get recorded source_hashes
+    const groundingCompleted = [...events].reverse().find(e => e.type === "grounding.completed");
+    if (!groundingCompleted) {
+        return { stale: false, stale_sources: [] };
+    }
+    const recordedHashes = groundingCompleted.payload.source_hashes;
+    // Load sources to know which ones to check
+    const sources = readSourcesYaml(paths.sourcesYaml);
+    const staleSources = [];
+    for (const source of sources) {
+        // Only check local sources (synchronous hash comparison).
+        // github-tarball: requires network access — not checked here.
+        // figma-mcp: requires MCP calls — delegated to agent protocol.
+        //   Agent calls get_metadata, compares lastModified, and records
+        //   snapshot.marked_stale if changed. See: readers/mcp-figma.ts
+        if (source.type !== "add-dir" && source.type !== "obsidian-vault") {
+            continue;
+        }
+        const key = sourceKey(source);
+        const oldHash = recordedHashes[key];
+        if (!oldHash)
+            continue; // Source wasn't in last grounding
+        const newHash = computeCurrentHash(source);
+        if (newHash !== oldHash) {
+            staleSources.push({ path: key, old_hash: oldHash, new_hash: newHash });
+        }
+    }
+    return {
+        stale: staleSources.length > 0,
+        stale_sources: staleSources,
+    };
+}
+/**
+ * Record snapshot.marked_stale event if stale sources detected.
+ * Returns true if stale was detected and recorded.
+ */
+export function checkAndRecordStale(paths) {
+    const result = checkStale(paths);
+    if (!result.stale)
+        return false;
+    const staleResult = appendScopeEvent(paths, {
+        type: "snapshot.marked_stale",
+        actor: "system",
+        payload: {
+            stale_sources: result.stale_sources,
+        },
+    });
+    // Update scope.md after stale event
+    if (staleResult.success) {
+        const state = reduce(readEvents(paths.events));
+        writeFileSync(paths.scopeMd, renderScopeMd(state), "utf-8");
+    }
+    return true;
+}
+// ─── Helpers ───
+function computeCurrentHash(source) {
+    const fullPath = normalizePath(source.path);
+    if (!existsSync(fullPath))
+        return "missing";
+    try {
+        const stat = statSync(fullPath);
+        if (stat.isFile()) {
+            return contentHash(readFileSync(fullPath, "utf-8"));
+        }
+        // Directory
+        const files = walkDirectory(fullPath);
+        return computeDirectoryHash(fullPath, files);
+    }
+    catch {
+        return "error";
+    }
+}

package/dist/core-runtime/evolve/commands/stale-check.test.js

@@ -0,0 +1,84 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtempSync, writeFileSync, rmSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { checkStale, checkAndRecordStale } from "./stale-check.js";
+import { createScope } from "../../scope-runtime/scope-manager.js";
+import { appendScopeEvent } from "../../scope-runtime/event-pipeline.js";
+import { readEvents } from "../../scope-runtime/event-store.js";
+import { reduce } from "../../scope-runtime/reducer.js";
+import { computeDirectoryHash, walkDirectory } from "../../readers/file-utils.js";
+let tmpDir;
+let srcDir;
+beforeEach(() => {
+    tmpDir = mkdtempSync(join(tmpdir(), "sprint-stale-"));
+    srcDir = join(tmpDir, "project-src");
+    mkdirSync(srcDir, { recursive: true });
+    writeFileSync(join(srcDir, "app.ts"), "const a = 1;");
+});
+afterEach(() => rmSync(tmpDir, { recursive: true, force: true }));
+function setupGroundedScope() {
+    const scopesDir = join(tmpDir, "scopes");
+    mkdirSync(scopesDir, { recursive: true });
+    const paths = createScope(scopesDir, "SC-STALE-001");
+    appendScopeEvent(paths, { type: "scope.created", actor: "user", payload: { title: "T", description: "d", entry_mode: "experience" } });
+    appendScopeEvent(paths, { type: "grounding.started", actor: "system", payload: { sources: [{ type: "add-dir", path_or_url: srcDir }] } });
+    // Compute actual hash for the source directory
+    const files = walkDirectory(srcDir);
+    const hash = computeDirectoryHash(srcDir, files);
+    appendScopeEvent(paths, { type: "grounding.completed", actor: "system", payload: { snapshot_revision: 1, source_hashes: { [`add-dir:${srcDir}`]: hash }, perspective_summary: { experience: 0, code: 0, policy: 0 } } });
+    // Write sources.yaml so stale-check can read it
+    const { stringify } = require("yaml");
+    writeFileSync(paths.sourcesYaml, stringify({ sources: [{ type: "add-dir", path: srcDir }] }), "utf-8");
+    return paths;
+}
+describe("checkStale", () => {
+    it("returns not stale when source unchanged", () => {
+        const paths = setupGroundedScope();
+        const result = checkStale(paths);
+        expect(result.stale).toBe(false);
+        expect(result.stale_sources).toEqual([]);
+    });
+    it("detects stale when file content changes", () => {
+        const paths = setupGroundedScope();
+        // Modify source file
+        writeFileSync(join(srcDir, "app.ts"), "const a = 2; // changed");
+        const result = checkStale(paths);
+        expect(result.stale).toBe(true);
+        expect(result.stale_sources).toHaveLength(1);
+        expect(result.stale_sources[0].path).toBe(`add-dir:${srcDir}`);
+    });
+    it("detects stale when file is added", () => {
+        const paths = setupGroundedScope();
+        writeFileSync(join(srcDir, "new-file.ts"), "const b = 1;");
+        const result = checkStale(paths);
+        expect(result.stale).toBe(true);
+    });
+    it("returns not stale when no grounding.completed exists", () => {
+        const scopesDir = join(tmpDir, "scopes2");
+        mkdirSync(scopesDir, { recursive: true });
+        const paths = createScope(scopesDir, "SC-STALE-002");
+        appendScopeEvent(paths, { type: "scope.created", actor: "user", payload: { title: "T", description: "d", entry_mode: "experience" } });
+        writeFileSync(paths.sourcesYaml, "", "utf-8");
+        const result = checkStale(paths);
+        expect(result.stale).toBe(false);
+    });
+});
+describe("checkAndRecordStale", () => {
+    it("records snapshot.marked_stale event when stale detected", () => {
+        const paths = setupGroundedScope();
+        // Proceed to align_proposed
+        appendScopeEvent(paths, { type: "align.proposed", actor: "system", payload: { packet_path: "build/align-packet.md", packet_hash: "h", snapshot_revision: 1 } });
+        // Modify source
+        writeFileSync(join(srcDir, "app.ts"), "const a = 999;");
+        const wasStale = checkAndRecordStale(paths);
+        expect(wasStale).toBe(true);
+        const state = reduce(readEvents(paths.events));
+        expect(state.stale).toBe(true);
+    });
+    it("does nothing when not stale", () => {
+        const paths = setupGroundedScope();
+        const wasStale = checkAndRecordStale(paths);
+        expect(wasStale).toBe(false);
+    });
+});