@vibecodetown/mcp-server 1.3.1 → 1.4.0

package/build/mcp/tools/bitnet/schemas.js

@@ -0,0 +1,147 @@
+import { z } from 'zod';
+// ============================================================
+// Input Schemas
+// ============================================================
+export const bitnetCheckInputSchema = z.object({
+    files: z.array(z.string()).optional().describe('변경된 파일 목록 (생략 시 git diff로 자동 감지)'),
+    context: z.string().optional().describe('추가 컨텍스트 (코드 스니펫 등)'),
+    project_id: z.string().optional().describe('프로젝트 ID (생략 시 현재 폴더 사용)'),
+});
+export const bitnetTraceInputSchema = z.object({
+    trace_id: z.string().optional().describe('특정 trace ID 조회'),
+    limit: z.number().optional().default(10).describe('최근 N개 조회'),
+    project_id: z.string().optional().describe('프로젝트 ID'),
+});
+// Signal input schema (extends check input)
+export const bitnetSignalInputSchema = z.object({
+    files: z.array(z.string()).optional().describe('변경된 파일 목록 (생략 시 git diff로 자동 감지)'),
+    context: z.string().optional().describe('추가 컨텍스트 (코드 스니펫 등)'),
+    project_id: z.string().optional().describe('프로젝트 ID (생략 시 현재 폴더 사용)'),
+    include_autopilot: z.boolean().optional().default(true).describe('Autopilot 제안 포함 여부'),
+    event_source: z
+        .enum(['tool', 'observer', 'feedback'])
+        .optional()
+        .describe('내부 호출 출처(옵션): tool | observer | feedback'),
+    workspace_root: z.string().optional().describe('내부 호출 시 작업 루트 경로'),
+});
+export const bitnetScoutInputSchema = z
+    .object({
+    trigger_type: z
+        .enum(['dep_shift', 'auth_touch', 'gate_fix'])
+        .describe('Scout trigger type'),
+    payload: z.record(z.unknown()).describe('Trigger payload'),
+    musu_url: z
+        .string()
+        .url()
+        .optional()
+        .describe('Rust worker base URL (default: MUSU_WORKER_URL/MUSU_BASE_URL or http://127.0.0.1:8080)'),
+    bearer_token: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('Worker bearer token (default: MUSU_ACCESS_TOKEN / MUSU_WORKER_SECRET)'),
+});
+// ============================================================
+// Output Schemas
+// ============================================================
+export const bitnetCheckOutputSchema = z.object({
+    status: z.enum(['OK', 'WARNING', 'ERROR']),
+    verdict: z.enum(['GO', 'BLOCK', 'WARNING']),
+    risk_tags: z.array(z.string()),
+    reason: z.string(),
+    next_actions: z.array(z.string()),
+    review_focus: z.array(z.string()),
+    trace_id: z.string(),
+    checked_files: z.array(z.string()),
+    timestamp: z.string(),
+    tensor_risk: z
+        .object({
+        score: z.number(),
+        gate: z.enum(['STOP', 'STEER', 'GO']),
+        top_factors: z.array(z.object({ key: z.string(), contribution: z.number() })),
+    })
+        .optional(),
+});
+export const bitnetTraceOutputSchema = z.object({
+    status: z.enum(['OK', 'ERROR']),
+    traces: z.array(z.object({
+        trace_id: z.string(),
+        timestamp: z.string(),
+        verdict: z.enum(['GO', 'BLOCK', 'WARNING']),
+        risk_tags: z.array(z.string()),
+        reason: z.string(),
+        files: z.array(z.string()),
+    })),
+    message: z.string().optional(),
+    // Pro tier fields
+    telemetry: z
+        .object({
+        cpu_percent: z.number(),
+        memory_percent: z.number(),
+        active_jobs: z.number(),
+        completed_jobs: z.number(),
+    })
+        .optional(),
+    pro_features: z
+        .object({
+        extended_history: z.boolean(),
+        telemetry_available: z.boolean(),
+    })
+        .optional(),
+});
+export const bitnetSignalOutputSchema = z.object({
+    schema_version: z.literal('bitnet_signal.v1'),
+    state_guess: z.object({
+        phase: z.string(),
+        confidence: z.number(),
+        evidence: z.array(z.string()),
+    }),
+    next_actions: z.array(z.object({
+        tool: z.string(),
+        priority: z.number(),
+        reason: z.string(),
+        autopilot_eligible: z.boolean(),
+    })),
+    risk_signals: z.object({
+        level: z.string(),
+        tags: z.array(z.string()),
+        blocking: z.boolean(),
+    }),
+    trace_id: z.string(),
+    timestamp: z.string(),
+    checked_files: z.array(z.string()).optional(),
+    autopilot: z
+        .object({
+        eligible: z.boolean(),
+        proposed_action: z.string().nullable(),
+        proposed_tool: z.string().nullable(),
+        reason: z.string(),
+        blocked_by: z.array(z.string()),
+    })
+        .optional(),
+    tier_info: z
+        .object({
+        plan: z.enum(['FREE', 'PRO']),
+        concurrent_slots: z.object({
+            used: z.number(),
+            max: z.number(),
+        }),
+        pro_features_available: z.array(z.string()),
+    })
+        .optional(),
+});
+export const bitnetScoutOutputSchema = z.object({
+    status: z.enum(['OK', 'ERROR']),
+    source: z.literal('musu_worker'),
+    trigger: z.object({
+        trigger_type: z.enum(['dep_shift', 'auth_touch', 'gate_fix']),
+        payload: z.record(z.unknown()),
+    }),
+    scenario: z.string(),
+    block_id: z.string(),
+    root_hash: z.string(),
+    analysis: z.string(),
+    latency_ms: z.number(),
+    tokens: z.number(),
+    timestamp: z.number(),
+});

package/build/mcp/tools/bitnet/scout_diagnosis.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Scout Diagnosis Loader — Read Scout findings from Block Store chains
+ *
+ * Enumerates `scout:*` chains, filters by file scope overlap,
+ * and formats diagnosis data for context enrichment.
+ *
+ * @since v1.8.0
+ */
+import type { BlockStore } from '../../../kernel/blocks/store.js';
+export interface ScoutDiagnosis {
+    triggerId: string;
+    scenario: string;
+    riskLevel: string;
+    confidence: number;
+    suggestions: string[];
+    analysis: string | null;
+    scope: string[];
+}
+/**
+ * Load Scout diagnoses relevant to the given files.
+ *
+ * 1. Enumerate scout:* chains from BlockIndex
+ * 2. Filter by scope ∩ files overlap
+ * 3. Parse Block 0 metadata + Block 1 analysis
+ *
+ * Best-effort per chain — corrupted chains are silently skipped.
+ */
+export declare function loadScoutDiagnoses(store: BlockStore, files: string[]): ScoutDiagnosis[];
+/**
+ * Format diagnoses into a [SCOUT_DIAGNOSIS] section string.
+ *
+ * Returns empty string when no diagnoses — caller should skip injection.
+ */
+export declare function formatScoutDiagnosis(diagnoses: ScoutDiagnosis[]): string;

package/build/mcp/tools/bitnet/scout_diagnosis.js

@@ -0,0 +1,82 @@
+/**
+ * Scout Diagnosis Loader — Read Scout findings from Block Store chains
+ *
+ * Enumerates `scout:*` chains, filters by file scope overlap,
+ * and formats diagnosis data for context enrichment.
+ *
+ * @since v1.8.0
+ */
+// ============================================================================
+// Public API
+// ============================================================================
+/**
+ * Load Scout diagnoses relevant to the given files.
+ *
+ * 1. Enumerate scout:* chains from BlockIndex
+ * 2. Filter by scope ∩ files overlap
+ * 3. Parse Block 0 metadata + Block 1 analysis
+ *
+ * Best-effort per chain — corrupted chains are silently skipped.
+ */
+export function loadScoutDiagnoses(store, files) {
+    const index = store.getIndex();
+    if (!index.chains)
+        return [];
+    const fileSet = new Set(files);
+    const diagnoses = [];
+    for (const [sourcePath, rootHash] of Object.entries(index.chains)) {
+        if (!sourcePath.startsWith('scout:'))
+            continue;
+        try {
+            const blocks = store.getChainBlocks(rootHash);
+            if (!blocks || blocks.length === 0)
+                continue;
+            // Block 0: metadata JSON
+            const meta = JSON.parse(blocks[0].content);
+            const scope = meta.scope ?? [];
+            // Check scope ∩ files overlap
+            const hasOverlap = scope.some((s) => fileSet.has(s));
+            if (!hasOverlap)
+                continue;
+            // Block 1: analysis text (optional)
+            const analysis = blocks.length > 1 ? blocks[1].content : null;
+            diagnoses.push({
+                triggerId: meta.trigger_id ?? sourcePath.replace('scout:', ''),
+                scenario: meta.scenario ?? 'unknown',
+                riskLevel: meta.risk_level ?? 'unknown',
+                confidence: meta.confidence ?? 0,
+                suggestions: meta.suggestions ?? [],
+                analysis,
+                scope,
+            });
+        }
+        catch {
+            // Best-effort: skip corrupted chain
+            continue;
+        }
+    }
+    return diagnoses;
+}
+/**
+ * Format diagnoses into a [SCOUT_DIAGNOSIS] section string.
+ *
+ * Returns empty string when no diagnoses — caller should skip injection.
+ */
+export function formatScoutDiagnosis(diagnoses) {
+    if (diagnoses.length === 0)
+        return '';
+    const lines = ['[SCOUT_DIAGNOSIS]'];
+    for (const d of diagnoses) {
+        lines.push(`- ${d.triggerId} (risk: ${d.riskLevel}, confidence: ${d.confidence}): ${d.scenario}`);
+        lines.push(`  Files: ${d.scope.join(', ')}`);
+        if (d.suggestions.length > 0) {
+            lines.push(`  Suggestions: ${d.suggestions.join(', ')}`);
+        }
+        if (d.analysis) {
+            // Truncate long analysis to keep context window manageable
+            const truncated = d.analysis.length > 500 ? d.analysis.slice(0, 500) + '...' : d.analysis;
+            lines.push(`  Analysis: ${truncated}`);
+        }
+    }
+    return lines.join('\n');
+}

package/build/mcp/tools/bitnet/trace_store.d.ts

@@ -0,0 +1,9 @@
+import type { BitNetTraceEntry, BitnetArtifactSource, Verdict } from './types.js';
+export declare function loadTraces(basePath: string): BitNetTraceEntry[];
+export declare function saveTrace(basePath: string, entry: BitNetTraceEntry): void;
+export declare function buildBitnetNote(entry: BitNetTraceEntry): string;
+export declare function buildBitnetSignalEventMetadata(entry: BitNetTraceEntry, options: {
+    source: BitnetArtifactSource;
+    artifact_path: string;
+}): Record<string, unknown>;
+export declare function deriveBitnetSignalType(verdict: Verdict): 'signal.doubt_created' | 'signal.risk_changed';

package/build/mcp/tools/bitnet/trace_store.js

@@ -0,0 +1,91 @@
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import { ensureDirSync, getBitnetTracePath, getVibeBitnetCacheDir, } from '../../../kernel/paths.js';
+import { emitEvent } from '../../events/emitter.js';
+function getTracePath(basePath) {
+    return getBitnetTracePath(basePath);
+}
+export function loadTraces(basePath) {
+    const tracePath = getTracePath(basePath);
+    const legacyPath = path.join(basePath, '.vibe-agent', 'bitnet_traces.json');
+    try {
+        if (fs.existsSync(tracePath)) {
+            const content = fs.readFileSync(tracePath, 'utf-8');
+            return JSON.parse(content);
+        }
+        if (fs.existsSync(legacyPath)) {
+            const content = fs.readFileSync(legacyPath, 'utf-8');
+            return JSON.parse(content);
+        }
+    }
+    catch {
+        // ignore
+    }
+    return [];
+}
+export function saveTrace(basePath, entry) {
+    const tracePath = getTracePath(basePath);
+    const dir = getVibeBitnetCacheDir(basePath);
+    try {
+        ensureDirSync(dir);
+        const traces = loadTraces(basePath);
+        traces.unshift(entry); // prepend
+        // Keep only last 1000 traces
+        const trimmed = traces.slice(0, 1000);
+        fs.writeFileSync(tracePath, JSON.stringify(trimmed, null, 2));
+        // Emit bitnet trace event (artifact + signal)
+        const note = buildBitnetNote(entry);
+        const metadata = buildBitnetSignalEventMetadata(entry, {
+            source: 'bitnet_check',
+            artifact_path: tracePath,
+        });
+        emitEvent({
+            runId: entry.trace_id ?? 'bitnet',
+            type: 'artifact.bitnet_signal_written',
+            reason: 'bitnet_trace_saved',
+            paths: [tracePath],
+            component: 'bitnet',
+            workspaceRoot: basePath,
+            note,
+            metadata,
+        });
+        const signalType = deriveBitnetSignalType(entry.verdict);
+        emitEvent({
+            runId: entry.trace_id ?? 'bitnet',
+            type: signalType,
+            reason: 'bitnet_trace_saved',
+            paths: [tracePath],
+            component: 'bitnet',
+            workspaceRoot: basePath,
+            note,
+            metadata: {
+                ...metadata,
+                signal_type: signalType,
+            },
+        });
+    }
+    catch {
+        // ignore storage errors
+    }
+}
+export function buildBitnetNote(entry) {
+    const risks = (entry.risk_tags || []).join(',');
+    const files = (entry.files || []).join(',');
+    return `verdict=${entry.verdict}; reason=${entry.reason}; risks=${risks}; files=${files}`;
+}
+export function buildBitnetSignalEventMetadata(entry, options) {
+    return {
+        contract: 'bitnet_signal_event.v1',
+        source: options.source,
+        trace_id: entry.trace_id,
+        verdict: entry.verdict,
+        verdict_reason: entry.reason,
+        risk_tags: entry.risk_tags,
+        checked_files: entry.files,
+        artifact_path: options.artifact_path,
+        checked_at: entry.timestamp,
+    };
+}
+export function deriveBitnetSignalType(verdict) {
+    return verdict === 'BLOCK' ? 'signal.doubt_created' : 'signal.risk_changed';
+}

package/build/mcp/tools/bitnet/types.d.ts

@@ -0,0 +1,44 @@
+export type Verdict = 'GO' | 'BLOCK' | 'WARNING';
+export type RiskTag = 'ENV_CHANGE' | 'BLACK_ZONE_TOUCH' | 'YELLOW_ZONE_TOUCH' | 'CONFIG_CHANGE' | 'SECRET_DETECTED' | 'PII_DETECTED' | 'DELETE_COMMAND' | 'PERMISSION_CHANGE' | 'TEST_MISSING' | 'DEPENDENCY_CHANGE' | 'API_CHANGE' | 'DB_SCHEMA_CHANGE';
+export declare const VALID_RISK_TAGS: RiskTag[];
+export interface BitNetOutput {
+    risk_tags: RiskTag[];
+    verdict: Verdict;
+    reason: string;
+}
+export interface BitNetCheckResult {
+    status: 'OK' | 'WARNING' | 'ERROR';
+    verdict: Verdict;
+    risk_tags: RiskTag[];
+    reason: string;
+    next_actions: string[];
+    review_focus: string[];
+    trace_id: string;
+    checked_files: string[];
+    timestamp: string;
+    tensor_risk?: {
+        score: number;
+        gate: 'STOP' | 'STEER' | 'GO';
+        top_factors: Array<{
+            key: string;
+            contribution: number;
+        }>;
+    };
+}
+export interface BitNetTraceEntry {
+    trace_id: string;
+    timestamp: string;
+    verdict: Verdict;
+    risk_tags: RiskTag[];
+    reason: string;
+    files: string[];
+    tensor_risk?: {
+        score: number;
+        gate: string;
+        top_factors: Array<{
+            key: string;
+            contribution: number;
+        }>;
+    };
+}
+export type BitnetArtifactSource = 'bitnet_check' | 'bitnet_signal' | 'observer';

package/build/mcp/tools/bitnet/types.js

@@ -0,0 +1,15 @@
+// BitNet tool types (SSOT)
+export const VALID_RISK_TAGS = [
+    'ENV_CHANGE',
+    'BLACK_ZONE_TOUCH',
+    'YELLOW_ZONE_TOUCH',
+    'CONFIG_CHANGE',
+    'SECRET_DETECTED',
+    'PII_DETECTED',
+    'DELETE_COMMAND',
+    'PERMISSION_CHANGE',
+    'TEST_MISSING',
+    'DEPENDENCY_CHANGE',
+    'API_CHANGE',
+    'DB_SCHEMA_CHANGE',
+];

package/build/mcp/tools/shared/boundary_errors.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Boundary Warning — structured fail-safe error reporting
+ *
+ * Captures suppressed errors at the MCP tool → Engine boundary
+ * without changing fail-safe behavior. Adds observability to
+ * the 129+ bare catch {} blocks in the tool layer.
+ *
+ * @since v1.10.0
+ */
+export interface BoundaryWarning {
+    /** Engine component that failed (e.g., 'scorecard', 'chain_storage') */
+    component: string;
+    /** Operation that was attempted (e.g., 'append', 'persist') */
+    operation: string;
+    /** Error class name or 'UNKNOWN' */
+    error_class: string;
+    /** Error message (truncated to 200 chars) */
+    message: string;
+    /** Always true — these are suppressed, non-fatal errors */
+    suppressed: true;
+}
+/**
+ * Capture a suppressed error as a BoundaryWarning.
+ *
+ * Call this inside existing fail-safe catch blocks to record
+ * diagnostic info without changing the fail-safe behavior.
+ */
+export declare function captureBoundaryWarning(warnings: BoundaryWarning[], component: string, operation: string, error: unknown): void;
+/**
+ * Attach warnings to a tool output object.
+ * Only adds the field if there are warnings (backwards-compatible).
+ */
+export declare function attachBoundaryWarnings(output: Record<string, unknown>, warnings: BoundaryWarning[]): void;

package/build/mcp/tools/shared/boundary_errors.js

@@ -0,0 +1,41 @@
+/**
+ * Boundary Warning — structured fail-safe error reporting
+ *
+ * Captures suppressed errors at the MCP tool → Engine boundary
+ * without changing fail-safe behavior. Adds observability to
+ * the 129+ bare catch {} blocks in the tool layer.
+ *
+ * @since v1.10.0
+ */
+// ============================================================================
+// Capture Helper
+// ============================================================================
+/**
+ * Capture a suppressed error as a BoundaryWarning.
+ *
+ * Call this inside existing fail-safe catch blocks to record
+ * diagnostic info without changing the fail-safe behavior.
+ */
+export function captureBoundaryWarning(warnings, component, operation, error) {
+    const errorClass = error instanceof Error ? error.constructor.name : 'UNKNOWN';
+    const message = error instanceof Error ? error.message.slice(0, 200) : String(error).slice(0, 200);
+    warnings.push({
+        component,
+        operation,
+        error_class: errorClass,
+        message,
+        suppressed: true,
+    });
+}
+// ============================================================================
+// Output Helper
+// ============================================================================
+/**
+ * Attach warnings to a tool output object.
+ * Only adds the field if there are warnings (backwards-compatible).
+ */
+export function attachBoundaryWarnings(output, warnings) {
+    if (warnings.length > 0) {
+        output['_boundary_warnings'] = warnings;
+    }
+}

package/build/mcp/tools/shared/tier_facade.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Tier Facade — canonical tier resolution for all MCP tools
+ *
+ * Wraps LicenseManager in a single-call snapshot so all tools
+ * within a request see the same tier state. Replaces the pattern
+ * of each tool independently calling new LicenseManager().
+ *
+ * @since v1.10.0
+ */
+import { type Plan, type LicenseStatus, type EntitlementsEffective } from '../../../license-manager.js';
+import { type SlotLimits } from '../../../bitnet-worker/hw_slots.js';
+export interface TierSnapshot {
+    plan: Plan;
+    isPro: boolean;
+    status: LicenseStatus;
+    daysLeft?: number;
+    refreshRecommended?: boolean;
+    switches: EntitlementsEffective['switches'];
+    slots: SlotLimits;
+}
+/**
+ * Resolve tier info in a single LicenseManager call.
+ * FAIL-SAFE: Returns FREE tier snapshot on any error.
+ */
+export declare function resolveTierSnapshot(): TierSnapshot;
+/**
+ * Derive bitnet/index.ts getTierInfo() shape from snapshot.
+ */
+export declare function deriveTierInfo(snap: TierSnapshot): {
+    plan: Plan;
+    concurrent_slots: {
+        used: number;
+        max: number;
+    };
+    pro_features_available: string[];
+};
+/**
+ * Derive status.ts getTierStatus() shape from snapshot.
+ */
+export declare function deriveTierStatus(snap: TierSnapshot): {
+    plan: Plan;
+    status: LicenseStatus;
+    days_left?: number;
+    concurrent_slots: {
+        free: number;
+        paid: number;
+    };
+    features: {
+        scorecard: boolean;
+        policy_analysis: boolean;
+        auto_fix: boolean;
+        bitnet_trace: boolean;
+    };
+    upgrade_hint?: string;
+};

package/build/mcp/tools/shared/tier_facade.js

@@ -0,0 +1,91 @@
+/**
+ * Tier Facade — canonical tier resolution for all MCP tools
+ *
+ * Wraps LicenseManager in a single-call snapshot so all tools
+ * within a request see the same tier state. Replaces the pattern
+ * of each tool independently calling new LicenseManager().
+ *
+ * @since v1.10.0
+ */
+import { LicenseManager, } from '../../../license-manager.js';
+import { calcSlotLimits } from '../../../bitnet-worker/hw_slots.js';
+// ============================================================================
+// Snapshot Resolution
+// ============================================================================
+/**
+ * Resolve tier info in a single LicenseManager call.
+ * FAIL-SAFE: Returns FREE tier snapshot on any error.
+ */
+export function resolveTierSnapshot() {
+    try {
+        const manager = new LicenseManager();
+        const entitlements = manager.loadEntitlements();
+        const slots = calcSlotLimits();
+        const isPro = entitlements.planEffective === 'PRO';
+        return {
+            plan: entitlements.planEffective,
+            isPro,
+            status: entitlements.status,
+            daysLeft: entitlements.daysLeft,
+            refreshRecommended: entitlements.refreshRecommended,
+            switches: entitlements.switches,
+            slots,
+        };
+    }
+    catch {
+        const slots = calcSlotLimits();
+        return {
+            plan: 'FREE',
+            isPro: false,
+            status: 'MISSING',
+            daysLeft: undefined,
+            refreshRecommended: undefined,
+            switches: { autoFix: false, kce: false, cloudSync: false },
+            slots,
+        };
+    }
+}
+// ============================================================================
+// Derived Shapes (match existing tool output contracts)
+// ============================================================================
+/**
+ * Derive bitnet/index.ts getTierInfo() shape from snapshot.
+ */
+export function deriveTierInfo(snap) {
+    const proFeatures = snap.isPro
+        ? ['scorecard', 'policy_analysis', 'auto_fix', 'bitnet_trace', 'signal_logger', 'bitnet_cache']
+        : [];
+    return {
+        plan: snap.plan,
+        concurrent_slots: {
+            used: 0,
+            max: snap.isPro ? snap.slots.paid : snap.slots.free,
+        },
+        pro_features_available: proFeatures,
+    };
+}
+/**
+ * Derive status.ts getTierStatus() shape from snapshot.
+ */
+export function deriveTierStatus(snap) {
+    return {
+        plan: snap.plan,
+        status: snap.status,
+        days_left: snap.daysLeft,
+        concurrent_slots: {
+            free: snap.slots.free,
+            paid: snap.slots.paid,
+        },
+        features: {
+            scorecard: snap.isPro,
+            policy_analysis: snap.isPro,
+            auto_fix: snap.isPro && snap.switches.autoFix,
+            bitnet_trace: snap.isPro,
+        },
+        upgrade_hint: !snap.isPro
+            ? 'Upgrade to PRO for advanced analysis features (Scorecard, Policy Analysis, Auto-Fix)'
+            : snap.refreshRecommended
+                ? `License expires in ${snap.daysLeft} days. Consider renewal.`
+                : undefined,
+    };
+}