@vibecodetown/mcp-server 2.1.4 → 2.2.1

package/build/local-mode/project-state.js

@@ -0,0 +1,176 @@
+// adapters/mcp-ts/src/local-mode/project-state.ts
+// Per-folder project state persistence
+// Stores workflow state, reminders, and pending actions
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getVibeRepoPaths } from "./paths.js";
+const DEFAULT_STATE = {
+    schema_version: 1,
+    phases: [],
+    pending_actions: [],
+    reminders: [],
+};
+/**
+ * Load project state from .vibe/project_state.json
+ */
+export function loadProjectState(basePath = process.cwd()) {
+    const paths = getVibeRepoPaths(basePath);
+    const statePath = path.join(paths.vibeDir, "project_state.json");
+    if (!fs.existsSync(statePath)) {
+        return null;
+    }
+    try {
+        const content = fs.readFileSync(statePath, "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Save project state to .vibe/project_state.json
+ */
+export function saveProjectState(state, basePath = process.cwd()) {
+    const paths = getVibeRepoPaths(basePath);
+    const statePath = path.join(paths.vibeDir, "project_state.json");
+    // Ensure .vibe directory exists
+    if (!fs.existsSync(paths.vibeDir)) {
+        fs.mkdirSync(paths.vibeDir, { recursive: true });
+    }
+    state.updated_at = new Date().toISOString();
+    fs.writeFileSync(statePath, JSON.stringify(state, null, 2));
+}
+/**
+ * Get or create project state
+ */
+export function getProjectState(basePath = process.cwd()) {
+    const existing = loadProjectState(basePath);
+    if (existing) {
+        return existing;
+    }
+    const projectId = path.basename(basePath).toLowerCase().replace(/[^a-z0-9_-]/g, "_");
+    return {
+        ...DEFAULT_STATE,
+        project_id: projectId,
+        updated_at: new Date().toISOString(),
+    };
+}
+/**
+ * Add a pending action
+ */
+export function addPendingAction(action, basePath = process.cwd()) {
+    const state = getProjectState(basePath);
+    // Check for duplicate
+    const exists = state.pending_actions.some((a) => a.type === action.type && a.reason === action.reason);
+    if (exists)
+        return;
+    state.pending_actions.push({
+        ...action,
+        created_at: new Date().toISOString(),
+    });
+    saveProjectState(state, basePath);
+}
+/**
+ * Remove a pending action by type
+ */
+export function removePendingAction(type, basePath = process.cwd()) {
+    const state = getProjectState(basePath);
+    state.pending_actions = state.pending_actions.filter((a) => a.type !== type);
+    saveProjectState(state, basePath);
+}
+/**
+ * Get all pending actions (for reminders)
+ */
+export function getPendingActions(basePath = process.cwd()) {
+    const state = loadProjectState(basePath);
+    return state?.pending_actions || [];
+}
+/**
+ * Update last commit info
+ */
+export function updateLastCommit(info, basePath = process.cwd()) {
+    const state = getProjectState(basePath);
+    state.last_commit = info;
+    // If pushed, remove git_push pending action
+    if (info.pushed) {
+        state.pending_actions = state.pending_actions.filter((a) => a.type !== "git_push");
+    }
+    else {
+        // Add git_push pending action if not pushed
+        const exists = state.pending_actions.some((a) => a.type === "git_push");
+        if (!exists) {
+            state.pending_actions.push({
+                type: "git_push",
+                reason: `커밋 ${info.hash.slice(0, 7)} 푸시 필요`,
+                created_at: new Date().toISOString(),
+                priority: "medium",
+            });
+        }
+    }
+    saveProjectState(state, basePath);
+}
+/**
+ * Update last MCP build info
+ */
+export function updateLastMcpBuild(info, basePath = process.cwd()) {
+    const state = getProjectState(basePath);
+    state.last_mcp_build = info;
+    // If published, remove mcp_build and npm_publish pending actions
+    if (info.published) {
+        state.pending_actions = state.pending_actions.filter((a) => a.type !== "mcp_build" && a.type !== "npm_publish");
+    }
+    saveProjectState(state, basePath);
+}
+/**
+ * Format pending actions as reminder text
+ */
+export function formatReminders(basePath = process.cwd()) {
+    const actions = getPendingActions(basePath);
+    if (actions.length === 0)
+        return null;
+    const lines = ["## 📋 대기 중인 작업"];
+    // Sort by priority
+    const sorted = [...actions].sort((a, b) => {
+        const order = { high: 0, medium: 1, low: 2 };
+        return order[a.priority] - order[b.priority];
+    });
+    for (const action of sorted) {
+        const emoji = action.priority === "high" ? "🔴" : action.priority === "medium" ? "🟡" : "🟢";
+        const tool = getToolForAction(action.type);
+        lines.push(`- ${emoji} ${action.reason}${tool ? ` → \`${tool}\`` : ""}`);
+    }
+    return lines.join("\n");
+}
+function getToolForAction(type) {
+    const mapping = {
+        mcp_build: "vibe_pm.publish_mcp",
+        engine_build: null, // Manual
+        npm_publish: "vibe_pm.publish_mcp",
+        git_push: "vibe_pm.finalize_work",
+        review: "vibe_pm.inspect_code",
+        custom: null,
+    };
+    return mapping[type];
+}
+/**
+ * Check and add MCP build pending action if needed
+ */
+export async function checkAndAddMcpBuildAction(basePath = process.cwd()) {
+    // Dynamically import to avoid circular dependency
+    const { needsMcpBuild } = await import("../tools/vibe_pm/publish_mcp.js");
+    try {
+        const needs = await needsMcpBuild(basePath);
+        if (needs) {
+            addPendingAction({
+                type: "mcp_build",
+                reason: "MCP 소스 변경됨 - 빌드 필요",
+                priority: "high",
+            }, basePath);
+            return true;
+        }
+    }
+    catch {
+        // ignore
+    }
+    return false;
+}

package/build/local-mode/setup.js

@@ -4,6 +4,7 @@ import { initLocalModeRepo } from "./init.js";
 import { writeVersionLock } from "./version-lock.js";
 import { ensureEngines } from "../bootstrap/installer.js";
 import { healthCheck } from "../bootstrap/doctor.js";
+import { activateSkills, getSkillsHealth } from "../bootstrap/skills-installer.js";
 /**
  * Run unified setup process
  */
@@ -42,5 +43,24 @@ export async function runSetup(repoRoot, cliVersion, opts) {
     catch (e) {
         warnings.push(`버전 잠금 파일 생성 실패: ${e instanceof Error ? e.message : String(e)}`);
     }
-    return { local, engines, versionLock, warnings };
+    // Step 4: Skills activation
+    let skills = { activated: [], errors: [] };
+    if (!opts.skipSkills) {
+        try {
+            const skillsHealth = getSkillsHealth();
+            if (skillsHealth.installed && skillsHealth.skills.length > 0) {
+                // Activate all available skills by default
+                skills = await activateSkills(repoRoot);
+                if (skills.errors.length > 0) {
+                    for (const err of skills.errors) {
+                        warnings.push(`스킬 활성화 오류: ${err}`);
+                    }
+                }
+            }
+        }
+        catch (e) {
+            warnings.push(`스킬 활성화 실패: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    return { local, engines, skills, versionLock, warnings };
 }

package/build/local-mode/templates.js

@@ -763,9 +763,9 @@ jobs:
       - name: Run Vibe guard
         shell: bash
         env:
-          # Default: WARN does not fail the job (seatbelt philosophy).
-          # Opt-in strict mode: set to "true" in the generated workflow.
-          VIBE_FAIL_ON_WARN: "false"
+          # P0-2: CI 환경에서는 WARN도 빌드 실패 처리 (기본값)
+          # 이전 동작이 필요하면 "false"로 변경
+          VIBE_FAIL_ON_WARN: "true"
         run: |
           set -euo pipefail
           if [[ ! -f ".vibe/lib/validate.sh" ]]; then

package/build/path-utils.js

@@ -0,0 +1,68 @@
+// adapters/mcp-ts/src/path-utils.ts
+// P1-5: Centralized path normalization utilities (DRY)
+import * as path from "node:path";
+/**
+ * Convert Windows backslashes to POSIX forward slashes.
+ * This is the most basic normalization used across the codebase.
+ */
+export function toPosixPath(value) {
+    return value.replace(/\\/g, "/");
+}
+/**
+ * Normalize a relative path for POSIX style:
+ * - Convert backslashes to forward slashes
+ * - Trim whitespace
+ * - Remove leading slashes (makes it relative)
+ */
+export function normalizeRelativePosix(value) {
+    return (value ?? "").trim().replace(/\\/g, "/").replace(/^\/+/, "");
+}
+/**
+ * Normalize a path for comparison/matching:
+ * - Convert backslashes to forward slashes
+ * - Trim whitespace
+ * - Remove leading "./" prefix
+ */
+export function normalizeForMatch(value) {
+    let v = (value ?? "").trim().replace(/\\/g, "/");
+    if (v.startsWith("./"))
+        v = v.slice(2);
+    return v;
+}
+/**
+ * Resolve a path relative to a base path and normalize to POSIX.
+ * Returns empty string for empty input, "." for base path itself.
+ */
+export function resolveRelativePosix(basePath, value) {
+    const trimmed = (value ?? "").trim();
+    if (!trimmed)
+        return "";
+    const absolute = path.isAbsolute(trimmed) ? trimmed : path.resolve(basePath, trimmed);
+    const relative = path.relative(basePath, absolute);
+    if (!relative)
+        return ".";
+    return toPosixPath(relative);
+}
+/**
+ * Process and deduplicate an array of paths, normalizing each to POSIX relative format.
+ * Empty and duplicate paths are filtered out.
+ */
+export function normalizePathArray(basePath, values) {
+    const seen = new Set();
+    const out = [];
+    for (const raw of values) {
+        const normalized = resolveRelativePosix(basePath, raw);
+        if (!normalized || seen.has(normalized))
+            continue;
+        seen.add(normalized);
+        out.push(normalized);
+    }
+    return out;
+}
+/**
+ * Deduplicate and normalize an array of strings for set operations.
+ * Uses basic POSIX normalization (backslash to forward slash).
+ */
+export function uniquePosixPaths(items) {
+    return Array.from(new Set(items.map((p) => normalizeRelativePosix(p)).filter(Boolean))).sort();
+}

package/build/runtime/cli_invoker.js

@@ -0,0 +1,416 @@
+/**
+ * cli_invoker.ts - Single CLI Invocation Point (SSOT)
+ *
+ * All MCP tools MUST use this module for CLI invocations.
+ * Direct usage of child_process outside this file is forbidden.
+ *
+ * This module provides:
+ * - Centralized CLI invocation
+ * - Invocation logging for test verification
+ * - Environment sanitization
+ * - Timeout handling
+ *
+ * @module runtime/cli_invoker
+ */
+import { spawn, spawnSync } from "node:child_process";
+import { sanitizeEnv } from "../cli.js";
+import { getEngineCtx } from "../engine.js";
+// ============================================================================
+// Invocation Log (for test verification)
+// ============================================================================
+const invocationLog = [];
+/**
+ * Get a copy of the invocation log
+ * Used by tests to verify CLI calls
+ */
+export function getInvocationLog() {
+    return [...invocationLog];
+}
+/**
+ * Clear the invocation log
+ * Should be called in test beforeEach()
+ */
+export function clearInvocationLog() {
+    invocationLog.length = 0;
+}
+/**
+ * Check if a specific CLI prefix was invoked
+ * Used by enforcement tests
+ */
+export function wasInvoked(bin, argsPrefix) {
+    return invocationLog.some((record) => record.bin === bin &&
+        argsPrefix.every((prefix, i) => record.args[i] === prefix));
+}
+// ============================================================================
+// Binary Resolution
+// ============================================================================
+let vibeBinPath = null;
+/**
+ * Get the vibe CLI binary path
+ * This is the path to the vibe-cli.ts entry point
+ */
+async function getVibeBinPath() {
+    if (vibeBinPath)
+        return vibeBinPath;
+    // In production, vibe is invoked via npx or global install
+    // For now, we use the current process argv
+    // TODO: Resolve proper vibe binary path from package
+    vibeBinPath = process.argv[1] ?? "vibe";
+    return vibeBinPath;
+}
+/** Known system binaries that should be resolved via PATH */
+const SYSTEM_BINS = new Set([
+    "git", "semgrep", "python", "python3", "opa", "node", "npm", "npx",
+    // Common utilities that might be needed
+    "tar", "curl", "wget", "which", "bash", "sh",
+]);
+/** Engine binary names (for type checking) */
+const ENGINE_BINS = new Set([
+    "spec-high", "vibe-execution-engine", "clinic",
+]);
+/**
+ * Resolve binary path for a given CLI bin
+ */
+async function resolveBinPath(bin) {
+    if (bin === "vibe") {
+        return getVibeBinPath();
+    }
+    // System binary - use the name directly (resolved via PATH)
+    if (SYSTEM_BINS.has(bin)) {
+        return bin;
+    }
+    // Engine binary - use cached path from bootstrap
+    if (ENGINE_BINS.has(bin)) {
+        const ctx = await getEngineCtx();
+        const enginePath = ctx.bins[bin];
+        if (!enginePath) {
+            throw new Error(`Engine binary not installed: ${bin}`);
+        }
+        return enginePath;
+    }
+    // Unknown binary - assume it's a system command (PATH resolution)
+    // This allows flexibility for arbitrary commands while logging them
+    return bin;
+}
+// ============================================================================
+// CLI Invocation
+// ============================================================================
+/**
+ * Invoke a CLI command
+ *
+ * This is the ONLY function that should spawn CLI processes.
+ * All other code should use this function.
+ *
+ * @param inv - Invocation request
+ * @returns CLI result with exit code, stdout, stderr, and duration
+ *
+ * @example
+ * ```typescript
+ * const result = await invokeCli({
+ *   bin: "vibe",
+ *   args: ["inspect", "--run-id", "abc123"],
+ *   cwd: "/path/to/project",
+ *   timeoutMs: 60000
+ * });
+ * ```
+ */
+export async function invokeCli(inv) {
+    const startTime = Date.now();
+    const timeoutMs = inv.timeoutMs ?? 120_000;
+    // Create log record
+    const record = {
+        ...inv,
+        timestamp: new Date().toISOString(),
+    };
+    invocationLog.push(record);
+    // Resolve binary path
+    const binPath = await resolveBinPath(inv.bin);
+    return new Promise((resolve) => {
+        let resolved = false;
+        const p = spawn(binPath, inv.args, {
+            cwd: inv.cwd,
+            env: sanitizeEnv(inv.env),
+            shell: false,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        const finish = (exitCode) => {
+            if (resolved)
+                return;
+            resolved = true;
+            const result = {
+                exitCode,
+                stdout,
+                stderr,
+                durationMs: Date.now() - startTime,
+            };
+            // Update log record with result
+            record.result = result;
+            resolve(result);
+        };
+        const killTimer = setTimeout(() => {
+            try {
+                p.kill("SIGKILL");
+            }
+            catch {
+                // Ignore kill errors
+            }
+            stderr += "\n[TIMEOUT]";
+            finish(124);
+        }, timeoutMs);
+        p.stdout.on("data", (d) => (stdout += d.toString("utf-8")));
+        p.stderr.on("data", (d) => (stderr += d.toString("utf-8")));
+        p.on("error", (e) => {
+            clearTimeout(killTimer);
+            const msg = e instanceof Error ? e.message : String(e);
+            stderr += `\n[SPAWN_ERROR] ${msg}`;
+            finish(127);
+        });
+        p.on("close", (code) => {
+            clearTimeout(killTimer);
+            finish(code ?? 1);
+        });
+    });
+}
+// ============================================================================
+// Convenience Functions
+// ============================================================================
+/**
+ * Invoke vibe CLI command (convenience wrapper)
+ *
+ * @example
+ * ```typescript
+ * const result = await invokeVibe(["inspect", "--run-id", "abc123"], "/project");
+ * ```
+ */
+export async function invokeVibe(args, cwd, opts) {
+    return invokeCli({
+        bin: "vibe",
+        args,
+        cwd,
+        env: opts?.env,
+        timeoutMs: opts?.timeoutMs,
+    });
+}
+/**
+ * Invoke engine binary directly (legacy, will be deprecated)
+ *
+ * Prefer using invokeVibe() with appropriate vibe subcommand instead.
+ *
+ * @deprecated Use invokeVibe() instead
+ */
+export async function invokeEngine(engine, args, cwd, opts) {
+    return invokeCli({
+        bin: engine,
+        args,
+        cwd,
+        env: opts?.env,
+        timeoutMs: opts?.timeoutMs,
+    });
+}
+/**
+ * Invoke a system binary (git, semgrep, python, etc.)
+ *
+ * These commands are resolved via PATH.
+ *
+ * @example
+ * ```typescript
+ * // Run git status
+ * const result = await invokeSystem("git", ["status"], "/project");
+ *
+ * // Run semgrep scan
+ * const result = await invokeSystem("semgrep", ["scan", "--config", "auto"], "/project");
+ * ```
+ */
+export async function invokeSystem(bin, args, cwd, opts) {
+    return invokeCli({
+        bin,
+        args,
+        cwd,
+        env: opts?.env,
+        timeoutMs: opts?.timeoutMs,
+    });
+}
+/**
+ * Invoke git command (convenience wrapper)
+ *
+ * @example
+ * ```typescript
+ * const result = await invokeGit(["status"], "/project");
+ * const result = await invokeGit(["add", "."], "/project");
+ * ```
+ */
+export async function invokeGit(args, cwd, opts) {
+    return invokeSystem("git", args, cwd, opts);
+}
+/**
+ * Invoke a system binary synchronously
+ *
+ * Use sparingly - prefer async versions. Only use for:
+ * - Startup/bootstrap code
+ * - Simple checks that must block
+ *
+ * @example
+ * ```typescript
+ * const result = invokeSystemSync("git", ["rev-parse", "--show-toplevel"], "/project");
+ *
+ * // With stdin input
+ * const result = invokeSystemSync("opa", ["eval", "-I", ...], "/project", {
+ *   input: JSON.stringify(data)
+ * });
+ * ```
+ */
+export function invokeSystemSync(bin, args, cwd, opts) {
+    const timeoutMs = opts?.timeoutMs ?? 30_000;
+    // Log the invocation (sync version also logs for consistency)
+    const record = {
+        bin,
+        args,
+        cwd,
+        env: opts?.env,
+        timeoutMs,
+        timestamp: new Date().toISOString(),
+    };
+    invocationLog.push(record);
+    const result = spawnSync(bin, args, {
+        cwd,
+        encoding: "utf-8",
+        env: sanitizeEnv(opts?.env),
+        input: opts?.input,
+        stdio: opts?.input ? ["pipe", "pipe", "pipe"] : ["ignore", "pipe", "pipe"],
+        timeout: timeoutMs,
+    });
+    const cliResult = {
+        exitCode: result.status ?? (result.signal ? 124 : 1),
+        stdout: result.stdout ?? "",
+        stderr: result.stderr ?? "",
+    };
+    // Check for spawn errors (e.g., binary not found)
+    if (result.error) {
+        const err = result.error;
+        cliResult.exitCode = err.code === "ENOENT" ? 127 : 1;
+        cliResult.stderr = `[SPAWN_ERROR] ${err.message}`;
+    }
+    // Update log record
+    record.result = { ...cliResult, durationMs: 0 };
+    return cliResult;
+}
+/**
+ * Invoke git command synchronously
+ *
+ * @example
+ * ```typescript
+ * const result = invokeGitSync(["rev-parse", "--show-toplevel"], "/project");
+ * ```
+ */
+export function invokeGitSync(args, cwd, opts) {
+    return invokeSystemSync("git", args, cwd, opts);
+}
+// ============================================================================
+// Detached Process (for background services)
+// ============================================================================
+/**
+ * Spawn a detached process that continues running after parent exits
+ *
+ * Use for background services like web servers.
+ * The process is spawned with `detached: true` and `unref()`.
+ *
+ * @returns PID of the spawned process, or null if spawn failed
+ *
+ * @example
+ * ```typescript
+ * const pid = spawnDetached("npm", ["run", "dev"], "/project", {
+ *   PORT: "3000"
+ * });
+ * ```
+ */
+export function spawnDetached(bin, args, cwd, env) {
+    // Log the invocation
+    const record = {
+        bin,
+        args,
+        cwd,
+        env,
+        timestamp: new Date().toISOString(),
+    };
+    invocationLog.push(record);
+    try {
+        const child = spawn(bin, args, {
+            cwd,
+            detached: true,
+            stdio: "ignore",
+            env: sanitizeEnv(env),
+        });
+        // Unref to allow parent to exit independently
+        child.unref();
+        const pid = child.pid ?? null;
+        // Update log record
+        record.result = {
+            exitCode: 0,
+            stdout: "",
+            stderr: "",
+            durationMs: 0,
+        };
+        return pid;
+    }
+    catch {
+        record.result = {
+            exitCode: 127,
+            stdout: "",
+            stderr: "[SPAWN_ERROR]",
+            durationMs: 0,
+        };
+        return null;
+    }
+}
+/**
+ * Parse VRIP control response from CLI result
+ *
+ * @param result - CLI invocation result
+ * @returns Parsed control response or error
+ */
+export function parseVripResponse(result) {
+    if (result.exitCode > 1) {
+        // System crash - no JSON expected
+        return { ok: false, error: `CLI crashed (code ${result.exitCode}): ${result.stderr}` };
+    }
+    try {
+        const ctrl = JSON.parse(result.stdout.trim());
+        if (typeof ctrl.ok !== "boolean" || typeof ctrl.run_id !== "string") {
+            return { ok: false, error: "Invalid VRIP response: missing ok or run_id" };
+        }
+        return { ok: true, ctrl };
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return { ok: false, error: `JSON parse failed: ${msg}\nRaw: ${result.stdout}` };
+    }
+}
+/**
+ * Invoke vibe CLI with VRIP protocol
+ *
+ * Automatically adds --json flag and parses VRIP response.
+ *
+ * @example
+ * ```typescript
+ * const { ctrl, result } = await invokeVibeVrip(
+ *   ["inspect", "--target", "src/"],
+ *   "/project"
+ * );
+ * if (ctrl.ok) {
+ *   const runDir = `.vibe/runs/${ctrl.run_id}`;
+ *   // Read actual results from run_dir
+ * }
+ * ```
+ */
+export async function invokeVibeVrip(args, cwd, opts) {
+    // Always add --json for VRIP protocol
+    const jsonArgs = args.includes("--json") ? args : [...args, "--json"];
+    const result = await invokeVibe(jsonArgs, cwd, opts);
+    const parsed = parseVripResponse(result);
+    if (!parsed.ok) {
+        throw new Error(parsed.error);
+    }
+    return { ctrl: parsed.ctrl, result };
+}