@vibecodetown/mcp-server 2.1.0

package/build/bootstrap/platform.js

@@ -0,0 +1,26 @@
+// adapters/mcp-ts/src/bootstrap/platform.ts
+// Platform detection and executable naming
+/**
+ * Detect current platform for asset download
+ */
+export function detectPlatform() {
+    const p = process.platform;
+    const a = process.arch;
+    if (p === "win32")
+        return "win_x64"; // win arm64 out of scope for v1
+    if (p === "darwin") {
+        if (a === "arm64")
+            return "darwin_arm64";
+        return "darwin_x64";
+    }
+    // linux
+    if (a === "arm64")
+        return "linux_arm64";
+    return "linux_x64";
+}
+/**
+ * Get executable name with platform-specific extension
+ */
+export function exeName(base) {
+    return process.platform === "win32" ? `${base}.exe` : base;
+}

package/build/bootstrap/registry.js

@@ -0,0 +1,37 @@
+// adapters/mcp-ts/src/bootstrap/registry.ts
+// SSOT: Engine versions and release asset naming
+/**
+ * Engine Registry (SSOT)
+ *
+ * VERSION_MATRIX.md와 동기화 필수.
+ * 여기 버전을 바꾸면 원클릭 설치 대상이 바뀐다.
+ */
+export const ENGINE_SPECS = {
+    "spec-high": {
+        name: "spec-high",
+        version: "1.0.0",
+        repo: "yellowhama/vibe-pm",
+        assetPrefix: "spec-high",
+        shaSumsAsset: "SHA256SUMS.txt"
+    },
+    "vibecoding-helper": {
+        name: "vibecoding-helper",
+        version: "1.0.0",
+        repo: "yellowhama/vibe-pm",
+        assetPrefix: "vibecoding-helper",
+        shaSumsAsset: "SHA256SUMS.txt"
+    },
+    "clinic": {
+        name: "clinic",
+        version: "2.3.0",
+        repo: "yellowhama/vibe-pm",
+        assetPrefix: "clinic",
+        shaSumsAsset: "SHA256SUMS.txt"
+    }
+};
+/**
+ * Asset naming convention:
+ * {assetPrefix}_{version}_{platform}.tar.gz
+ *
+ * Example: spec-high_1.0.0_linux_x64.tar.gz
+ */

package/build/cache/index.js

@@ -0,0 +1,147 @@
+// adapters/mcp-ts/src/cache/index.ts
+// TieredCache - TTL + mtime-based cache with LRU eviction
+/**
+ * TieredCache - Multi-level cache with TTL and mtime validation
+ *
+ * Features:
+ * - TTL-based expiration
+ * - Optional mtime validation for file-based caching
+ * - LRU eviction when maxEntries exceeded
+ * - Pattern-based invalidation
+ */
+export class TieredCache {
+    config;
+    cache = new Map();
+    accessOrder = [];
+    hits = 0;
+    misses = 0;
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Get cached value if valid
+     *
+     * @param key - Cache key
+     * @param mtimeGetter - Optional function to get current mtime for validation
+     * @returns Cached value or null if expired/invalid
+     */
+    get(key, mtimeGetter) {
+        const entry = this.cache.get(key);
+        if (!entry) {
+            this.misses++;
+            return null;
+        }
+        // Check TTL expiration
+        const now = Date.now();
+        if (now - entry.timestamp > this.config.ttlMs) {
+            this.cache.delete(key);
+            this.removeFromAccessOrder(key);
+            this.misses++;
+            return null;
+        }
+        // Check mtime validation if provided
+        if (mtimeGetter && entry.mtime !== undefined) {
+            const currentMtime = mtimeGetter();
+            if (currentMtime !== null && currentMtime !== entry.mtime) {
+                this.cache.delete(key);
+                this.removeFromAccessOrder(key);
+                this.misses++;
+                return null;
+            }
+        }
+        // Update access order for LRU
+        this.updateAccessOrder(key);
+        this.hits++;
+        return entry.value;
+    }
+    /**
+     * Set cache value
+     *
+     * @param key - Cache key
+     * @param value - Value to cache
+     * @param mtime - Optional mtime for file-based validation
+     */
+    set(key, value, mtime) {
+        // Evict if at capacity
+        if (this.cache.size >= this.config.maxEntries && !this.cache.has(key)) {
+            this.evictLRU();
+        }
+        this.cache.set(key, {
+            value,
+            timestamp: Date.now(),
+            mtime,
+        });
+        this.updateAccessOrder(key);
+    }
+    /**
+     * Invalidate specific cache entry
+     */
+    invalidate(key) {
+        this.cache.delete(key);
+        this.removeFromAccessOrder(key);
+    }
+    /**
+     * Invalidate all entries matching a pattern
+     */
+    invalidatePattern(pattern) {
+        const keysToDelete = [];
+        for (const key of this.cache.keys()) {
+            if (pattern.test(key)) {
+                keysToDelete.push(key);
+            }
+        }
+        for (const key of keysToDelete) {
+            this.cache.delete(key);
+            this.removeFromAccessOrder(key);
+        }
+    }
+    /**
+     * Clear all cache entries
+     */
+    clear() {
+        this.cache.clear();
+        this.accessOrder = [];
+    }
+    /**
+     * Get cache statistics
+     */
+    stats() {
+        return {
+            size: this.cache.size,
+            maxEntries: this.config.maxEntries,
+            name: this.config.name,
+            hits: this.hits,
+            misses: this.misses,
+        };
+    }
+    /**
+     * Check if key exists and is valid
+     */
+    has(key, mtimeGetter) {
+        return this.get(key, mtimeGetter) !== null;
+    }
+    updateAccessOrder(key) {
+        this.removeFromAccessOrder(key);
+        this.accessOrder.push(key);
+    }
+    removeFromAccessOrder(key) {
+        const index = this.accessOrder.indexOf(key);
+        if (index !== -1) {
+            this.accessOrder.splice(index, 1);
+        }
+    }
+    evictLRU() {
+        if (this.accessOrder.length === 0)
+            return;
+        const lruKey = this.accessOrder.shift();
+        if (lruKey) {
+            this.cache.delete(lruKey);
+        }
+    }
+}
+/**
+ * Create a cache key from multiple parts
+ */
+export function createCacheKey(...parts) {
+    return parts.filter((p) => p !== undefined).join("::");
+}

package/build/cli.js

@@ -0,0 +1,101 @@
+import { spawn } from "node:child_process";
+/**
+ * Environment variable whitelist for subprocess execution
+ * Only these variables are passed through to child processes
+ */
+const ENV_WHITELIST = new Set([
+    // System essentials
+    "PATH",
+    "HOME",
+    "USER",
+    "LANG",
+    "LC_ALL",
+    "LC_CTYPE",
+    "TZ",
+    "TERM",
+    "SHELL",
+    // Vibe-specific
+    "VIBECODE_CACHE",
+    "VIBECODE_ROOT",
+    "VIBECODE_DEBUG",
+    "VIBECODE_OFFLINE",
+    // Runtime paths
+    "NODE_PATH",
+    "PYTHONPATH",
+    "PYTHONIOENCODING",
+    // Build tools
+    "CC",
+    "CXX",
+    "MAKE",
+]);
+/**
+ * Sanitize environment variables by filtering through whitelist
+ *
+ * @param additionalEnv - Optional additional env vars to include
+ * @returns Filtered environment object
+ */
+export function sanitizeEnv(additionalEnv) {
+    const result = {};
+    // Filter process.env through whitelist
+    for (const key of ENV_WHITELIST) {
+        if (process.env[key] !== undefined) {
+            result[key] = process.env[key];
+        }
+    }
+    // Add any additional env vars (also filtered through whitelist for security)
+    if (additionalEnv) {
+        for (const [key, value] of Object.entries(additionalEnv)) {
+            if (value !== undefined && ENV_WHITELIST.has(key)) {
+                result[key] = value;
+            }
+        }
+    }
+    return result;
+}
+export async function runCmd(cmd, args, opts) {
+    const timeoutMs = opts?.timeoutMs ?? 120_000;
+    return await new Promise((resolve) => {
+        let resolved = false;
+        const p = spawn(cmd, args, {
+            cwd: opts?.cwd,
+            env: sanitizeEnv(opts?.env),
+            shell: false,
+            stdio: ["ignore", "pipe", "pipe"]
+        });
+        let stdout = "";
+        let stderr = "";
+        const finish = (code, out, err) => {
+            if (resolved)
+                return;
+            resolved = true;
+            resolve({ code, stdout: out, stderr: err });
+        };
+        const killTimer = setTimeout(() => {
+            try {
+                p.kill("SIGKILL");
+            }
+            catch { }
+            finish(124, stdout, stderr + "\n[TIMEOUT]");
+        }, 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);
+            finish(127, stdout, stderr + `\n[SPAWN_ERROR] ${msg}`);
+        });
+        p.on("close", (code) => {
+            clearTimeout(killTimer);
+            finish(code ?? 1, stdout, stderr);
+        });
+    });
+}
+export function safeJsonParse(raw) {
+    try {
+        return { ok: true, value: JSON.parse(raw) };
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return { ok: false, error: msg };
+    }
+}

package/build/contracts.js

@@ -0,0 +1,22 @@
+// contracts.ts
+// Central contract types for MCP adapter
+// SelectionValidationResult is generated from JSON Schema SSOT
+import { SelectionValidationResultSchema } from "./generated/selection_validation_result.js";
+import { ToolErrorOutputSchema } from "./generated/tool_error_output.js";
+// ============================================================
+// Generated Types (from JSON Schema SSOT)
+// ============================================================
+export { SelectionValidationResultSchema };
+export { ToolErrorOutputSchema };
+export const SignalLevelSchema = SelectionValidationResultSchema.shape.signal_level;
+export const DetailsSchema = SelectionValidationResultSchema.shape.details;
+export const NextActionSchema = SelectionValidationResultSchema.shape.next_action;
+// Backwards-compat alias (older docs / consumers)
+export const NextActionObjectSchema = NextActionSchema;
+export const PathsSchema = SelectionValidationResultSchema.shape.paths;
+export function parseSelectionValidationResult(input) {
+    return SelectionValidationResultSchema.parse(input);
+}
+export function safeParseSelectionValidationResult(input) {
+    return SelectionValidationResultSchema.safeParse(input);
+}

package/build/control_plane/gate.js

@@ -0,0 +1,161 @@
+/**
+ * System Design Gate - Control Plane for Vibe PM
+ *
+ * Provides gate enforcement for work orders before execution.
+ * All work orders must pass through the gate before any work can proceed.
+ */
+import { spawn } from "child_process";
+import { WorkOrderV1Schema } from "../generated/work_order_v1.js";
+import { GateResultV1Schema } from "../generated/gate_result_v1.js";
+/**
+ * Run the system design gate check on a work order
+ */
+export async function runSystemDesignGate(workOrder, options) {
+    const { repoRoot, pythonExe = "python3", timeoutMs = 30000 } = options;
+    // Validate work order first
+    const parseResult = WorkOrderV1Schema.safeParse(workOrder);
+    if (!parseResult.success) {
+        return {
+            success: false,
+            error: `Invalid work order: ${parseResult.error.message}`,
+        };
+    }
+    const workOrderJson = JSON.stringify(workOrder);
+    const overrideFlags = [];
+    const pushBool = (name, value) => {
+        if (typeof value !== "boolean")
+            return;
+        overrideFlags.push(value ? `--${name}` : `--no-${name}`);
+    };
+    pushBool("fail-fast", options.failFast);
+    pushBool("semgrep", options.semgrep);
+    pushBool("runtime", options.runtime);
+    return new Promise((resolve) => {
+        const child = spawn(pythonExe, [
+            "-m",
+            "vibecoding_helper",
+            "--repo-root",
+            repoRoot,
+            "gate-check",
+            ...overrideFlags,
+            "--work-order",
+            workOrderJson,
+            "--format",
+            "json",
+        ], {
+            cwd: repoRoot,
+            timeout: timeoutMs,
+            env: { ...process.env, PYTHONIOENCODING: "utf-8" },
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout?.on("data", (data) => {
+            stdout += data.toString();
+        });
+        child.stderr?.on("data", (data) => {
+            stderr += data.toString();
+        });
+        child.on("close", (code) => {
+            // Exit code 0 = ALLOW, 2 = BLOCK, other = error
+            if (code === null) {
+                resolve({
+                    success: false,
+                    error: "Gate check timed out",
+                });
+                return;
+            }
+            if (code !== 0 && code !== 2) {
+                resolve({
+                    success: false,
+                    error: `Gate check failed with code ${code}: ${stderr || stdout}`,
+                });
+                return;
+            }
+            try {
+                const result = JSON.parse(stdout.trim());
+                const validated = GateResultV1Schema.safeParse(result);
+                if (!validated.success) {
+                    resolve({
+                        success: false,
+                        error: `Invalid gate result: ${validated.error.message}`,
+                    });
+                    return;
+                }
+                resolve({
+                    success: true,
+                    result: validated.data,
+                });
+            }
+            catch (e) {
+                resolve({
+                    success: false,
+                    error: `Failed to parse gate result: ${e instanceof Error ? e.message : String(e)}`,
+                });
+            }
+        });
+        child.on("error", (err) => {
+            resolve({
+                success: false,
+                error: `Gate check process error: ${err.message}`,
+            });
+        });
+    });
+}
+/**
+ * Execute a work order only if it passes the gate
+ *
+ * @throws Error if gate blocks the work order
+ */
+export async function executeWithGate(workOrder, options) {
+    const gateResult = await runSystemDesignGate(workOrder, options);
+    if (!gateResult.success || !gateResult.result) {
+        throw new Error(`Gate check failed: ${gateResult.error || "Unknown error"}`);
+    }
+    if (gateResult.result.verdict === "BLOCK") {
+        const violations = gateResult.result.violations
+            .map((v) => `[${v.rule_id}] ${v.message}`)
+            .join("; ");
+        throw new Error(`Gate BLOCKED: ${violations}`);
+    }
+    return gateResult.result;
+}
+/**
+ * Check if a work order would pass the gate (without executing)
+ */
+export async function checkGate(workOrder, options) {
+    const gateResult = await runSystemDesignGate(workOrder, options);
+    if (!gateResult.success || !gateResult.result) {
+        return {
+            allowed: false,
+            result: null,
+            error: gateResult.error,
+        };
+    }
+    return {
+        allowed: gateResult.result.verdict === "ALLOW",
+        result: gateResult.result,
+    };
+}
+/**
+ * Format gate violations for display
+ */
+export function formatViolations(result) {
+    if (result.violations.length === 0) {
+        return "No violations";
+    }
+    const lines = result.violations.map((v) => {
+        const emoji = v.level === "BLOCK" ? "❌" : v.level === "WARN" ? "⚠️" : "ℹ️";
+        let line = `${emoji} [${v.rule_id}] ${v.message}`;
+        if (v.remediation) {
+            line += `\n   Fix: ${v.remediation}`;
+        }
+        if (v.location?.file) {
+            line += `\n   Location: ${v.location.file}`;
+            if (v.location.line) {
+                line += `:${v.location.line}`;
+            }
+        }
+        return line;
+    });
+    return lines.join("\n\n");
+}

package/build/control_plane/index.js

@@ -0,0 +1,6 @@
+/**
+ * Control Plane module for Vibe PM
+ *
+ * Provides gate-based enforcement of system design rules.
+ */
+export { runSystemDesignGate, executeWithGate, checkGate, formatViolations, } from "./gate.js";

package/build/dx/activity.js

@@ -0,0 +1,139 @@
+// adapters/mcp-ts/src/dx/activity.ts
+// Activity/DX helpers: branded header, status icons, optional desktop notifications
+function boolEnv(name, defaultValue) {
+    const raw = (process.env[name] ?? "").trim().toLowerCase();
+    if (!raw)
+        return defaultValue;
+    if (["1", "true", "yes", "y", "on"].includes(raw))
+        return true;
+    if (["0", "false", "no", "n", "off"].includes(raw))
+        return false;
+    return defaultValue;
+}
+function intEnv(name, defaultValue) {
+    const raw = (process.env[name] ?? "").trim();
+    if (!raw)
+        return defaultValue;
+    const n = Number(raw);
+    return Number.isFinite(n) ? Math.trunc(n) : defaultValue;
+}
+export function isActivityHeaderEnabled() {
+    return boolEnv("VIBECODE_ACTIVITY_HEADER", true);
+}
+export function isDesktopNotifyEnabled() {
+    return boolEnv("VIBECODE_NOTIFY", false);
+}
+export function desktopNotifyMinMs() {
+    return intEnv("VIBECODE_NOTIFY_MIN_MS", 1500);
+}
+function toolBadge(toolName, data) {
+    const map = {
+        "vibe_pm.briefing": { icon: "🧭", label: "프로젝트 접수" },
+        "vibe_pm.get_decision": { icon: "🗳️", label: "결재 확인" },
+        "vibe_pm.submit_decision": { icon: "✍️", label: "결재 반영" },
+        "vibe_pm.create_work_order": { icon: "🧾", label: "작업 지시서 생성" },
+        "vibe_pm.inspect_code": { icon: "🔍", label: "검수" },
+        "vibe_pm.repair_plan": { icon: "🛠️", label: "수정 지시서" },
+        "vibe_pm.status": { icon: "📍", label: "상태 확인" },
+        "vibe_pm.scaffold": { icon: "🧱", label: "구조 생성" },
+        "vibe_pm.finalize_work": { icon: "✅", label: "마감 정리" },
+        "vibe_pm.undo_last_task": { icon: "↩️", label: "롤백" },
+        "vibe_pm.run_app": { icon: "🚀", label: "실행" },
+        "vibe_pm.export_output": { icon: "📦", label: "내보내기" },
+        "vibe_pm.search_oss": { icon: "🔎", label: "검색" },
+        "vibe_pm.zoekt_evidence": { icon: "🧾", label: "근거 수집" },
+        "vibe_pm.gate": { icon: "🛡️", label: "안전 점검" },
+        "vibe_pm.doctor": { icon: "🩺", label: "진단" },
+        "vibe_pm.update": { icon: "⬆️", label: "업데이트" },
+        "vibe_pm.activate": { icon: "🔑", label: "활성화" },
+        "vibe_pm.memory_status": { icon: "🧠", label: "메모리 상태" },
+        "vibe_pm.memory_sync": { icon: "🧠", label: "메모리 동기화" },
+        "vibe_pm.advisory_review": { icon: "🧪", label: "사전 점검" },
+        "react_perf.check_patterns": { icon: "⚡️", label: "성능 점검" },
+        "react_perf.generate_report": { icon: "📄", label: "리포트 생성" }
+    };
+    if (toolName === "vibe_pm.run_app" && data && typeof data === "object") {
+        const obj = data;
+        const runtime = (obj.runtime ?? null);
+        const containerId = obj.container_id ?? runtime?.container_id;
+        const container = runtime?.container;
+        if (containerId || container === "podman") {
+            return { icon: "📦", label: "샌드박스 실행" };
+        }
+    }
+    if (toolName in map)
+        return map[toolName];
+    if (toolName.startsWith("vibe_pm."))
+        return { icon: "⚡️", label: "작업" };
+    return { icon: "⚙️", label: "작업" };
+}
+function verdictIcon(data, outcome) {
+    if (outcome === "error")
+        return "❌";
+    if (!data || typeof data !== "object")
+        return "✅";
+    const obj = data;
+    const verdict = String(obj.verdict ?? "").toUpperCase();
+    if (verdict === "BLOCK")
+        return "❌";
+    if (verdict === "ALLOW")
+        return "✅";
+    const reviewSummary = obj.review_summary;
+    if (reviewSummary && typeof reviewSummary === "object") {
+        const rs = reviewSummary;
+        const rr = String(rs.review_result ?? "").toUpperCase();
+        if (rr === "GO")
+            return "✅";
+        if (rr === "FIX")
+            return "⚠️";
+        if (rr === "BLOCK")
+            return "❌";
+    }
+    return "✅";
+}
+export function renderActivityHeader(toolName, data, outcome = "success", durationMs) {
+    const badge = toolBadge(toolName, data);
+    const status = verdictIcon(data, outcome);
+    const duration = typeof durationMs === "number" && durationMs >= 0 ? ` · ${Math.round(durationMs)}ms` : "";
+    return [
+        "╭──────────────────────────────╮",
+        "│  VibePM ⚡️ Active            │",
+        `│  ${status} ${badge.icon} ${badge.label}${duration}`,
+        "╰──────────────────────────────╯"
+    ].join("\n");
+}
+export function decorateToolOutputText(toolName, jsonText, data, outcome = "success", durationMs) {
+    if (!isActivityHeaderEnabled()) {
+        return [{ type: "text", text: jsonText }];
+    }
+    const header = renderActivityHeader(toolName, data, outcome, durationMs);
+    return [
+        { type: "text", text: header },
+        { type: "text", text: jsonText }
+    ];
+}
+export async function notifyDesktopBestEffort(args) {
+    if (!isDesktopNotifyEnabled())
+        return;
+    const minMs = desktopNotifyMinMs();
+    const durationMs = args.durationMs ?? 0;
+    if (args.outcome !== "error" && minMs > 0 && durationMs < minMs)
+        return;
+    try {
+        const mod = await import("node-notifier");
+        const notifier = mod.default ?? mod;
+        const badge = toolBadge(args.toolName, args.data);
+        const status = verdictIcon(args.data, args.outcome);
+        const duration = durationMs ? ` (${Math.round(durationMs)}ms)` : "";
+        notifier.notify({
+            title: "VibePM ⚡️",
+            message: `${status} ${badge.icon} ${badge.label}${duration}`,
+            sound: false,
+            wait: false,
+            timeout: 3
+        });
+    }
+    catch {
+        // Best-effort: never fail tool execution due to notify issues (headless/permissions).
+    }
+}