onto-mcp 0.3.2 → 0.4.1

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

@@ -1,323 +0,0 @@
-/**
- * /draft command orchestration.
- *
- * State-dependent behavior:
- * - align_locked → generate surface + transition to surface_iterating
- * - surface_iterating → apply feedback or confirm surface
- * - surface_confirmed → deep constraint discovery + Draft Packet rendering
- * - constraints_resolved → lock target
- * - target_locked → compile
- *
- * Surface generation and constraint discovery are agent-driven.
- * This module provides the event recording orchestration.
- */
-import { writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { readEvents } from "../../scope-runtime/event-store.js";
-import { reduce } from "../../scope-runtime/reducer.js";
-import { appendScopeEvent } from "../../scope-runtime/event-pipeline.js";
-import { renderDraftPacket } from "../renderers/draft-packet.js";
-import { wrapGateError } from "./error-messages.js";
-import { refreshScopeMd } from "./shared.js";
-import { contentHash } from "../../scope-runtime/hash.js";
-import { compile } from "../adapters/code-product/compile/compile.js";
-// ─── Main ───
-export function executeDraft(input) {
-    const { paths, action } = input;
-    const events = readEvents(paths.events);
-    const state = reduce(events);
-    switch (action.type) {
-        case "generate_surface":
-            return handleGenerateSurface(paths, state, action);
-        case "apply_feedback":
-            return handleApplyFeedback(paths, state, action);
-        case "confirm_surface":
-            return handleConfirmSurface(paths, state, action);
-        case "surface_change_required":
-            return handleSurfaceChangeRequired(paths, action);
-        case "record_constraint":
-            return handleRecordConstraint(paths, action);
-        case "record_decision":
-            return handleRecordDecision(paths, action);
-        case "lock_target":
-            return handleLockTarget(paths, state);
-        case "compile":
-            return handleCompile(paths, state, action);
-    }
-}
-// ─── Action Handlers ───
-function handleGenerateSurface(paths, state, action) {
-    if (state.current_state !== "align_locked") {
-        return { success: false, reason: `Surface 생성은 align_locked 상태에서만 가능합니다. 현재: ${state.current_state}` };
-    }
-    const result = appendScopeEvent(paths, {
-        type: "surface.generated",
-        actor: "system",
-        payload: {
-            surface_type: state.entry_mode,
-            surface_path: action.surfacePath,
-            content_hash: action.surfaceHash,
-            based_on_snapshot: action.snapshotRevision,
-        },
-    });
-    if (!result.success)
-        return { success: false, reason: wrapGateError(result.reason) };
-    refreshScopeMd(paths, result.state);
-    const guide = state.entry_mode === "experience"
-        ? "`cd surface/preview && npm run dev`로 mockup을 확인하세요."
-        : "`surface/contract-diff/`의 API 명세를 확인하세요.";
-    return {
-        success: true,
-        nextState: "surface_iterating",
-        message: `Surface가 생성되었습니다. ${guide} 수정이 필요하면 피드백을 주세요. 이 모습이 맞으면 '확정합니다'라고 말씀해 주세요.`,
-    };
-}
-function handleApplyFeedback(paths, state, action) {
-    const classification = action.classification ?? "surface_only";
-    // 1. Record feedback
-    const fbResult = appendScopeEvent(paths, {
-        type: "surface.revision_requested",
-        actor: "user",
-        payload: { feedback_text: action.feedbackText },
-    });
-    if (!fbResult.success)
-        return { success: false, reason: wrapGateError(fbResult.reason) };
-    // 2. Record feedback classification
-    const classifyResult = appendScopeEvent(paths, {
-        type: "feedback.classified",
-        actor: "system",
-        payload: {
-            classification,
-            confidence: action.classification ? 1.0 : 0.8,
-            confirmed_by: action.classification ? "user" : "auto",
-        },
-    });
-    if (!classifyResult.success)
-        return { success: false, reason: wrapGateError(classifyResult.reason) };
-    // 3. direction_change → redirect to align, early return
-    if (classification === "direction_change") {
-        const redirectResult = appendScopeEvent(paths, {
-            type: "redirect.to_align",
-            actor: "system",
-            payload: {
-                from_state: state.current_state,
-                reason: "피드백 분류: direction_change — 방향 재검토가 필요합니다.",
-            },
-        });
-        if (!redirectResult.success)
-            return { success: false, reason: wrapGateError(redirectResult.reason) };
-        refreshScopeMd(paths, redirectResult.state);
-        return {
-            success: true,
-            nextState: "align_proposed",
-            message: "방향 변경 피드백이 감지되었습니다. /align으로 방향을 재검토합니다.",
-        };
-    }
-    // 4. Record revision
-    const revResult = appendScopeEvent(paths, {
-        type: "surface.revision_applied",
-        actor: "system",
-        payload: {
-            revision_count: state.revision_count_surface + 1,
-            surface_path: action.surfacePath,
-            content_hash: action.surfaceHash,
-        },
-    });
-    if (!revResult.success)
-        return { success: false, reason: wrapGateError(revResult.reason) };
-    refreshScopeMd(paths, revResult.state);
-    // 5. target_change → append scope change notice
-    const message = classification === "target_change"
-        ? "피드백이 반영되었습니다. 범위가 변경되었습니다. Surface를 다시 확인해 주세요."
-        : "피드백이 반영되었습니다. Surface를 다시 확인해 주세요.";
-    return {
-        success: true,
-        nextState: "surface_iterating",
-        message,
-    };
-}
-function handleConfirmSurface(paths, state, action) {
-    const result = appendScopeEvent(paths, {
-        type: "surface.confirmed",
-        actor: "user",
-        payload: {
-            final_surface_path: action.surfacePath,
-            final_content_hash: action.surfaceHash,
-            total_revisions: state.revision_count_surface,
-        },
-    });
-    if (!result.success)
-        return { success: false, reason: wrapGateError(result.reason) };
-    refreshScopeMd(paths, result.state);
-    return {
-        success: true,
-        nextState: "surface_confirmed",
-        message: "Surface가 확정되었습니다. 3개 관점에서 정밀 스캔을 수행합니다.",
-    };
-}
-function handleSurfaceChangeRequired(paths, action) {
-    const result = appendScopeEvent(paths, {
-        type: "surface.change_required",
-        actor: "system",
-        payload: {
-            constraint_id: action.constraintId,
-            reason: action.reason,
-        },
-    });
-    if (!result.success)
-        return { success: false, reason: wrapGateError(result.reason) };
-    refreshScopeMd(paths, result.state);
-    return {
-        success: true,
-        nextState: "surface_iterating",
-        message: `${action.constraintId}: 제약 사항으로 인해 Surface 수정이 필요합니다. Surface를 다시 검토해 주세요.`,
-    };
-}
-function handleRecordConstraint(paths, action) {
-    const result = appendScopeEvent(paths, {
-        type: "constraint.discovered",
-        actor: "system",
-        payload: action.constraintPayload,
-    });
-    if (!result.success)
-        return { success: false, reason: wrapGateError(result.reason) };
-    refreshScopeMd(paths, result.state);
-    const cstId = action.constraintPayload.constraint_id ?? "?";
-    return {
-        success: true,
-        nextState: "surface_confirmed",
-        message: `Constraint ${cstId}이 기록되었습니다.`,
-    };
-}
-function handleRecordDecision(paths, action) {
-    const result = appendScopeEvent(paths, {
-        type: "constraint.decision_recorded",
-        actor: "user",
-        payload: action.decisionPayload,
-    });
-    if (!result.success)
-        return { success: false, reason: wrapGateError(result.reason) };
-    const cstId = action.decisionPayload.constraint_id ?? "?";
-    const decision = action.decisionPayload.decision ?? "?";
-    // modify-direction → automatically redirect to Align
-    if (decision === "modify-direction") {
-        const redirectResult = appendScopeEvent(paths, {
-            type: "redirect.to_align",
-            actor: "system",
-            payload: {
-                from_state: result.next_state,
-                reason: `${cstId}: modify-direction 결정으로 방향 재검토 필요`,
-            },
-        });
-        if (!redirectResult.success)
-            return { success: false, reason: wrapGateError(redirectResult.reason) };
-        refreshScopeMd(paths, redirectResult.state);
-        return {
-            success: true,
-            nextState: "align_proposed",
-            message: `${cstId}: modify-direction. 방향을 재검토합니다. /align으로 진행하세요.`,
-        };
-    }
-    refreshScopeMd(paths, result.state);
-    return {
-        success: true,
-        nextState: result.next_state,
-        message: `${cstId}: ${decision} 결정이 기록되었습니다.`,
-    };
-}
-function handleLockTarget(paths, state) {
-    // Filter: decided constraints only (matches gate-guard Rule 6 criteria)
-    const activeConstraints = state.constraint_pool.constraints
-        .filter(c => c.status === "decided")
-        .map(c => ({ constraint_id: c.constraint_id, decision: c.decision }));
-    const result = appendScopeEvent(paths, {
-        type: "target.locked",
-        actor: "system",
-        payload: {
-            surface_hash: state.surface_hash ?? "",
-            constraint_decisions: activeConstraints,
-        },
-    });
-    if (!result.success)
-        return { success: false, reason: wrapGateError(result.reason) };
-    refreshScopeMd(paths, result.state);
-    return {
-        success: true,
-        nextState: "target_locked",
-        message: "모든 결정이 완료되었습니다. compile을 시작합니다.",
-    };
-}
-function handleCompile(paths, state, action) {
-    // Execute compile FIRST (before recording compile.started)
-    // This prevents orphaned compile.started events in the event stream on failure.
-    const compileResult = compile(action.compileInput);
-    if (!compileResult.success) {
-        return {
-            success: false,
-            reason: wrapGateError(`Compile 실패: ${compileResult.reason}`),
-            violations: compileResult.violations,
-        };
-    }
-    // Record compile.started (only after successful compile)
-    const startResult = appendScopeEvent(paths, {
-        type: "compile.started",
-        actor: "system",
-        payload: {
-            snapshot_revision: state.snapshot_revision,
-            surface_hash: state.surface_hash ?? "",
-        },
-    });
-    if (!startResult.success)
-        return { success: false, reason: wrapGateError(startResult.reason) };
-    const success = compileResult;
-    // Save artifacts
-    writeFileSync(join(paths.build, "build-spec.md"), success.buildSpecMd, "utf-8");
-    writeFileSync(join(paths.build, "brownfield-detail.md"), success.brownfieldDetailMd, "utf-8");
-    writeFileSync(join(paths.build, "delta-set.json"), success.deltaSetJson, "utf-8");
-    writeFileSync(join(paths.build, "validation-plan.md"), success.validationPlanMd, "utf-8");
-    // Record compile.completed
-    const completeResult = appendScopeEvent(paths, {
-        type: "compile.completed",
-        actor: "system",
-        payload: {
-            build_spec_path: "build/build-spec.md",
-            build_spec_hash: success.buildSpecHash,
-            brownfield_detail_path: "build/brownfield-detail.md",
-            brownfield_detail_hash: success.brownfieldDetailHash,
-            delta_set_path: "build/delta-set.json",
-            delta_set_hash: success.deltaSetHash,
-            validation_plan_path: "build/validation-plan.md",
-            validation_plan_hash: success.validationPlanHash,
-        },
-    });
-    if (!completeResult.success)
-        return { success: false, reason: wrapGateError(completeResult.reason) };
-    refreshScopeMd(paths, completeResult.state);
-    return {
-        success: true,
-        nextState: "compiled",
-        message: "Build Spec이 생성되었습니다. 구현을 적용하세요.",
-        data: {
-            buildSpecHash: success.buildSpecHash,
-            deltaSetHash: success.deltaSetHash,
-            validationPlanHash: success.validationPlanHash,
-            warnings: success.warnings,
-        },
-    };
-}
-// ─── Packet Rendering (UF-STRUCTURE-PACKET-SEAT) ───
-/**
- * Render a Draft Packet and write it to `build/draft-packet.md`.
- *
- * Called by the agent when it has assembled DraftPacketContent
- * (after surface confirmation + constraint discovery).
- * Returns the content hash of the written packet.
- */
-export function writeDraftPacket(paths, content) {
-    const state = reduce(readEvents(paths.events));
-    const md = renderDraftPacket(state, content);
-    const packetPath = join(paths.build, "draft-packet.md");
-    writeFileSync(packetPath, md, "utf-8");
-    return { packetPath, packetHash: contentHash(md) };
-}
-// refreshScopeMd is imported from ./shared.ts (UF-CONCISENESS-SCOPE-MD consolidated)

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

@@ -1,178 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { mkdtempSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { executeDraft } from "./draft.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";
-let tmpDir;
-beforeEach(() => { tmpDir = mkdtempSync(join(tmpdir(), "sprint-draft-")); });
-afterEach(() => { rmSync(tmpDir, { recursive: true, force: true }); });
-/** Set up scope through align_locked */
-function setupAlignLocked() {
-    const paths = createScope(tmpDir, "SC-DRAFT-001");
-    appendScopeEvent(paths, { type: "scope.created", actor: "user", payload: { title: "Test", description: "d", entry_mode: "experience" } });
-    appendScopeEvent(paths, { type: "grounding.started", actor: "system", payload: { sources: [{ type: "add-dir", path_or_url: "/test" }] } });
-    appendScopeEvent(paths, { type: "grounding.completed", actor: "system", payload: { snapshot_revision: 1, source_hashes: { "add-dir:/test": "h1" }, perspective_summary: { experience: 1, code: 1, policy: 1 } } });
-    appendScopeEvent(paths, { type: "align.proposed", actor: "system", payload: { packet_path: "build/align-packet.md", packet_hash: "h", snapshot_revision: 1 } });
-    appendScopeEvent(paths, { type: "align.locked", actor: "user", payload: { locked_direction: "test", locked_scope_boundaries: { in: ["a"], out: ["b"] }, locked_in_out: true } });
-    return paths;
-}
-/** Set up scope through surface_iterating */
-function setupSurfaceIterating() {
-    const paths = setupAlignLocked();
-    appendScopeEvent(paths, { type: "surface.generated", actor: "system", payload: { surface_type: "experience", surface_path: "surface/preview/", content_hash: "sf1", based_on_snapshot: 1 } });
-    return paths;
-}
-describe("executeDraft", () => {
-    it("generate_surface: align_locked → surface_iterating", () => {
-        const paths = setupAlignLocked();
-        const result = executeDraft({
-            paths,
-            action: { type: "generate_surface", surfacePath: "surface/preview/", surfaceHash: "sf1", snapshotRevision: 1 },
-        });
-        expect(result.success).toBe(true);
-        if (!result.success)
-            return;
-        expect(result.nextState).toBe("surface_iterating");
-        const state = reduce(readEvents(paths.events));
-        expect(state.current_state).toBe("surface_iterating");
-    });
-    it("apply_feedback: surface_iterating → surface_iterating", () => {
-        const paths = setupSurfaceIterating();
-        const result = executeDraft({
-            paths,
-            action: { type: "apply_feedback", feedbackText: "버튼 위치 변경", surfacePath: "surface/preview/", surfaceHash: "sf2" },
-        });
-        expect(result.success).toBe(true);
-        if (!result.success)
-            return;
-        expect(result.nextState).toBe("surface_iterating");
-    });
-    it("confirm_surface: surface_iterating → surface_confirmed", () => {
-        const paths = setupSurfaceIterating();
-        const result = executeDraft({
-            paths,
-            action: { type: "confirm_surface", surfacePath: "surface/preview/", surfaceHash: "sf_final" },
-        });
-        expect(result.success).toBe(true);
-        if (!result.success)
-            return;
-        expect(result.nextState).toBe("surface_confirmed");
-    });
-    it("generate_surface fails when not align_locked", () => {
-        const paths = setupSurfaceIterating(); // already surface_iterating
-        const result = executeDraft({
-            paths,
-            action: { type: "generate_surface", surfacePath: "surface/preview/", surfaceHash: "sf", snapshotRevision: 1 },
-        });
-        expect(result.success).toBe(false);
-    });
-    it("apply_feedback with classification=surface_only records feedback.classified", () => {
-        const paths = setupSurfaceIterating();
-        const result = executeDraft({
-            paths,
-            action: { type: "apply_feedback", feedbackText: "색상 변경", surfacePath: "surface/preview/", surfaceHash: "sf3", classification: "surface_only" },
-        });
-        expect(result.success).toBe(true);
-        if (!result.success)
-            return;
-        expect(result.nextState).toBe("surface_iterating");
-        const events = readEvents(paths.events);
-        const classifiedEvents = events.filter(e => e.type === "feedback.classified");
-        expect(classifiedEvents.length).toBe(1);
-        expect(classifiedEvents[0].payload).toEqual({
-            classification: "surface_only",
-            confidence: 1.0,
-            confirmed_by: "user",
-        });
-        // revision_applied should also be recorded
-        const revisionEvents = events.filter(e => e.type === "surface.revision_applied");
-        expect(revisionEvents.length).toBe(1);
-    });
-    it("apply_feedback with classification=direction_change issues redirect.to_align", () => {
-        const paths = setupSurfaceIterating();
-        const result = executeDraft({
-            paths,
-            action: { type: "apply_feedback", feedbackText: "방향을 바꿔야 합니다", surfacePath: "surface/preview/", surfaceHash: "sf4", classification: "direction_change" },
-        });
-        expect(result.success).toBe(true);
-        if (!result.success)
-            return;
-        expect(result.nextState).toBe("align_proposed");
-        const events = readEvents(paths.events);
-        const classifiedEvents = events.filter(e => e.type === "feedback.classified");
-        expect(classifiedEvents.length).toBe(1);
-        expect(classifiedEvents[0].payload).toEqual({
-            classification: "direction_change",
-            confidence: 1.0,
-            confirmed_by: "user",
-        });
-        const redirectEvents = events.filter(e => e.type === "redirect.to_align");
-        expect(redirectEvents.length).toBe(1);
-        // revision_applied should NOT be recorded (early return)
-        const revisionEvents = events.filter(e => e.type === "surface.revision_applied");
-        expect(revisionEvents.length).toBe(0);
-        const state = reduce(events);
-        expect(state.current_state).toBe("align_proposed");
-    });
-    it("apply_feedback without classification defaults to surface_only", () => {
-        const paths = setupSurfaceIterating();
-        const result = executeDraft({
-            paths,
-            action: { type: "apply_feedback", feedbackText: "간격 조정", surfacePath: "surface/preview/", surfaceHash: "sf5" },
-        });
-        expect(result.success).toBe(true);
-        if (!result.success)
-            return;
-        expect(result.nextState).toBe("surface_iterating");
-        const events = readEvents(paths.events);
-        const classifiedEvents = events.filter(e => e.type === "feedback.classified");
-        expect(classifiedEvents.length).toBe(1);
-        expect(classifiedEvents[0].payload).toEqual({
-            classification: "surface_only",
-            confidence: 0.8,
-            confirmed_by: "auto",
-        });
-    });
-    it("apply_feedback with classification=target_change appends scope change message", () => {
-        const paths = setupSurfaceIterating();
-        const result = executeDraft({
-            paths,
-            action: { type: "apply_feedback", feedbackText: "범위 수정", surfacePath: "surface/preview/", surfaceHash: "sf6", classification: "target_change" },
-        });
-        expect(result.success).toBe(true);
-        if (!result.success)
-            return;
-        expect(result.nextState).toBe("surface_iterating");
-        expect(result.message).toContain("범위가 변경되었습니다");
-    });
-    it("full flow: generate → feedback → confirm → constraint → decision → lock", () => {
-        const paths = setupAlignLocked();
-        // Generate surface
-        executeDraft({ paths, action: { type: "generate_surface", surfacePath: "surface/preview/", surfaceHash: "sf1", snapshotRevision: 1 } });
-        // Confirm surface
-        executeDraft({ paths, action: { type: "confirm_surface", surfacePath: "surface/preview/", surfaceHash: "sf1" } });
-        // Discover constraint
-        executeDraft({ paths, action: { type: "record_constraint", constraintPayload: {
-                    constraint_id: "CST-001", perspective: "code", summary: "test", severity: "required",
-                    discovery_stage: "draft_phase2", decision_owner: "product_owner",
-                    impact_if_ignored: "fails", source_refs: [{ source: "test.ts", detail: "d" }],
-                } } });
-        // Record decision
-        executeDraft({ paths, action: { type: "record_decision", decisionPayload: {
-                    constraint_id: "CST-001", decision: "inject", selected_option: "fix",
-                    decision_owner: "product_owner", rationale: "필수",
-                } } });
-        // Lock target
-        const lockResult = executeDraft({ paths, action: { type: "lock_target" } });
-        expect(lockResult.success).toBe(true);
-        if (!lockResult.success)
-            return;
-        expect(lockResult.nextState).toBe("target_locked");
-        const state = reduce(readEvents(paths.events));
-        expect(state.current_state).toBe("target_locked");
-    });
-});