@vibecodetown/mcp-server 1.3.1 → 1.5.0

package/build/domains/bee/bee_context_enricher.js

@@ -0,0 +1,194 @@
+/**
+ * Bee Context Enricher — Dependency context gathering for Swarm
+ *
+ * Reads dependency files discovered by BeeImportParser and produces
+ * a token-efficient enriched context that Swarm can consume.
+ *
+ * Concentration strategy:
+ * - Target files: full content (up to maxTokensPerFile)
+ * - Forward deps: skeletonized (signatures only)
+ * - Reverse deps: file paths only (blast radius metadata)
+ *
+ * Uses existing skeletonize() from ContextAssembler.
+ *
+ * @since v1.12.0
+ */
+import { readFileSync, existsSync } from 'fs';
+import { resolve, extname } from 'path';
+import { estimateCodeTokens, skeletonize } from '../../kernel/blocks/assembler.js';
+import { getForwardDeps, getReverseDeps } from './bee_import_parser.js';
+// ============================================================================
+// Constants
+// ============================================================================
+const DEFAULT_MAX_TOKENS = 4000;
+const DEFAULT_MAX_TOKENS_PER_FILE = 1500;
+const MAX_FILE_SIZE = 256 * 1024; // 256KB
+const SUPPORTED_EXTENSIONS = new Set([
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx',
+    '.mjs',
+    '.cjs',
+    '.mts',
+    '.cts',
+    '.rs',
+    '.py',
+    '.go',
+    '.java',
+    '.c',
+    '.cpp',
+    '.h',
+    '.hpp',
+]);
+// ============================================================================
+// Public API
+// ============================================================================
+/**
+ * Enrich dependency context for Swarm consumption.
+ *
+ * Reads target files (full) and their forward dependencies (skeleton),
+ * respecting a total token budget.
+ *
+ * @param basePath - Workspace root
+ * @param targetFiles - Files under analysis (workspace-relative)
+ * @param graph - Dependency graph from BeeImportParser
+ * @param maxTokens - Total token budget (default 4000)
+ * @returns Enriched context with targets + nutrients + blast radius
+ */
+export function enrichDependencyContext(basePath, targetFiles, graph, maxTokens = DEFAULT_MAX_TOKENS) {
+    let remaining = maxTokens;
+    const targets = [];
+    const nutrients = [];
+    const seenPaths = new Set();
+    // Phase 1: Target files — full content (priority)
+    for (const filePath of targetFiles) {
+        if (remaining <= 0)
+            break;
+        seenPaths.add(filePath);
+        const content = readFileSafe(basePath, filePath);
+        if (!content)
+            continue;
+        const truncated = truncateToLines(content, Math.min(remaining, DEFAULT_MAX_TOKENS_PER_FILE));
+        const tokens = estimateCodeTokens(truncated);
+        targets.push({ path: filePath, content: truncated, tokens, mode: 'full' });
+        remaining -= tokens;
+    }
+    // Phase 2: Forward deps — skeletonized (signatures only)
+    const allForwardDeps = new Set();
+    for (const fp of targetFiles) {
+        for (const dep of getForwardDeps(graph, fp)) {
+            allForwardDeps.add(dep);
+        }
+    }
+    for (const depPath of allForwardDeps) {
+        if (remaining <= 0)
+            break;
+        if (seenPaths.has(depPath))
+            continue;
+        seenPaths.add(depPath);
+        const content = readFileSafe(basePath, depPath);
+        if (!content)
+            continue;
+        const skeleton = skeletonize(content);
+        const truncated = truncateToLines(skeleton, Math.min(remaining, DEFAULT_MAX_TOKENS_PER_FILE));
+        const tokens = estimateCodeTokens(truncated);
+        nutrients.push({ path: depPath, content: truncated, tokens, mode: 'skeleton' });
+        remaining -= tokens;
+    }
+    // Phase 3: Reverse deps — paths only (no content read)
+    const blastRadius = [];
+    for (const fp of targetFiles) {
+        for (const rev of getReverseDeps(graph, fp)) {
+            if (!seenPaths.has(rev) && !blastRadius.includes(rev)) {
+                blastRadius.push(rev);
+            }
+        }
+    }
+    return {
+        targets,
+        nutrients,
+        blastRadius,
+        totalTokens: maxTokens - remaining,
+        truncated: remaining <= 0,
+    };
+}
+/**
+ * Format enriched context as a single string for Swarm prompt injection.
+ *
+ * Structure:
+ * ```
+ * === TARGET: src/auth/login.ts ===
+ * <full content>
+ *
+ * === DEPENDENCY (skeleton): src/lib/validator.ts ===
+ * <skeleton content>
+ *
+ * === BLAST RADIUS: 3 file(s) ===
+ * - src/app.ts
+ * - src/routes/auth.ts
+ * - tests/auth.test.ts
+ * ```
+ */
+export function formatEnrichedContext(ctx) {
+    const parts = [];
+    for (const t of ctx.targets) {
+        parts.push(`=== TARGET: ${t.path} ===`);
+        parts.push(t.content);
+        parts.push('');
+    }
+    for (const n of ctx.nutrients) {
+        parts.push(`=== DEPENDENCY (skeleton): ${n.path} ===`);
+        parts.push(n.content);
+        parts.push('');
+    }
+    if (ctx.blastRadius.length > 0) {
+        parts.push(`=== BLAST RADIUS: ${ctx.blastRadius.length} file(s) ===`);
+        for (const br of ctx.blastRadius) {
+            parts.push(`- ${br}`);
+        }
+        parts.push('');
+    }
+    return parts.join('\n').trim();
+}
+// ============================================================================
+// Helpers
+// ============================================================================
+/**
+ * Read a file safely. Returns null if file doesn't exist, is too large,
+ * or has an unsupported extension.
+ */
+function readFileSafe(basePath, filePath) {
+    try {
+        const absPath = resolve(basePath, filePath);
+        const ext = extname(absPath);
+        if (!SUPPORTED_EXTENSIONS.has(ext))
+            return null;
+        if (!existsSync(absPath))
+            return null;
+        const content = readFileSync(absPath, 'utf-8');
+        if (content.length > MAX_FILE_SIZE)
+            return null;
+        return content;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Truncate text to approximately maxTokens, cutting at line boundaries.
+ * Preserves complete code statements (no mid-line cuts).
+ */
+function truncateToLines(text, maxTokens) {
+    const lines = text.split('\n');
+    let tokens = 0;
+    const result = [];
+    for (const line of lines) {
+        const lineTokens = estimateCodeTokens(line);
+        if (tokens + lineTokens > maxTokens && result.length > 0)
+            break;
+        result.push(line);
+        tokens += lineTokens;
+    }
+    return result.join('\n');
+}

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

@@ -0,0 +1,68 @@
+/**
+ * Bee Import Parser — Regex-based dependency graph builder
+ *
+ * Parses import/export/require statements from TypeScript/JavaScript files
+ * and builds a 1-level forward/reverse dependency graph.
+ *
+ * Design decisions:
+ * - Regex-based (not AST) to keep dependencies minimal (no ts-morph ~30MB)
+ * - 1-level only: direct imports/exports, no transitive closure
+ * - maxFiles cap to prevent runaway on large monorepos
+ * - Best-effort: unparseable files are silently skipped
+ *
+ * @since v1.12.0
+ */
+import type { ParsedImport, DependencyGraph, DependencyGraphSnapshot } from './bee_types.js';
+/**
+ * Strip comments from source code, preserving string literals.
+ *
+ * Replaces comment content with spaces, preserving newlines so that
+ * line numbers remain intact. String literals are tracked (to avoid
+ * stripping comment-like patterns inside strings) but NOT stripped,
+ * because import specifiers are themselves string literals.
+ *
+ * Handles: // line comments, block comments
+ * Tracks (but preserves): 'single', "double", `template` strings
+ * Respects: escape sequences, template literal ${} interpolation
+ */
+export declare function stripCommentsAndStrings(code: string): string;
+/**
+ * Parse all import/export/require statements from file content.
+ * Returns deduplicated list of ParsedImport entries.
+ */
+export declare function parseImports(content: string): ParsedImport[];
+/**
+ * Resolve a relative import specifier to a workspace-relative path.
+ * Returns null for non-relative (package) imports.
+ *
+ * Handles:
+ * - './utils' → 'src/utils.ts' (tries extensions)
+ * - '../lib/auth.js' → 'lib/auth.ts' (strips .js, tries .ts)
+ * - './index' → 'src/index.ts'
+ */
+export declare function resolveSpecifier(specifier: string, fromFile: string, basePath: string): string | null;
+/**
+ * Build a 1-level dependency graph from a set of file paths.
+ *
+ * @param basePath - Workspace root directory
+ * @param filePaths - Files to analyze (workspace-relative paths)
+ * @param maxFiles - Maximum files to process (default 50)
+ * @returns DependencyGraph with forward and reverse maps
+ */
+export declare function buildDependencyGraph(basePath: string, filePaths: string[], maxFiles?: number): DependencyGraph;
+/**
+ * Get forward dependencies for a file (files it imports from).
+ */
+export declare function getForwardDeps(graph: DependencyGraph, filePath: string): string[];
+/**
+ * Get reverse dependencies for a file (files that import it = blast radius).
+ */
+export declare function getReverseDeps(graph: DependencyGraph, filePath: string): string[];
+/**
+ * Compute blast radius: unique reverse deps across multiple files.
+ */
+export declare function computeBlastRadius(graph: DependencyGraph, filePaths: string[]): string[];
+/**
+ * Convert DependencyGraph to a serializable snapshot (Maps → Records).
+ */
+export declare function snapshotGraph(graph: DependencyGraph): DependencyGraphSnapshot;

package/build/domains/bee/bee_import_parser.js

@@ -0,0 +1,359 @@
+/**
+ * Bee Import Parser — Regex-based dependency graph builder
+ *
+ * Parses import/export/require statements from TypeScript/JavaScript files
+ * and builds a 1-level forward/reverse dependency graph.
+ *
+ * Design decisions:
+ * - Regex-based (not AST) to keep dependencies minimal (no ts-morph ~30MB)
+ * - 1-level only: direct imports/exports, no transitive closure
+ * - maxFiles cap to prevent runaway on large monorepos
+ * - Best-effort: unparseable files are silently skipped
+ *
+ * @since v1.12.0
+ */
+import { readFileSync, existsSync, statSync } from 'fs';
+import { resolve, dirname, relative, extname } from 'path';
+// ============================================================================
+// Constants
+// ============================================================================
+const DEFAULT_MAX_FILES = 50;
+const MAX_FILE_SIZE = 512 * 1024; // 512KB — skip huge files
+const SUPPORTED_EXTENSIONS = new Set([
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx',
+    '.mjs',
+    '.cjs',
+    '.mts',
+    '.cts',
+]);
+// ============================================================================
+// Comment/String Stripping
+// ============================================================================
+/**
+ * Strip comments from source code, preserving string literals.
+ *
+ * Replaces comment content with spaces, preserving newlines so that
+ * line numbers remain intact. String literals are tracked (to avoid
+ * stripping comment-like patterns inside strings) but NOT stripped,
+ * because import specifiers are themselves string literals.
+ *
+ * Handles: // line comments, block comments
+ * Tracks (but preserves): 'single', "double", `template` strings
+ * Respects: escape sequences, template literal ${} interpolation
+ */
+export function stripCommentsAndStrings(code) {
+    const len = code.length;
+    const out = new Array(len);
+    // States: 0=NORMAL, 1=LINE_COMMENT, 2=BLOCK_COMMENT,
+    //         3=SINGLE_QUOTE, 4=DOUBLE_QUOTE, 5=TEMPLATE_LIT
+    let state = 0;
+    let templateDepth = 0;
+    let braceDepth = 0;
+    for (let i = 0; i < len; i++) {
+        const ch = code[i];
+        const next = i + 1 < len ? code[i + 1] : '';
+        switch (state) {
+            case 0: // NORMAL
+                if (ch === '/' && next === '/') {
+                    out[i] = ' ';
+                    out[++i] = ' ';
+                    state = 1; // LINE_COMMENT
+                }
+                else if (ch === '/' && next === '*') {
+                    out[i] = ' ';
+                    out[++i] = ' ';
+                    state = 2; // BLOCK_COMMENT
+                }
+                else if (ch === "'") {
+                    out[i] = ch; // preserve quote
+                    state = 3; // SINGLE_QUOTE
+                }
+                else if (ch === '"') {
+                    out[i] = ch; // preserve quote
+                    state = 4; // DOUBLE_QUOTE
+                }
+                else if (ch === '`') {
+                    out[i] = ch; // preserve quote
+                    state = 5; // TEMPLATE_LIT
+                    templateDepth++;
+                }
+                else {
+                    out[i] = ch;
+                }
+                break;
+            case 1: // LINE_COMMENT — strip content
+                out[i] = ch === '\n' ? '\n' : ' ';
+                if (ch === '\n')
+                    state = 0;
+                break;
+            case 2: // BLOCK_COMMENT — strip content
+                if (ch === '\n') {
+                    out[i] = '\n';
+                }
+                else if (ch === '*' && next === '/') {
+                    out[i] = ' ';
+                    out[++i] = ' ';
+                    state = 0;
+                }
+                else {
+                    out[i] = ' ';
+                }
+                break;
+            case 3: // SINGLE_QUOTE — preserve content (import specifiers are strings)
+                out[i] = ch;
+                if (ch === '\\' && i + 1 < len) {
+                    out[++i] = code[i]; // skip escaped char
+                }
+                else if (ch === "'") {
+                    state = 0;
+                }
+                break;
+            case 4: // DOUBLE_QUOTE — preserve content
+                out[i] = ch;
+                if (ch === '\\' && i + 1 < len) {
+                    out[++i] = code[i]; // skip escaped char
+                }
+                else if (ch === '"') {
+                    state = 0;
+                }
+                break;
+            case 5: // TEMPLATE_LIT — preserve content
+                out[i] = ch;
+                if (ch === '\\' && i + 1 < len) {
+                    out[++i] = code[i]; // skip escaped char
+                }
+                else if (ch === '$' && next === '{') {
+                    out[++i] = code[i]; // preserve ${
+                    braceDepth = 1;
+                    state = 0; // inside ${} is normal code
+                }
+                else if (ch === '`') {
+                    templateDepth--;
+                    state = 0;
+                }
+                break;
+        }
+        // Track brace depth for template interpolation return
+        if (state === 0 && templateDepth > 0) {
+            if (ch === '{')
+                braceDepth++;
+            else if (ch === '}') {
+                braceDepth--;
+                if (braceDepth === 0) {
+                    state = 5; // back to TEMPLATE_LIT
+                }
+            }
+        }
+    }
+    return out.join('');
+}
+// ============================================================================
+// Import Parsing
+// ============================================================================
+/**
+ * Regex patterns for import/export/require extraction.
+ *
+ * Matches:
+ * - import ... from 'specifier'
+ * - import 'specifier' (side-effect)
+ * - export ... from 'specifier'
+ * - import('specifier') (dynamic)
+ * - require('specifier')
+ */
+const IMPORT_PATTERN = /import\s+(?:[\s\S]*?\s+from\s+)?['"]([^'"]+)['"]/g;
+const EXPORT_FROM_PATTERN = /export\s+(?:[\s\S]*?\s+from\s+)['"]([^'"]+)['"]/g;
+const DYNAMIC_IMPORT_PATTERN = /import\(\s*['"]([^'"]+)['"]\s*\)/g;
+const REQUIRE_PATTERN = /require\(\s*['"]([^'"]+)['"]\s*\)/g;
+/**
+ * Parse all import/export/require statements from file content.
+ * Returns deduplicated list of ParsedImport entries.
+ */
+export function parseImports(content) {
+    // Strip comments and string literals to avoid false positives
+    const cleaned = stripCommentsAndStrings(content);
+    const seen = new Set();
+    const results = [];
+    function add(specifier, kind) {
+        const key = `${kind}:${specifier}`;
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        results.push({
+            specifier,
+            isRelative: specifier.startsWith('.'),
+            kind,
+        });
+    }
+    // Static imports (import ... from '...' and import '...')
+    let match;
+    const importRe = new RegExp(IMPORT_PATTERN.source, 'g');
+    while ((match = importRe.exec(cleaned)) !== null) {
+        add(match[1], 'import');
+    }
+    // Re-exports (export ... from '...')
+    const exportRe = new RegExp(EXPORT_FROM_PATTERN.source, 'g');
+    while ((match = exportRe.exec(cleaned)) !== null) {
+        add(match[1], 'export');
+    }
+    // Dynamic imports (import('...'))
+    const dynamicRe = new RegExp(DYNAMIC_IMPORT_PATTERN.source, 'g');
+    while ((match = dynamicRe.exec(cleaned)) !== null) {
+        add(match[1], 'dynamic');
+    }
+    // CommonJS requires (require('...'))
+    const requireRe = new RegExp(REQUIRE_PATTERN.source, 'g');
+    while ((match = requireRe.exec(cleaned)) !== null) {
+        add(match[1], 'require');
+    }
+    return results;
+}
+// ============================================================================
+// Specifier Resolution
+// ============================================================================
+/**
+ * Resolve a relative import specifier to a workspace-relative path.
+ * Returns null for non-relative (package) imports.
+ *
+ * Handles:
+ * - './utils' → 'src/utils.ts' (tries extensions)
+ * - '../lib/auth.js' → 'lib/auth.ts' (strips .js, tries .ts)
+ * - './index' → 'src/index.ts'
+ */
+export function resolveSpecifier(specifier, fromFile, basePath) {
+    if (!specifier.startsWith('.'))
+        return null;
+    const fromDir = dirname(resolve(basePath, fromFile));
+    let target = resolve(fromDir, specifier);
+    // Strip .js/.mjs/.cjs extension (common in TS projects with .js imports)
+    const ext = extname(target);
+    if (ext === '.js' || ext === '.mjs' || ext === '.cjs') {
+        target = target.slice(0, -ext.length);
+    }
+    // Try exact match first, then common extensions
+    const candidates = [
+        target,
+        ...Array.from(SUPPORTED_EXTENSIONS).map(e => target + e),
+        resolve(target, 'index.ts'),
+        resolve(target, 'index.js'),
+    ];
+    for (const candidate of candidates) {
+        if (existsSync(candidate) && isFile(candidate)) {
+            return relative(basePath, candidate);
+        }
+    }
+    return null;
+}
+function isFile(p) {
+    try {
+        return statSync(p).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+// ============================================================================
+// Dependency Graph Builder
+// ============================================================================
+/**
+ * Build a 1-level dependency graph from a set of file paths.
+ *
+ * @param basePath - Workspace root directory
+ * @param filePaths - Files to analyze (workspace-relative paths)
+ * @param maxFiles - Maximum files to process (default 50)
+ * @returns DependencyGraph with forward and reverse maps
+ */
+export function buildDependencyGraph(basePath, filePaths, maxFiles = DEFAULT_MAX_FILES) {
+    const forward = new Map();
+    const reverse = new Map();
+    const files = filePaths.slice(0, maxFiles);
+    for (const filePath of files) {
+        const absPath = resolve(basePath, filePath);
+        // Skip non-existent, non-supported, or oversized files
+        if (!existsSync(absPath))
+            continue;
+        if (!SUPPORTED_EXTENSIONS.has(extname(absPath)))
+            continue;
+        let content;
+        try {
+            content = readFileSync(absPath, 'utf-8');
+            if (content.length > MAX_FILE_SIZE)
+                continue;
+        }
+        catch {
+            continue;
+        }
+        const imports = parseImports(content);
+        const deps = [];
+        for (const imp of imports) {
+            if (!imp.isRelative)
+                continue;
+            const resolved = resolveSpecifier(imp.specifier, filePath, basePath);
+            if (resolved) {
+                deps.push(resolved);
+                // Build reverse index
+                const existing = reverse.get(resolved);
+                if (existing) {
+                    if (!existing.includes(filePath)) {
+                        existing.push(filePath);
+                    }
+                }
+                else {
+                    reverse.set(resolved, [filePath]);
+                }
+            }
+        }
+        if (deps.length > 0) {
+            forward.set(filePath, deps);
+        }
+    }
+    return { forward, reverse };
+}
+// ============================================================================
+// Graph Queries
+// ============================================================================
+/**
+ * Get forward dependencies for a file (files it imports from).
+ */
+export function getForwardDeps(graph, filePath) {
+    return graph.forward.get(filePath) ?? [];
+}
+/**
+ * Get reverse dependencies for a file (files that import it = blast radius).
+ */
+export function getReverseDeps(graph, filePath) {
+    return graph.reverse.get(filePath) ?? [];
+}
+/**
+ * Compute blast radius: unique reverse deps across multiple files.
+ */
+export function computeBlastRadius(graph, filePaths) {
+    const result = new Set();
+    for (const fp of filePaths) {
+        for (const dep of getReverseDeps(graph, fp)) {
+            if (!filePaths.includes(dep)) {
+                result.add(dep);
+            }
+        }
+    }
+    return Array.from(result);
+}
+// ============================================================================
+// Serialization
+// ============================================================================
+/**
+ * Convert DependencyGraph to a serializable snapshot (Maps → Records).
+ */
+export function snapshotGraph(graph) {
+    const forward = {};
+    const reverse = {};
+    for (const [k, v] of graph.forward) {
+        forward[k] = v;
+    }
+    for (const [k, v] of graph.reverse) {
+        reverse[k] = v;
+    }
+    return { forward, reverse };
+}

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

@@ -0,0 +1,59 @@
+/**
+ * Bee Incremental Analyzer — Block-level analysis with cache
+ *
+ * Analyzes only changed blocks + their immediate neighbors (seq ± 1).
+ * Uses InferenceCache for per-block result caching.
+ *
+ * Flow:
+ * 1. Compute invalidation set (changed + neighbors)
+ * 2. Invalidate cache entries for affected blocks
+ * 3. For each block in chain: cache hit → reuse, miss → infer + cache
+ * 4. Aggregate results into summary
+ *
+ * @since v1.21.0 (P34)
+ */
+import type { SemanticBlock } from '../../kernel/blocks/types.js';
+import type { InferenceFn } from '../swarm/swarm_dispatcher.js';
+import type { InferenceCache } from '../../kernel/blocks/inference_cache.js';
+import type { IBlockStore } from '../../kernel/contracts.js';
+export interface BlockAnalysisResult {
+    blockId: string;
+    seq: number;
+    analysis: string;
+    fromCache: boolean;
+}
+export interface IncrementalAnalysisResult {
+    filePath: string;
+    totalBlocks: number;
+    analyzedBlocks: number;
+    cachedBlocks: number;
+    skippedBlocks: number;
+    results: BlockAnalysisResult[];
+    aggregatedSummary: string;
+}
+export interface AnalyzeBlocksParams {
+    basePath: string;
+    filePath: string;
+    rootHash: string;
+    changedBlockIds: string[];
+    cache: InferenceCache;
+    inferenceFn: InferenceFn;
+    /** Optional injected block store */
+    blockStore?: IBlockStore;
+}
+/**
+ * Analyze blocks incrementally — only changed + neighbor blocks are re-inferred.
+ *
+ * Blocks outside the invalidation set use cached results when available.
+ * Blocks without cache and outside the invalidation set are skipped
+ * (not analyzed — they haven't changed and have no prior result).
+ */
+export declare function analyzeBlocksIncremental(params: AnalyzeBlocksParams): Promise<IncrementalAnalysisResult>;
+/**
+ * Compute the set of block IDs that need re-analysis.
+ *
+ * Includes:
+ * - Changed blocks themselves
+ * - Immediate neighbors (seq ± 1) — their context has changed
+ */
+export declare function computeInvalidationSet(blocks: SemanticBlock[], changedBlockIds: string[]): Set<string>;