@vibecodetown/mcp-server 2.1.0

package/build/tools.js

@@ -0,0 +1,269 @@
+// adapters/mcp-ts/src/tools.ts
+// MCP tool definitions using bootstrap-based engine execution
+import { z } from "zod";
+import { safeJsonParse } from "./cli.js";
+import { parseSelectionValidationResult } from "./contracts.js";
+import { runEngine } from "./engine.js";
+import { doctor as doctorImpl } from "./bootstrap/doctor.js";
+import { ToolErrorOutputSchema } from "./generated/tool_error_output.js";
+function toolText(obj) {
+    return { content: [{ type: "text", text: JSON.stringify(obj, null, 2) }] };
+}
+function err(reason, extra) {
+    const out = ToolErrorOutputSchema.parse({
+        status: "ERROR",
+        reason,
+        message: extra?.message ?? "요청을 처리하는 중 문제가 생겼습니다.",
+        recovery: extra?.recovery,
+        is_retryable: extra?.is_retryable,
+        details: extra?.details,
+        debug: extra?.debug
+    });
+    return {
+        content: [{ type: "text", text: JSON.stringify(out, null, 2) }],
+        structuredContent: out,
+        isError: true
+    };
+}
+export function defineTools() {
+    // ---------- vibecode.doctor ----------
+    const doctorInput = z.object({});
+    async function vibecodeDoctor(_input) {
+        try {
+            return toolText(await doctorImpl());
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            return err("unknown", { message: msg });
+        }
+    }
+    // ---------- vibecode.one_loop (PRIMARY) ----------
+    const oneLoopInput = z.object({
+        run_id: z.string().default("default"),
+        output: z.enum(["selection"]).default("selection"),
+        timeout_ms: z.number().int().positive().optional()
+    });
+    async function vibecodeOneLoop(input) {
+        try {
+            const { code, stdout, stderr } = await runEngine("vibecoding-helper", ["one-loop", input.run_id, "--output", input.output], { timeoutMs: input.timeout_ms ?? 120_000 });
+            const parsed = safeJsonParse(stdout);
+            if (!parsed.ok) {
+                return err("invalid_json", {
+                    message: parsed.error,
+                    recovery: "도구를 업데이트한 뒤 다시 시도해 주세요.",
+                    is_retryable: true,
+                    details: { exit_code: code },
+                    debug: { stdout, stderr }
+                });
+            }
+            try {
+                const validated = parseSelectionValidationResult(parsed.value);
+                return toolText(validated);
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                return err("schema_mismatch", {
+                    message: msg,
+                    recovery: "도구를 업데이트한 뒤 다시 시도해 주세요.",
+                    is_retryable: true,
+                    details: { exit_code: code },
+                    debug: { stdout, stderr }
+                });
+            }
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            return err("unknown", { message: msg, recovery: "잠시 후 다시 시도해 주세요.", is_retryable: true });
+        }
+    }
+    // ---------- spec_high.validate ----------
+    const validateInput = z.object({
+        run_id: z.string().default("default")
+    });
+    async function specHighValidate(input) {
+        try {
+            const { code, stdout, stderr } = await runEngine("spec-high", ["--root", "engines/spec_high", "validate", input.run_id], { timeoutMs: 120_000 });
+            return toolText({
+                status: code === 0 ? "OK" : "FAIL",
+                exit_code: code,
+                stdout,
+                stderr
+            });
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            return err("unknown", { message: msg });
+        }
+    }
+    // ---------- spec_high.clinic_bridge ----------
+    const bridgeInput = z.object({
+        run_id: z.string().default("default"),
+        format: z.enum(["yaml", "json"]).default("yaml"),
+        timeout_ms: z.number().int().positive().optional()
+    });
+    async function specHighClinicBridge(input) {
+        try {
+            const { code, stdout, stderr } = await runEngine("spec-high", ["--root", "engines/spec_high", "clinic-bridge", input.run_id, "--write", "--format", input.format], { timeoutMs: input.timeout_ms ?? 120_000 });
+            const bridge_path = input.format === "json"
+                ? `engines/spec_high/runs/${input.run_id}/handoff/clinic_bridge.json`
+                : `engines/spec_high/runs/${input.run_id}/handoff/clinic_bridge.yaml`;
+            return toolText({
+                status: code === 0 ? "OK" : "FAIL",
+                exit_code: code,
+                bridge_path,
+                stdout,
+                stderr
+            });
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            return err("unknown", { message: msg });
+        }
+    }
+    // ---------- spec_high.quality_eval ----------
+    const qualityInput = z.object({
+        run_id: z.string().default("default"),
+        timeout_ms: z.number().int().positive().optional()
+    });
+    async function specHighQualityEval(input) {
+        try {
+            const { code, stdout, stderr } = await runEngine("spec-high", ["--root", "engines/spec_high", "quality-eval", input.run_id, "--write"], { timeoutMs: input.timeout_ms ?? 120_000 });
+            return toolText({
+                status: code === 0 ? "OK" : "FAIL",
+                exit_code: code,
+                quality_report_path: `engines/spec_high/runs/${input.run_id}/quality/quality_report.json`,
+                stdout,
+                stderr
+            });
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            return err("unknown", { message: msg });
+        }
+    }
+    // ---------- vibecode.show_ask_queue ----------
+    const askQueueInput = z.object({
+        run_id: z.string().default("default"),
+        timeout_ms: z.number().int().positive().optional()
+    });
+    async function vibecodeShowAskQueue(input) {
+        try {
+            const { code, stdout, stderr } = await runEngine("vibecoding-helper", ["show-ask-queue", input.run_id], { timeoutMs: input.timeout_ms ?? 60_000 });
+            return toolText({
+                status: code === 0 ? "OK" : "FAIL",
+                exit_code: code,
+                text: stdout.trim(),
+                stderr
+            });
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            return err("unknown", { message: msg });
+        }
+    }
+    // ---------- vibecode.show_decisions ----------
+    const showDecisionsInput = z.object({
+        run_id: z.string().default("default"),
+        timeout_ms: z.number().int().positive().optional()
+    });
+    async function vibecodeShowDecisions(input) {
+        try {
+            const { code, stdout, stderr } = await runEngine("vibecoding-helper", ["show-decisions", input.run_id], { timeoutMs: input.timeout_ms ?? 60_000 });
+            return toolText({
+                status: code === 0 ? "OK" : "FAIL",
+                exit_code: code,
+                summary_markdown: stdout.trim(),
+                stderr
+            });
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            return err("unknown", { message: msg });
+        }
+    }
+    // ---------- vibecode.answer ----------
+    const answerInput = z.object({
+        run_id: z.string().default("default"),
+        text: z.string(),
+        timeout_ms: z.number().int().positive().optional()
+    });
+    async function vibecodeAnswer(input) {
+        try {
+            const { code, stdout, stderr } = await runEngine("vibecoding-helper", ["answer", input.run_id, "--text", input.text], { timeoutMs: input.timeout_ms ?? 120_000 });
+            return toolText({
+                status: code === 0 ? "OK" : "FAIL",
+                exit_code: code,
+                stdout: stdout.trim(),
+                stderr
+            });
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            return err("unknown", { message: msg });
+        }
+    }
+    // ---------- clinic.verify ----------
+    const clinicVerifyInput = z.object({
+        run_id: z.string().default("default"),
+        bridge_path: z.string(),
+        timeout_ms: z.number().int().positive().optional()
+    });
+    async function clinicVerify(input) {
+        try {
+            const resultPath = `runs/${input.run_id}/clinic/result.json`;
+            const { code, stdout, stderr } = await runEngine("clinic", ["selection-validate", "--bridge", input.bridge_path], { timeoutMs: input.timeout_ms ?? 180_000 });
+            return toolText({
+                status: code === 0 ? "OK" : "FAIL",
+                exit_code: code,
+                result_path: resultPath,
+                stdout: stdout.trim(),
+                stderr
+            });
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            return err("unknown", { message: msg });
+        }
+    }
+    // ---------- clinic.report_latest ----------
+    const clinicReportInput = z.object({
+        timeout_ms: z.number().int().positive().optional()
+    });
+    async function clinicReportLatest(input) {
+        try {
+            const { code, stdout, stderr } = await runEngine("clinic", ["report", "--latest"], { timeoutMs: input.timeout_ms ?? 60_000 });
+            return toolText({
+                status: code === 0 ? "OK" : "FAIL",
+                exit_code: code,
+                text: stdout.trim(),
+                stderr
+            });
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            return err("unknown", { message: msg });
+        }
+    }
+    return {
+        doctorInput,
+        vibecodeDoctor,
+        oneLoopInput,
+        vibecodeOneLoop,
+        validateInput,
+        specHighValidate,
+        bridgeInput,
+        specHighClinicBridge,
+        qualityInput,
+        specHighQualityEval,
+        askQueueInput,
+        vibecodeShowAskQueue,
+        showDecisionsInput,
+        vibecodeShowDecisions,
+        answerInput,
+        vibecodeAnswer,
+        clinicVerifyInput,
+        clinicVerify,
+        clinicReportInput,
+        clinicReportLatest
+    };
+}

package/build/version-check.js

@@ -0,0 +1,239 @@
+// adapters/mcp-ts/src/version-check.ts
+// CLI 진입 훅: 자동 업데이트 체크
+// 정책: 절대 실행을 막지 않는다 (모든 실패는 GO)
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import readline from "node:readline";
+function execGit(args, cwd) {
+    const r = spawnSync("git", args, { cwd, encoding: "utf-8", timeout: 10000 });
+    return {
+        status: r.status,
+        stdout: r.stdout ?? "",
+        stderr: r.stderr ?? "",
+    };
+}
+function repoRootOrNull(cwd) {
+    const r = execGit(["rev-parse", "--show-toplevel"], cwd);
+    if (r.status !== 0)
+        return null;
+    return r.stdout.trim() || null;
+}
+function readLocalVersion(repoRoot) {
+    const p = path.join(repoRoot, ".vibe", "version.json");
+    if (!fs.existsSync(p))
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(p, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function readAutoUpdatePolicy(repoRoot) {
+    const p = path.join(repoRoot, ".vibe", "config.json");
+    if (!fs.existsSync(p))
+        return "prompt";
+    try {
+        const raw = JSON.parse(fs.readFileSync(p, "utf-8"));
+        const v = raw?.policy?.auto_update_on_start;
+        if (v === "off" || v === "prompt" || v === "silent")
+            return v;
+        return "prompt";
+    }
+    catch {
+        return "prompt";
+    }
+}
+function isDirtyTree(repoRoot) {
+    const r = execGit(["status", "--porcelain"], repoRoot);
+    if (r.status !== 0)
+        return null;
+    return r.stdout.trim().length > 0;
+}
+function getDefaultBranch(repoRoot) {
+    // origin/HEAD → origin/main 심볼릭 참조
+    const r = execGit(["symbolic-ref", "refs/remotes/origin/HEAD"], repoRoot);
+    if (r.status !== 0)
+        return "main";
+    const full = r.stdout.trim();
+    const parts = full.split("/");
+    return parts[parts.length - 1] || "main";
+}
+function readRemoteVersion(repoRoot, branch) {
+    // 네트워크 최소화: fetch quiet + git show
+    execGit(["fetch", "--quiet", "origin", branch], repoRoot);
+    const r = execGit(["show", `origin/${branch}:.vibe/version.json`], repoRoot);
+    if (r.status !== 0)
+        return null;
+    try {
+        return JSON.parse(r.stdout);
+    }
+    catch {
+        return null;
+    }
+}
+function compareSemver(a, b) {
+    const pa = a.split(".").map((x) => parseInt(x, 10) || 0);
+    const pb = b.split(".").map((x) => parseInt(x, 10) || 0);
+    for (let i = 0; i < 3; i++) {
+        if ((pa[i] ?? 0) < (pb[i] ?? 0))
+            return -1;
+        if ((pa[i] ?? 0) > (pb[i] ?? 0))
+            return 1;
+    }
+    return 0;
+}
+async function promptYesNo(question) {
+    // Non-TTY 환경에서는 자동 스킵
+    if (!process.stdin.isTTY)
+        return false;
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await new Promise((res) => rl.question(question, res));
+    rl.close();
+    const a = answer.trim().toLowerCase();
+    return a === "" || a === "y" || a === "yes";
+}
+/**
+ * CLI 진입 훅: 자동 업데이트 체크
+ *
+ * 정책:
+ * - dirty tree → GO (경고만)
+ * - ff-only 실패 → GO (경고만)
+ * - 네트워크 실패 → GO (조용히 스킵)
+ * - 절대 throw 하지 않음
+ */
+export async function autoUpdateOnStart(opts) {
+    const result = {
+        checked: false,
+        updateAvailable: false,
+        localVersion: null,
+        remoteVersion: null,
+        updated: false,
+        skipped: false,
+    };
+    try {
+        // --no-update 플래그
+        if (opts.noUpdate) {
+            result.skipped = true;
+            result.reason = "noUpdate flag";
+            return result;
+        }
+        // Git 레포 확인
+        const repoRoot = repoRootOrNull(opts.cwd);
+        if (!repoRoot) {
+            result.reason = "not a git repo";
+            return result;
+        }
+        // Config 정책: auto_update_on_start
+        const policy = readAutoUpdatePolicy(repoRoot);
+        const effectiveSilent = opts.silent === true || policy === "silent";
+        if (policy === "off") {
+            result.skipped = true;
+            result.reason = "policy.auto_update_on_start=off";
+            return result;
+        }
+        // 로컬 버전 읽기
+        const local = readLocalVersion(repoRoot);
+        if (!local) {
+            result.reason = "no local version file";
+            return result;
+        }
+        result.localVersion = local.version;
+        // dirty tree 확인
+        const dirty = isDirtyTree(repoRoot);
+        const isDirty = dirty === true;
+        // 원격 버전 조회
+        const branch = getDefaultBranch(repoRoot);
+        const remote = readRemoteVersion(repoRoot, branch);
+        if (!remote) {
+            result.reason = "failed to fetch remote version";
+            return result;
+        }
+        result.remoteVersion = remote.version;
+        result.checked = true;
+        // 버전 비교
+        const versionNewer = compareSemver(remote.version, local.version) > 0;
+        const contractsDiff = remote.contracts.bundle_sha256 !== local.contracts.bundle_sha256;
+        result.updateAvailable = versionNewer || contractsDiff;
+        if (!result.updateAvailable) {
+            result.reason = "already up to date";
+            return result;
+        }
+        // dirty tree면 업데이트 스킵 (경고만)
+        if (isDirty) {
+            if (!effectiveSilent) {
+                console.log(`\u26A0\uFE0F  새 버전 감지됨 (${local.version} → ${remote.version})`);
+                console.log(`\u26A0\uFE0F  로컬 변경사항이 있어 자동 업데이트를 건너뜀 (dirty working tree)`);
+            }
+            result.skipped = true;
+            result.reason = "dirty working tree";
+            return result;
+        }
+        if (policy === "prompt") {
+            // 사용자 확인
+            const ok = await promptYesNo(`\uD83D\uDD04 새 버전 감지됨 (${local.version} → ${remote.version}) 지금 업데이트할까? [Y/n] `);
+            if (!ok) {
+                result.skipped = true;
+                result.reason = "user declined";
+                return result;
+            }
+        }
+        // git pull --ff-only
+        const pull = execGit(["pull", "--ff-only", "origin", branch], repoRoot);
+        if (pull.status === 0) {
+            if (!effectiveSilent) {
+                console.log("\u2705 업데이트 완료");
+            }
+            result.updated = true;
+        }
+        else {
+            if (!effectiveSilent) {
+                console.log("\u26A0\uFE0F  자동 업데이트 실패 (충돌/fast-forward 불가)");
+            }
+            result.skipped = true;
+            result.reason = "ff-only failed";
+        }
+        return result;
+    }
+    catch {
+        // 모든 예외는 GO (조용히 진행)
+        result.reason = "unexpected error";
+        return result;
+    }
+}
+/**
+ * 버전 파일 갱신 (finalize_work / release 시점)
+ */
+export function updateVersionFile(opts) {
+    try {
+        const gitBranch = execGit(["rev-parse", "--abbrev-ref", "HEAD"], opts.repoRoot);
+        const gitCommit = execGit(["rev-parse", "--short", "HEAD"], opts.repoRoot);
+        const dirty = isDirtyTree(opts.repoRoot);
+        const versionFile = {
+            app: "vibe-pm",
+            version: opts.version,
+            channel: opts.channel ?? "stable",
+            git: {
+                branch: gitBranch.stdout.trim() || "unknown",
+                commit: gitCommit.stdout.trim() || "unknown",
+                dirty: dirty === true,
+            },
+            contracts: {
+                bundle_semver: opts.contractsSemver,
+                bundle_sha256: opts.contractsSha256,
+            },
+            updated_at: new Date().toISOString(),
+        };
+        const vibeDir = path.join(opts.repoRoot, ".vibe");
+        if (!fs.existsSync(vibeDir)) {
+            fs.mkdirSync(vibeDir, { recursive: true });
+        }
+        const filePath = path.join(vibeDir, "version.json");
+        fs.writeFileSync(filePath, JSON.stringify(versionFile, null, 2) + "\n", "utf-8");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}