@vibecodetown/mcp-server 2.1.4 → 2.2.1

package/build/tools/vibe_pm/waiter_mapping.js

@@ -0,0 +1,155 @@
+// adapters/mcp-ts/src/tools/vibe_pm/waiter_mapping.ts
+// Waiter(Front) rendering: message_template_id mapping + term dictionary (data-driven)
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { MessageTemplateIdMappingFileSchema } from "../../generated/message_template_id_mapping_file.js";
+let cache = null;
+function packageRoot() {
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    // src/tools/vibe_pm → package root
+    return path.resolve(here, "..", "..", "..");
+}
+function repoRoot(pkgRoot) {
+    // adapters/mcp-ts → repo root
+    return path.resolve(pkgRoot, "..", "..");
+}
+function existsFile(p) {
+    try {
+        return fs.existsSync(p) && fs.statSync(p).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function readJsonFile(p) {
+    const raw = fs.readFileSync(p, "utf-8");
+    return JSON.parse(raw);
+}
+function safeLocaleList(mapping) {
+    const locales = mapping?.supported_locales;
+    return Array.isArray(locales) ? locales.map((x) => String(x).trim()).filter(Boolean) : [];
+}
+function safeDefaultLocale(mapping) {
+    const d = mapping?.default_locale;
+    return typeof d === "string" && d.trim() ? d.trim() : "ko";
+}
+function safeFallbackLocale(mapping) {
+    const f = mapping?.human_language_policy?.fallback_locale;
+    const s = typeof f === "string" && f.trim() ? f.trim() : "";
+    return s || safeDefaultLocale(mapping);
+}
+export function resetWaiterMappingCacheForTest() {
+    cache = null;
+}
+export function getWaiterMapping() {
+    const pkgRoot = packageRoot();
+    const candidates = [
+        path.join(pkgRoot, "assets", "message_template_id_mapping.v1.json"),
+        path.join(repoRoot(pkgRoot), "schemas", "message_template_id_mapping.v1.json")
+    ];
+    for (const p of candidates) {
+        if (!existsFile(p))
+            continue;
+        const mtimeMs = fs.statSync(p).mtimeMs;
+        if (cache && cache.mappingPath === p && cache.mtimeMs === mtimeMs) {
+            return cache.mapping;
+        }
+        const raw = readJsonFile(p);
+        const parsed = MessageTemplateIdMappingFileSchema.parse(raw);
+        cache = { mappingPath: p, mtimeMs, mapping: parsed };
+        return parsed;
+    }
+    // Fail-closed is too harsh for user-facing rendering; fall back to a minimal internal default.
+    const fallback = MessageTemplateIdMappingFileSchema.parse({
+        version: "message_template_id_mapping.v1",
+        default_locale: "ko",
+        supported_locales: ["ko", "en"],
+        templates: {
+            "GO-01": { category: "GO", verdict: { ko: "진행 가능", en: "OK to proceed" }, next_action_prefix: { ko: "다음 단계:", en: "Next:" } },
+            "GO-02": { category: "GO", verdict: { ko: "진행 가능", en: "OK to proceed" }, next_action_prefix: { ko: "다음 단계:", en: "Next:" } },
+            "FIX-01": { category: "FIX", verdict: { ko: "보완 필요", en: "Needs changes" }, next_action_prefix: { ko: "다음 단계:", en: "Next:" } },
+            "FIX-02": { category: "FIX", verdict: { ko: "보완 필요", en: "Needs changes" }, next_action_prefix: { ko: "다음 단계:", en: "Next:" } },
+            "BLOCK-01": { category: "BLOCK", verdict: { ko: "반려", en: "Blocked" }, next_action_prefix: { ko: "다음 단계:", en: "Next:" } },
+            "BLOCK-02": { category: "BLOCK", verdict: { ko: "반려", en: "Blocked" }, next_action_prefix: { ko: "다음 단계:", en: "Next:" } },
+            "TRIAGE-SKIP-01": { category: "TRIAGE", verdict: { ko: "사전 점검 생략", en: "Pre-check skipped" }, next_action_prefix: { ko: "다음 단계:", en: "Next:" } },
+            "TRIAGE-RUN-01": { category: "TRIAGE", verdict: { ko: "사전 점검 실행", en: "Pre-check running" }, next_action_prefix: { ko: "다음 단계:", en: "Next:" } },
+            "TRIAGE-RUN-02": { category: "TRIAGE", verdict: { ko: "사전 점검 실행", en: "Pre-check running" }, next_action_prefix: { ko: "다음 단계:", en: "Next:" } },
+            "ADV-01": { category: "ADVICE", verdict: { ko: "참고", en: "Advice" }, next_action_prefix: { ko: "다음 단계:", en: "Next:" } },
+            "ADV-02": { category: "ADVICE", verdict: { ko: "참고", en: "Advice" }, next_action_prefix: { ko: "다음 단계:", en: "Next:" } },
+            "WARN-01": { category: "WARN", verdict: { ko: "주의", en: "Warning" }, next_action_prefix: { ko: "다음 단계:", en: "Next:" } },
+            "WARN-02": { category: "WARN", verdict: { ko: "주의", en: "Warning" }, next_action_prefix: { ko: "다음 단계:", en: "Next:" } },
+            "SOFTBLOCK-01": { category: "SOFTBLOCK", verdict: { ko: "잠깐 멈춤", en: "Pause" }, next_action_prefix: { ko: "다음 단계:", en: "Next:" } }
+        },
+        term_dictionary: { entries: [{ id: "ENGINE_RUN_ID", aliases: ["run_id"], replacement: { ko: "프로젝트", en: "project" }, category: "engine_term" }] }
+    });
+    cache = { mappingPath: "<fallback>", mtimeMs: 0, mapping: fallback };
+    return fallback;
+}
+export function resolveLocaleFromText(text, mapping = getWaiterMapping()) {
+    const env = (process.env.VIBECODE_LOCALE ?? "").trim();
+    const supported = safeLocaleList(mapping);
+    if (env && supported.includes(env))
+        return env;
+    const hasKo = /[가-힣]/.test(text);
+    if (hasKo && supported.includes("ko"))
+        return "ko";
+    if (!hasKo && supported.includes("en"))
+        return "en";
+    return safeFallbackLocale(mapping);
+}
+export function resolveLocaleFromData(data, mapping = getWaiterMapping()) {
+    const env = (process.env.VIBECODE_LOCALE ?? "").trim();
+    const supported = safeLocaleList(mapping);
+    if (env && supported.includes(env))
+        return env;
+    if (data && typeof data === "object") {
+        const obj = data;
+        const oneLine = obj.review_summary?.one_line_verdict;
+        const msg = typeof oneLine === "string" ? oneLine : typeof obj.message === "string" ? obj.message : "";
+        if (msg)
+            return resolveLocaleFromText(msg, mapping);
+    }
+    return safeFallbackLocale(mapping);
+}
+export function renderVerdictFromTemplateId(templateId, locale, mapping = getWaiterMapping()) {
+    const templates = mapping?.templates ?? {};
+    const t = templates[templateId];
+    if (!t || typeof t !== "object")
+        return null;
+    const verdict = t?.verdict;
+    if (!verdict || typeof verdict !== "object")
+        return null;
+    const v = verdict[locale];
+    if (typeof v === "string" && v.trim())
+        return v.trim();
+    const fallback = safeFallbackLocale(mapping);
+    const vf = verdict[fallback];
+    if (typeof vf === "string" && vf.trim())
+        return vf.trim();
+    return null;
+}
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+export function applyTermDictionary(text, locale, mapping = getWaiterMapping()) {
+    let out = text;
+    const entries = mapping?.term_dictionary?.entries;
+    if (!Array.isArray(entries) || entries.length === 0)
+        return out;
+    for (const e of entries) {
+        const obj = e;
+        const aliases = Array.isArray(obj?.aliases) ? obj.aliases.map((a) => String(a)).filter(Boolean) : [];
+        const rep = obj?.replacement;
+        const replacement = typeof rep === "object" && rep !== null ? String(rep[locale] ?? "").trim() : "";
+        if (!replacement || aliases.length === 0)
+            continue;
+        for (const a of aliases) {
+            const alias = String(a).trim();
+            if (!alias)
+                continue;
+            out = out.replace(new RegExp(escapeRegex(alias), "gi"), replacement);
+        }
+    }
+    return out;
+}

package/build/tools/vibe_pm/zoekt_evidence.js

@@ -1,10 +1,11 @@
 // adapters/mcp-ts/src/tools/vibe_pm/zoekt_evidence.ts
 // vibe_pm.zoekt_evidence - Collect pattern evidence across local roots (zoekt/rg/python_scan)
 import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
-import { runEngine } from "../../engine.js";
+import { runPythonCli } from "../../engine.js";
 import { safeJsonParse } from "../../cli.js";
 import { validateToolInput } from "../../security/input-validator.js";
 import { resolveProjectId, resolveRunId } from "./context.js";
+import { classifyPythonError } from "./python_error.js";
 function toCsv(values) {
     return values
         .map((v) => (typeof v === "string" ? v.trim() : ""))
@@ -43,9 +44,10 @@ export async function zoektEvidence(input) {
     const writeEvidence = input?.write_evidence !== false;
     if (!writeEvidence)
         cmd.push("--no-write-evidence");
-    const res = await runEngine("vibecoding-helper", cmd, { timeoutMs: 300_000 });
+    const res = await runPythonCli(cmd, { timeoutMs: 300_000 });
     if (res.code !== 0) {
-        throw new Error(`zoekt-evidence failed: ${res.stderr || res.stdout || `exit_code=${res.code}`}`);
+        const classified = classifyPythonError(res.stderr ?? "", res.code, "패턴 증거 수집");
+        throw new Error(`${classified.issueCode}: ${classified.summary}`);
     }
     const parsed = safeJsonParse(res.stdout);
     if (!parsed.ok) {

package/build/tools.js

@@ -3,7 +3,7 @@
 import { z } from "zod";
 import { safeJsonParse } from "./cli.js";
 import { parseSelectionValidationResult } from "./contracts.js";
-import { runEngine } from "./engine.js";
+import { runEngine, runPythonCli } from "./engine.js";
 import { doctor as doctorImpl } from "./bootstrap/doctor.js";
 import { ToolErrorOutputSchema } from "./generated/tool_error_output.js";
 function toolText(obj) {
@@ -45,7 +45,9 @@ export function defineTools() {
     });
     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 });
+            // [DEPRECATED] Use vibe_pm.inspect_code instead
+            // Changed from runEngine("vibecoding-helper") to runPythonCli for correct routing
+            const { code, stdout, stderr } = await runPythonCli(["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", {
@@ -148,7 +150,9 @@ export function defineTools() {
     });
     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 });
+            // [DEPRECATED] Use vibe_pm.get_decision instead
+            // Changed from runEngine("vibecoding-helper") to runPythonCli for correct routing
+            const { code, stdout, stderr } = await runPythonCli(["show-ask-queue", input.run_id], { timeoutMs: input.timeout_ms ?? 60_000 });
             return toolText({
                 status: code === 0 ? "OK" : "FAIL",
                 exit_code: code,
@@ -168,7 +172,9 @@ export function defineTools() {
     });
     async function vibecodeShowDecisions(input) {
         try {
-            const { code, stdout, stderr } = await runEngine("vibecoding-helper", ["show-decisions", input.run_id], { timeoutMs: input.timeout_ms ?? 60_000 });
+            // [DEPRECATED] Use vibe_pm.status instead
+            // Changed from runEngine("vibecoding-helper") to runPythonCli for correct routing
+            const { code, stdout, stderr } = await runPythonCli(["show-decisions", input.run_id], { timeoutMs: input.timeout_ms ?? 60_000 });
             return toolText({
                 status: code === 0 ? "OK" : "FAIL",
                 exit_code: code,
@@ -189,7 +195,9 @@ export function defineTools() {
     });
     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 });
+            // [DEPRECATED] Use vibe_pm.submit_decision instead
+            // Changed from runEngine("vibecoding-helper") to runPythonCli for correct routing
+            const { code, stdout, stderr } = await runPythonCli(["answer", input.run_id, "--text", input.text], { timeoutMs: input.timeout_ms ?? 120_000 });
             return toolText({
                 status: code === 0 ? "OK" : "FAIL",
                 exit_code: code,

package/build/version-check.js

@@ -3,14 +3,14 @@
 // 정책: 절대 실행을 막지 않는다 (모든 실패는 GO)
 import fs from "node:fs";
 import path from "node:path";
-import { spawnSync } from "node:child_process";
 import readline from "node:readline";
+import { invokeGitSync } from "./runtime/cli_invoker.js";
 function execGit(args, cwd) {
-    const r = spawnSync("git", args, { cwd, encoding: "utf-8", timeout: 10000 });
+    const result = invokeGitSync(args, cwd, { timeoutMs: 10000 });
     return {
-        status: r.status,
-        stdout: r.stdout ?? "",
-        stderr: r.stderr ?? "",
+        status: result.exitCode,
+        stdout: result.stdout,
+        stderr: result.stderr,
     };
 }
 function repoRootOrNull(cwd) {