@vibecodetown/mcp-server 2.1.0

package/build/tools/vibe_pm/doctor.js

@@ -0,0 +1,262 @@
+// adapters/mcp-ts/src/tools/vibe_pm/doctor.ts
+// vibe_pm.doctor - Installation health check and auto-repair
+import { DoctorInputSchema } from "../../generated/doctor_input.js";
+import { doctor as runDoctor, healthCheck, checkForUpdates } from "../../bootstrap/doctor.js";
+import { CONTRACTS_BUNDLE_SHA256, CONTRACTS_SCHEMA_COUNT, CONTRACTS_VERSION } from "../../generated/contracts_bundle_info.js";
+import { getAuthGate } from "../../auth/index.js";
+import { resolveProjectId } from "./context.js";
+import { memoryStatus } from "./memory_status.js";
+import { memorySync } from "./memory_sync.js";
+// ============================================================
+// Input/Output Types
+// ============================================================
+export { DoctorInputSchema };
+// ============================================================
+// Status Mapping (PM Language)
+// ============================================================
+function mapEngineStatus(status) {
+    switch (status) {
+        case "ok":
+            return "정상";
+        case "needs_update":
+            return "업데이트 필요";
+        case "missing":
+            return "설치 필요";
+        case "corrupted":
+            return "손상됨";
+    }
+}
+// ============================================================
+// Doctor Implementation
+// ============================================================
+/**
+ * vibe_pm.doctor - Installation health check and auto-repair
+ *
+ * PM-friendly description:
+ * 설치 상태를 점검하고 문제가 있으면 자동으로 수정합니다.
+ */
+export async function doctor(input) {
+    const autoFix = input.auto_fix ?? true;
+    const actionsTaken = [];
+    const basePath = process.cwd();
+    const contracts = {
+        version: CONTRACTS_VERSION,
+        bundle_sha256: CONTRACTS_BUNDLE_SHA256,
+        schema_count: CONTRACTS_SCHEMA_COUNT
+    };
+    async function getLocalMemoryStatus() {
+        try {
+            const projectId = resolveProjectId(undefined, basePath);
+            return await memoryStatus({
+                project_id: projectId,
+                docs_root: "docs",
+                persist_dir: ".vibe/chroma"
+            });
+        }
+        catch {
+            return null;
+        }
+    }
+    try {
+        // Step 1: Quick health check
+        const quickCheck = await healthCheck();
+        if (quickCheck.status === "OK") {
+            // All good, return immediately
+            const engines = quickCheck.engines.map((e) => ({
+                name: e.name,
+                status: mapEngineStatus(e.status),
+                version: e.version,
+                current_version: e.currentVersion
+            }));
+            // Local Memory check (best-effort)
+            let localMemory = await getLocalMemoryStatus();
+            if (autoFix && localMemory?.status === "NEEDS_SYNC") {
+                try {
+                    const gate = getAuthGate();
+                    const allowed = await gate.check("local_memory_pro_tools");
+                    if (allowed.allowed) {
+                        actionsTaken.push("Local Memory 갱신 시도");
+                        const projectId = resolveProjectId(undefined, basePath);
+                        const syncRes = await memorySync({
+                            project_id: projectId,
+                            docs_root: "docs",
+                            mode: "on_demand",
+                            force_full: false
+                        });
+                        actionsTaken.push(`Local Memory 결과: ${syncRes.status}`);
+                        localMemory = await getLocalMemoryStatus();
+                    }
+                }
+                catch {
+                    // ignore
+                }
+            }
+            if (localMemory && localMemory.status !== "READY") {
+                const msg = localMemory.status === "NEEDS_SYNC"
+                    ? "Local Memory 갱신이 필요합니다. vibe_pm.memory_sync를 실행해 보세요."
+                    : localMemory.status === "OFFLINE_NO_INDEX"
+                        ? "오프라인 모드라 Local Memory 인덱스를 만들 수 없습니다. 온라인 환경에서 한 번 동기화가 필요합니다."
+                        : "Local Memory 설치/환경 상태를 확인해 주세요.";
+                return {
+                    status: "NEEDS_ATTENTION",
+                    contracts,
+                    summary: "엔진은 정상입니다. 다만 Local Memory 준비가 필요합니다.",
+                    engines,
+                    local_memory: localMemory,
+                    actions_taken: actionsTaken.length > 0 ? actionsTaken : undefined,
+                    next_action: {
+                        type: "MANUAL_FIX",
+                        message: msg
+                    }
+                };
+            }
+            return {
+                status: "OK",
+                contracts,
+                summary: "모든 엔진이 정상적으로 설치되어 있습니다.",
+                engines,
+                local_memory: localMemory,
+                actions_taken: actionsTaken.length > 0 ? actionsTaken : undefined,
+                next_action: {
+                    type: "NONE",
+                    message: "추가 조치가 필요하지 않습니다."
+                }
+            };
+        }
+        // Step 2: Issues found - check details
+        const updateCheck = await checkForUpdates();
+        if (autoFix) {
+            // Step 3: Auto-fix by running full doctor
+            actionsTaken.push("설치 상태 점검 시작");
+            const doctorResult = await runDoctor();
+            // Map results
+            const engines = Object.entries(doctorResult.engines).map(([name, info]) => ({
+                name,
+                status: mapEngineStatus(info.status),
+                version: info.version,
+                current_version: info.currentVersion
+            }));
+            if (doctorResult.status === "OK") {
+                actionsTaken.push("문제 자동 수정 완료");
+                // Local Memory check (best-effort)
+                let localMemory = await getLocalMemoryStatus();
+                if (localMemory?.status === "NEEDS_SYNC") {
+                    try {
+                        const gate = getAuthGate();
+                        const allowed = await gate.check("local_memory_pro_tools");
+                        if (allowed.allowed) {
+                            actionsTaken.push("Local Memory 갱신 시도");
+                            const projectId = resolveProjectId(undefined, basePath);
+                            const syncRes = await memorySync({
+                                project_id: projectId,
+                                docs_root: "docs",
+                                mode: "on_demand",
+                                force_full: false
+                            });
+                            actionsTaken.push(`Local Memory 결과: ${syncRes.status}`);
+                            localMemory = await getLocalMemoryStatus();
+                        }
+                    }
+                    catch {
+                        // ignore
+                    }
+                }
+                if (localMemory && localMemory.status !== "READY") {
+                    const msg = localMemory.status === "NEEDS_SYNC"
+                        ? "Local Memory 갱신이 필요합니다. vibe_pm.memory_sync를 실행해 보세요."
+                        : localMemory.status === "OFFLINE_NO_INDEX"
+                            ? "오프라인 모드라 Local Memory 인덱스를 만들 수 없습니다. 온라인 환경에서 한 번 동기화가 필요합니다."
+                            : "Local Memory 설치/환경 상태를 확인해 주세요.";
+                    return {
+                        status: "NEEDS_ATTENTION",
+                        contracts,
+                        summary: "엔진은 정상입니다. 다만 Local Memory 준비가 필요합니다.",
+                        engines,
+                        actions_taken: actionsTaken,
+                        local_memory: localMemory,
+                        next_action: {
+                            type: "MANUAL_FIX",
+                            message: msg
+                        }
+                    };
+                }
+                return {
+                    status: "FIXED",
+                    contracts,
+                    summary: "문제를 발견하고 자동으로 수정했습니다.",
+                    engines,
+                    actions_taken: actionsTaken,
+                    local_memory: localMemory,
+                    next_action: {
+                        type: "NONE",
+                        message: "모든 문제가 해결되었습니다."
+                    }
+                };
+            }
+            // Some issues couldn't be fixed
+            if (doctorResult.status === "NEEDS_UPDATE") {
+                const localMemory = await getLocalMemoryStatus();
+                return {
+                    status: "NEEDS_ATTENTION",
+                    contracts,
+                    summary: "일부 엔진 업데이트가 필요합니다.",
+                    engines,
+                    actions_taken: actionsTaken,
+                    local_memory: localMemory,
+                    next_action: {
+                        type: "MANUAL_FIX",
+                        message: "vibe_pm.update 도구를 실행하여 업데이트하세요."
+                    }
+                };
+            }
+            // Error state
+            const localMemory = await getLocalMemoryStatus();
+            return {
+                status: "ERROR",
+                contracts,
+                summary: doctorResult.error ?? "알 수 없는 오류가 발생했습니다.",
+                engines,
+                actions_taken: actionsTaken,
+                local_memory: localMemory,
+                next_action: {
+                    type: "CONTACT_SUPPORT",
+                    message: "문제가 지속되면 지원팀에 문의하세요."
+                }
+            };
+        }
+        // Auto-fix disabled - just report
+        const engines = quickCheck.engines.map((e) => ({
+            name: e.name,
+            status: mapEngineStatus(e.status),
+            version: e.version,
+            current_version: e.currentVersion
+        }));
+        const issueCount = engines.filter((e) => e.status !== "정상").length;
+        const localMemory = await getLocalMemoryStatus();
+        return {
+            status: "NEEDS_ATTENTION",
+            contracts,
+            summary: `${issueCount}개의 엔진에 문제가 있습니다.`,
+            engines,
+            local_memory: localMemory,
+            next_action: {
+                type: "MANUAL_FIX",
+                message: "auto_fix: true로 다시 실행하여 자동 수정하세요."
+            }
+        };
+    }
+    catch (e) {
+        const localMemory = await getLocalMemoryStatus();
+        return {
+            status: "ERROR",
+            contracts,
+            summary: e instanceof Error ? e.message : "알 수 없는 오류",
+            engines: [],
+            local_memory: localMemory,
+            next_action: {
+                type: "CONTACT_SUPPORT",
+                message: "설치 점검 중 오류가 발생했습니다. 지원팀에 문의하세요."
+            }
+        };
+    }
+}

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

@@ -0,0 +1,78 @@
+// adapters/mcp-ts/src/tools/vibe_pm/entity_gate/preflight.ts
+// Internal: Entity Gate runner (schema + rules) + 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 EntityGateReportSchema = z.object({
+    status: z.enum(["OK", "FAIL"]),
+    errors: z.array(z.string()),
+    entity_files: z.number().int().nonnegative().optional()
+});
+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
+    }
+}
+function tryAppendJsonl(pathAbs, record) {
+    try {
+        fs.mkdirSync(path.dirname(pathAbs), { recursive: true });
+        fs.appendFileSync(pathAbs, JSON.stringify(record) + "\n", "utf-8");
+    }
+    catch {
+        // ignore
+    }
+}
+function kceEventsPath(run_id, basePath) {
+    const resolved = resolveRunDir(run_id, basePath);
+    if (!resolved)
+        return null;
+    return path.join(resolved.run_dir, "kce", "kce_events.jsonl");
+}
+export async function runEntityGate(args) {
+    const eventsPath = args.writeEvidence && args.run_id ? kceEventsPath(args.run_id, args.basePath) : null;
+    try {
+        const { code, stdout, stderr } = await runEngine("vibecoding-helper", ["entity-gate"], { timeoutMs: 60_000 });
+        if (code !== 0 && !stdout.trim()) {
+            throw new Error(`entity-gate failed: ${stderr || `exit_code=${code}`}`);
+        }
+        const parsed = safeJsonParse(stdout);
+        if (!parsed.ok)
+            throw new Error(`entity-gate invalid_json: ${parsed.error}`);
+        const validated = EntityGateReportSchema.safeParse(parsed.value);
+        if (!validated.success)
+            throw new Error("entity-gate schema mismatch");
+        const report = validated.data;
+        if (args.writeEvidence && args.run_id) {
+            const resolved = resolveRunDir(args.run_id, args.basePath);
+            if (resolved) {
+                tryWriteJson(path.join(resolved.run_dir, "kce", "entity_gate_report.json"), report);
+            }
+        }
+        if (eventsPath) {
+            tryAppendJsonl(eventsPath, {
+                ts: new Date().toISOString(),
+                event: report.status === "OK" ? "ENTITY_GATE_OK" : "ENTITY_GATE_FAIL",
+                errors_count: report.errors?.length ?? 0
+            });
+        }
+        return report;
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        if (eventsPath) {
+            tryAppendJsonl(eventsPath, {
+                ts: new Date().toISOString(),
+                event: "ENTITY_GATE_FAIL",
+                error: msg
+            });
+        }
+        throw e;
+    }
+}

package/build/tools/vibe_pm/export_output.js

@@ -0,0 +1,135 @@
+// adapters/mcp-ts/src/tools/vibe_pm/export_output.ts
+// vibe_pm.export_output - Export a feature into a chosen output format via Output Adapters
+import * as path from "node:path";
+import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
+import { runEngine } from "../../engine.js";
+import { safeJsonParse } from "../../cli.js";
+import { validateToolInput } from "../../security/input-validator.js";
+import { isPathForbidden, validatePath } from "../../security/path-policy.js";
+import { resolveProjectId, resolveRunId, resolveRunDir } from "./context.js";
+function normalizeRelPosix(p) {
+    return p.replace(/\\/g, "/").replace(/^\/+/, "");
+}
+function resolveDefaultOutputDir(target) {
+    const t = (target ?? "").trim();
+    return t ? `export/${t}` : "export/out";
+}
+function featureSpecPath(runDirAbs) {
+    return path.join(runDirAbs, "export", "feature_output_spec.json");
+}
+function exportPlanPath(runDirAbs) {
+    return path.join(runDirAbs, "export", "export_plan.json");
+}
+function exportArtifactsPath(runDirAbs) {
+    return path.join(runDirAbs, "export", "export_artifacts.json");
+}
+export async function exportOutput(input) {
+    const basePath = process.cwd();
+    validateToolInput({ project_id: input.project_id, run_id: input.run_id });
+    const resolvedRun = resolveRunId(input.run_id ?? input.project_id, basePath);
+    const run_id = resolvedRun.run_id;
+    const project_id = resolveProjectId(run_id, basePath);
+    const resolved = resolveRunDir(run_id, basePath);
+    if (!resolved) {
+        throw new McpError(ErrorCode.InvalidParams, "Run not found.");
+    }
+    const runDirAbs = resolved.run_dir;
+    const specAbs = featureSpecPath(runDirAbs);
+    const target = String(input.target ?? "").trim();
+    if (!target) {
+        throw new McpError(ErrorCode.InvalidParams, "[VALIDATION] target is required");
+    }
+    const outputDirInput = (input.output_dir ?? "").trim() || resolveDefaultOutputDir(target);
+    const outputDirAbs = validatePath(outputDirInput, basePath);
+    const outputDirRel = normalizeRelPosix(path.relative(basePath, outputDirAbs));
+    const forbid = isPathForbidden(outputDirRel);
+    if (forbid.forbidden) {
+        throw new McpError(ErrorCode.InvalidParams, "Forbidden export output_dir.", {
+            category: "SECURITY",
+            context: { path: outputDirRel, zone: forbid.zone, reason: forbid.reason },
+            recovery: "Choose a different output directory inside the project."
+        });
+    }
+    const cliLanguage = input.cli_language ?? "python";
+    const dryRun = Boolean(input.dry_run);
+    const templateRepo = typeof input.template_pin?.repo === "string" ? input.template_pin.repo.trim() : "";
+    const templateRef = typeof input.template_pin?.ref === "string" ? input.template_pin.ref.trim() : "";
+    const needsTemplatePin = target === "web_template_repo";
+    const planCmd = ["export-plan", run_id, "--target", target, "--output-dir", outputDirRel, "--cli-language", cliLanguage];
+    if (needsTemplatePin) {
+        if (!templateRepo || !templateRef) {
+            throw new McpError(ErrorCode.InvalidParams, "[VALIDATION] template_pin.repo/ref is required for target=web_template_repo");
+        }
+        planCmd.push("--template-repo", templateRepo, "--template-ref", templateRef);
+    }
+    if (dryRun)
+        planCmd.push("--dry-run");
+    const planRes = await runEngine("vibecoding-helper", planCmd, { timeoutMs: 120_000 });
+    if (planRes.code !== 0) {
+        throw new Error(`export-plan failed: ${planRes.stderr || `exit_code=${planRes.code}`}`);
+    }
+    const planParsed = safeJsonParse(planRes.stdout);
+    if (!planParsed.ok) {
+        throw new Error(`export-plan invalid_json: ${planParsed.error}`);
+    }
+    const warnings = [];
+    if (Array.isArray(planParsed.value?.warnings)) {
+        for (const w of planParsed.value.warnings) {
+            if (typeof w === "string" && w.trim())
+                warnings.push(w.trim());
+        }
+    }
+    const createdPaths = [];
+    let artifactsPathRel;
+    if (!dryRun) {
+        const genCmd = [
+            "export-generate",
+            run_id,
+            "--target",
+            target,
+            "--output-dir",
+            outputDirRel,
+            "--cli-language",
+            cliLanguage
+        ];
+        if (needsTemplatePin)
+            genCmd.push("--template-repo", templateRepo, "--template-ref", templateRef);
+        const genRes = await runEngine("vibecoding-helper", genCmd, { timeoutMs: 300_000 });
+        if (genRes.code !== 0) {
+            throw new Error(`export-generate failed: ${genRes.stderr || `exit_code=${genRes.code}`}`);
+        }
+        const genParsed = safeJsonParse(genRes.stdout);
+        if (!genParsed.ok) {
+            throw new Error(`export-generate invalid_json: ${genParsed.error}`);
+        }
+        const files = genParsed.value?.files;
+        if (Array.isArray(files)) {
+            for (const f of files) {
+                const p = typeof f?.path === "string" ? f.path : "";
+                if (p)
+                    createdPaths.push(normalizeRelPosix(p));
+            }
+        }
+        artifactsPathRel = normalizeRelPosix(path.relative(basePath, exportArtifactsPath(runDirAbs)));
+    }
+    const out = {
+        success: true,
+        project_id,
+        run_id,
+        target,
+        output_dir: outputDirRel,
+        dry_run: dryRun,
+        paths: {
+            feature_output_spec_path: normalizeRelPosix(path.relative(basePath, specAbs)),
+            export_plan_path: normalizeRelPosix(path.relative(basePath, exportPlanPath(runDirAbs))),
+            export_artifacts_path: artifactsPathRel
+        },
+        created_paths: createdPaths,
+        warnings,
+        next_action: {
+            tool: "vibe_pm.status",
+            reason: "Review the export outputs and continue."
+        }
+    };
+    return out;
+}