@vibecodetown/mcp-server 1.3.1 → 1.5.0

package/build/mcp/tools/vibe_pm/scout.js

@@ -0,0 +1,224 @@
+/**
+ * vibe_pm.scout — Bee Trigger Dispatch Tool (Scout→Bee upgrade)
+ *
+ * Execution priority:
+ *   1. Native BitNet dispatch (S1 Warm singleton) → full AI analysis
+ *   2. Musu HTTP adapter fallback
+ *   3. Heuristic analysis (static, no I/O) → rule-based guidance
+ *   4. Bee enrichment: dependency context (import graph, blast radius) — PRO
+ *   5. Bee auto-trigger: Swarm dispatch on high risk — PRO
+ *
+ * Supports T3 (AUTH_TOUCH), T6 (DEP_SHIFT), T8 (GATE_FIX), and auto mode.
+ *
+ * @since v1.7.0 (Scout)
+ * @since v1.12.0 (Bee upgrade — Option C internal replacement)
+ */
+import { createBeeRunner } from '../../../domains/bee/bee_orchestrator.js';
+import { createTriggerEvaluator, TRIGGER_RULES } from '../../../domains/bee/trigger_evaluator.js';
+import { collectTriggerFacts } from '../../../domains/bee/trigger_facts_collector.js';
+import { analyzeAuthTouch } from '../../../domains/bee/scout_heuristics.js';
+import { saveScoutReport } from '../../../native/index.js';
+import { getSignalBridge } from '../../../kernel/blocks/signal_bridge.js';
+import { writeScoutResultToChain } from '../../../domains/bee/scout_chain_storage.js';
+import { captureBoundaryWarning } from '../shared/boundary_errors.js';
+import { appendSignal } from './signals/index.js';
+/**
+ * Execute a scout/bee scan for the given trigger.
+ */
+export async function scout(input, progress, log) {
+    const basePath = process.cwd();
+    const triggerId = input.trigger_id ?? 'auto';
+    progress?.report(1, 3, 'Scout: 트리거 평가 중');
+    // --- Auto mode: evaluate triggers and pick the highest priority ---
+    if (triggerId === 'auto') {
+        return runAutoMode(basePath, input, progress, log);
+    }
+    // --- Explicit trigger mode ---
+    const ruleId = triggerId;
+    const rule = TRIGGER_RULES.find(r => r.id === ruleId);
+    if (!rule) {
+        return {
+            triggered: false,
+            skipped_reason: `Unknown trigger: ${triggerId}`,
+        };
+    }
+    progress?.report(2, 3, 'Scout: 분석 실행 중');
+    const out = await runForRule(basePath, rule, input, progress, log);
+    progress?.report(3, 3, 'Scout: 완료');
+    return out;
+}
+/**
+ * Auto mode: collect facts, evaluate triggers, run the highest priority one.
+ * If no BitNet/Musu is available, tries heuristic detection for supported triggers.
+ */
+async function runAutoMode(basePath, input, progress, log) {
+    try {
+        log?.log('info', { mode: 'auto' }, 'scout auto evaluate');
+        const facts = await collectTriggerFacts(basePath);
+        const evaluator = createTriggerEvaluator(basePath, 'PRO');
+        const evalResult = await evaluator.evaluate(facts);
+        if (evalResult.should_skip_all) {
+            const result = {
+                triggered: false,
+                skipped_reason: 'T7_ENGINE_BACKLOG: engine queue overloaded, all triggers skipped',
+            };
+            emitScoutSignal(result, basePath, 'T7_ENGINE_BACKLOG');
+            return result;
+        }
+        if (!evalResult.highest_priority) {
+            // No triggers matched — try heuristic T3 on changed paths as last resort
+            if (facts.repo.changed_paths.length > 0) {
+                const heuristic = analyzeAuthTouch({
+                    changedPaths: facts.repo.changed_paths,
+                });
+                if (heuristic.triggered) {
+                    heuristic.analysis = `[Auto-detected] ${heuristic.analysis ?? ''}`;
+                    persistResult(heuristic, basePath, 'T3_AUTH_TOUCH', facts.repo.changed_paths);
+                    emitScoutSignal(heuristic, basePath, 'T3_AUTH_TOUCH');
+                    return { ...heuristic, source: 'heuristic' };
+                }
+            }
+            const noTriggerResult = {
+                triggered: false,
+                skipped_reason: 'No active triggers detected',
+            };
+            emitScoutSignal(noTriggerResult, basePath, 'auto');
+            return noTriggerResult;
+        }
+        const rule = evalResult.highest_priority;
+        progress?.report(2, 3, `Scout: ${rule.id} 분석 실행 중`);
+        const out = await runForRule(basePath, rule, input, progress, log);
+        progress?.report(3, 3, 'Scout: 완료');
+        return out;
+    }
+    catch (err) {
+        return {
+            triggered: false,
+            skipped_reason: `Auto evaluation failed: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+}
+/**
+ * Run BeeOrchestrator for a specific trigger rule.
+ * Replaces the old ScoutRunner path with Bee analysis pipeline.
+ */
+async function runForRule(basePath, rule, input, _progress, log) {
+    const changedPaths = buildChangedPaths(rule.id, input);
+    const runner = createBeeRunner(basePath);
+    log?.log('info', { trigger: rule.id, changed_paths: changedPaths.length }, 'bee run');
+    const beeResult = await runner.run(rule, changedPaths, input);
+    // Persist triggered results (best-effort)
+    if (beeResult.triggered) {
+        persistResult(beeResult, basePath, rule.id, changedPaths);
+    }
+    // Emit signal for all results (triggered + untriggered)
+    emitScoutSignal(beeResult, basePath, rule.id);
+    return toBeeOutput(beeResult);
+}
+/**
+ * Convert BeeOrchestratorResult to BeeOutput.
+ */
+function toBeeOutput(result) {
+    return {
+        triggered: result.triggered,
+        scenario: result.scenario,
+        block_id: result.block_id,
+        analysis: result.analysis,
+        latency_ms: result.latency_ms,
+        skipped_reason: result.skipped_reason,
+        confidence: result.confidence,
+        risk_level: result.risk_level,
+        suggestions: result.suggestions,
+        forward_deps: result.forward_deps,
+        reverse_deps: result.reverse_deps,
+        blast_radius_count: result.blast_radius_count,
+        swarm_triggered: result.swarm_triggered,
+        swarm_verdict: result.swarm_verdict,
+        source: result.source,
+    };
+}
+/**
+ * Persist result to BlockStore via native bridge (best-effort).
+ * Handles native storage, chain storage, and signal emission.
+ */
+function persistResult(result, basePath, triggerId, scope, warnings) {
+    if (!result.triggered)
+        return;
+    // Save to native BlockStore
+    try {
+        const analysisJson = JSON.stringify(result);
+        const scenario = result.scenario ?? 'unknown';
+        const blockId = saveScoutReport(analysisJson, scenario, basePath);
+        if (blockId) {
+            result.block_id = blockId;
+        }
+    }
+    catch (e) {
+        if (warnings)
+            captureBoundaryWarning(warnings, 'scout_report', 'persist', e);
+    }
+    // Store as Block Store chain (P4)
+    if (triggerId && scope) {
+        try {
+            writeScoutResultToChain(basePath, triggerId, result, scope);
+        }
+        catch (e) {
+            if (warnings)
+                captureBoundaryWarning(warnings, 'chain_storage', 'persist', e);
+        }
+    }
+    // Signal Bridge emission moved to emitScoutSignal() — called from runForRule()/runAutoMode()
+}
+/**
+ * Emit a scout signal to the Signal Bridge (best-effort).
+ * Called for ALL results (triggered + untriggered) to enable full observability.
+ */
+function emitScoutSignal(result, basePath, triggerId) {
+    try {
+        const bridge = getSignalBridge(basePath);
+        bridge.writeSignalDirect({
+            kind: result.triggered ? 'swarm_inference' : 'scout_scan',
+            metadata: {
+                trigger_id: triggerId,
+                triggered: result.triggered,
+                scenario: result.scenario,
+                confidence: result.confidence,
+                risk_level: result.risk_level,
+                skipped_reason: result.triggered ? undefined : result.skipped_reason,
+                source_type: ('source' in result ? result.source : 'heuristic'),
+            },
+        });
+    }
+    catch { /* best-effort */ }
+    // Observer signal (dual-write for dashboard visibility)
+    try {
+        const riskLevel = result.risk_level;
+        void appendSignal(basePath, {
+            type: result.triggered ? 'SCOUT_TRIGGERED' : 'SCOUT_UNTRIGGERED',
+            severity: result.triggered ? (riskLevel === 'high' ? 'P0' : 'P1') : 'P2',
+            data: {
+                trigger_id: triggerId,
+                scenario: result.scenario,
+                confidence: result.confidence,
+                risk_level: riskLevel,
+                skipped_reason: result.triggered ? undefined : result.skipped_reason,
+            },
+        });
+    }
+    catch { /* fail-safe */ }
+}
+/**
+ * Build changed paths list from tool input context.
+ */
+function buildChangedPaths(ruleId, input) {
+    switch (ruleId) {
+        case 'T3_AUTH_TOUCH':
+            return input.file_path ? [input.file_path] : [];
+        case 'T6_DEP_SHIFT':
+            return ['package.json', 'package-lock.json', 'yarn.lock', 'pnpm-lock.yaml'];
+        case 'T8_GATE_FIX':
+            return input.file_path ? [input.file_path] : [];
+        default:
+            return [];
+    }
+}

package/build/mcp/tools/vibe_pm/setup.d.ts

@@ -2,11 +2,14 @@ import { z } from "zod";
 export declare const SetupInputSchema: z.ZodObject<{
     mode: z.ZodDefault<z.ZodEnum<["check", "install", "uninstall"]>>;
     force: z.ZodDefault<z.ZodBoolean>;
+    scope: z.ZodDefault<z.ZodEnum<["user", "project"]>>;
 }, "strip", z.ZodTypeAny, {
     mode: "check" | "install" | "uninstall";
+    scope: "project" | "user";
     force: boolean;
 }, {
     mode?: "check" | "install" | "uninstall" | undefined;
+    scope?: "project" | "user" | undefined;
     force?: boolean | undefined;
 }>;
 export type SetupInput = z.infer<typeof SetupInputSchema>;

package/build/mcp/tools/vibe_pm/setup.js

@@ -13,6 +13,8 @@ export const SetupInputSchema = z.object({
         .describe("check: 설정 상태 확인만, install: MCP 설정 추가, uninstall: MCP 설정 제거"),
     force: z.boolean().default(false)
         .describe("이미 설정된 경우에도 덮어쓰기"),
+    scope: z.enum(["user", "project"]).default("user")
+        .describe("user: 사용자 설정(~/.config), project: 프로젝트 .mcp.json"),
 });
 /**
  * Get Claude Code settings paths for current platform
@@ -32,37 +34,41 @@ function getClaudeCodePaths() {
                 settingsFile: path.join(homeDir, "Library", "Application Support", "claude-code", "settings.json"),
             };
         case "win32": // Windows
-            const appData = process.env.APPDATA ?? path.join(homeDir, "AppData", "Roaming");
-            return {
-                settingsDir: path.join(appData, "claude-code"),
-                settingsFile: path.join(appData, "claude-code", "settings.json"),
-            };
+            {
+                const appData = process.env.APPDATA ?? path.join(homeDir, "AppData", "Roaming");
+                return {
+                    settingsDir: path.join(appData, "claude-code"),
+                    settingsFile: path.join(appData, "claude-code", "settings.json"),
+                };
+            }
         case "linux":
         default:
-            // Check XDG_CONFIG_HOME first
-            const xdgConfig = process.env.XDG_CONFIG_HOME ?? path.join(homeDir, ".config");
-            const xdgPath = path.join(xdgConfig, "claude-code");
-            // Fallback to ~/.claude-code if XDG doesn't exist
-            const fallbackPath = path.join(homeDir, ".claude-code");
-            // Use XDG path if it exists, otherwise fallback
-            if (fs.existsSync(xdgPath)) {
+            {
+                // Check XDG_CONFIG_HOME first
+                const xdgConfig = process.env.XDG_CONFIG_HOME ?? path.join(homeDir, ".config");
+                const xdgPath = path.join(xdgConfig, "claude-code");
+                // Fallback to ~/.claude-code if XDG doesn't exist
+                const fallbackPath = path.join(homeDir, ".claude-code");
+                // Use XDG path if it exists, otherwise fallback
+                if (fs.existsSync(xdgPath)) {
+                    return {
+                        settingsDir: xdgPath,
+                        settingsFile: path.join(xdgPath, "settings.json"),
+                    };
+                }
+                // Check fallback
+                if (fs.existsSync(fallbackPath)) {
+                    return {
+                        settingsDir: fallbackPath,
+                        settingsFile: path.join(fallbackPath, "settings.json"),
+                    };
+                }
+                // Default to XDG for new installations
                 return {
                     settingsDir: xdgPath,
                     settingsFile: path.join(xdgPath, "settings.json"),
                 };
             }
-            // Check fallback
-            if (fs.existsSync(fallbackPath)) {
-                return {
-                    settingsDir: fallbackPath,
-                    settingsFile: path.join(fallbackPath, "settings.json"),
-                };
-            }
-            // Default to XDG for new installations
-            return {
-                settingsDir: xdgPath,
-                settingsFile: path.join(xdgPath, "settings.json"),
-            };
     }
 }
 /**
@@ -79,18 +85,22 @@ function getClaudeDesktopPaths() {
                 settingsFile: path.join(homeDir, "Library", "Application Support", "Claude", "claude_desktop_config.json"),
             };
         case "win32":
-            const appData = process.env.APPDATA ?? path.join(homeDir, "AppData", "Roaming");
-            return {
-                settingsDir: path.join(appData, "Claude"),
-                settingsFile: path.join(appData, "Claude", "claude_desktop_config.json"),
-            };
+            {
+                const appData = process.env.APPDATA ?? path.join(homeDir, "AppData", "Roaming");
+                return {
+                    settingsDir: path.join(appData, "Claude"),
+                    settingsFile: path.join(appData, "Claude", "claude_desktop_config.json"),
+                };
+            }
         case "linux":
         default:
-            const xdgConfig = process.env.XDG_CONFIG_HOME ?? path.join(homeDir, ".config");
-            return {
-                settingsDir: path.join(xdgConfig, "Claude"),
-                settingsFile: path.join(xdgConfig, "Claude", "claude_desktop_config.json"),
-            };
+            {
+                const xdgConfig = process.env.XDG_CONFIG_HOME ?? path.join(homeDir, ".config");
+                return {
+                    settingsDir: path.join(xdgConfig, "Claude"),
+                    settingsFile: path.join(xdgConfig, "Claude", "claude_desktop_config.json"),
+                };
+            }
     }
 }
 // ============================================================
@@ -177,6 +187,141 @@ function removeVibePmConfig(config) {
     };
 }
 // ============================================================
+// Project Scope Setup (.mcp.json)
+// ============================================================
+const PROJECT_MCP_FILENAME = ".mcp.json";
+/**
+ * Project-scope setup: creates/updates .mcp.json in cwd
+ */
+async function setupProjectScope(input) {
+    const mcpJsonPath = path.join(process.cwd(), PROJECT_MCP_FILENAME);
+    // Read existing .mcp.json if present
+    const existing = readSettings(mcpJsonPath);
+    const configCheck = checkVibePmConfig(existing);
+    const currentConfigResponse = existing ? {
+        has_vibepm: configCheck.hasVibepm,
+        vibepm_command: configCheck.command,
+        vibepm_args: configCheck.args,
+        other_mcps: configCheck.otherMcps,
+    } : null;
+    switch (input.mode) {
+        case "check": {
+            if (!existing) {
+                return {
+                    status: "NOT_INSTALLED",
+                    message: `${PROJECT_MCP_FILENAME}이 프로젝트에 없습니다.`,
+                    settings_path: mcpJsonPath,
+                    current_config: null,
+                    action_taken: "none",
+                    next_action: {
+                        type: "NONE",
+                        message: "mode='install', scope='project'로 호출하면 자동 생성합니다.",
+                    },
+                };
+            }
+            return {
+                status: configCheck.hasVibepm ? "CONFIGURED" : "NOT_CONFIGURED",
+                message: configCheck.hasVibepm
+                    ? `${PROJECT_MCP_FILENAME}에 vibepm이 설정되어 있습니다.`
+                    : `${PROJECT_MCP_FILENAME}은 있지만 vibepm이 없습니다.`,
+                settings_path: mcpJsonPath,
+                current_config: currentConfigResponse,
+                action_taken: "none",
+                next_action: { type: "NONE", message: "확인 완료." },
+            };
+        }
+        case "install": {
+            if (configCheck.hasVibepm && !input.force) {
+                return {
+                    status: "CONFIGURED",
+                    message: `${PROJECT_MCP_FILENAME}에 vibepm이 이미 설정되어 있습니다.`,
+                    settings_path: mcpJsonPath,
+                    current_config: currentConfigResponse,
+                    action_taken: "none",
+                    next_action: { type: "NONE", message: "이미 설정 완료." },
+                };
+            }
+            const base = existing ?? { mcpServers: {} };
+            const newConfig = addVibePmConfig(base);
+            const actionTaken = !existing ? "created_file" : !configCheck.hasVibepm ? "added_mcp" : "updated_mcp";
+            const success = writeSettings(mcpJsonPath, newConfig);
+            if (!success) {
+                return {
+                    status: "ERROR",
+                    message: `${mcpJsonPath} 파일을 저장할 수 없습니다.`,
+                    settings_path: mcpJsonPath,
+                    current_config: currentConfigResponse,
+                    action_taken: "none",
+                    next_action: { type: "MANUAL_CHECK", message: `${mcpJsonPath} 쓰기 권한을 확인하세요.` },
+                };
+            }
+            const verify = readSettings(mcpJsonPath);
+            const verifyCheck = checkVibePmConfig(verify);
+            return {
+                status: actionTaken === "updated_mcp" ? "CONFIGURED_UPDATED" : "CONFIGURED_NEW",
+                message: actionTaken === "created_file"
+                    ? `${PROJECT_MCP_FILENAME}을 생성하고 vibepm을 설정했습니다.`
+                    : actionTaken === "added_mcp"
+                        ? `${PROJECT_MCP_FILENAME}에 vibepm을 추가했습니다.`
+                        : `${PROJECT_MCP_FILENAME}의 vibepm 설정을 업데이트했습니다.`,
+                settings_path: mcpJsonPath,
+                current_config: {
+                    has_vibepm: verifyCheck.hasVibepm,
+                    vibepm_command: verifyCheck.command,
+                    vibepm_args: verifyCheck.args,
+                    other_mcps: verifyCheck.otherMcps,
+                },
+                action_taken: actionTaken,
+                next_action: {
+                    type: "RESTART_CLAUDE",
+                    message: "이 프로젝트 폴더에서 Claude Code를 다시 시작하면 자동으로 vibepm이 연동됩니다.",
+                },
+            };
+        }
+        case "uninstall": {
+            if (!existing || !configCheck.hasVibepm) {
+                return {
+                    status: "NOT_CONFIGURED",
+                    message: `${PROJECT_MCP_FILENAME}에 vibepm이 없습니다.`,
+                    settings_path: mcpJsonPath,
+                    current_config: currentConfigResponse,
+                    action_taken: "none",
+                    next_action: { type: "NONE", message: "제거할 설정이 없습니다." },
+                };
+            }
+            const newConfig = removeVibePmConfig(existing);
+            const success = writeSettings(mcpJsonPath, newConfig);
+            if (!success) {
+                return {
+                    status: "ERROR",
+                    message: `${mcpJsonPath} 파일을 저장할 수 없습니다.`,
+                    settings_path: mcpJsonPath,
+                    current_config: currentConfigResponse,
+                    action_taken: "none",
+                    next_action: { type: "MANUAL_CHECK", message: `${mcpJsonPath} 쓰기 권한을 확인하세요.` },
+                };
+            }
+            return {
+                status: "UNINSTALLED",
+                message: `${PROJECT_MCP_FILENAME}에서 vibepm을 제거했습니다.`,
+                settings_path: mcpJsonPath,
+                current_config: { has_vibepm: false, other_mcps: configCheck.otherMcps },
+                action_taken: "removed_mcp",
+                next_action: { type: "RESTART_CLAUDE", message: "Claude Code를 다시 시작하세요." },
+            };
+        }
+        default:
+            return {
+                status: "ERROR",
+                message: `알 수 없는 모드: ${input.mode}`,
+                settings_path: mcpJsonPath,
+                current_config: currentConfigResponse,
+                action_taken: "none",
+                next_action: { type: "NONE", message: "mode는 'check', 'install', 'uninstall' 중 하나여야 합니다." },
+            };
+    }
+}
+// ============================================================
 // Main Setup Function
 // ============================================================
 /**
@@ -194,6 +339,11 @@ function removeVibePmConfig(config) {
  * - Never ask about tool names: Just configure automatically
  */
 export async function setup(input) {
+    // Project scope: write .mcp.json to cwd
+    if (input.scope === "project") {
+        return setupProjectScope(input);
+    }
+    // User scope: Claude Code / Claude Desktop settings
     // Try Claude Code first, then Claude Desktop
     const codePathsResult = getClaudeCodePaths();
     const desktopPaths = getClaudeDesktopPaths();

package/build/mcp/tools/vibe_pm/signals/logger.js

@@ -2,6 +2,7 @@
 // Append-only JSONL log at .vibe/observer/signals.v1.jsonl
 import * as fs from "node:fs/promises";
 import { getSignalsDir, getSignalsPath, rotateIfNeeded } from "./rotation.js";
+import { logger } from '../../../../shared/logger.js';
 /**
  * Append a signal event to the log
  * Creates the file and directory if they don't exist
@@ -29,7 +30,7 @@ export async function appendSignal(basePath, eventInput) {
     catch (err) {
         // Best-effort: log and continue
         if (process.env.VIBE_SIGNALS_DEBUG === "1") {
-            console.error("[signals] Append failed:", err instanceof Error ? err.message : err);
+            logger.error("[signals] Append failed: %s", err instanceof Error ? err.message : err);
         }
     }
 }

package/build/mcp/tools/vibe_pm/signals/rotation.js

@@ -2,6 +2,7 @@
 // Rotates .vibe/observer/signals.v1.jsonl when limits exceeded
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
+import { logger } from '../../../../shared/logger.js';
 /** Maximum number of lines before rotation */
 export const MAX_LINES = 1000;
 /** Maximum file size in bytes before rotation (5MB) */
@@ -91,13 +92,13 @@ export async function rotateIfNeeded(basePath) {
         // Rename current to rotated (overwrites if exists)
         await fs.rename(currentPath, rotatedPath);
         if (process.env.VIBE_SIGNALS_DEBUG === "1") {
-            console.error(`[signals] Rotated log to ${rotatedPath}`);
+            logger.error(`[signals] Rotated log to ${rotatedPath}`);
         }
     }
     catch (err) {
         // Best-effort: log and continue
         if (process.env.VIBE_SIGNALS_DEBUG === "1") {
-            console.error("[signals] Rotation failed:", err instanceof Error ? err.message : err);
+            logger.error("[signals] Rotation failed: %s", err instanceof Error ? err.message : err);
         }
     }
 }

package/build/mcp/tools/vibe_pm/signals/types.d.ts

@@ -1,7 +1,7 @@
 /**
  * Types of signals that can be logged
  */
-export type SignalType = "DIRTY_DETECTED" | "BOTTLENECK_SUSPECTED" | "DRIFT_DETECTED" | "BITNET_RAN" | "ENGINE_MISSING" | "INSPECT_VERDICT" | "MAPPING_BLOCK" | "POLICY_RECOMMENDED";
+export type SignalType = "DIRTY_DETECTED" | "BOTTLENECK_SUSPECTED" | "DRIFT_DETECTED" | "BITNET_RAN" | "ENGINE_MISSING" | "INSPECT_VERDICT" | "MAPPING_BLOCK" | "POLICY_RECOMMENDED" | "SCOUT_TRIGGERED" | "SCOUT_UNTRIGGERED";
 /**
  * Severity levels for signals
  * P0 = Critical (immediate attention)

package/build/mcp/tools/vibe_pm/signals/types.js

@@ -13,6 +13,8 @@ export function isSignalType(value) {
         "INSPECT_VERDICT",
         "MAPPING_BLOCK",
         "POLICY_RECOMMENDED",
+        "SCOUT_TRIGGERED",
+        "SCOUT_UNTRIGGERED",
     ];
     return validTypes.includes(value);
 }

package/build/mcp/tools/vibe_pm/skills_tool.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+export declare const skillsInputSchema: z.ZodObject<{
+    mode: z.ZodDefault<z.ZodEnum<["list", "detail"]>>;
+    skill_id: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    mode: "list" | "detail";
+    skill_id?: string | undefined;
+}, {
+    mode?: "list" | "detail" | undefined;
+    skill_id?: string | undefined;
+}>;
+export type SkillsInput = z.infer<typeof skillsInputSchema>;
+export declare function skills(input: SkillsInput): Promise<unknown>;

package/build/mcp/tools/vibe_pm/skills_tool.js

@@ -0,0 +1,57 @@
+// vibe_pm.skills — Skill pack listing and detail
+import { z } from 'zod';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { listActivatedSkills } from '../../bootstrap/skills-installer.js';
+export const skillsInputSchema = z.object({
+    mode: z.enum(['list', 'detail']).default('list'),
+    skill_id: z.string().optional(),
+});
+export async function skills(input) {
+    const skillsDir = path.resolve(__dirname, '../../../../skills');
+    const skillpackPath = path.join(skillsDir, 'skillpack.json');
+    let entries = [];
+    try {
+        const raw = fs.readFileSync(skillpackPath, 'utf8');
+        const parsed = JSON.parse(raw);
+        entries = Array.isArray(parsed.skills) ? parsed.skills : [];
+    }
+    catch {
+        return { skills: [], error: 'skillpack.json을 읽을 수 없습니다.' };
+    }
+    // Get activation state
+    let activated = [];
+    try {
+        activated = await listActivatedSkills();
+    }
+    catch {
+        // fail-safe
+    }
+    const activatedSet = new Set(activated);
+    if (input.mode === 'detail' && input.skill_id) {
+        const skill = entries.find(s => s.id === input.skill_id);
+        if (!skill) {
+            return { error: `스킬 '${input.skill_id}'을(를) 찾을 수 없습니다.` };
+        }
+        return {
+            skill: {
+                id: skill.id,
+                name: skill.name,
+                description: skill.description ?? '',
+                required_tools: skill.required_tools ?? [],
+                version: skill.version ?? '1.0.0',
+                activated: activatedSet.has(skill.id),
+            },
+        };
+    }
+    return {
+        skills: entries.map(s => ({
+            id: s.id,
+            name: s.name,
+            description: s.description ?? '',
+            activated: activatedSet.has(s.id),
+        })),
+        total: entries.length,
+        activated_count: entries.filter(s => activatedSet.has(s.id)).length,
+    };
+}