@vibecodetown/mcp-server 1.3.1

package/build/mcp/cache/index.js

@@ -0,0 +1,147 @@
+// adapters/mcp-ts/src/cache/index.ts
+// TieredCache - TTL + mtime-based cache with LRU eviction
+/**
+ * TieredCache - Multi-level cache with TTL and mtime validation
+ *
+ * Features:
+ * - TTL-based expiration
+ * - Optional mtime validation for file-based caching
+ * - LRU eviction when maxEntries exceeded
+ * - Pattern-based invalidation
+ */
+export class TieredCache {
+    config;
+    cache = new Map();
+    accessOrder = [];
+    hits = 0;
+    misses = 0;
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Get cached value if valid
+     *
+     * @param key - Cache key
+     * @param mtimeGetter - Optional function to get current mtime for validation
+     * @returns Cached value or null if expired/invalid
+     */
+    get(key, mtimeGetter) {
+        const entry = this.cache.get(key);
+        if (!entry) {
+            this.misses++;
+            return null;
+        }
+        // Check TTL expiration
+        const now = Date.now();
+        if (now - entry.timestamp > this.config.ttlMs) {
+            this.cache.delete(key);
+            this.removeFromAccessOrder(key);
+            this.misses++;
+            return null;
+        }
+        // Check mtime validation if provided
+        if (mtimeGetter && entry.mtime !== undefined) {
+            const currentMtime = mtimeGetter();
+            if (currentMtime !== null && currentMtime !== entry.mtime) {
+                this.cache.delete(key);
+                this.removeFromAccessOrder(key);
+                this.misses++;
+                return null;
+            }
+        }
+        // Update access order for LRU
+        this.updateAccessOrder(key);
+        this.hits++;
+        return entry.value;
+    }
+    /**
+     * Set cache value
+     *
+     * @param key - Cache key
+     * @param value - Value to cache
+     * @param mtime - Optional mtime for file-based validation
+     */
+    set(key, value, mtime) {
+        // Evict if at capacity
+        if (this.cache.size >= this.config.maxEntries && !this.cache.has(key)) {
+            this.evictLRU();
+        }
+        this.cache.set(key, {
+            value,
+            timestamp: Date.now(),
+            mtime,
+        });
+        this.updateAccessOrder(key);
+    }
+    /**
+     * Invalidate specific cache entry
+     */
+    invalidate(key) {
+        this.cache.delete(key);
+        this.removeFromAccessOrder(key);
+    }
+    /**
+     * Invalidate all entries matching a pattern
+     */
+    invalidatePattern(pattern) {
+        const keysToDelete = [];
+        for (const key of this.cache.keys()) {
+            if (pattern.test(key)) {
+                keysToDelete.push(key);
+            }
+        }
+        for (const key of keysToDelete) {
+            this.cache.delete(key);
+            this.removeFromAccessOrder(key);
+        }
+    }
+    /**
+     * Clear all cache entries
+     */
+    clear() {
+        this.cache.clear();
+        this.accessOrder = [];
+    }
+    /**
+     * Get cache statistics
+     */
+    stats() {
+        return {
+            size: this.cache.size,
+            maxEntries: this.config.maxEntries,
+            name: this.config.name,
+            hits: this.hits,
+            misses: this.misses,
+        };
+    }
+    /**
+     * Check if key exists and is valid
+     */
+    has(key, mtimeGetter) {
+        return this.get(key, mtimeGetter) !== null;
+    }
+    updateAccessOrder(key) {
+        this.removeFromAccessOrder(key);
+        this.accessOrder.push(key);
+    }
+    removeFromAccessOrder(key) {
+        const index = this.accessOrder.indexOf(key);
+        if (index !== -1) {
+            this.accessOrder.splice(index, 1);
+        }
+    }
+    evictLRU() {
+        if (this.accessOrder.length === 0)
+            return;
+        const lruKey = this.accessOrder.shift();
+        if (lruKey) {
+            this.cache.delete(lruKey);
+        }
+    }
+}
+/**
+ * Create a cache key from multiple parts
+ */
+export function createCacheKey(...parts) {
+    return parts.filter((p) => p !== undefined).join("::");
+}

package/build/mcp/chunking/artifacts.d.ts

@@ -0,0 +1,9 @@
+import { ChunkData, ChunkManifest } from "./types.js";
+export declare function writeChunkArtifacts(params: {
+    workspaceRoot: string;
+    runId: string;
+    chunks: ChunkData[];
+    manifest: ChunkManifest;
+}): {
+    chunkDir: string;
+};

package/build/mcp/chunking/artifacts.js

@@ -0,0 +1,41 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { ensureDirSync, getPmRunDir } from "../paths.js";
+import { emitEvent } from "../events/emitter.js";
+export function writeChunkArtifacts(params) {
+    const runDir = getPmRunDir(params.workspaceRoot, params.runId);
+    const chunkDir = path.join(runDir, "chunks");
+    ensureDirSync(chunkDir);
+    for (const chunk of params.chunks) {
+        const filePath = path.join(chunkDir, `${chunk.chunk_id}.json`);
+        fs.writeFileSync(filePath, JSON.stringify(chunk, null, 2));
+    }
+    const manifestPath = path.join(chunkDir, "chunk_manifest.v1.json");
+    fs.writeFileSync(manifestPath, JSON.stringify(params.manifest, null, 2));
+    const summaryPath = path.join(chunkDir, "chunk_summary.md");
+    const summaryLines = [
+        "# Chunk Summary",
+        "",
+        ...params.chunks.map((c) => `- ${c.chunk_id} (${c.profile}) ${c.source.path}:${c.source.line_start}-${c.source.line_end} (${c.token_estimate} tokens)`),
+    ];
+    fs.writeFileSync(summaryPath, summaryLines.join("\n"));
+    emitEvent({
+        runId: params.manifest.run_id,
+        type: "artifact.chunk_manifest_written",
+        reason: "chunk_manifest_written",
+        paths: [manifestPath],
+        component: "chunking",
+        actor: "engine",
+        workspaceRoot: params.workspaceRoot,
+    });
+    emitEvent({
+        runId: params.manifest.run_id,
+        type: "artifact.chunk_summary_written",
+        reason: "chunk_summary_written",
+        paths: [summaryPath],
+        component: "chunking",
+        actor: "engine",
+        workspaceRoot: params.workspaceRoot,
+    });
+    return { chunkDir };
+}

package/build/mcp/chunking/chunking.d.ts

@@ -0,0 +1,10 @@
+import { ChunkData, ChunkInput, ChunkManifest, ChunkPolicy } from "./types.js";
+export declare function buildChunks(input: ChunkInput, overridePolicy?: ChunkPolicy): {
+    chunks: ChunkData[];
+    manifest: ChunkManifest;
+};
+export declare function buildAndWriteChunks(input: ChunkInput, overridePolicy?: ChunkPolicy): {
+    chunks: ChunkData[];
+    manifest: ChunkManifest;
+    chunkDir: string;
+};

package/build/mcp/chunking/chunking.js

@@ -0,0 +1,193 @@
+import * as crypto from "node:crypto";
+import * as path from "node:path";
+import { loadChunkPolicy } from "./policy.js";
+import { writeChunkArtifacts } from "./artifacts.js";
+function estimateTokens(text) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return 0;
+    return trimmed.split(/\s+/).length;
+}
+function hashText(text) {
+    return crypto.createHash("sha256").update(text).digest("hex");
+}
+function getFileExt(filePath) {
+    if (!filePath)
+        return undefined;
+    return path.extname(filePath).toLowerCase();
+}
+function selectProfile(input, policy) {
+    if (input.profile)
+        return input.profile;
+    const ext = getFileExt(input.filePath);
+    if (ext && policy.routing?.extensions?.extraction?.includes(ext))
+        return "extraction";
+    if (ext && policy.routing?.extensions?.reasoning?.includes(ext))
+        return "reasoning";
+    if (input.filePath) {
+        const normalized = input.filePath.replace(/\\/g, "/");
+        const referencePaths = policy.routing?.extensions?.reference ?? [];
+        if (referencePaths.some((p) => normalized.includes(p)))
+            return "reference";
+    }
+    return "reasoning";
+}
+function findBoundaryLines(lines, profile, ext) {
+    const boundaries = [0];
+    const rust = /\.(rs)$/i.test(ext ?? "");
+    const ts = /\.(ts|tsx|js|jsx)$/i.test(ext ?? "");
+    const md = /\.(md|markdown)$/i.test(ext ?? "");
+    const headerRe = /^#{1,6}\s+/;
+    const tsFunc = /^\s*(export\s+)?(async\s+)?function\s+\w+/;
+    const tsClass = /^\s*(export\s+)?class\s+\w+/;
+    const tsConstFn = /^\s*(export\s+)?const\s+\w+\s*=\s*\(/;
+    const rsFn = /^\s*fn\s+\w+/;
+    const rsStruct = /^\s*(pub\s+)?struct\s+\w+/;
+    const rsImpl = /^\s*impl\s+\w+/;
+    const rsEnum = /^\s*(pub\s+)?enum\s+\w+/;
+    const logStamp = /^\s*\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}/;
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i];
+        if (profile === "extraction") {
+            if (logStamp.test(line) || headerRe.test(line))
+                boundaries.push(i);
+            continue;
+        }
+        if (profile === "reference") {
+            if (headerRe.test(line))
+                boundaries.push(i);
+            continue;
+        }
+        // reasoning
+        if (md && headerRe.test(line)) {
+            boundaries.push(i);
+            continue;
+        }
+        if (ts && (tsFunc.test(line) || tsClass.test(line) || tsConstFn.test(line))) {
+            boundaries.push(i);
+            continue;
+        }
+        if (rust && (rsFn.test(line) || rsStruct.test(line) || rsImpl.test(line) || rsEnum.test(line))) {
+            boundaries.push(i);
+            continue;
+        }
+    }
+    return Array.from(new Set(boundaries)).sort((a, b) => a - b);
+}
+function splitSegments(lines, boundaries) {
+    const segments = [];
+    for (let i = 0; i < boundaries.length; i += 1) {
+        const start = boundaries[i];
+        const end = i + 1 < boundaries.length ? boundaries[i + 1] : lines.length;
+        if (start < end)
+            segments.push({ start, end });
+    }
+    return segments;
+}
+function windowSplit(lines, start, end, maxTokens, overlapRatio) {
+    const chunks = [];
+    const overlapTokens = Math.max(1, Math.floor(maxTokens * overlapRatio));
+    let i = start;
+    while (i < end) {
+        let tokenCount = 0;
+        let j = i;
+        while (j < end) {
+            const lineTokens = estimateTokens(lines[j]);
+            if (tokenCount + lineTokens > maxTokens && j > i)
+                break;
+            tokenCount += lineTokens;
+            j += 1;
+            if (tokenCount >= maxTokens)
+                break;
+        }
+        if (j <= i)
+            j = i + 1;
+        chunks.push({ start: i, end: j });
+        // move by overlap
+        let backTokens = 0;
+        let k = j - 1;
+        while (k > i && backTokens < overlapTokens) {
+            backTokens += estimateTokens(lines[k]);
+            k -= 1;
+        }
+        i = Math.max(i + 1, k + 1);
+    }
+    return chunks;
+}
+function mergeSmall(chunks, lines, minTokens, maxTokens) {
+    const merged = [];
+    for (let i = 0; i < chunks.length; i += 1) {
+        const cur = chunks[i];
+        const curTokens = estimateTokens(lines.slice(cur.start, cur.end).join("\n"));
+        if (curTokens >= minTokens || merged.length === 0) {
+            merged.push(cur);
+            continue;
+        }
+        const prev = merged[merged.length - 1];
+        const combinedTokens = estimateTokens(lines.slice(prev.start, cur.end).join("\n"));
+        if (combinedTokens <= maxTokens) {
+            merged[merged.length - 1] = { start: prev.start, end: cur.end };
+        }
+        else {
+            merged.push(cur);
+        }
+    }
+    return merged;
+}
+export function buildChunks(input, overridePolicy) {
+    const policy = overridePolicy ?? loadChunkPolicy(input.workspaceRoot).policy;
+    const profile = selectProfile(input, policy);
+    const profileRule = policy.profiles[profile];
+    const lines = input.text.split(/\r?\n/);
+    const ext = getFileExt(input.filePath);
+    const boundaries = findBoundaryLines(lines, profile, ext);
+    const segments = splitSegments(lines, boundaries);
+    let ranges = [];
+    for (const seg of segments) {
+        const segText = lines.slice(seg.start, seg.end).join("\n");
+        const segTokens = estimateTokens(segText);
+        if (segTokens <= profileRule.max) {
+            ranges.push(seg);
+        }
+        else {
+            ranges = ranges.concat(windowSplit(lines, seg.start, seg.end, profileRule.max, profileRule.overlap));
+        }
+    }
+    ranges = mergeSmall(ranges, lines, profileRule.min, profileRule.max);
+    const chunks = ranges.map((range, index) => {
+        const payload = lines.slice(range.start, range.end).join("\n");
+        const tokenEstimate = estimateTokens(payload);
+        const hash = hashText(payload);
+        const chunkId = `chk_${hash.slice(0, 12)}_${index}`;
+        return {
+            chunk_id: chunkId,
+            profile,
+            source: {
+                path: input.filePath ?? "<inline>",
+                line_start: range.start + 1,
+                line_end: range.end,
+            },
+            token_estimate: tokenEstimate,
+            links: [],
+            hash,
+            payload,
+        };
+    });
+    const manifest = {
+        schema_version: "chunk_manifest.v1",
+        run_id: input.runId,
+        created_at: new Date().toISOString(),
+        chunks: chunks.map((c) => ({ chunk_id: c.chunk_id, profile: c.profile, token_estimate: c.token_estimate })),
+    };
+    return { chunks, manifest };
+}
+export function buildAndWriteChunks(input, overridePolicy) {
+    const { chunks, manifest } = buildChunks(input, overridePolicy);
+    const { chunkDir } = writeChunkArtifacts({
+        workspaceRoot: input.workspaceRoot,
+        runId: input.runId,
+        chunks,
+        manifest,
+    });
+    return { chunks, manifest, chunkDir };
+}

package/build/mcp/chunking/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./types.js";
+export * from "./chunking.js";
+export * from "./policy.js";
+export * from "./artifacts.js";

package/build/mcp/chunking/index.js

@@ -0,0 +1,4 @@
+export * from "./types.js";
+export * from "./chunking.js";
+export * from "./policy.js";
+export * from "./artifacts.js";

package/build/mcp/chunking/policy.d.ts

@@ -0,0 +1,27 @@
+import { ChunkPolicy, PackPolicy } from "./types.js";
+export declare function getChunkPolicyPath(workspaceRoot: string): string;
+export declare function getPackPolicyPath(workspaceRoot: string): string;
+export declare function loadChunkPolicy(workspaceRoot: string): {
+    policy: ChunkPolicy;
+    sha256: string;
+    absPath: string;
+    source: "file" | "default";
+    validation: {
+        ok: true;
+    } | {
+        ok: false;
+        error: string;
+    };
+};
+export declare function loadPackPolicy(workspaceRoot: string): {
+    policy: PackPolicy;
+    sha256: string;
+    absPath: string;
+    source: "file" | "default";
+    validation: {
+        ok: true;
+    } | {
+        ok: false;
+        error: string;
+    };
+};

package/build/mcp/chunking/policy.js

@@ -0,0 +1,71 @@
+import * as path from "node:path";
+import { getVibeConfigDir } from "../paths.js";
+import { ChunkPolicySchema, PackPolicySchema } from "../policy/schema.js";
+import { loadJsonPolicy } from "../policy/loader.js";
+export function getChunkPolicyPath(workspaceRoot) {
+    const override = process.env.CHUNK_POLICY_PATH?.trim();
+    if (override) {
+        return path.isAbsolute(override) ? override : path.join(workspaceRoot, override);
+    }
+    return path.join(getVibeConfigDir(workspaceRoot), "chunk_policy.v1.json");
+}
+export function getPackPolicyPath(workspaceRoot) {
+    const override = process.env.PACK_POLICY_PATH?.trim();
+    if (override) {
+        return path.isAbsolute(override) ? override : path.join(workspaceRoot, override);
+    }
+    return path.join(getVibeConfigDir(workspaceRoot), "pack_policy.v1.json");
+}
+const DEFAULT_CHUNK_POLICY = {
+    schema_version: "chunk_policy.v1",
+    profiles: {
+        extraction: { target: [450, 750], max: 900, min: 250, overlap: 0.07 },
+        reasoning: { target: [800, 1200], max: 1500, min: 400, overlap: 0.12 },
+        reference: { target: [600, 1000], max: 1200, min: 300, overlap: 0.0 },
+    },
+    routing: {
+        extensions: {
+            extraction: [".log", ".jsonl", ".trace"],
+            reasoning: [".rs", ".ts", ".tsx", ".js", ".py"],
+            reference: [".vibe/", "docs/specs/"],
+        },
+    },
+};
+const DEFAULT_PACK_POLICY = {
+    schema_version: "pack_policy.v1",
+    main_input: { min: 1600, max: 2200, recommended: 1800 },
+    conclusion_lines: 3,
+    evidence_max: 5,
+    link_max: 3,
+    require_evidence_for_conclusion: true,
+};
+export function loadChunkPolicy(workspaceRoot) {
+    const absPath = getChunkPolicyPath(workspaceRoot);
+    const loaded = loadJsonPolicy({
+        absPath,
+        defaultValue: DEFAULT_CHUNK_POLICY,
+        schema: ChunkPolicySchema,
+    });
+    return {
+        policy: loaded.value,
+        sha256: loaded.sha256,
+        absPath: loaded.absPath,
+        source: loaded.source,
+        validation: loaded.validation,
+    };
+}
+export function loadPackPolicy(workspaceRoot) {
+    const absPath = getPackPolicyPath(workspaceRoot);
+    const loaded = loadJsonPolicy({
+        absPath,
+        defaultValue: DEFAULT_PACK_POLICY,
+        schema: PackPolicySchema,
+    });
+    return {
+        policy: loaded.value,
+        sha256: loaded.sha256,
+        absPath: loaded.absPath,
+        source: loaded.source,
+        validation: loaded.validation,
+    };
+}

package/build/mcp/chunking/types.d.ts

@@ -0,0 +1,66 @@
+export type ChunkProfile = "extraction" | "reasoning" | "reference";
+export interface ChunkProfileRule {
+    target: [number, number];
+    max: number;
+    min: number;
+    overlap: number;
+}
+export interface ChunkPolicy {
+    schema_version: "chunk_policy.v1";
+    profiles: Record<ChunkProfile, ChunkProfileRule>;
+    routing?: {
+        extensions?: {
+            extraction?: string[];
+            reasoning?: string[];
+            reference?: string[];
+        };
+    };
+}
+export interface PackPolicy {
+    schema_version: "pack_policy.v1";
+    main_input: {
+        min: number;
+        max: number;
+        recommended: number;
+    };
+    conclusion_lines: number;
+    evidence_max: number;
+    link_max: number;
+    require_evidence_for_conclusion: boolean;
+}
+export interface ChunkSource {
+    path: string;
+    line_start: number;
+    line_end: number;
+}
+export interface ChunkData {
+    chunk_id: string;
+    profile: ChunkProfile;
+    source: ChunkSource;
+    token_estimate: number;
+    links?: string[];
+    hash: string;
+    payload: string;
+}
+export interface ChunkManifest {
+    schema_version: "chunk_manifest.v1";
+    run_id: string;
+    created_at: string;
+    chunks: Array<{
+        chunk_id: string;
+        profile: ChunkProfile;
+        token_estimate: number;
+    }>;
+}
+export interface ChunkInput {
+    runId: string;
+    workspaceRoot: string;
+    text: string;
+    filePath?: string;
+    profile?: ChunkProfile;
+}
+export interface ChunkingResult {
+    chunks: ChunkData[];
+    manifest: ChunkManifest;
+    chunkDir: string;
+}

package/build/mcp/chunking/types.js

@@ -0,0 +1 @@
+export {};

package/build/mcp/cli.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Sanitize environment variables by filtering through whitelist
+ *
+ * @param additionalEnv - Optional additional env vars to include
+ * @returns Filtered environment object
+ */
+export declare function sanitizeEnv(additionalEnv?: Record<string, string | undefined>): Record<string, string>;
+export declare function runCmd(cmd: string, args: string[], opts?: {
+    cwd?: string;
+    timeoutMs?: number;
+    env?: Record<string, string | undefined>;
+    stdin?: string;
+}): Promise<{
+    code: number;
+    stdout: string;
+    stderr: string;
+}>;
+/**
+ * Synchronous version of runCmd for compatibility with existing code.
+ * Prefer runCmd (async) where possible.
+ *
+ * Exit codes:
+ * - 124: Timeout
+ * - 127: Spawn error (command not found, permission denied, etc.)
+ *
+ * @param cmd - Command to execute
+ * @param args - Command arguments
+ * @param opts - Optional: cwd, timeoutMs (default 120_000), env
+ */
+export declare function runCmdSync(cmd: string, args: string[], opts?: {
+    cwd?: string;
+    timeoutMs?: number;
+    env?: Record<string, string | undefined>;
+}): {
+    code: number;
+    stdout: string;
+    stderr: string;
+};
+/**
+ * Git-specific wrapper with appropriate defaults
+ * Uses synchronous execution as git operations are typically fast
+ */
+export declare function runGit(args: string[], opts?: {
+    cwd?: string;
+    timeoutMs?: number;
+}): {
+    code: number;
+    stdout: string;
+    stderr: string;
+};
+export declare function safeJsonParse<T>(raw: string): {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};