@vibecodetown/mcp-server 1.3.1 → 1.5.0

package/build/kernel/musu_adapter_types.d.ts

@@ -0,0 +1,212 @@
+/**
+ * Musu Adapter Types
+ * ==================
+ *
+ * Shared type definitions for the Musu Worker HTTP API.
+ * Extracted from musu_adapter.ts for DDD boundary clarity.
+ *
+ * @since v1.8.0
+ */
+/**
+ * Job types supported by musu (Bee 4종 보직)
+ */
+export type MusuJobType = 'semantic_grep' | 'sanity_check' | 'dependency_scan' | 'doc_draft';
+/**
+ * Job priority levels
+ */
+export type MusuPriority = 'low' | 'normal' | 'high';
+/**
+ * Scope definition for work requests
+ */
+export interface MusuScope {
+    workspace: string;
+    paths?: string[];
+    globs?: string[];
+    exclude_globs?: string[];
+    max_files?: number;
+    max_lines_per_file?: number;
+}
+/**
+ * Work request to musu
+ */
+export interface MusuWorkRequest {
+    job_id: string;
+    job_type: MusuJobType;
+    scope: MusuScope;
+    params?: Record<string, unknown>;
+    priority?: MusuPriority;
+    timeout_ms?: number;
+}
+/**
+ * Job status from musu
+ */
+export type MusuJobStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+/**
+ * Response metadata
+ */
+export interface MusuResponseMeta {
+    files_scanned: number;
+    scope_hash: string;
+    job_params_hash: string;
+    started_at: string;
+    completed_at: string;
+    duration_ms: number;
+    tokens_used: number;
+    engine: string;
+    model: string;
+}
+/**
+ * Response artifacts
+ */
+export interface MusuArtifacts {
+    log_path?: string;
+    evidence_files: string[];
+    written_to: string[];
+}
+/**
+ * Work response from musu
+ */
+export interface MusuWorkResponse {
+    job_id: string;
+    job_type: MusuJobType;
+    status: MusuJobStatus;
+    result?: unknown;
+    cached: boolean;
+    duration_ms: number;
+    timestamp: string;
+    meta?: MusuResponseMeta;
+    artifacts?: MusuArtifacts;
+}
+/**
+ * Health status
+ */
+export interface MusuHealth {
+    status: 'ok' | 'degraded' | 'error' | 'draining';
+    version?: string;
+    mode?: string;
+    uptime_ms?: number;
+}
+/**
+ * Telemetry data
+ */
+export interface MusuTelemetry {
+    cpu_percent: number;
+    memory_percent: number;
+    available_memory_mb: number;
+    timestamp: string;
+    active_jobs?: number;
+    queued_jobs?: number;
+    completed_jobs?: number;
+    failed_jobs?: number;
+}
+/**
+ * Adapter status
+ */
+export type MusuAdapterStatus = 'stopped' | 'starting' | 'running' | 'error';
+/**
+ * Payload for an approval request
+ */
+export interface ApprovalRequestPayload {
+    command: string;
+    cwd?: string;
+    ask?: string;
+    risk?: string;
+    agent_id?: string;
+}
+/**
+ * Approval decision
+ */
+export type ApprovalDecision = 'approved' | 'denied';
+/**
+ * Full approval record (snapshot)
+ */
+export interface ApprovalRecord {
+    id: string;
+    request: ApprovalRequestPayload;
+    created_at_ms: number;
+    expires_at_ms: number;
+    resolved_at_ms?: number;
+    decision?: ApprovalDecision;
+    resolved_by?: string;
+}
+/**
+ * Request body for creating an approval
+ */
+export interface CreateApprovalBody {
+    request: ApprovalRequestPayload;
+    timeout_ms?: number;
+    id?: string;
+}
+/**
+ * Request body for resolving an approval
+ */
+export interface ResolveApprovalBody {
+    decision: ApprovalDecision;
+    resolved_by?: string;
+}
+/**
+ * Request body for waiting on an approval
+ */
+export interface WaitApprovalBody {
+    timeout_ms?: number;
+}
+/**
+ * Wait result from the server
+ */
+export interface WaitApprovalResult {
+    status: 'resolved' | 'timeout';
+    decision?: ApprovalDecision;
+}
+/**
+ * Engine info from the pool
+ */
+export interface EngineInfo {
+    port: number;
+    threads: number;
+    state: string;
+    active_requests: number;
+    avg_latency_ms: number;
+    total_inferences: number;
+}
+/**
+ * Election snapshot
+ */
+export interface ElectionSnapshot {
+    peer_id: string;
+    priority: number;
+    role: string;
+    term: number;
+    leader_id?: string;
+    peer_count: number;
+    running: boolean;
+}
+/**
+ * Aggregated swarm health state
+ */
+export interface SwarmHealthState {
+    node_id?: string;
+    quic_addr?: string;
+    election?: ElectionSnapshot;
+    engine_pool_count: number;
+    engine_infos: EngineInfo[];
+    memex_peer_count: number;
+    broadcaster_peer_count: number;
+    localai_status?: string;
+}
+export interface SwarmHealthEnvelope {
+    status: string;
+    uptime_secs: number;
+    resources: {
+        cpu_percent: number;
+        memory_percent: number;
+        available_memory_mb: number;
+    };
+    swarm: SwarmHealthState;
+}
+/**
+ * A single SSE event from the work stream
+ */
+export interface WorkStreamEvent {
+    event: string;
+    data: unknown;
+}

package/build/kernel/musu_adapter_types.js

@@ -0,0 +1,10 @@
+/**
+ * Musu Adapter Types
+ * ==================
+ *
+ * Shared type definitions for the Musu Worker HTTP API.
+ * Extracted from musu_adapter.ts for DDD boundary clarity.
+ *
+ * @since v1.8.0
+ */
+export {};

package/build/kernel/musu_endpoint.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Musu endpoint resolution (SSOT)
+ *
+ * Purpose:
+ * - Keep Musu Worker base URL/port resolution in one place.
+ * - Prefer current Musu defaults (8080) while preserving legacy fallback (3000).
+ */
+export declare function getMusuWorkerPort(): number;
+export declare function getMusuBaseUrl(): string;
+/**
+ * Candidate URLs in priority order.
+ * - Explicit URL env exists: return only that URL.
+ * - Otherwise: current default (8080) then legacy fallback (3000).
+ */
+export declare function getMusuBaseUrlCandidates(): string[];

package/build/kernel/musu_endpoint.js

@@ -0,0 +1,62 @@
+/**
+ * Musu endpoint resolution (SSOT)
+ *
+ * Purpose:
+ * - Keep Musu Worker base URL/port resolution in one place.
+ * - Prefer current Musu defaults (8080) while preserving legacy fallback (3000).
+ */
+const DEFAULT_HOST = '127.0.0.1';
+const DEFAULT_MUSU_PORT = 8080;
+const LEGACY_MUSU_PORT = 3000;
+function parsePort(raw) {
+    if (!raw)
+        return null;
+    const n = Number.parseInt(raw, 10);
+    if (!Number.isFinite(n) || n <= 0 || n > 65535)
+        return null;
+    return n;
+}
+function normalizeUrl(url) {
+    return url.trim().replace(/\/+$/, '');
+}
+function explicitUrlFromEnv() {
+    const raw = process.env.MUSU_WORKER_URL?.trim()
+        || process.env.MUSU_BASE_URL?.trim()
+        || process.env.VIBE_MUSU_URL?.trim();
+    if (!raw)
+        return null;
+    return normalizeUrl(raw);
+}
+export function getMusuWorkerPort() {
+    const byWorkerPort = parsePort(process.env.MUSU_WORKER_PORT);
+    if (byWorkerPort !== null)
+        return byWorkerPort;
+    const byLegacyMusuPort = parsePort(process.env.MUSU_PORT);
+    if (byLegacyMusuPort !== null)
+        return byLegacyMusuPort;
+    return DEFAULT_MUSU_PORT;
+}
+export function getMusuBaseUrl() {
+    const explicit = explicitUrlFromEnv();
+    if (explicit)
+        return explicit;
+    const host = process.env.MUSU_WORKER_HOST?.trim() || DEFAULT_HOST;
+    return `http://${host}:${getMusuWorkerPort()}`;
+}
+/**
+ * Candidate URLs in priority order.
+ * - Explicit URL env exists: return only that URL.
+ * - Otherwise: current default (8080) then legacy fallback (3000).
+ */
+export function getMusuBaseUrlCandidates() {
+    const explicit = explicitUrlFromEnv();
+    if (explicit)
+        return [explicit];
+    const host = process.env.MUSU_WORKER_HOST?.trim() || DEFAULT_HOST;
+    const primaryPort = getMusuWorkerPort();
+    const primary = `http://${host}:${primaryPort}`;
+    const legacy = `http://${host}:${LEGACY_MUSU_PORT}`;
+    if (primaryPort === LEGACY_MUSU_PORT)
+        return [primary];
+    return [primary, legacy];
+}

package/build/kernel/paths.d.ts

@@ -0,0 +1,90 @@
+export declare function getPackageRoot(): string;
+/** Reset cached package root (for testing only). */
+export declare function _resetPackageRoot(): void;
+/** Read version from package.json */
+export declare function getPackageVersion(): string;
+/** bin/ directory (package_root/bin) */
+export declare function getBinDir(): string;
+/** build/bin/ directory */
+export declare function getBuildBinDir(): string;
+/** Worker script path with build→src fallback */
+export declare function getWorkerScriptPath(workerName: string): string;
+/** Musu binary candidate paths (ordered by priority) */
+export declare function getMusuBinaryPaths(): string[];
+export type SpecMapPathSource = 'vibe_config_dir' | 'legacy_vibe_root';
+export declare function getVibeDir(workspaceRoot: string): string;
+export declare function getVibeConfigDir(workspaceRoot: string): string;
+export declare function getVibeCacheDir(workspaceRoot: string): string;
+export declare function getVibeChromaCacheDir(workspaceRoot: string): string;
+export declare function getVibeBitnetCacheDir(workspaceRoot: string): string;
+export declare function getBitnetTracePath(workspaceRoot: string): string;
+export declare function getBitnetSignalPath(workspaceRoot: string): string;
+export declare function ensureDirSync(dirPath: string): void;
+export declare function resolveSpecMapPath(workspaceRoot: string): {
+    absPath: string;
+    source: SpecMapPathSource;
+};
+export declare function getPmRunsDir(workspaceRoot: string): string;
+export declare function getLegacyRunsDir(workspaceRoot: string): string;
+export declare function getEngineRunsDir(workspaceRoot: string): string;
+export declare function getEngineRunDir(workspaceRoot: string, runId: string): string;
+export declare function getPmRunDir(workspaceRoot: string, runId: string): string;
+/**
+ * Resolve run directory for reading, checking multiple locations.
+ * Priority order:
+ *   1. .vibe/runs/<runId>           (PM 표준)
+ *   2. engines/spec_high/runs/<runId> (엔진 출력)
+ *   3. runs/<runId>                 (레거시)
+ *
+ * @param workspaceRoot - Workspace root path
+ * @param runId - Run ID to resolve
+ * @returns Resolved run directory path (may not exist)
+ */
+export declare function resolvePmRunDirForRead(workspaceRoot: string, runId: string): string;
+/**
+ * Get the Block Store root directory.
+ * Blocks are stored repo-wide (not per-run).
+ *
+ * @param workspaceRoot - Workspace root path
+ * @returns Path to .vibe/blocks/
+ */
+export declare function getBlockStoreDir(workspaceRoot: string): string;
+/**
+ * Get path to a specific block file.
+ * Uses hash prefix directories for better filesystem performance.
+ *
+ * @param workspaceRoot - Workspace root path
+ * @param blockId - Block ID (e.g., "blk_abcd1234567890ef")
+ * @returns Path to block JSON file (e.g., .vibe/blocks/ab/blk_abcd1234567890ef.json)
+ */
+export declare function getBlockPath(workspaceRoot: string, blockId: string): string;
+/**
+ * Get path to a block chain file.
+ *
+ * @param workspaceRoot - Workspace root path
+ * @param rootHash - Root hash of the chain (e.g., "doc_xyz123...")
+ * @returns Path to chain JSON file (e.g., .vibe/blocks/chains/doc_xyz123....json)
+ */
+export declare function getBlockChainPath(workspaceRoot: string, rootHash: string): string;
+/**
+ * Get path to the Block Store index file.
+ *
+ * @param workspaceRoot - Workspace root path
+ * @returns Path to index.json
+ */
+export declare function getBlockIndexPath(workspaceRoot: string): string;
+/**
+ * Get path to the Block Store chains directory.
+ *
+ * @param workspaceRoot - Workspace root path
+ * @returns Path to .vibe/blocks/chains/
+ */
+export declare function getBlockChainsDir(workspaceRoot: string): string;
+/** Repo-bundled tensor config (SSOT — git tracked) */
+export declare function getTensorConfigDir(): string;
+/** .vibe override tensor config (local, git ignored) */
+export declare function getVibeTensorConfigDir(workspaceRoot: string): string;
+/** Tensor scorecard cache (local) */
+export declare function getVibeTensorCacheDir(workspaceRoot: string): string;
+/** Rebinder proposal cache (local) */
+export declare function getVibeRebinderCacheDir(workspaceRoot: string): string;

package/build/kernel/paths.js

@@ -0,0 +1,240 @@
+// Centralized storage paths SSOT for repo-local `.vibe/` layout.
+//
+// Goals:
+// - Prevent "random folder sprawl" by routing all system writes under `.vibe/`.
+// - Support gradual migration from legacy `runs/<run_id>/...` to `.vibe/runs/<run_id>/...`.
+// - Keep path computation in one place (no ad-hoc string joins).
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// ============================================================
+// Package Root SSOT — __dirname 중앙 관리
+// ============================================================
+/** Package root (mvp_core_clinic/). Cached after first call. */
+let _packageRoot = null;
+export function getPackageRoot() {
+    if (_packageRoot)
+        return _packageRoot;
+    // Walk up from this file's location to find package.json
+    let dir = __dirname;
+    for (let i = 0; i < 5; i++) {
+        if (fs.existsSync(path.join(dir, 'package.json'))) {
+            _packageRoot = dir;
+            return dir;
+        }
+        dir = path.dirname(dir);
+    }
+    // Static fallback: build/kernel/paths.js → build/kernel → build → root
+    _packageRoot = path.resolve(__dirname, '..', '..');
+    return _packageRoot;
+}
+/** Reset cached package root (for testing only). */
+export function _resetPackageRoot() {
+    _packageRoot = null;
+}
+/** Read version from package.json */
+export function getPackageVersion() {
+    try {
+        const pkgPath = path.join(getPackageRoot(), 'package.json');
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        return pkg.version ?? '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+/** bin/ directory (package_root/bin) */
+export function getBinDir() {
+    return path.join(getPackageRoot(), 'bin');
+}
+/** build/bin/ directory */
+export function getBuildBinDir() {
+    return path.join(getPackageRoot(), 'build', 'bin');
+}
+/** Worker script path with build→src fallback */
+export function getWorkerScriptPath(workerName) {
+    const buildPath = path.join(getBuildBinDir(), `${workerName}.js`);
+    if (fs.existsSync(buildPath))
+        return buildPath;
+    const srcPath = path.join(getPackageRoot(), 'src', 'bin', `${workerName}.ts`);
+    if (fs.existsSync(srcPath))
+        return srcPath;
+    return buildPath; // fallback to build path even if not found
+}
+/** Musu binary candidate paths (ordered by priority) */
+export function getMusuBinaryPaths() {
+    const root = getPackageRoot();
+    const isWin = process.platform === 'win32';
+    const arch = process.arch;
+    const bundledName = isWin ? `musu-win32-${arch}.exe` : `musu-${process.platform}-${arch}`;
+    const candidates = [
+        process.env.MUSU_BIN_PATH,
+        // dev path (engines/ in monorepo root)
+        path.resolve(root, '..', '..', 'engines', 'bitnet-musu', 'target', 'release', isWin ? 'musu.exe' : 'musu'),
+        // bundled (bin/)
+        path.join(root, 'bin', bundledName),
+        // legacy bundled
+        path.join(root, 'bin', isWin ? 'musu.exe' : 'musu'),
+    ];
+    return candidates.filter((p) => !!p);
+}
+export function getVibeDir(workspaceRoot) {
+    return path.join(workspaceRoot, '.vibe');
+}
+export function getVibeConfigDir(workspaceRoot) {
+    return path.join(getVibeDir(workspaceRoot), 'config');
+}
+export function getVibeCacheDir(workspaceRoot) {
+    return path.join(getVibeDir(workspaceRoot), 'cache');
+}
+export function getVibeChromaCacheDir(workspaceRoot) {
+    // NOTE: This is a repo-local cache directory (not run-local).
+    return path.join(getVibeCacheDir(workspaceRoot), 'chroma');
+}
+export function getVibeBitnetCacheDir(workspaceRoot) {
+    return path.join(getVibeCacheDir(workspaceRoot), 'bitnet');
+}
+export function getBitnetTracePath(workspaceRoot) {
+    return path.join(getVibeBitnetCacheDir(workspaceRoot), 'bitnet_traces.json');
+}
+export function getBitnetSignalPath(workspaceRoot) {
+    return path.join(getVibeBitnetCacheDir(workspaceRoot), 'bitnet_signal.latest.json');
+}
+export function ensureDirSync(dirPath) {
+    if (!fs.existsSync(dirPath))
+        fs.mkdirSync(dirPath, { recursive: true });
+}
+export function resolveSpecMapPath(workspaceRoot) {
+    const primary = path.join(getVibeConfigDir(workspaceRoot), 'spec_map.v1.json');
+    if (fs.existsSync(primary))
+        return { absPath: primary, source: 'vibe_config_dir' };
+    const legacy = path.join(getVibeDir(workspaceRoot), 'spec_map.v1.json');
+    return { absPath: legacy, source: 'legacy_vibe_root' };
+}
+export function getPmRunsDir(workspaceRoot) {
+    return path.join(getVibeDir(workspaceRoot), 'runs');
+}
+export function getLegacyRunsDir(workspaceRoot) {
+    return path.join(workspaceRoot, 'runs');
+}
+// ============================================================
+// Engine Paths (spec-high 엔진 출력 경로)
+// ============================================================
+export function getEngineRunsDir(workspaceRoot) {
+    return path.join(workspaceRoot, 'engines', 'spec_high', 'runs');
+}
+export function getEngineRunDir(workspaceRoot, runId) {
+    return path.join(getEngineRunsDir(workspaceRoot), runId);
+}
+// ============================================================
+// Run Directory Resolution
+// ============================================================
+export function getPmRunDir(workspaceRoot, runId) {
+    return path.join(getPmRunsDir(workspaceRoot), runId);
+}
+/**
+ * Resolve run directory for reading, checking multiple locations.
+ * Priority order:
+ *   1. .vibe/runs/<runId>           (PM 표준)
+ *   2. engines/spec_high/runs/<runId> (엔진 출력)
+ *   3. runs/<runId>                 (레거시)
+ *
+ * @param workspaceRoot - Workspace root path
+ * @param runId - Run ID to resolve
+ * @returns Resolved run directory path (may not exist)
+ */
+export function resolvePmRunDirForRead(workspaceRoot, runId) {
+    // Skip engine path check if legacy-only mode is enabled
+    const legacyOnly = process.env.VIBE_LEGACY_PATH_ONLY === '1';
+    // 1. PM 표준 경로 (.vibe/runs/)
+    const pm = getPmRunDir(workspaceRoot, runId);
+    if (fs.existsSync(pm))
+        return pm;
+    // 2. 엔진 출력 경로 (engines/spec_high/runs/)
+    if (!legacyOnly) {
+        const engine = getEngineRunDir(workspaceRoot, runId);
+        if (fs.existsSync(engine))
+            return engine;
+    }
+    // 3. 레거시 경로 (runs/)
+    const legacy = path.join(getLegacyRunsDir(workspaceRoot), runId);
+    if (fs.existsSync(legacy))
+        return legacy;
+    // Default to target location (even if it doesn't exist yet)
+    return pm;
+}
+// ============================================================
+// Block Store Paths
+// ============================================================
+/**
+ * Get the Block Store root directory.
+ * Blocks are stored repo-wide (not per-run).
+ *
+ * @param workspaceRoot - Workspace root path
+ * @returns Path to .vibe/blocks/
+ */
+export function getBlockStoreDir(workspaceRoot) {
+    return path.join(getVibeDir(workspaceRoot), 'blocks');
+}
+/**
+ * Get path to a specific block file.
+ * Uses hash prefix directories for better filesystem performance.
+ *
+ * @param workspaceRoot - Workspace root path
+ * @param blockId - Block ID (e.g., "blk_abcd1234567890ef")
+ * @returns Path to block JSON file (e.g., .vibe/blocks/ab/blk_abcd1234567890ef.json)
+ */
+export function getBlockPath(workspaceRoot, blockId) {
+    // Extract prefix from block ID (strip "blk_" prefix, take first 2 chars)
+    const prefix = blockId.replace(/^blk_/, '').slice(0, 2);
+    return path.join(getBlockStoreDir(workspaceRoot), prefix, `${blockId}.json`);
+}
+/**
+ * Get path to a block chain file.
+ *
+ * @param workspaceRoot - Workspace root path
+ * @param rootHash - Root hash of the chain (e.g., "doc_xyz123...")
+ * @returns Path to chain JSON file (e.g., .vibe/blocks/chains/doc_xyz123....json)
+ */
+export function getBlockChainPath(workspaceRoot, rootHash) {
+    return path.join(getBlockStoreDir(workspaceRoot), 'chains', `${rootHash}.json`);
+}
+/**
+ * Get path to the Block Store index file.
+ *
+ * @param workspaceRoot - Workspace root path
+ * @returns Path to index.json
+ */
+export function getBlockIndexPath(workspaceRoot) {
+    return path.join(getBlockStoreDir(workspaceRoot), 'index.json');
+}
+/**
+ * Get path to the Block Store chains directory.
+ *
+ * @param workspaceRoot - Workspace root path
+ * @returns Path to .vibe/blocks/chains/
+ */
+export function getBlockChainsDir(workspaceRoot) {
+    return path.join(getBlockStoreDir(workspaceRoot), 'chains');
+}
+// ============================================================
+// Tensor Scoring Paths (P14)
+// ============================================================
+/** Repo-bundled tensor config (SSOT — git tracked) */
+export function getTensorConfigDir() {
+    return path.join(getPackageRoot(), 'config', 'tensor');
+}
+/** .vibe override tensor config (local, git ignored) */
+export function getVibeTensorConfigDir(workspaceRoot) {
+    return path.join(getVibeConfigDir(workspaceRoot), 'tensor');
+}
+/** Tensor scorecard cache (local) */
+export function getVibeTensorCacheDir(workspaceRoot) {
+    return path.join(getVibeCacheDir(workspaceRoot), 'tensor');
+}
+/** Rebinder proposal cache (local) */
+export function getVibeRebinderCacheDir(workspaceRoot) {
+    return path.join(getVibeCacheDir(workspaceRoot), 'rebinder');
+}

package/build/kernel/resolve_deps.d.ts

@@ -0,0 +1,12 @@
+import { BlockStore } from './blocks/store.js';
+import { ChainManager } from './blocks/chain.js';
+import type { IBlockStore, IChainManager } from './contracts.js';
+export interface BlockRuntimeDepsInput {
+    blockStore?: IBlockStore;
+    chainManager?: IChainManager;
+}
+export declare function resolveBlockStore(workspaceRoot: string, injected?: IBlockStore): BlockStore;
+export declare function resolveChainManager(workspaceRoot: string, deps?: BlockRuntimeDepsInput): {
+    blockStore: BlockStore;
+    chainManager: ChainManager;
+};

package/build/kernel/resolve_deps.js

@@ -0,0 +1,14 @@
+import { BlockStore } from './blocks/store.js';
+import { ChainManager } from './blocks/chain.js';
+export function resolveBlockStore(workspaceRoot, injected) {
+    if (injected)
+        return injected;
+    const store = new BlockStore(workspaceRoot);
+    store.initialize();
+    return store;
+}
+export function resolveChainManager(workspaceRoot, deps) {
+    const blockStore = resolveBlockStore(workspaceRoot, deps?.blockStore);
+    const chainManager = deps?.chainManager ?? new ChainManager(blockStore);
+    return { blockStore, chainManager };
+}