@vibecodetown/mcp-server 2.1.0

package/build/tools/vibe_pm/intent/verifier.js

@@ -0,0 +1,237 @@
+// adapters/mcp-ts/src/tools/vibe_pm/intent/verifier.ts
+// Intent-based Verification
+// inspect_code에서 Intent 문서 기반 검증
+import { loadIntent, updateIntentStatus } from "./generator.js";
+// ============================================================
+// Intent-based Verification
+// ============================================================
+/**
+ * Verify implementation against Intent acceptance criteria
+ */
+export function verifyAgainstIntent(intent, inspectionResults) {
+    const details = [];
+    let passCount = 0;
+    let totalCount = 0;
+    // Check each acceptance criterion
+    for (const ac of intent.acceptance) {
+        const detail = verifyAcceptanceCriterion(ac, inspectionResults);
+        details.push(detail);
+        if (detail.status === "pass") {
+            passCount++;
+        }
+        if (detail.status !== "skip") {
+            totalCount++;
+        }
+    }
+    // Check scope compliance
+    const scopeDetails = verifyScopeCompliance(intent, inspectionResults);
+    details.push(...scopeDetails);
+    for (const sd of scopeDetails) {
+        if (sd.status === "pass")
+            passCount++;
+        if (sd.status !== "skip")
+            totalCount++;
+    }
+    // Check risk mitigations
+    const riskDetails = verifyRiskMitigation(intent, inspectionResults);
+    details.push(...riskDetails);
+    for (const rd of riskDetails) {
+        if (rd.status === "pass")
+            passCount++;
+        if (rd.status !== "skip")
+            totalCount++;
+    }
+    // Calculate score
+    const score = totalCount > 0 ? Math.round((passCount / totalCount) * 100) : 100;
+    const passed = score >= 70; // 70% threshold
+    // Generate summary
+    const failedCount = details.filter((d) => d.status === "fail").length;
+    const warnCount = details.filter((d) => d.status === "warn").length;
+    let summary;
+    if (passed && failedCount === 0) {
+        summary = "모든 검증 기준을 충족했습니다.";
+    }
+    else if (passed) {
+        summary = `대부분 충족했지만 ${warnCount}개 주의 항목이 있습니다.`;
+    }
+    else {
+        summary = `${failedCount}개 기준이 미충족되었습니다. 수정이 필요합니다.`;
+    }
+    return { passed, score, details, summary };
+}
+/**
+ * Verify a single acceptance criterion
+ */
+function verifyAcceptanceCriterion(ac, data) {
+    // If not verifiable, skip
+    if (!ac.verifiable) {
+        return {
+            criterion_id: ac.id,
+            criterion: ac.description,
+            status: "skip",
+            message: "수동 검증이 필요합니다"
+        };
+    }
+    // Check if related issues exist
+    const relatedIssues = data.issues.filter((issue) => issue.description.includes(ac.description) ||
+        ac.description.includes(issue.type));
+    if (relatedIssues.length > 0) {
+        const critical = relatedIssues.some((i) => i.severity === "critical");
+        return {
+            criterion_id: ac.id,
+            criterion: ac.description,
+            status: critical ? "fail" : "warn",
+            message: `관련 이슈 ${relatedIssues.length}개 발견: ${relatedIssues[0].description}`
+        };
+    }
+    // Check if verification passed
+    if (data.buildSuccess) {
+        return {
+            criterion_id: ac.id,
+            criterion: ac.description,
+            status: "pass",
+            message: "검증 통과"
+        };
+    }
+    return {
+        criterion_id: ac.id,
+        criterion: ac.description,
+        status: "warn",
+        message: "빌드 실패로 검증 불가"
+    };
+}
+/**
+ * Verify scope compliance - check do_not_touch files weren't modified
+ */
+function verifyScopeCompliance(intent, data) {
+    const details = [];
+    // Check do_not_touch files
+    for (const protectedItem of intent.scope.do_not_touch) {
+        const modified = data.modifiedFiles.some((f) => f.toLowerCase().includes(protectedItem.toLowerCase()));
+        if (modified) {
+            details.push({
+                criterion_id: "SCOPE-DNT",
+                criterion: `"${protectedItem}" 수정 금지`,
+                status: "fail",
+                message: `보호된 항목 "${protectedItem}"이(가) 수정되었습니다`
+            });
+        }
+    }
+    // Check exclude items weren't implemented
+    for (const excluded of intent.scope.exclude) {
+        const implemented = data.implementedFeatures.some((f) => f.toLowerCase().includes(excluded.item.toLowerCase()) ||
+            excluded.item.toLowerCase().includes(f.toLowerCase()));
+        if (implemented) {
+            details.push({
+                criterion_id: "SCOPE-EXC",
+                criterion: `"${excluded.item}" 제외 범위`,
+                status: "warn",
+                message: `제외 범위 항목 "${excluded.item}"이(가) 구현된 것 같습니다`
+            });
+        }
+    }
+    // If no scope issues, add pass
+    if (details.length === 0) {
+        details.push({
+            criterion_id: "SCOPE-ALL",
+            criterion: "범위 준수",
+            status: "pass",
+            message: "범위 제약을 준수했습니다"
+        });
+    }
+    return details;
+}
+/**
+ * Verify risk mitigations were applied
+ */
+function verifyRiskMitigation(intent, data) {
+    const details = [];
+    for (const risk of intent.risks) {
+        if (risk.impact === "high" && risk.mitigation) {
+            // Check if related issues exist for high-impact risks
+            const relatedIssues = data.issues.filter((issue) => issue.description.includes(risk.description) ||
+                risk.description.includes(issue.type));
+            if (relatedIssues.length > 0) {
+                details.push({
+                    criterion_id: risk.id,
+                    criterion: `리스크 완화: ${risk.description}`,
+                    status: "warn",
+                    message: `고위험 항목에 관련 이슈 발견: ${risk.mitigation}`
+                });
+            }
+            else {
+                details.push({
+                    criterion_id: risk.id,
+                    criterion: `리스크 완화: ${risk.description}`,
+                    status: "pass",
+                    message: "리스크 완화 조치 적용됨"
+                });
+            }
+        }
+    }
+    return details;
+}
+/**
+ * Convert one-loop results to InspectionData
+ */
+export function toInspectionData(oneLoopResult) {
+    return {
+        buildSuccess: oneLoopResult.status === "OK",
+        issues: (oneLoopResult.issues || []).map((i) => ({
+            type: i.type,
+            description: i.message || i.business_risk || "",
+            severity: i.type.includes("FAIL") ? "critical" : "minor"
+        })),
+        modifiedFiles: oneLoopResult.modified_files || [],
+        implementedFeatures: oneLoopResult.features || []
+    };
+}
+// ============================================================
+// Integration with inspect_code
+// ============================================================
+/**
+ * Run intent verification and update status
+ */
+export async function runIntentVerification(runsDir, runId, inspectionData) {
+    // Load intent
+    const intent = await loadIntent(runsDir, runId);
+    if (!intent) {
+        return null; // No intent document
+    }
+    // Run verification
+    const result = verifyAgainstIntent(intent, inspectionData);
+    // Update intent status based on result
+    if (result.passed && result.score >= 90) {
+        await updateIntentStatus(runsDir, runId, "verified");
+    }
+    else if (result.passed) {
+        await updateIntentStatus(runsDir, runId, "implemented");
+    }
+    return result;
+}
+/**
+ * Generate verification summary for PM output
+ */
+export function formatVerificationForPM(result) {
+    const failedCriteria = result.details
+        .filter((d) => d.status === "fail")
+        .map((d) => `${d.criterion_id}: ${d.criterion}`);
+    let status;
+    if (result.score >= 90) {
+        status = "PASS";
+    }
+    else if (result.passed) {
+        status = "WARN";
+    }
+    else {
+        status = "FAIL";
+    }
+    return {
+        intent_check: {
+            status,
+            score: result.score,
+            summary: result.summary,
+            failed_criteria: failedCriteria
+        }
+    };
+}

package/build/tools/vibe_pm/kce/doc_usage.js

@@ -0,0 +1,51 @@
+// adapters/mcp-ts/src/tools/vibe_pm/kce/doc_usage.ts
+// Internal: run evidence for deterministic doc usage (touched/injected).
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { resolveRunDir } from "../context.js";
+function normalizeRelPosix(p) {
+    return (p ?? "").trim().replace(/\\\\/g, "/");
+}
+function tryReadJson(p) {
+    try {
+        if (!fs.existsSync(p))
+            return null;
+        return JSON.parse(fs.readFileSync(p, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function uniqSorted(items) {
+    return Array.from(new Set(items.map(normalizeRelPosix).filter(Boolean))).sort();
+}
+export function kceDocUsagePath(run_id, basePath) {
+    const resolved = resolveRunDir(run_id, basePath);
+    if (!resolved)
+        return null;
+    return path.join(resolved.run_dir, "kce", "kce_doc_usage.json");
+}
+export function updateKceDocUsage(args) {
+    const p = kceDocUsagePath(args.run_id, args.basePath);
+    if (!p)
+        return;
+    const existing = tryReadJson(p);
+    const touched = uniqSorted([...(existing?.touched_docs ?? []), ...(args.touched_docs ?? [])]);
+    const injected = uniqSorted([...(existing?.injected_docs ?? []), ...(args.injected_docs ?? [])]);
+    const entities = uniqSorted([...(existing?.referenced_entities ?? []), ...(args.referenced_entities ?? [])]);
+    const out = {
+        version: "kce_doc_usage.v1",
+        created_at: new Date().toISOString(),
+        run_id: args.run_id,
+        touched_docs: touched,
+        injected_docs: injected,
+        referenced_entities: entities
+    };
+    try {
+        fs.mkdirSync(path.dirname(p), { recursive: true });
+        fs.writeFileSync(p, JSON.stringify(out, null, 2) + "\n", "utf-8");
+    }
+    catch {
+        // ignore (best-effort evidence)
+    }
+}

package/build/tools/vibe_pm/kce/on_finalize.js

@@ -0,0 +1,11 @@
+// adapters/mcp-ts/src/tools/vibe_pm/kce/on_finalize.ts
+// Internal: best-effort KCE sync after finalize_work (keeps KCE warm).
+import { runEngine } from "../../../engine.js";
+export async function kickoffKceSyncBestEffort() {
+    try {
+        await runEngine("vibecoding-helper", ["kce-sync", "--prune", "--skip-missing-roots"], { timeoutMs: 300_000 });
+    }
+    catch {
+        // ignore
+    }
+}

package/build/tools/vibe_pm/kce/preflight.js

@@ -0,0 +1,232 @@
+// adapters/mcp-ts/src/tools/vibe_pm/kce/preflight.ts
+// Internal: KCE preflight (FTS + Chroma readiness) with auto-heal + run evidence
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { z } from "zod";
+import { runEngine } from "../../../engine.js";
+import { safeJsonParse } from "../../../cli.js";
+import { resolveRunDir } from "../context.js";
+const KceStatusSchema = z.object({
+    version: z.literal("kce_status.v1"),
+    readiness_state: z.enum(["READY", "HEALING", "FAILED"]),
+    roots_snapshot_hash: z.string().min(1),
+    missing_roots: z.array(z.string()).optional(),
+    last_indexed_at: z.string().optional(),
+    fts: z.object({
+        ok: z.boolean(),
+        db_path: z.string().min(1),
+        doc_count: z.number().int().nonnegative(),
+        chunk_count: z.number().int().nonnegative()
+    }),
+    chroma: z.object({
+        ok: z.boolean(),
+        persist_dir: z.string().min(1),
+        collection: z.string().min(1),
+        chunk_count: z.number().int().nonnegative(),
+        manifest_path: z.string().min(1)
+    }),
+    fingerprints: z.object({
+        embedding: z.string().min(1),
+        chunking: z.string().min(1),
+        policy: z.string().min(1)
+    }),
+    issues: z.array(z.string()),
+    next_action: z
+        .object({
+        tool: z.string().min(1),
+        reason: z.string().min(1)
+    })
+        .nullable()
+        .optional()
+});
+const KceRetrieveOutputSchema = z.object({
+    version: z.literal("kce_retrieve.v1"),
+    query: z.string(),
+    hits: z.array(z.object({
+        path: z.string(),
+        abs_path: z.string().optional().default(""),
+        start_line: z.number().int().optional().default(1),
+        end_line: z.number().int().optional().default(1),
+        section_title: z.string().optional().default(""),
+        content: z.string().optional().default(""),
+        score: z.number().optional().default(0),
+        backend: z.string().optional().default("unknown")
+    })),
+    context_block: z.string()
+});
+const inFlight = new Map();
+function inFlightKey(args) {
+    return `${args.basePath}::${args.run_id ?? "no_run"}::${args.purpose}`;
+}
+function tryWriteJson(pathAbs, doc) {
+    try {
+        fs.mkdirSync(path.dirname(pathAbs), { recursive: true });
+        fs.writeFileSync(pathAbs, JSON.stringify(doc, null, 2) + "\n", "utf-8");
+    }
+    catch {
+        // ignore (best-effort evidence)
+    }
+}
+function tryAppendJsonl(pathAbs, record) {
+    try {
+        fs.mkdirSync(path.dirname(pathAbs), { recursive: true });
+        fs.appendFileSync(pathAbs, JSON.stringify(record) + "\n", "utf-8");
+    }
+    catch {
+        // ignore (best-effort evidence)
+    }
+}
+export function kceEvidenceDir(run_id, basePath) {
+    const resolved = resolveRunDir(run_id, basePath);
+    if (!resolved)
+        return null;
+    return path.join(resolved.run_dir, "kce");
+}
+function kceEventsPath(run_id, basePath) {
+    const dir = kceEvidenceDir(run_id, basePath);
+    if (!dir)
+        return null;
+    return path.join(dir, "kce_events.jsonl");
+}
+export async function runKceStatus() {
+    const { code, stdout, stderr } = await runEngine("vibecoding-helper", ["kce-status"], { timeoutMs: 60_000 });
+    if (code !== 0) {
+        throw new Error(`kce-status failed: ${stderr || `exit_code=${code}`}`);
+    }
+    const parsed = safeJsonParse(stdout);
+    if (!parsed.ok)
+        throw new Error(`kce-status invalid_json: ${parsed.error}`);
+    const validated = KceStatusSchema.safeParse(parsed.value);
+    if (!validated.success)
+        throw new Error("kce-status schema mismatch");
+    return validated.data;
+}
+export async function runKceSync(args) {
+    const cmd = ["kce-sync"];
+    if (args.prune)
+        cmd.push("--prune");
+    if (args.skipMissingRoots)
+        cmd.push("--skip-missing-roots");
+    if (args.forceFull)
+        cmd.push("--force-full");
+    const { code, stdout, stderr } = await runEngine("vibecoding-helper", cmd, {
+        timeoutMs: Math.max(60_000, args.timeoutMs ?? 300_000)
+    });
+    if (code !== 0) {
+        throw new Error(`kce-sync failed: ${stderr || `exit_code=${code}`}`);
+    }
+    const parsed = safeJsonParse(stdout);
+    if (!parsed.ok)
+        throw new Error(`kce-sync invalid_json: ${parsed.error}`);
+    const validated = KceStatusSchema.safeParse(parsed.value);
+    if (!validated.success)
+        throw new Error("kce-sync schema mismatch");
+    return validated.data;
+}
+export async function runKceRetrieve(args) {
+    const cmd = [
+        "kce-retrieve",
+        "--query",
+        args.query,
+        "--limit",
+        String(Math.max(1, Math.min(20, args.limit ?? 10))),
+        "--max-items",
+        String(Math.max(1, Math.min(10, args.maxItems ?? 6))),
+        "--max-total-chars",
+        String(Math.max(500, Math.min(20_000, args.maxTotalChars ?? 6000))),
+        "--max-chunk-chars",
+        String(Math.max(200, Math.min(4000, args.maxChunkChars ?? 1200)))
+    ];
+    if (args.pathPrefix)
+        cmd.push("--path-prefix", args.pathPrefix);
+    const { code, stdout, stderr } = await runEngine("vibecoding-helper", cmd, { timeoutMs: 60_000 });
+    if (code !== 0) {
+        throw new Error(`kce-retrieve failed: ${stderr || `exit_code=${code}`}`);
+    }
+    const parsed = safeJsonParse(stdout);
+    if (!parsed.ok)
+        throw new Error(`kce-retrieve invalid_json: ${parsed.error}`);
+    const validated = KceRetrieveOutputSchema.safeParse(parsed.value);
+    if (!validated.success)
+        throw new Error("kce-retrieve schema mismatch");
+    return validated.data;
+}
+export async function kcePreflight(args) {
+    const key = inFlightKey({ basePath: args.basePath, run_id: args.run_id, purpose: args.purpose });
+    const existing = inFlight.get(key);
+    if (existing)
+        return existing;
+    const promise = (async () => {
+        const eventsPath = args.writeEvidence && args.run_id ? kceEventsPath(args.run_id, args.basePath) : null;
+        let loggedOutcome = false;
+        try {
+            let status = await runKceStatus();
+            if (status.readiness_state === "HEALING") {
+                const needsBootstrap = Array.isArray(status.issues) && status.issues.some((i) => typeof i === "string" && i.startsWith("chroma_unavailable"));
+                const syncTimeoutMs = needsBootstrap ? 900_000 : 300_000;
+                if (eventsPath) {
+                    tryAppendJsonl(eventsPath, {
+                        ts: new Date().toISOString(),
+                        event: "KCE_SYNC",
+                        phase: "start",
+                        prune: true,
+                        skip_missing_roots: true,
+                        force_full: false,
+                        timeout_ms: syncTimeoutMs
+                    });
+                }
+                status = await runKceSync({
+                    prune: true,
+                    skipMissingRoots: true,
+                    forceFull: false,
+                    timeoutMs: syncTimeoutMs
+                });
+                if (eventsPath) {
+                    tryAppendJsonl(eventsPath, {
+                        ts: new Date().toISOString(),
+                        event: "KCE_SYNC",
+                        phase: "finish",
+                        readiness_state: status.readiness_state,
+                        issues: status.issues ?? []
+                    });
+                }
+            }
+            if (args.writeEvidence && args.run_id) {
+                const dir = kceEvidenceDir(args.run_id, args.basePath);
+                if (dir) {
+                    tryWriteJson(path.join(dir, "kce_status.json"), status);
+                }
+            }
+            if (eventsPath) {
+                tryAppendJsonl(eventsPath, {
+                    ts: new Date().toISOString(),
+                    event: "KCE_PREFLIGHT",
+                    purpose: args.purpose,
+                    readiness_state: status.readiness_state,
+                    issues: status.issues ?? []
+                });
+                loggedOutcome = true;
+            }
+            if (status.readiness_state !== "READY") {
+                const why = status.issues?.slice(0, 3).join("; ") || "unknown";
+                throw new Error(`KCE_NOT_READY: ${why}`);
+            }
+            return status;
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            if (eventsPath && !loggedOutcome) {
+                tryAppendJsonl(eventsPath, {
+                    ts: new Date().toISOString(),
+                    event: "KCE_PREFLIGHT",
+                    purpose: args.purpose,
+                    error: msg
+                });
+            }
+            throw e;
+        }
+    })();
+    inFlight.set(key, promise);
+    promise.finally(() => inFlight.delete(key)).catch(() => { });
+    return promise;
+}

package/build/tools/vibe_pm/local_memory.js

@@ -0,0 +1,26 @@
+// adapters/mcp-ts/src/tools/vibe_pm/local_memory.ts
+// Internal helper: best-effort Local Memory reference injection (client-agnostic)
+import { runKceRetrieve, runKceStatus } from "./kce/preflight.js";
+export async function maybeGetLocalMemoryContextBlock(args) {
+    const query = (args.query ?? "").trim();
+    if (!query)
+        return null;
+    // Avoid expensive fallback scans: only inject when KCE is READY.
+    try {
+        const status = await runKceStatus();
+        if (status.readiness_state !== "READY")
+            return null;
+    }
+    catch {
+        return null;
+    }
+    try {
+        const maxItems = Math.max(1, Math.min(5, args.maxItems ?? 3));
+        const out = await runKceRetrieve({ query, maxItems, limit: 10, maxTotalChars: 4000, maxChunkChars: 900 });
+        const block = out.context_block.trim();
+        return block ? block : null;
+    }
+    catch {
+        return null;
+    }
+}

package/build/tools/vibe_pm/memory_status.js

@@ -0,0 +1,82 @@
+// adapters/mcp-ts/src/tools/vibe_pm/memory_status.ts
+// vibe_pm.memory_status - Local Memory status (ChromaDB index readiness)
+import { runEngine } from "../../engine.js";
+import { safeJsonParse } from "../../cli.js";
+import { validateToolInput } from "../../security/input-validator.js";
+import { resolveProjectId } from "./context.js";
+import { MemoryStatusOutputSchema } from "../../generated/memory_status_output.js";
+function isOfflineMode() {
+    const v = (process.env.VIBECODE_OFFLINE ?? "").trim().toLowerCase();
+    return v === "1" || v === "true" || v === "yes" || v === "on";
+}
+function defaultPersistDir() {
+    return ".vibe/chroma";
+}
+/**
+ * vibe_pm.memory_status - Local Memory readiness check
+ *
+ * Internal mapping:
+ *   → vibecoding-helper memory-status --project-id ... --docs-root ... --persist-dir ...
+ */
+export async function memoryStatus(input) {
+    const basePath = process.cwd();
+    validateToolInput({
+        project_id: input.project_id,
+        custom_input: input.docs_root,
+    });
+    const project_id = input.project_id ?? resolveProjectId(undefined, basePath);
+    const docsRoot = (input.docs_root ?? "docs").trim();
+    const persistDir = (input.persist_dir ?? defaultPersistDir()).trim();
+    try {
+        const args = ["memory-status", "--project-id", project_id, "--docs-root", docsRoot, "--persist-dir", persistDir];
+        const { code, stdout, stderr } = await runEngine("vibecoding-helper", args, { timeoutMs: 60_000 });
+        if (code !== 0) {
+            return MemoryStatusOutputSchema.parse({
+                project_id,
+                status: "ERROR",
+                summary: "Local Memory 상태 확인에 실패했습니다.",
+                docs_root: docsRoot,
+                persist_dir: persistDir,
+                collection: "vibe_docs",
+                stats: { document_count: 0, chunk_count: 0, last_sync_at: null },
+                embedding: { backend: "unknown", model: null, ready: false },
+                offline_mode: isOfflineMode(),
+                issues: [stderr?.trim() ? `engine_error: ${stderr.trim()}` : `engine_exit_code: ${code}`],
+                next_action: { tool: "vibe_pm.doctor", reason: "설치/환경 상태를 점검하겠습니다." }
+            });
+        }
+        const parsed = safeJsonParse(stdout);
+        if (!parsed.ok) {
+            return MemoryStatusOutputSchema.parse({
+                project_id,
+                status: "ERROR",
+                summary: "Local Memory 상태 응답을 해석할 수 없습니다.",
+                docs_root: docsRoot,
+                persist_dir: persistDir,
+                collection: "vibe_docs",
+                stats: { document_count: 0, chunk_count: 0, last_sync_at: null },
+                embedding: { backend: "unknown", model: null, ready: false },
+                offline_mode: isOfflineMode(),
+                issues: [`invalid_json: ${parsed.error}`],
+                next_action: { tool: "vibe_pm.doctor", reason: "설치/환경 상태를 점검하겠습니다." }
+            });
+        }
+        return MemoryStatusOutputSchema.parse(parsed.value);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return MemoryStatusOutputSchema.parse({
+            project_id,
+            status: "ERROR",
+            summary: "Local Memory 상태 확인 중 오류가 발생했습니다.",
+            docs_root: docsRoot,
+            persist_dir: persistDir,
+            collection: "vibe_docs",
+            stats: { document_count: 0, chunk_count: 0, last_sync_at: null },
+            embedding: { backend: "unknown", model: null, ready: false },
+            offline_mode: isOfflineMode(),
+            issues: [msg],
+            next_action: { tool: "vibe_pm.doctor", reason: "설치/환경 상태를 점검하겠습니다." }
+        });
+    }
+}