@10et/cli 1.0.0

package/dist/mcp/context-hub-mcp.js

@@ -0,0 +1,797 @@
+#!/usr/bin/env node
+/**
+ * Context Hub MCP Server
+ *
+ * Provides context tools to Claude Code via MCP protocol.
+ * Communicates with the Context Hub daemon via HTTP.
+ *
+ * @purpose MCP server for Context Hub integration with Claude Code
+ */
+import * as readline from "readline";
+import * as fs from "fs";
+import * as path from "path";
+import { execSync } from "child_process";
+import { getProjectHubUrl } from "../utils/context-hub-port.js";
+import { telemetry } from "../lib/telemetry.js";
+import { TrajectoryLoader } from "../lib/trajectory-loader.js";
+const CONTEXT_HUB_URL = process.env.CONTEXT_HUB_URL || getProjectHubUrl();
+const TOKEN_FILE = ".jfl/context-hub.token";
+let lastAutoRecoveryTime = 0;
+const AUTO_RECOVERY_COOLDOWN_MS = 30_000;
+// ============================================================================
+// Auth
+// ============================================================================
+function getAuthToken() {
+    // Try to find token file by walking up from cwd
+    let dir = process.cwd();
+    const root = path.parse(dir).root;
+    while (dir !== root) {
+        const tokenPath = path.join(dir, TOKEN_FILE);
+        if (fs.existsSync(tokenPath)) {
+            return fs.readFileSync(tokenPath, 'utf-8').trim();
+        }
+        dir = path.dirname(dir);
+    }
+    return null;
+}
+// ============================================================================
+// MCP Server Implementation
+// ============================================================================
+import { HUB_TOOLS, toMcpTools } from "../lib/tool-schemas.js";
+// Shared schemas from tool-schemas.ts + any MCP-only additions
+const TOOLS = [
+    ...toMcpTools(HUB_TOOLS),
+];
+// Legacy: keep the old TOOLS array commented out as reference during migration
+const _LEGACY_TOOLS = [
+    {
+        name: "context_get",
+        description: "Get unified context from journal, knowledge docs, and code. Use at the start of tasks to understand the project.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: {
+                    type: "string",
+                    description: "Optional search query to filter results"
+                },
+                taskType: {
+                    type: "string",
+                    enum: ["code", "spec", "content", "strategy", "general"],
+                    description: "Type of task for context prioritization"
+                },
+                maxItems: {
+                    type: "number",
+                    description: "Maximum number of context items to return (default: 30)"
+                }
+            }
+        }
+    },
+    {
+        name: "context_search",
+        description: "Search across all context sources (journal, knowledge, code, content) for relevant information.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: {
+                    type: "string",
+                    description: "Search query"
+                },
+                maxItems: {
+                    type: "number",
+                    description: "Maximum results (default: 20)"
+                }
+            },
+            required: ["query"]
+        }
+    },
+    {
+        name: "context_status",
+        description: "Check Context Hub status and available sources.",
+        inputSchema: {
+            type: "object",
+            properties: {}
+        }
+    },
+    {
+        name: "context_sessions",
+        description: "See activity from other sessions (informational only).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                hours: {
+                    type: "number",
+                    description: "Hours of history to include (default: 24)"
+                }
+            }
+        }
+    },
+    {
+        name: "memory_search",
+        description: "Search through indexed journal entries and memories. Finds relevant past work, decisions, and learnings across all sessions.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: {
+                    type: "string",
+                    description: "Search query (e.g., 'what did we decide about pricing?')"
+                },
+                type: {
+                    type: "string",
+                    enum: ["feature", "fix", "decision", "discovery", "milestone", "all"],
+                    description: "Filter by entry type (optional)"
+                },
+                maxItems: {
+                    type: "number",
+                    description: "Maximum results to return (default: 10)"
+                },
+                since: {
+                    type: "string",
+                    description: "ISO date - only return entries after this date (optional)"
+                }
+            },
+            required: ["query"]
+        }
+    },
+    {
+        name: "memory_add",
+        description: "Manually add a memory or note. Useful for capturing insights not in journal.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                title: {
+                    type: "string",
+                    description: "Short title for the memory"
+                },
+                content: {
+                    type: "string",
+                    description: "Full content/description"
+                },
+                tags: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Tags for categorization (optional)"
+                }
+            },
+            required: ["title", "content"]
+        }
+    },
+    {
+        name: "memory_status",
+        description: "Get memory system statistics and health.",
+        inputSchema: {
+            type: "object",
+            properties: {}
+        }
+    },
+    {
+        name: "events_publish",
+        description: "Publish an event to the MAP event bus. Use to signal state changes, task completion, or custom events.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                type: {
+                    type: "string",
+                    description: "Event type (e.g., 'task:completed', 'decision:made', 'journal:entry', 'custom')"
+                },
+                source: {
+                    type: "string",
+                    description: "Event source identifier (e.g., 'claude-code', 'peter-parker')"
+                },
+                data: {
+                    type: "object",
+                    description: "Event payload data"
+                },
+                target: {
+                    type: "string",
+                    description: "Optional specific consumer"
+                }
+            },
+            required: ["type", "source"]
+        }
+    },
+    {
+        name: "events_recent",
+        description: "Get recent events from the MAP event bus. Check what happened across services and agents.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                pattern: {
+                    type: "string",
+                    description: "Glob pattern to filter events (e.g., 'peter:*', 'session:*', '*')"
+                },
+                since: {
+                    type: "string",
+                    description: "ISO date - only return events after this time"
+                },
+                limit: {
+                    type: "number",
+                    description: "Maximum events to return (default: 20)"
+                }
+            }
+        }
+    },
+    {
+        name: "query_experiment_history",
+        description: "Search past experiments, their outcomes, and what was learned. Use before starting new experiments to avoid repeating failures.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                files: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Filter by files changed"
+                },
+                minDelta: {
+                    type: "number",
+                    description: "Min score improvement"
+                },
+                maxAge: {
+                    type: "string",
+                    description: "Max age e.g. 7d, 30d"
+                },
+                outcome: {
+                    type: "string",
+                    enum: ["confirmed", "rejected", "inconclusive"],
+                    description: "Filter by experiment outcome"
+                },
+                limit: {
+                    type: "number",
+                    description: "Max results (default: 20)"
+                },
+                type: {
+                    type: "string",
+                    description: "Filter by entry type (e.g., 'experiment')"
+                },
+                agent: {
+                    type: "string",
+                    description: "Filter by agent ID"
+                }
+            }
+        }
+    }
+];
+async function doFetch(endpoint, body) {
+    const url = `${CONTEXT_HUB_URL}${endpoint}`;
+    const token = getAuthToken();
+    const headers = {
+        "Content-Type": "application/json"
+    };
+    if (token) {
+        headers["Authorization"] = `Bearer ${token}`;
+    }
+    const response = await fetch(url, {
+        method: body ? "POST" : "GET",
+        headers,
+        body: body ? JSON.stringify(body) : undefined
+    });
+    if (response.status === 401) {
+        throw new Error("Unauthorized. Token file may be missing or invalid. Restart Context Hub: jfl context-hub restart");
+    }
+    if (!response.ok) {
+        throw new Error(`Context Hub returned ${response.status}`);
+    }
+    return await response.json();
+}
+function isRecoverableError(error) {
+    if (error.code === "ECONNREFUSED")
+        return true;
+    if (error.cause?.code === "ECONNREFUSED")
+        return true;
+    const msg = String(error.message || "").toLowerCase();
+    return msg.includes("fetch failed") || msg.includes("econnrefused");
+}
+async function callContextHub(endpoint, body) {
+    try {
+        return await doFetch(endpoint, body);
+    }
+    catch (error) {
+        if (!isRecoverableError(error))
+            throw error;
+        const now = Date.now();
+        if (now - lastAutoRecoveryTime < AUTO_RECOVERY_COOLDOWN_MS) {
+            throw new Error("Context Hub is not running. Start it with: jfl context-hub start");
+        }
+        lastAutoRecoveryTime = now;
+        try {
+            execSync("jfl context-hub ensure", {
+                stdio: "ignore",
+                timeout: 10_000
+            });
+        }
+        catch {
+            throw new Error("Context Hub is not running and auto-recovery failed. Start it with: jfl context-hub start");
+        }
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        return await doFetch(endpoint, body);
+    }
+}
+function formatContextItems(items) {
+    if (items.length === 0) {
+        return "No context items found.";
+    }
+    const grouped = {};
+    for (const item of items) {
+        if (!grouped[item.source]) {
+            grouped[item.source] = [];
+        }
+        grouped[item.source].push(item);
+    }
+    const sections = [];
+    for (const [source, sourceItems] of Object.entries(grouped)) {
+        const header = `## ${source.toUpperCase()}\n`;
+        const itemLines = sourceItems.map(item => {
+            let line = `- **${item.title}**`;
+            if (item.path) {
+                line += ` (${item.path})`;
+            }
+            line += `\n  ${item.content.slice(0, 200)}${item.content.length > 200 ? "..." : ""}`;
+            return line;
+        }).join("\n");
+        sections.push(header + itemLines);
+    }
+    return sections.join("\n\n");
+}
+function formatMemoryResults(results) {
+    if (results.length === 0) {
+        return "No memories found.";
+    }
+    const items = results.map((r, index) => {
+        const relevanceBadge = r.relevance === 'high' ? '●' : r.relevance === 'medium' ? '◐' : '○';
+        const type = r.type || 'unknown';
+        const date = r.ts ? new Date(r.ts).toISOString().split('T')[0] : '';
+        return `${index + 1}. [${type}] ${r.title}
+   ${date} | ${relevanceBadge} Relevance: ${(r.score || 0).toFixed(2)}
+   ${r.summary || r.content?.slice(0, 150) || ''}`;
+    }).join('\n\n');
+    return `Found ${results.length} ${results.length === 1 ? 'memory' : 'memories'}:\n\n${items}`;
+}
+function findRepoRoot() {
+    let dir = process.cwd();
+    const root = path.parse(dir).root;
+    while (dir !== root) {
+        if (fs.existsSync(path.join(dir, '.git')) || fs.existsSync(path.join(dir, '.jfl'))) {
+            return dir;
+        }
+        dir = path.dirname(dir);
+    }
+    return null;
+}
+function loadPrivacyConfig(repoRoot) {
+    const defaultConfig = {
+        sessionVisibility: 'public',
+        showFileDetails: true,
+        showCommitMessages: true
+    };
+    try {
+        const configPath = path.join(repoRoot, '.jfl', 'config.json');
+        if (fs.existsSync(configPath)) {
+            const content = fs.readFileSync(configPath, 'utf-8');
+            const config = JSON.parse(content);
+            if (config.privacy) {
+                return {
+                    sessionVisibility: config.privacy.sessionVisibility || defaultConfig.sessionVisibility,
+                    showFileDetails: config.privacy.showFileDetails ?? defaultConfig.showFileDetails,
+                    showCommitMessages: config.privacy.showCommitMessages ?? defaultConfig.showCommitMessages
+                };
+            }
+        }
+    }
+    catch {
+        // Config doesn't exist or is invalid, use defaults
+    }
+    return defaultConfig;
+}
+function formatRelativeTime(timestamp) {
+    const now = Date.now();
+    const then = new Date(timestamp).getTime();
+    const diffMs = now - then;
+    const diffMin = Math.floor(diffMs / 60000);
+    if (diffMin < 1)
+        return 'just now';
+    if (diffMin < 60)
+        return `${diffMin}m ago`;
+    const diffHr = Math.floor(diffMin / 60);
+    if (diffHr < 24)
+        return `${diffHr}h ago`;
+    const diffDay = Math.floor(diffHr / 24);
+    return `${diffDay}d ago`;
+}
+function getSessionUser(sessionName) {
+    // Extract user from session name: session-username-YYYYMMDD-HHMM-hash
+    const parts = sessionName.split('-');
+    if (parts.length >= 2 && parts[0] === 'session') {
+        return parts[1];
+    }
+    return sessionName;
+}
+function getSessionsActivity(hours) {
+    const repoRoot = findRepoRoot();
+    if (!repoRoot) {
+        return "Not in a JFL project directory.";
+    }
+    const privacy = loadPrivacyConfig(repoRoot);
+    // If privacy is set to private, don't show any session info
+    if (privacy.sessionVisibility === 'private') {
+        return "Session visibility is set to private.";
+    }
+    const currentBranch = execSync('git branch --show-current', { cwd: repoRoot, encoding: 'utf-8' }).trim();
+    const sessions = [];
+    try {
+        // Get all session branches
+        const branchOutput = execSync('git branch --list "session-*"', { cwd: repoRoot, encoding: 'utf-8' });
+        const branches = branchOutput.split('\n')
+            .map(b => b.trim().replace(/^\*\s+/, ''))
+            .filter(b => b.startsWith('session-'));
+        // Get journal directory (should be in main repo)
+        const journalDir = path.join(repoRoot, '.jfl', 'journal');
+        for (const branch of branches) {
+            const session = {
+                name: branch,
+                path: repoRoot, // All sessions work in main repo now
+                branch: branch,
+                isActive: branch === currentBranch, // Active if it's the current branch
+                recentCommits: getRecentCommits(repoRoot, branch, 3),
+                journalSummary: '',
+                workingOn: ''
+            };
+            // Read journal for this session
+            const journalFile = path.join(journalDir, `${branch}.jsonl`);
+            if (fs.existsSync(journalFile)) {
+                const entries = readJournalEntries(journalFile, hours);
+                if (entries.length > 0) {
+                    session.journalSummary = entries.map(e => `- ${e.title}`).join('\n');
+                    session.workingOn = entries[entries.length - 1].title;
+                }
+            }
+            sessions.push(session);
+        }
+    }
+    catch (error) {
+        return `Error reading sessions: ${error.message}`;
+    }
+    if (sessions.length === 0) {
+        return "No other sessions found.";
+    }
+    // Format output
+    const lines = [`Team Activity (last ${hours}h):\n`];
+    const activeSessions = sessions.filter(s => s.isActive && s.branch !== currentBranch);
+    const staleSessions = sessions.filter(s => !s.isActive && s.branch !== currentBranch);
+    if (activeSessions.length > 0) {
+        lines.push('## Currently Active\n');
+        for (const s of activeSessions) {
+            const user = getSessionUser(s.name);
+            lines.push(`🟢 **${user}** - active`);
+            // Show work details based on privacy settings
+            if (privacy.sessionVisibility !== 'limited') {
+                if (s.workingOn) {
+                    lines.push(`   Working on: ${s.workingOn}`);
+                }
+                if (s.recentCommits.length > 0 && privacy.showCommitMessages) {
+                    lines.push(`   Recent commits:`);
+                    for (const c of s.recentCommits) {
+                        lines.push(`     - ${c}`);
+                    }
+                }
+            }
+            lines.push('');
+        }
+    }
+    if (staleSessions.length > 0) {
+        lines.push('## Recently Active\n');
+        for (const s of staleSessions.slice(0, 5)) {
+            const user = getSessionUser(s.name);
+            lines.push(`🟡 **${user}** - idle`);
+            // Show work details based on privacy settings
+            if (privacy.sessionVisibility !== 'limited' && s.workingOn) {
+                lines.push(`   Last worked on: ${s.workingOn}`);
+            }
+            lines.push('');
+        }
+    }
+    // Check for potential overlap
+    const currentJournalFile = path.join(repoRoot, '.jfl', 'journal', `${currentBranch}.jsonl`);
+    if (fs.existsSync(currentJournalFile)) {
+        const currentEntries = readJournalEntries(currentJournalFile, hours);
+        if (currentEntries.length > 0 && activeSessions.length > 0) {
+            const currentWork = currentEntries[currentEntries.length - 1].title.toLowerCase();
+            for (const s of activeSessions) {
+                if (s.workingOn && hasOverlap(currentWork, s.workingOn.toLowerCase())) {
+                    const user = getSessionUser(s.name);
+                    lines.push(`\n⚠️  **Potential overlap detected** with ${user}`);
+                    lines.push(`   They're working on: ${s.workingOn}`);
+                }
+            }
+        }
+    }
+    return lines.join('\n');
+}
+// Removed parseWorktrees and checkIfActive functions - no longer needed since we use branches instead of worktrees
+function getRecentCommits(repoRoot, branch, count) {
+    try {
+        const output = execSync(`git log --oneline -${count} "${branch}" 2>/dev/null`, { cwd: repoRoot, encoding: 'utf-8' });
+        return output.trim().split('\n').filter(l => l);
+    }
+    catch {
+        return [];
+    }
+}
+function readJournalEntries(journalFile, hours) {
+    const entries = [];
+    const cutoff = Date.now() - (hours * 60 * 60 * 1000);
+    try {
+        const content = fs.readFileSync(journalFile, 'utf-8');
+        for (const line of content.split('\n')) {
+            if (!line.trim())
+                continue;
+            try {
+                const entry = JSON.parse(line);
+                const entryTime = new Date(entry.ts).getTime();
+                if (entryTime >= cutoff) {
+                    entries.push(entry);
+                }
+            }
+            catch {
+                // Skip invalid JSON lines
+            }
+        }
+    }
+    catch {
+        // File doesn't exist or can't be read
+    }
+    return entries;
+}
+function hasOverlap(work1, work2) {
+    // Simple keyword overlap detection
+    const keywords1 = new Set(work1.split(/\s+/).filter(w => w.length > 4));
+    const keywords2 = new Set(work2.split(/\s+/).filter(w => w.length > 4));
+    let overlap = 0;
+    for (const kw of keywords1) {
+        if (keywords2.has(kw))
+            overlap++;
+    }
+    return overlap >= 2; // At least 2 significant words in common
+}
+async function handleToolCall(name, args) {
+    switch (name) {
+        case "context_get": {
+            const result = await callContextHub("/api/context", {
+                query: args.query,
+                taskType: args.taskType,
+                maxItems: args.maxItems || 30
+            });
+            return formatContextItems(result.items);
+        }
+        case "context_search": {
+            if (!args.query) {
+                throw new Error("query is required");
+            }
+            const result = await callContextHub("/api/context/search", {
+                query: args.query,
+                maxItems: args.maxItems || 20
+            });
+            return formatContextItems(result.items);
+        }
+        case "context_status": {
+            const result = await callContextHub("/api/context/status");
+            const sources = Object.entries(result.sources)
+                .filter(([, v]) => v)
+                .map(([k]) => k)
+                .join(", ");
+            return `Context Hub Status:
+- Status: ${result.status}
+- Port: ${result.port}
+- Sources: ${sources || "none"}
+- Items: ${result.itemCount}`;
+        }
+        case "context_sessions": {
+            return getSessionsActivity(args.hours || 24);
+        }
+        case "memory_search": {
+            if (!args.query) {
+                throw new Error("query is required");
+            }
+            const result = await callContextHub("/api/memory/search", {
+                query: args.query,
+                type: args.type,
+                maxItems: args.maxItems || 10,
+                since: args.since
+            });
+            return formatMemoryResults(result.results);
+        }
+        case "memory_add": {
+            if (!args.title || !args.content) {
+                throw new Error("title and content are required");
+            }
+            const result = await callContextHub("/api/memory/add", {
+                title: args.title,
+                content: args.content,
+                tags: args.tags || []
+            });
+            return `Memory added successfully (ID: ${result.id})`;
+        }
+        case "memory_status": {
+            const result = await callContextHub("/api/memory/status");
+            return `Memory System Status:
+- Total memories: ${result.total_memories}
+- By type: ${Object.entries(result.by_type).map(([k, v]) => `${k}(${v})`).join(', ')}
+- Date range: ${result.date_range.earliest ? new Date(result.date_range.earliest).toISOString().split('T')[0] : 'N/A'} to ${result.date_range.latest ? new Date(result.date_range.latest).toISOString().split('T')[0] : 'N/A'}
+- Embeddings: ${result.embeddings.available ? `✓ ${result.embeddings.count} indexed` : '✗ Not available'}
+- Last index: ${result.last_index ? new Date(result.last_index).toISOString() : 'N/A'}`;
+        }
+        case "events_publish": {
+            const result = await callContextHub("/api/events", {
+                type: args.type,
+                source: args.source,
+                target: args.target,
+                data: args.data || {},
+            });
+            return `Event published: ${result.type} (${result.id})`;
+        }
+        case "events_recent": {
+            const params = new URLSearchParams();
+            if (args.pattern)
+                params.set("pattern", args.pattern);
+            if (args.since)
+                params.set("since", args.since);
+            params.set("limit", String(args.limit || 20));
+            const result = await callContextHub(`/api/events?${params.toString()}`);
+            if (!result.events || result.events.length === 0) {
+                return "No events found.";
+            }
+            const lines = result.events.map((e, i) => {
+                const time = new Date(e.ts).toISOString().replace('T', ' ').slice(0, 19);
+                return `${i + 1}. [${e.type}] from ${e.source} (${time})\n   ${JSON.stringify(e.data).slice(0, 150)}`;
+            });
+            return `${result.count} event(s):\n\n${lines.join('\n\n')}`;
+        }
+        case "query_experiment_history": {
+            // Find project root by walking up from cwd
+            const projectRoot = findRepoRoot();
+            if (!projectRoot) {
+                return "Not in a JFL project directory.";
+            }
+            const loader = new TrajectoryLoader(projectRoot);
+            const entries = loader.load({
+                files: args.files,
+                minDelta: args.minDelta,
+                maxAge: args.maxAge,
+                outcome: args.outcome,
+                limit: args.limit || 20,
+                type: args.type,
+                agent: args.agent,
+            });
+            // Deduplicate entries
+            const deduped = loader.deduplicate(entries);
+            return loader.renderForContext(deduped);
+        }
+        default:
+            throw new Error(`Unknown tool: ${name}`);
+    }
+}
+function handleRequest(request) {
+    const response = {
+        jsonrpc: "2.0",
+        id: request.id
+    };
+    try {
+        switch (request.method) {
+            case "initialize":
+                response.result = {
+                    protocolVersion: "2024-11-05",
+                    capabilities: {
+                        tools: {}
+                    },
+                    serverInfo: {
+                        name: "tenet-context-hub",
+                        version: "1.0.0"
+                    }
+                };
+                break;
+            case "tools/list":
+                response.result = { tools: TOOLS };
+                break;
+            case "tools/call":
+                // Handle async in caller
+                throw new Error("ASYNC");
+            case "notifications/initialized":
+                // Acknowledge initialization
+                return response;
+            default:
+                response.error = {
+                    code: -32601,
+                    message: `Method not found: ${request.method}`
+                };
+        }
+    }
+    catch (error) {
+        if (error.message === "ASYNC")
+            throw error;
+        response.error = {
+            code: -32000,
+            message: error.message
+        };
+    }
+    return response;
+}
+async function handleAsyncRequest(request) {
+    if (request.method === "tools/call") {
+        const { name, arguments: args } = request.params || {};
+        const start = Date.now();
+        try {
+            const result = await handleToolCall(name, args || {});
+            telemetry.track({
+                category: 'context_hub',
+                event: 'context_hub:mcp_call',
+                mcp_tool: name,
+                mcp_duration_ms: Date.now() - start,
+                success: true,
+            });
+            return {
+                jsonrpc: "2.0",
+                id: request.id,
+                result: {
+                    content: [{ type: "text", text: result }]
+                }
+            };
+        }
+        catch (error) {
+            telemetry.track({
+                category: 'context_hub',
+                event: 'context_hub:mcp_call',
+                mcp_tool: name,
+                mcp_duration_ms: Date.now() - start,
+                success: false,
+                error_type: error.constructor.name,
+            });
+            return {
+                jsonrpc: "2.0",
+                id: request.id,
+                error: {
+                    code: -32000,
+                    message: error.message
+                }
+            };
+        }
+    }
+    return handleRequest(request);
+}
+// ============================================================================
+// Main
+// ============================================================================
+async function main() {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        terminal: false
+    });
+    rl.on("line", async (line) => {
+        try {
+            const request = JSON.parse(line);
+            let response;
+            try {
+                response = handleRequest(request);
+            }
+            catch (error) {
+                if (error.message === "ASYNC") {
+                    response = await handleAsyncRequest(request);
+                }
+                else {
+                    throw error;
+                }
+            }
+            // Only send response if it has an id (not a notification)
+            if (request.id !== undefined) {
+                console.log(JSON.stringify(response));
+            }
+        }
+        catch (error) {
+            // Log errors to stderr so they don't corrupt the MCP stream
+            console.error(`MCP Error: ${error.message}`);
+        }
+    });
+    rl.on("close", () => {
+        process.exit(0);
+    });
+}
+main().catch(console.error);
+//# sourceMappingURL=context-hub-mcp.js.map