@vibecodetown/mcp-server 2.2.0 → 2.2.1

package/build/tools/vibe_pm/doctor.js

@@ -2,11 +2,13 @@
 // 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 { getSkillsHealth } from "../../bootstrap/skills-installer.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";
+import { runPythonCli, findPythonRepoRoot } from "../../engine.js";
 // ============================================================
 // Input/Output Types
 // ============================================================
@@ -26,6 +28,36 @@ function mapEngineStatus(status) {
             return "손상됨";
     }
 }
+/**
+ * Check Python CLI health
+ * Verifies that `python -m vibecoding_helper` can be executed
+ */
+async function checkPythonCli() {
+    const cwd = process.cwd();
+    const detectedRoot = findPythonRepoRoot(cwd);
+    try {
+        const result = await runPythonCli(["--help"], { timeoutMs: 10_000 });
+        if (result.code === 0) {
+            return {
+                status: "정상",
+                message: "Python CLI 정상 동작",
+                pythonpath_detected: detectedRoot
+            };
+        }
+        return {
+            status: "오류",
+            message: `Python CLI 오류: ${result.stderr?.slice(0, 100) ?? "알 수 없는 오류"}`,
+            pythonpath_detected: detectedRoot
+        };
+    }
+    catch (e) {
+        return {
+            status: "오류",
+            message: e instanceof Error ? e.message : "알 수 없는 오류",
+            pythonpath_detected: detectedRoot
+        };
+    }
+}
 // ============================================================
 // Doctor Implementation
 // ============================================================
@@ -57,6 +89,23 @@ export async function doctor(input) {
             return null;
         }
     }
+    function getSkillBundleStatus() {
+        const skillsHealth = getSkillsHealth();
+        let status = "OK";
+        if (!skillsHealth.installed || skillsHealth.summary.missing > 0 || skillsHealth.summary.corrupted > 0) {
+            status = "ERROR";
+        }
+        else if (skillsHealth.version !== skillsHealth.version) {
+            // Note: In a real scenario, compare with expected version from registry
+            status = "WARN";
+        }
+        return {
+            status,
+            version: skillsHealth.version,
+            installed: skillsHealth.summary.ok,
+            total: skillsHealth.summary.total
+        };
+    }
     try {
         // Step 1: Quick health check
         const quickCheck = await healthCheck();
@@ -68,6 +117,8 @@ export async function doctor(input) {
                 version: e.version,
                 current_version: e.currentVersion
             }));
+            // Python CLI check
+            const pythonCliStatus = await checkPythonCli();
             // Local Memory check (best-effort)
             let localMemory = await getLocalMemoryStatus();
             if (autoFix && localMemory?.status === "NEEDS_SYNC") {
@@ -91,6 +142,23 @@ export async function doctor(input) {
                     // ignore
                 }
             }
+            // Check if Python CLI has issues
+            if (pythonCliStatus.status === "오류") {
+                return {
+                    status: "NEEDS_ATTENTION",
+                    contracts,
+                    summary: "Python CLI에 문제가 있습니다.",
+                    engines,
+                    python_cli: pythonCliStatus,
+                    skills: getSkillBundleStatus(),
+                    local_memory: localMemory,
+                    actions_taken: actionsTaken.length > 0 ? actionsTaken : undefined,
+                    next_action: {
+                        type: "MANUAL_FIX",
+                        message: `Python CLI 오류: ${pythonCliStatus.message}. PYTHONPATH 설정을 확인하세요.`
+                    }
+                };
+            }
             if (localMemory && localMemory.status !== "READY") {
                 const msg = localMemory.status === "NEEDS_SYNC"
                     ? "Local Memory 갱신이 필요합니다. vibe_pm.memory_sync를 실행해 보세요."
@@ -102,6 +170,8 @@ export async function doctor(input) {
                     contracts,
                     summary: "엔진은 정상입니다. 다만 Local Memory 준비가 필요합니다.",
                     engines,
+                    python_cli: pythonCliStatus,
+                    skills: getSkillBundleStatus(),
                     local_memory: localMemory,
                     actions_taken: actionsTaken.length > 0 ? actionsTaken : undefined,
                     next_action: {
@@ -115,6 +185,8 @@ export async function doctor(input) {
                 contracts,
                 summary: "모든 엔진이 정상적으로 설치되어 있습니다.",
                 engines,
+                python_cli: pythonCliStatus,
+                skills: getSkillBundleStatus(),
                 local_memory: localMemory,
                 actions_taken: actionsTaken.length > 0 ? actionsTaken : undefined,
                 next_action: {
@@ -136,6 +208,8 @@ export async function doctor(input) {
                 version: info.version,
                 current_version: info.currentVersion
             }));
+            // Python CLI check (after auto-fix)
+            const pythonCliStatus = await checkPythonCli();
             if (doctorResult.status === "OK") {
                 actionsTaken.push("문제 자동 수정 완료");
                 // Local Memory check (best-effort)
@@ -172,6 +246,8 @@ export async function doctor(input) {
                         contracts,
                         summary: "엔진은 정상입니다. 다만 Local Memory 준비가 필요합니다.",
                         engines,
+                        python_cli: pythonCliStatus,
+                        skills: getSkillBundleStatus(),
                         actions_taken: actionsTaken,
                         local_memory: localMemory,
                         next_action: {
@@ -185,6 +261,8 @@ export async function doctor(input) {
                     contracts,
                     summary: "문제를 발견하고 자동으로 수정했습니다.",
                     engines,
+                    python_cli: pythonCliStatus,
+                    skills: getSkillBundleStatus(),
                     actions_taken: actionsTaken,
                     local_memory: localMemory,
                     next_action: {
@@ -201,6 +279,8 @@ export async function doctor(input) {
                     contracts,
                     summary: "일부 엔진 업데이트가 필요합니다.",
                     engines,
+                    python_cli: pythonCliStatus,
+                    skills: getSkillBundleStatus(),
                     actions_taken: actionsTaken,
                     local_memory: localMemory,
                     next_action: {
@@ -216,6 +296,8 @@ export async function doctor(input) {
                 contracts,
                 summary: doctorResult.error ?? "알 수 없는 오류가 발생했습니다.",
                 engines,
+                python_cli: pythonCliStatus,
+                skills: getSkillBundleStatus(),
                 actions_taken: actionsTaken,
                 local_memory: localMemory,
                 next_action: {
@@ -231,6 +313,7 @@ export async function doctor(input) {
             version: e.version,
             current_version: e.currentVersion
         }));
+        const pythonCliStatus = await checkPythonCli();
         const issueCount = engines.filter((e) => e.status !== "정상").length;
         const localMemory = await getLocalMemoryStatus();
         return {
@@ -238,6 +321,8 @@ export async function doctor(input) {
             contracts,
             summary: `${issueCount}개의 엔진에 문제가 있습니다.`,
             engines,
+            python_cli: pythonCliStatus,
+            skills: getSkillBundleStatus(),
             local_memory: localMemory,
             next_action: {
                 type: "MANUAL_FIX",
@@ -247,11 +332,21 @@ export async function doctor(input) {
     }
     catch (e) {
         const localMemory = await getLocalMemoryStatus();
+        // Try to get Python CLI status even in error state
+        let pythonCliStatus;
+        try {
+            pythonCliStatus = await checkPythonCli();
+        }
+        catch {
+            // ignore
+        }
         return {
             status: "ERROR",
             contracts,
             summary: e instanceof Error ? e.message : "알 수 없는 오류",
             engines: [],
+            python_cli: pythonCliStatus,
+            skills: getSkillBundleStatus(),
             local_memory: localMemory,
             next_action: {
                 type: "CONTACT_SUPPORT",

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

@@ -3,9 +3,10 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { z } from "zod";
-import { runEngine } from "../../../engine.js";
+import { runPythonCli } from "../../../engine.js";
 import { safeJsonParse } from "../../../cli.js";
 import { resolveRunDir } from "../context.js";
+import { classifyPythonError } from "../python_error.js";
 const EntityGateReportSchema = z.object({
     status: z.enum(["OK", "FAIL"]),
     errors: z.array(z.string()),
@@ -38,9 +39,13 @@ function kceEventsPath(run_id, basePath) {
 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 });
+        const { code, stdout, stderr } = await runPythonCli(["entity-gate"], { timeoutMs: 60_000 });
         if (code !== 0 && !stdout.trim()) {
-            throw new Error(`entity-gate failed: ${stderr || `exit_code=${code}`}`);
+            const classified = classifyPythonError(stderr ?? "", code, "Entity Gate");
+            const hint = classified.issueCode === "python_module_not_found"
+                ? " (PYTHONPATH 문제 - vibe_pm.doctor 실행 권장)"
+                : "";
+            throw new Error(`${classified.issueCode}: ${classified.summary}${hint}`);
         }
         const parsed = safeJsonParse(stdout);
         if (!parsed.ok)

package/build/tools/vibe_pm/export_output.js

@@ -2,14 +2,13 @@
 // 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 { runPythonCli } 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(/^\/+/, "");
-}
+import { classifyPythonError } from "./python_error.js";
+import { normalizeRelativePosix } from "../../path-utils.js";
 function resolveDefaultOutputDir(target) {
     const t = (target ?? "").trim();
     return t ? `export/${t}` : "export/out";
@@ -41,7 +40,7 @@ export async function exportOutput(input) {
     }
     const outputDirInput = (input.output_dir ?? "").trim() || resolveDefaultOutputDir(target);
     const outputDirAbs = validatePath(outputDirInput, basePath);
-    const outputDirRel = normalizeRelPosix(path.relative(basePath, outputDirAbs));
+    const outputDirRel = normalizeRelativePosix(path.relative(basePath, outputDirAbs));
     const forbid = isPathForbidden(outputDirRel);
     if (forbid.forbidden) {
         throw new McpError(ErrorCode.InvalidParams, "Forbidden export output_dir.", {
@@ -64,9 +63,10 @@ export async function exportOutput(input) {
     }
     if (dryRun)
         planCmd.push("--dry-run");
-    const planRes = await runEngine("vibecoding-helper", planCmd, { timeoutMs: 120_000 });
+    const planRes = await runPythonCli(planCmd, { timeoutMs: 120_000 });
     if (planRes.code !== 0) {
-        throw new Error(`export-plan failed: ${planRes.stderr || `exit_code=${planRes.code}`}`);
+        const classified = classifyPythonError(planRes.stderr ?? "", planRes.code, "export-plan");
+        throw new Error(`${classified.issueCode}: ${classified.summary}`);
     }
     const planParsed = safeJsonParse(planRes.stdout);
     if (!planParsed.ok) {
@@ -94,9 +94,10 @@ export async function exportOutput(input) {
         ];
         if (needsTemplatePin)
             genCmd.push("--template-repo", templateRepo, "--template-ref", templateRef);
-        const genRes = await runEngine("vibecoding-helper", genCmd, { timeoutMs: 300_000 });
+        const genRes = await runPythonCli(genCmd, { timeoutMs: 300_000 });
         if (genRes.code !== 0) {
-            throw new Error(`export-generate failed: ${genRes.stderr || `exit_code=${genRes.code}`}`);
+            const classified = classifyPythonError(genRes.stderr ?? "", genRes.code, "export-generate");
+            throw new Error(`${classified.issueCode}: ${classified.summary}`);
         }
         const genParsed = safeJsonParse(genRes.stdout);
         if (!genParsed.ok) {
@@ -107,10 +108,10 @@ export async function exportOutput(input) {
             for (const f of files) {
                 const p = typeof f?.path === "string" ? f.path : "";
                 if (p)
-                    createdPaths.push(normalizeRelPosix(p));
+                    createdPaths.push(normalizeRelativePosix(p));
             }
         }
-        artifactsPathRel = normalizeRelPosix(path.relative(basePath, exportArtifactsPath(runDirAbs)));
+        artifactsPathRel = normalizeRelativePosix(path.relative(basePath, exportArtifactsPath(runDirAbs)));
     }
     const out = {
         success: true,
@@ -120,8 +121,8 @@ export async function exportOutput(input) {
         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))),
+            feature_output_spec_path: normalizeRelativePosix(path.relative(basePath, specAbs)),
+            export_plan_path: normalizeRelativePosix(path.relative(basePath, exportPlanPath(runDirAbs))),
             export_artifacts_path: artifactsPathRel
         },
         created_paths: createdPaths,

package/build/tools/vibe_pm/finalize_work.js

@@ -10,7 +10,60 @@ import { runDocStatusTriage } from "./doc_status_gate.js";
 import { kickoffKceSyncBestEffort } from "./kce/on_finalize.js";
 import { updateVersionFile } from "../../version-check.js";
 import { CONTRACTS_VERSION, CONTRACTS_BUNDLE_SHA256 } from "../../generated/contracts_bundle_info.js";
-import { updateLastCommit, checkAndAddMcpBuildAction, formatReminders, } from "../../local-mode/project-state.js";
+import { resolveRunId } from "./context.js";
+/**
+ * Detect if a file is a spec/doc file
+ */
+function isSpecFile(filePath) {
+    const normalized = filePath.replace(/\\/g, "/");
+    return (normalized === "docs/SSOT.md" ||
+        normalized === "docs/CURRENT_SPEC.md" ||
+        normalized.startsWith("docs/ssot/") ||
+        normalized.startsWith("docs/specs/") ||
+        normalized.startsWith("docs/dev_logs/") ||
+        normalized.startsWith("docs/planning/"));
+}
+/**
+ * Detect if a file is a code file
+ */
+function isCodeFile(filePath) {
+    const normalized = filePath.replace(/\\/g, "/");
+    const codePatterns = [
+        /^src\//,
+        /^lib\//,
+        /^tests?\//,
+        /^scripts\//,
+        /^adapters\//,
+        /^engines\//,
+        /^vibecoding_helper\//,
+        /\.ts$/,
+        /\.tsx$/,
+        /\.js$/,
+        /\.jsx$/,
+        /\.py$/,
+        /\.rs$/,
+        /\.go$/
+    ];
+    return codePatterns.some((p) => p.test(normalized));
+}
+/**
+ * Write spec update evidence file for audit trail
+ */
+function writeSpecUpdateEvidence(basePath, runId, evidence) {
+    try {
+        const specDir = path.join(basePath, "engines", "spec_high", "runs", runId, "spec");
+        fs.mkdirSync(specDir, { recursive: true });
+        const evidencePath = path.join(specDir, "spec_update.json");
+        const fullEvidence = {
+            version: "spec_update_evidence.v1",
+            ...evidence
+        };
+        fs.writeFileSync(evidencePath, JSON.stringify(fullEvidence, null, 2) + "\n", "utf-8");
+    }
+    catch {
+        // Best-effort: do not block finalize_work
+    }
+}
 /**
  * vibe_pm.finalize_work - Complete work with documentation and Git
  *
@@ -162,13 +215,6 @@ export async function finalizeWork(input, basePath = process.cwd()) {
                     await git.commit(commitMessage);
                     commitHash = (await git.revparse(["HEAD"])).trim() || "unknown";
                     commitCreated = true;
-                    // Update project state with commit info
-                    updateLastCommit({
-                        hash: commitHash,
-                        message: commitMessage.split("\n")[0],
-                        timestamp: new Date().toISOString(),
-                        pushed: false, // Will be updated after push
-                    }, basePath);
                 }
                 catch (err) {
                     warning = appendWarning(warning, `Git commit 실패: ${err instanceof Error ? err.message : String(err)}`);
@@ -230,13 +276,6 @@ export async function finalizeWork(input, basePath = process.cwd()) {
                     try {
                         await git.push("origin", branchName);
                         pushedToRemote = true;
-                        // Update project state - mark as pushed
-                        updateLastCommit({
-                            hash: commitHash,
-                            message: commitMessage.split("\n")[0],
-                            timestamp: new Date().toISOString(),
-                            pushed: true,
-                        }, basePath);
                     }
                     catch (err) {
                         warning = appendWarning(warning, `Git push 실패: ${err instanceof Error ? err.message : String(err)}`);
@@ -249,6 +288,26 @@ export async function finalizeWork(input, basePath = process.cwd()) {
         // Git not available / not a repo / unexpected error: keep docs work, but surface warning
         warning = appendWarning(warning, `Git 처리 실패: ${err instanceof Error ? err.message : String(err)}`);
     }
+    // SRWP: Write spec update evidence (best-effort audit trail)
+    try {
+        const { run_id } = resolveRunId(undefined, basePath);
+        const specFiles = updatedFiles.filter((f) => isSpecFile(f));
+        const codeFiles = updatedFiles.filter((f) => isCodeFile(f));
+        if (specFiles.length > 0 || codeFiles.length > 0) {
+            writeSpecUpdateEvidence(basePath, run_id, {
+                run_id,
+                timestamp: new Date().toISOString(),
+                updated_spec_files: specFiles,
+                updated_code_files: codeFiles,
+                reason: "FinalizeWork",
+                commit_subject: input.git_commit.subject,
+                diff_summary: input.task_summary
+            });
+        }
+    }
+    catch {
+        // Best-effort: do not block finalize_work
+    }
     // Best-effort: KCE sync (do not block finalize_work)
     if (shouldKickoffAutoMemorySync(basePath)) {
         void kickoffKceSyncBestEffort();
@@ -272,22 +331,6 @@ export async function finalizeWork(input, basePath = process.cwd()) {
     catch {
         // Best-effort: do not block finalize_work
     }
-    // Best-effort: Check if MCP package needs rebuild and update project state
-    let mcpBuildNeeded = false;
-    try {
-        mcpBuildNeeded = await checkAndAddMcpBuildAction(basePath);
-        if (mcpBuildNeeded) {
-            warning = appendWarning(warning, "MCP_BUILD_NEEDED: adapters/mcp-ts 소스 변경됨. vibe_pm.publish_mcp로 빌드 필요");
-        }
-        // Add reminder summary to warning if there are pending actions
-        const reminders = formatReminders(basePath);
-        if (reminders) {
-            warning = appendWarning(warning, `\n${reminders}`);
-        }
-    }
-    catch {
-        // ignore (best-effort)
-    }
     return {
         success: commitHash !== "no-commit" || updatedFiles.length > 0,
         updated_files: updatedFiles,
@@ -295,15 +338,10 @@ export async function finalizeWork(input, basePath = process.cwd()) {
         pushed_to_remote: pushedToRemote,
         remote_url: remoteUrl,
         warning,
-        next_action: mcpBuildNeeded
-            ? {
-                tool: "vibe_pm.publish_mcp",
-                reason: "MCP 패키지 빌드 필요 (소스 변경 감지)"
-            }
-            : {
-                tool: "vibe_pm.status",
-                reason: "작업 완료 상태를 확인하세요"
-            }
+        next_action: {
+            tool: "vibe_pm.status",
+            reason: "작업 완료 상태를 확인하세요"
+        }
     };
 }
 /**

package/build/tools/vibe_pm/get_decision.js

@@ -2,7 +2,7 @@
 // vibe_pm.get_decision - Fetch approval items
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { runEngineWithCache } from "../../engine.js";
+import { runPythonCliWithCache } from "../../engine.js";
 import { safeJsonParse } from "../../cli.js";
 import { getRunsDir, resolveRunId, resolveProjectId, resolveSpecHighRunDir } from "./context.js";
 import { transformAskQueueText } from "./pm_language.js";
@@ -42,7 +42,7 @@ export async function getDecision(input, basePath = process.cwd()) {
     }
     else {
         // Fallback: run show-ask-queue command (with caching)
-        const { code, stdout } = await runEngineWithCache("vibecoding-helper", ["show-ask-queue", run_id], { timeoutMs: 60_000 });
+        const { code, stdout } = await runPythonCliWithCache(["show-ask-queue", run_id], { timeoutMs: 60_000 });
         if (code === 0) {
             // Parse response
             const parsed = safeJsonParse(stdout);