@vibecodetown/mcp-server 1.3.1 → 1.5.0

package/build/domains/bee/bee_triangulation.js

@@ -0,0 +1,186 @@
+/**
+ * Bee Triangulation — Intent Inference + Signal Alignment
+ *
+ * Infers developer intent from file change patterns and cross-validates
+ * against the active trigger rule. Adjusts confidence and risk based on
+ * alignment between inferred intent and observed behavior.
+ *
+ * Two-axis model:
+ * - Top-Down (Intent): What the developer is TRYING to do (inferred from file paths)
+ * - Bottom-Up (Behavior): What's actually HAPPENING (trigger, errors, dependencies)
+ *
+ * Pure functions — no side effects, no external dependencies.
+ *
+ * @since v1.22.0 (P31)
+ */
+// ============================================================================
+// Intent Inference
+// ============================================================================
+const AUTH_KEYWORDS = [
+    'auth',
+    'login',
+    'session',
+    'token',
+    'password',
+    'credential',
+    'oauth',
+    'jwt',
+];
+const TEST_PATTERNS = [/\/tests?\//, /\.test\.\w+$/, /\.spec\.\w+$/];
+const DEP_FILES = [
+    'package.json',
+    'package-lock.json',
+    'yarn.lock',
+    'pnpm-lock.yaml',
+    'cargo.toml',
+];
+const CONFIG_PATTERNS = [/\.config\./, /\.env/, /tsconfig/, /eslint/, /prettier/, /\.rc$/];
+/**
+ * Infer developer intent from changed file paths.
+ * Priority: AUTH_WORK > TEST_WORK > DEP_MANAGEMENT > CONFIG_CHANGE > FEATURE_WORK
+ */
+export function inferIntentFromPaths(changedPaths) {
+    if (changedPaths.length === 0)
+        return 'UNKNOWN';
+    const lower = changedPaths.map(p => p.toLowerCase());
+    // Auth work: any file touches auth-related paths
+    if (lower.some(p => AUTH_KEYWORDS.some(k => p.includes(k)))) {
+        return 'AUTH_WORK';
+    }
+    // Test work: primarily test files
+    if (lower.some(p => TEST_PATTERNS.some(re => re.test(p)))) {
+        return 'TEST_WORK';
+    }
+    // Dependency management: package manifest changes
+    const basenames = changedPaths.map(p => {
+        const idx = p.lastIndexOf('/');
+        return idx >= 0 ? p.slice(idx + 1).toLowerCase() : p.toLowerCase();
+    });
+    if (basenames.some(b => DEP_FILES.includes(b))) {
+        return 'DEP_MANAGEMENT';
+    }
+    // Config changes
+    if (lower.some(p => CONFIG_PATTERNS.some(re => re.test(p)))) {
+        return 'CONFIG_CHANGE';
+    }
+    return 'FEATURE_WORK';
+}
+// ============================================================================
+// Trigger Alignment
+// ============================================================================
+/** Map of intent → naturally aligned trigger IDs */
+const INTENT_TRIGGER_MAP = {
+    AUTH_WORK: ['T3_AUTH_TOUCH'],
+    DEP_MANAGEMENT: ['T6_DEP_SHIFT'],
+    BUG_FIX: ['T8_GATE_FIX'],
+};
+/**
+ * Check how well the inferred intent aligns with the active trigger.
+ */
+export function checkTriggerAlignment(intent, triggerId) {
+    if (intent === 'UNKNOWN')
+        return 'UNKNOWN';
+    // FEATURE_WORK is generic — always partial alignment
+    if (intent === 'FEATURE_WORK')
+        return 'PARTIAL';
+    // Generic intents are always partial
+    if (intent === 'TEST_WORK' || intent === 'CONFIG_CHANGE')
+        return 'PARTIAL';
+    const aligned = INTENT_TRIGGER_MAP[intent];
+    if (!aligned)
+        return 'UNKNOWN';
+    if (aligned.includes(triggerId))
+        return 'ALIGNED';
+    // Specific intent but different trigger → misaligned
+    return 'MISALIGNED';
+}
+// ============================================================================
+// Confidence & Risk Adjustment
+// ============================================================================
+/**
+ * Adjust confidence based on signal alignment and additional signals.
+ */
+export function adjustConfidence(base, alignment, errorsDetected, blastRadiusCount) {
+    let adjusted = base;
+    // Alignment factor
+    switch (alignment) {
+        case 'ALIGNED':
+            adjusted *= 1.15;
+            break;
+        case 'MISALIGNED':
+            adjusted *= 0.8;
+            break;
+        case 'UNKNOWN':
+            adjusted *= 0.9;
+            break;
+        // PARTIAL: no change
+    }
+    // Additional signal bonuses
+    if (errorsDetected > 0)
+        adjusted += 0.05;
+    if (blastRadiusCount > 10)
+        adjusted += 0.05;
+    return Math.min(Math.max(adjusted, 0), 0.95);
+}
+const RISK_LEVELS = ['low', 'medium', 'high'];
+/**
+ * Adjust risk level based on alignment and error signals.
+ */
+export function adjustRisk(base, alignment, errorsDetected) {
+    const idx = RISK_LEVELS.indexOf(base);
+    // MISALIGNED → escalate one level
+    if (alignment === 'MISALIGNED' && idx < 2) {
+        return RISK_LEVELS[idx + 1];
+    }
+    // Errors on low-risk → escalate to medium
+    if (errorsDetected > 0 && base === 'low') {
+        return 'medium';
+    }
+    return base;
+}
+// ============================================================================
+// Triangulation
+// ============================================================================
+/**
+ * Perform triangulation: infer intent, check alignment, adjust signals.
+ *
+ * Pure function — no side effects.
+ */
+export function triangulate(input) {
+    const intent = inferIntentFromPaths(input.changedPaths);
+    const alignment = checkTriggerAlignment(intent, input.triggerId);
+    const baseConfidence = input.heuristicConfidence ?? 0.5;
+    const baseRisk = input.heuristicRiskLevel ?? 'medium';
+    const errors = input.errorsDetected ?? 0;
+    const blast = input.blastRadiusCount ?? 0;
+    const adjustedConfidence = adjustConfidence(baseConfidence, alignment, errors, blast);
+    const adjustedRisk = adjustRisk(baseRisk, alignment, errors);
+    const reason = buildReason(intent, alignment, input.triggerId, adjustedConfidence, adjustedRisk);
+    return {
+        inferredIntent: intent,
+        alignment,
+        adjustedConfidence,
+        adjustedRisk,
+        reason,
+    };
+}
+// ============================================================================
+// Helpers
+// ============================================================================
+function buildReason(intent, alignment, triggerId, confidence, risk) {
+    const intentLabel = intent.replace(/_/g, ' ').toLowerCase();
+    const triggerLabel = triggerId
+        .replace(/^T\d+_/, '')
+        .replace(/_/g, ' ')
+        .toLowerCase();
+    switch (alignment) {
+        case 'ALIGNED':
+            return `Inferred ${intentLabel} aligns with ${triggerLabel} trigger (confidence: ${confidence.toFixed(2)}, risk: ${risk})`;
+        case 'MISALIGNED':
+            return `Inferred ${intentLabel} conflicts with ${triggerLabel} trigger — risk escalated (confidence: ${confidence.toFixed(2)}, risk: ${risk})`;
+        case 'PARTIAL':
+            return `Inferred ${intentLabel} partially matches ${triggerLabel} trigger (confidence: ${confidence.toFixed(2)}, risk: ${risk})`;
+        case 'UNKNOWN':
+            return `Cannot determine intent alignment with ${triggerLabel} trigger (confidence: ${confidence.toFixed(2)}, risk: ${risk})`;
+    }
+}

package/build/domains/bee/bee_types.d.ts

@@ -0,0 +1,142 @@
+/**
+ * Bee Types — Scout→Bee Upgrade type definitions
+ *
+ * Types for dependency graph analysis, Bee orchestration,
+ * and automatic Swarm triggering.
+ *
+ * Bee = Scout + Context Gathering + Auto Swarm Trigger
+ *
+ * @since v1.12.0
+ */
+/**
+ * 1-level import dependency graph.
+ * forward: file → files it imports
+ * reverse: file → files that import it (blast radius)
+ */
+export interface DependencyGraph {
+    /** file → files it imports from */
+    forward: Map<string, string[]>;
+    /** file → files that import it */
+    reverse: Map<string, string[]>;
+}
+/**
+ * Serializable version of DependencyGraph for output.
+ */
+export interface DependencyGraphSnapshot {
+    forward: Record<string, string[]>;
+    reverse: Record<string, string[]>;
+}
+/**
+ * A single parsed import/require/export statement.
+ */
+export interface ParsedImport {
+    /** Raw module specifier (e.g., './utils', 'fs', '../lib/auth.js') */
+    specifier: string;
+    /** Whether this is a relative import (starts with . or ..) */
+    isRelative: boolean;
+    /** Import type: static import, dynamic import(), require(), or re-export */
+    kind: 'import' | 'dynamic' | 'require' | 'export';
+}
+/**
+ * Enrichment data produced by Bee's dependency analysis.
+ * Attached to BeeOutput when PRO tier is active.
+ */
+export interface BeeEnrichment {
+    /** Files that the target imports (forward deps) */
+    forward_deps: string[];
+    /** Files that import the target (reverse deps / blast radius) */
+    reverse_deps: string[];
+    /** Total count of affected files (reverse_deps.length) */
+    blast_radius_count: number;
+}
+/**
+ * Input for automatic Swarm triggering via Bee.
+ */
+export interface BeeSwarmInput {
+    /** Workspace root */
+    basePath: string;
+    /** Files under analysis */
+    targetFiles: string[];
+    /** Risk level from heuristic/Scout analysis */
+    riskLevel: 'low' | 'medium' | 'high';
+    /** Confidence score (0.0~1.0) */
+    confidence: number;
+    /** Analysis text for Swarm context */
+    analysisContext: string;
+    /** Dependency enrichment (if available) */
+    enrichment?: BeeEnrichment;
+}
+/**
+ * Result from automatic Swarm bridge invocation.
+ * FAIL-SAFE: never throws, includes skipReason on failure.
+ */
+export interface BeeSwarmResult {
+    /** Whether Swarm was triggered */
+    triggered: boolean;
+    /** Why Swarm was skipped (if not triggered) */
+    skipReason?: string;
+    /** Consensus verdict from Swarm */
+    verdict?: 'EXECUTE' | 'WARNING' | 'ABORT';
+    /** Risk score from Red evaluation (0.0~1.0) */
+    riskScore?: number;
+    /** Error message if Swarm failed */
+    error?: string;
+}
+/**
+ * Full result from BeeOrchestrator.run().
+ * Superset of ScoutOutput fields — maps to BeeOutputSchema.
+ */
+export interface BeeOrchestratorResult {
+    /** Whether any analysis was triggered */
+    triggered: boolean;
+    /** Scenario name (e.g., 'AUTH_TOUCH', 'DEP_SHIFT') */
+    scenario?: string;
+    /** Generated block ID */
+    block_id?: string;
+    /** Analysis text */
+    analysis?: string;
+    /** Total latency in milliseconds */
+    latency_ms?: number;
+    /** Skip reason if not triggered */
+    skipped_reason?: string;
+    /** Confidence score (0.0~1.0) */
+    confidence?: number;
+    /** Risk level */
+    risk_level?: 'low' | 'medium' | 'high';
+    /** Suggested actions */
+    suggestions?: string[];
+    /** Forward dependencies of target files */
+    forward_deps?: string[];
+    /** Reverse dependencies (blast radius) */
+    reverse_deps?: string[];
+    /** Blast radius count */
+    blast_radius_count?: number;
+    /** Whether Swarm was auto-triggered */
+    swarm_triggered?: boolean;
+    /** Swarm consensus verdict */
+    swarm_verdict?: string;
+    /** Analysis source */
+    source?: 'bitnet' | 'musu' | 'heuristic' | 'bee';
+    /** Triangulation result from intent inference + signal alignment */
+    triangulation?: {
+        inferredIntent: string;
+        alignment: string;
+        adjustedConfidence: number;
+        adjustedRisk: string;
+        reason: string;
+    };
+    /** Historical block snippets from DB FTS (best-effort) */
+    historical_context?: string;
+}
+/**
+ * Thresholds for automatic Swarm triggering.
+ * Swarm is triggered when risk >= riskLevel AND confidence >= confidenceMin.
+ */
+export interface BeeSwarmThresholds {
+    /** Minimum risk level to trigger Swarm */
+    riskLevel: 'medium' | 'high';
+    /** Minimum confidence to trigger Swarm */
+    confidenceMin: number;
+}
+/** Default thresholds: high risk + confidence >= 0.7 */
+export declare const DEFAULT_BEE_SWARM_THRESHOLDS: BeeSwarmThresholds;

package/build/domains/bee/bee_types.js

@@ -0,0 +1,15 @@
+/**
+ * Bee Types — Scout→Bee Upgrade type definitions
+ *
+ * Types for dependency graph analysis, Bee orchestration,
+ * and automatic Swarm triggering.
+ *
+ * Bee = Scout + Context Gathering + Auto Swarm Trigger
+ *
+ * @since v1.12.0
+ */
+/** Default thresholds: high risk + confidence >= 0.7 */
+export const DEFAULT_BEE_SWARM_THRESHOLDS = {
+    riskLevel: 'high',
+    confidenceMin: 0.7,
+};

package/build/domains/bee/bee_watcher.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Bee Watcher — Proactive source file monitoring
+ *
+ * Watches source files for changes and auto-triggers Bee analysis
+ * when modifications are detected. Uses debouncing to batch rapid
+ * save events into a single analysis pass.
+ *
+ * Opt-in via `VIBE_BEE_WATCHER=1` environment variable.
+ *
+ * Uses existing infrastructure:
+ * - startFileWatcher() from file_watcher.ts (chokidar)
+ * - collectTriggerFacts() + TriggerEvaluator for trigger selection
+ * - createBeeRunner() for analysis execution
+ *
+ * FAIL-SAFE: Analysis failures are caught and logged, never crash the watcher.
+ *
+ * @since v1.12.0
+ */
+export interface BeeWatcherConfig {
+    /** Paths to watch (relative to basePath). Default: ['src/'] */
+    watchPaths?: string[];
+    /** Debounce window in ms. Default: 500 */
+    debounceMs?: number;
+    /** File extensions to include. Default: common source extensions */
+    extensions?: string[];
+}
+export interface BeeWatcherStatus {
+    /** Whether the watcher is actively watching */
+    watching: boolean;
+    /** Workspace root */
+    basePath: string;
+    /** Total file events received */
+    eventsReceived: number;
+    /** Total analysis runs triggered */
+    analysesTriggered: number;
+    /** Number of analyses that found a matching trigger */
+    triggersMatched: number;
+    /** Last event timestamp (epoch ms) or null */
+    lastEventAt: number | null;
+    /** Total source files re-chunked */
+    filesRechunked: number;
+    /** Pending paths in current debounce window */
+    pendingCount: number;
+}
+export interface BeeWatcherHandle {
+    /** Stop the watcher and release resources */
+    stop(): Promise<void>;
+    /** Get current watcher status */
+    status(): BeeWatcherStatus;
+}
+/**
+ * Check if Bee Watcher is enabled via environment variable.
+ */
+export declare function isBeeWatcherEnabled(): boolean;
+/**
+ * Start the Bee Watcher for proactive source monitoring.
+ *
+ * Returns a handle with stop() and status() methods.
+ * Returns null if VIBE_BEE_WATCHER is not set.
+ *
+ * Never throws — returns null on any startup failure.
+ */
+export declare function startBeeWatcher(basePath: string, config?: BeeWatcherConfig): BeeWatcherHandle | null;

package/build/domains/bee/bee_watcher.js

@@ -0,0 +1,267 @@
+/**
+ * Bee Watcher — Proactive source file monitoring
+ *
+ * Watches source files for changes and auto-triggers Bee analysis
+ * when modifications are detected. Uses debouncing to batch rapid
+ * save events into a single analysis pass.
+ *
+ * Opt-in via `VIBE_BEE_WATCHER=1` environment variable.
+ *
+ * Uses existing infrastructure:
+ * - startFileWatcher() from file_watcher.ts (chokidar)
+ * - collectTriggerFacts() + TriggerEvaluator for trigger selection
+ * - createBeeRunner() for analysis execution
+ *
+ * FAIL-SAFE: Analysis failures are caught and logged, never crash the watcher.
+ *
+ * @since v1.12.0
+ */
+import { startFileWatcher } from '../../kernel/file_watcher.js';
+import { collectTriggerFacts } from './trigger_facts_collector.js';
+import { TriggerEvaluator } from './trigger_evaluator.js';
+import { CooldownStore } from './cooldown_store.js';
+import { FileHashRegistry } from './file_hash_registry.js';
+import { createBeeRunner } from './bee_orchestrator.js';
+import { rechunkFilesAsync } from './bee_rechunk.js';
+import { rechunkFileIncrementalAsync } from './bee_rechunk_incremental.js';
+import { getFeatureGate, BEE_FEATURES } from '../../tier/feature_gate.js';
+import { loadEntitlements } from '../../license-manager.js';
+// ============================================================================
+// Constants
+// ============================================================================
+const DEFAULT_WATCH_PATHS = ['src/'];
+const DEFAULT_DEBOUNCE_MS = 500;
+const DEFAULT_EXTENSIONS = new Set([
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx',
+    '.mjs',
+    '.cjs',
+    '.rs',
+    '.py',
+    '.go',
+    '.java',
+    '.c',
+    '.cpp',
+    '.h',
+]);
+const IGNORE_DIRS = [
+    'node_modules',
+    '.git',
+    '.vibe',
+    'build',
+    'dist',
+    'coverage',
+    '.next',
+    '.cache',
+    'target',
+];
+// ============================================================================
+// Public API
+// ============================================================================
+/**
+ * Check if Bee Watcher is enabled via environment variable.
+ */
+export function isBeeWatcherEnabled() {
+    return process.env.VIBE_BEE_WATCHER === '1';
+}
+/**
+ * Start the Bee Watcher for proactive source monitoring.
+ *
+ * Returns a handle with stop() and status() methods.
+ * Returns null if VIBE_BEE_WATCHER is not set.
+ *
+ * Never throws — returns null on any startup failure.
+ */
+export function startBeeWatcher(basePath, config = {}) {
+    if (!isBeeWatcherEnabled())
+        return null;
+    try {
+        return createWatcher(basePath, config);
+    }
+    catch {
+        return null;
+    }
+}
+// ============================================================================
+// Internal Watcher
+// ============================================================================
+function createWatcher(basePath, config) {
+    const watchPaths = config.watchPaths ?? DEFAULT_WATCH_PATHS;
+    const debounceMs = config.debounceMs ?? DEFAULT_DEBOUNCE_MS;
+    const extensions = config.extensions ? new Set(config.extensions) : DEFAULT_EXTENSIONS;
+    // State
+    let pendingPaths = new Set();
+    let debounceTimer = null;
+    let watching = true;
+    let eventsReceived = 0;
+    let analysesTriggered = 0;
+    let triggersMatched = 0;
+    let filesRechunked = 0;
+    let lastEventAt = null;
+    // Cooldown, evaluator, and file hash registry
+    const cooldownStore = new CooldownStore(basePath);
+    const hashRegistry = new FileHashRegistry(basePath);
+    // Start file watcher
+    const watcher = startFileWatcher(watchPaths, {
+        cwd: basePath,
+        persistent: true,
+        ignore: (filePath) => shouldIgnore(filePath, extensions),
+        onEvent: (_type, filePath) => {
+            if (!watching)
+                return;
+            eventsReceived++;
+            lastEventAt = Date.now();
+            // Convert absolute path to workspace-relative
+            const relative = toRelative(basePath, filePath);
+            if (relative) {
+                pendingPaths.add(relative);
+            }
+            // Reset debounce timer
+            if (debounceTimer)
+                clearTimeout(debounceTimer);
+            debounceTimer = setTimeout(() => flush(), debounceMs);
+        },
+    });
+    // Flush accumulated changes
+    async function flush() {
+        if (pendingPaths.size === 0)
+            return;
+        const paths = [...pendingPaths];
+        pendingPaths = new Set();
+        debounceTimer = null;
+        // Filter to only changed files (hash comparison)
+        const changedPaths = hashRegistry.getChangedFiles(paths);
+        if (changedPaths.length === 0)
+            return;
+        // Re-chunk changed source files (best-effort)
+        try {
+            const useIncremental = getFeatureGate().isAllowed(BEE_FEATURES.INCREMENTAL_INFERENCE);
+            if (useIncremental) {
+                // PRO: delta-first incremental rechunk per file
+                let count = 0;
+                for (const fp of changedPaths) {
+                    try {
+                        const r = await rechunkFileIncrementalAsync(basePath, fp);
+                        if (r)
+                            count++;
+                    }
+                    catch {
+                        // Per-file isolation
+                    }
+                }
+                filesRechunked += count;
+            }
+            else {
+                // FREE: full rechunk (existing path)
+                const rechunked = await rechunkFilesAsync(basePath, changedPaths);
+                filesRechunked += rechunked.length;
+            }
+        }
+        catch {
+            // Best-effort: rechunk failure doesn't block analysis
+        }
+        analysesTriggered++;
+        try {
+            await runAnalysis(basePath, changedPaths, cooldownStore);
+            // Record analyzed files so next flush can skip them
+            hashRegistry.recordAllAnalyzed(changedPaths);
+            triggersMatched++;
+        }
+        catch {
+            // FAIL-SAFE: analysis failure doesn't crash the watcher
+        }
+    }
+    return {
+        async stop() {
+            watching = false;
+            if (debounceTimer) {
+                clearTimeout(debounceTimer);
+                debounceTimer = null;
+            }
+            pendingPaths.clear();
+            await watcher.close();
+        },
+        status() {
+            return {
+                watching,
+                basePath,
+                eventsReceived,
+                analysesTriggered,
+                triggersMatched,
+                filesRechunked,
+                lastEventAt,
+                pendingCount: pendingPaths.size,
+            };
+        },
+    };
+}
+// ============================================================================
+// Analysis Runner
+// ============================================================================
+/**
+ * Run trigger evaluation and Bee analysis for changed paths.
+ * Best-effort: throws on failure (caller catches).
+ */
+async function runAnalysis(basePath, changedPaths, cooldownStore) {
+    // Determine user tier for trigger filtering
+    const tier = resolveTier();
+    // Collect facts and evaluate triggers
+    const facts = await collectTriggerFacts(basePath);
+    // Override changed_paths with watcher-detected paths
+    facts.repo.changed_paths = changedPaths;
+    facts.repo.dirty = true;
+    facts.repo.changed_files_count = changedPaths.length;
+    const evaluator = new TriggerEvaluator(cooldownStore, tier);
+    const evaluation = await evaluator.evaluate(facts);
+    if (evaluation.should_skip_all || !evaluation.highest_priority) {
+        return;
+    }
+    // Run Bee analysis for highest-priority trigger
+    const runner = createBeeRunner(basePath);
+    await runner.run(evaluation.highest_priority, changedPaths);
+}
+/**
+ * Resolve current license tier. FAIL-SAFE to FREE.
+ */
+function resolveTier() {
+    try {
+        const ent = loadEntitlements();
+        return ent.planEffective === 'PRO' ? 'PRO' : 'FREE';
+    }
+    catch {
+        return 'FREE';
+    }
+}
+// ============================================================================
+// Helpers
+// ============================================================================
+/**
+ * Check if a file path should be ignored.
+ */
+function shouldIgnore(filePath, extensions) {
+    // Ignore known directories
+    const lower = filePath.toLowerCase();
+    for (const dir of IGNORE_DIRS) {
+        if (lower.includes(`/${dir}/`) || lower.includes(`\\${dir}\\`)) {
+            return true;
+        }
+    }
+    // Only watch files with matching extensions
+    const dotIdx = filePath.lastIndexOf('.');
+    if (dotIdx === -1)
+        return true;
+    const ext = filePath.slice(dotIdx).toLowerCase();
+    return !extensions.has(ext);
+}
+/**
+ * Convert absolute path to workspace-relative path.
+ */
+function toRelative(basePath, absPath) {
+    const normalized = absPath.replace(/\\/g, '/');
+    const base = basePath.replace(/\\/g, '/').replace(/\/$/, '');
+    if (!normalized.startsWith(base + '/'))
+        return null;
+    return normalized.slice(base.length + 1);
+}

package/build/{tier → domains/bee}/cooldown_store.d.ts

@@ -7,7 +7,7 @@
  *
  * @since v1.6.0
  */
-import { TriggerRuleId } from "./trigger_types.js";
+import { TriggerRuleId } from './trigger_types.js';
 export declare class CooldownStore {
     private records;
     private filePath;