regen-koi-mcp 1.2.0 → 1.3.0

package/dist/index.js

@@ -19,15 +19,14 @@ import dotenv from 'dotenv';
 import { TOOLS } from './tools.js';
 // Use enhanced SPARQL client with focused retrieval
 import { SPARQLClient } from './sparql-client-enhanced.js';
-import HybridSearchClient from './hybrid-client.js';
-import { QueryRouter } from './query_router.js';
-import { UnifiedSearch } from './unified_search.js';
 import { executeGraphTool } from './graph_tool.js';
 // Production hardening modules
 import { logger } from './logger.js';
 import { recordQuery, getMetricsMarkdown, getMetricsSummary } from './metrics.js';
 import { validateToolInput } from './validation.js';
 import { queryCache } from './cache.js';
+// Shared auth module
+import { USER_EMAIL, getAccessToken, setAccessToken } from './auth.js';
 // Load environment variables
 dotenv.config();
 // Configuration
@@ -35,54 +34,51 @@ const KOI_API_ENDPOINT = process.env.KOI_API_ENDPOINT || 'https://regen.gaiaai.x
 const KOI_API_KEY = process.env.KOI_API_KEY || '';
 const SERVER_NAME = process.env.MCP_SERVER_NAME || 'regen-koi';
 const SERVER_VERSION = process.env.MCP_SERVER_VERSION || '1.0.0';
+console.error(`[${SERVER_NAME}] User email for auth: ${USER_EMAIL}`);
+// Check if user is authenticated (with caching)
+async function isUserAuthenticated() {
+    const token = getAccessToken();
+    if (!token)
+        return false;
+    // Validate token with server
+    try {
+        const response = await axios.get(`${KOI_API_ENDPOINT}/auth/status`, {
+            headers: { 'Authorization': `Bearer ${token}` },
+            timeout: 5000
+        });
+        return response.data.authenticated || false;
+    }
+    catch (error) {
+        return false;
+    }
+}
 // API client configuration
+// SECURITY: Authorization header is set dynamically based on access token
 const apiClient = axios.create({
     baseURL: KOI_API_ENDPOINT,
     timeout: 30000,
     headers: {
         'Content-Type': 'application/json',
-        ...(KOI_API_KEY ? { 'Authorization': `Bearer ${KOI_API_KEY}` } : {})
+        'X-User-Email': USER_EMAIL, // Kept for logging purposes only, not for auth
     }
 });
+// Add request interceptor to dynamically include access token
+apiClient.interceptors.request.use((config) => {
+    const token = getAccessToken();
+    if (token && config.headers) {
+        config.headers['Authorization'] = `Bearer ${token}`;
+    }
+    return config;
+});
 // Tool definitions are imported from tools.ts
 class KOIServer {
     server;
     sparqlClient;
-    hybridClient;
-    queryRouter = null;
-    unifiedSearch = null;
     constructor() {
         this.sparqlClient = new SPARQLClient();
-        this.hybridClient = new HybridSearchClient();
-        // Initialize QueryRouter and UnifiedSearch if database config is available
-        try {
-            if (process.env.GRAPH_DB_HOST && process.env.GRAPH_DB_NAME) {
-                this.queryRouter = new QueryRouter({
-                    host: process.env.GRAPH_DB_HOST,
-                    port: parseInt(process.env.GRAPH_DB_PORT || '5432'),
-                    database: process.env.GRAPH_DB_NAME,
-                    user: process.env.GRAPH_DB_USER,
-                    password: process.env.GRAPH_DB_PASSWORD,
-                    entitySimilarityThreshold: parseFloat(process.env.ENTITY_SIMILARITY_THRESHOLD || '0.15'),
-                });
-                this.unifiedSearch = new UnifiedSearch({
-                    host: process.env.GRAPH_DB_HOST,
-                    port: parseInt(process.env.GRAPH_DB_PORT || '5432'),
-                    database: process.env.GRAPH_DB_NAME,
-                    user: process.env.GRAPH_DB_USER,
-                    password: process.env.GRAPH_DB_PASSWORD,
-                    graphName: process.env.GRAPH_NAME || 'regen_graph',
-                    embeddingDimension: parseInt(process.env.EMBEDDING_DIM || '1536'),
-                    rrfConstant: parseInt(process.env.RRF_K || '60'),
-                });
-                console.error(`[${SERVER_NAME}] Initialized QueryRouter and UnifiedSearch`);
-            }
-            else {
-                console.error(`[${SERVER_NAME}] Graph database configuration not found - hybrid_search and query_code_graph tools will be unavailable`);
-            }
-        }
-        catch (error) {
-            console.error(`[${SERVER_NAME}] Failed to initialize graph components:`, error);
+        // Check for graph database configuration (only for logging)
+        if (!(process.env.GRAPH_DB_HOST && process.env.GRAPH_DB_NAME)) {
+            console.error(`[${SERVER_NAME}] Graph database configuration not found - query_code_graph tool will rely on fallback`);
         }
         this.server = new Server({
             name: SERVER_NAME,
@@ -121,7 +117,7 @@ class KOIServer {
             }, `Executing tool: ${name}`);
             try {
                 // Input validation for applicable tools
-                const validationRequired = ['search_knowledge', 'hybrid_search', 'search_github_docs', 'get_repo_overview', 'get_tech_stack', 'generate_weekly_digest'];
+                const validationRequired = ['search', 'search_github_docs', 'get_repo_overview', 'get_tech_stack', 'generate_weekly_digest'];
                 if (validationRequired.includes(name)) {
                     const validation = validateToolInput(name, args);
                     if (!validation.success) {
@@ -144,11 +140,8 @@ class KOIServer {
                     case 'query_code_graph':
                         result = await executeGraphTool(args);
                         break;
-                    case 'hybrid_search':
-                        result = await this.handleHybridSearch(args);
-                        break;
-                    case 'search_knowledge':
-                        result = await this.searchKnowledge(args);
+                    case 'search':
+                        result = await this.search(args);
                         break;
                     case 'get_stats':
                         result = await this.getStats(args);
@@ -372,8 +365,8 @@ class KOIServer {
             return { content: [{ type: 'text', text: `Error: ${e instanceof Error ? e.message : String(e)}` }] };
         }
     }
-    async searchKnowledge(args) {
-        const { query, limit = 5, published_from, published_to, include_undated = false, useHybrid = false } = args || {};
+    async search(args) {
+        const { query, limit = 10, published_from, published_to, include_undated = false } = args || {};
         const vectorFilters = {};
         // Respect explicit date filter
         if (published_from || published_to) {
@@ -395,30 +388,7 @@ class KOIServer {
         if (include_undated) {
             vectorFilters.include_undated = true;
         }
-        // Use true hybrid search if enabled
-        if (useHybrid) {
-            try {
-                const results = await this.hybridClient.hybridSearch(query, {
-                    sparqlLimit: limit * 2,
-                    vectorLimit: limit,
-                    fusionStrategy: 'rrf',
-                    filters: vectorFilters
-                });
-                const formattedResults = this.hybridClient.formatResults(results);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: formattedResults,
-                        },
-                    ],
-                };
-            }
-            catch (error) {
-                console.error('Hybrid search failed, falling back to vector-only:', error);
-            }
-        }
-        // Fallback to original vector search
+        // Call the KOI API (which handles hybrid search with entity boosting)
         try {
             const body = { question: query, limit };
             if (Object.keys(vectorFilters).length > 0)
@@ -616,16 +586,23 @@ class KOIServer {
     async getStats(args) {
         const { detailed = false } = args;
         try {
-            const response = await apiClient.get('/health');
-            const health = response.data;
+            const response = await apiClient.get('/stats');
+            const stats = response.data;
             let formatted = `# KOI Knowledge Base Statistics\n\n`;
-            formatted += `- **Status**: ${health.status || 'Unknown'}\n`;
-            // Since /health is minimal, we'll provide estimated stats
-            formatted += `- **Total Documents**: 15,000+\n`;
-            formatted += `- **Topics Covered**: Regen Network, Carbon Credits, Ecological Assets\n`;
-            formatted += `- **Data Sources**: Multiple (Websites, Podcasts, Documentation)\n`;
-            // Display the resolved endpoint that this server is using
-            formatted += `- **API Endpoint**: ${KOI_API_ENDPOINT}\n`;
+            // Main statistics
+            formatted += `- **Total Documents**: ${stats.total_documents?.toLocaleString() || 'Unknown'}\n`;
+            formatted += `- **Recent (7 days)**: ${stats.recent_7_days?.toLocaleString() || 'Unknown'}\n`;
+            formatted += `- **API Endpoint**: ${KOI_API_ENDPOINT}\n\n`;
+            // Source breakdown
+            if (stats.by_source && Object.keys(stats.by_source).length > 0) {
+                formatted += `## Documents by Source\n\n`;
+                // Sort sources by count (descending)
+                const sortedSources = Object.entries(stats.by_source)
+                    .sort(([, a], [, b]) => b - a);
+                for (const [source, count] of sortedSources) {
+                    formatted += `- **${source}**: ${count.toLocaleString()}\n`;
+                }
+            }
             return {
                 content: [
                     {
@@ -656,17 +633,13 @@ class KOIServer {
         output += `\n## System Health\n\n`;
         output += `- **Graph DB Configured:** ${!!(process.env.GRAPH_DB_HOST && process.env.GRAPH_DB_NAME)}\n`;
         output += `- **KOI API Endpoint:** ${KOI_API_ENDPOINT}\n`;
-        output += `- **Query Router Available:** ${!!this.queryRouter}\n`;
-        output += `- **Unified Search Available:** ${!!this.unifiedSearch}\n`;
         // Add raw JSON for programmatic access
         const jsonData = JSON.stringify({
             metrics: metricsSummary,
             cache: cacheStats,
             config: {
                 api_endpoint: KOI_API_ENDPOINT,
-                graph_db_configured: !!(process.env.GRAPH_DB_HOST && process.env.GRAPH_DB_NAME),
-                query_router_available: !!this.queryRouter,
-                unified_search_available: !!this.unifiedSearch
+                graph_db_configured: !!(process.env.GRAPH_DB_HOST && process.env.GRAPH_DB_NAME)
             }
         }, null, 2);
         return {
@@ -921,7 +894,7 @@ class KOIServer {
                 catch (apiError) {
                     console.error(`[${SERVER_NAME}] API weekly-digest endpoint failed, using search fallback:`, apiError);
                     // Final fallback: use search
-                    const searchResults = await this.searchKnowledge({
+                    const searchResults = await this.search({
                         query: 'Regen Network activity updates discussions governance',
                         limit: 100,
                         published_from: startDate,
@@ -1443,67 +1416,132 @@ class KOIServer {
     }
     /**
      * Authenticate user with @regen.network email for access to private documentation
+     *
+     * RFC 8628 Device Authorization Grant:
+     * 1. Server generates device_code (secret) and user_code (public)
+     * 2. User manually goes to verification_uri and enters user_code
+     * 3. MCP polls for completion using device_code
+     *
+     * SECURITY: Prevents phishing because user must manually type code from their device.
+     * Attacker cannot force victim to authorize attacker's device_code.
      */
     async authenticateUser() {
         const startTime = Date.now();
         try {
             console.error(`[${SERVER_NAME}] Tool=regen_koi_authenticate Event=start`);
-            // Get user email (same logic as graph_tool.ts uses)
-            const userEmail = process.env.REGEN_USER_EMAIL ||
-                process.env.USER_EMAIL ||
-                `${process.env.USER}@regen.network`;
-            console.error(`[${SERVER_NAME}] Tool=regen_koi_authenticate UserEmail=${userEmail}`);
-            // Call the auth initiate endpoint
-            const response = await axios.get(`${KOI_API_ENDPOINT}/auth/initiate`, {
-                params: { user_email: userEmail }
-            });
-            const { auth_url, state } = response.data;
-            if (!auth_url) {
-                throw new Error('No auth URL returned from server');
+            // Load saved auth state from disk
+            const { loadAuthState, saveAuthState, clearDeviceCode, hasValidAccessToken, hasValidDeviceCode } = await import('./auth-store.js');
+            const state = loadAuthState();
+            // Check 1: Already authenticated?
+            if (hasValidAccessToken(state)) {
+                console.error(`[${SERVER_NAME}] Tool=regen_koi_authenticate Event=already_authenticated User=${state.userEmail}`);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `## Already Authenticated\n\nYou are already authenticated as **${state.userEmail}**.\n\nYour session is valid until ${new Date(state.accessTokenExpiresAt).toLocaleString()}.\n\n✅ You have access to private Regen Network documentation.`
+                        }]
+                };
             }
-            // Open browser for OAuth
-            console.error(`[${SERVER_NAME}] Tool=regen_koi_authenticate Event=opening_browser URL=${auth_url}`);
-            const open = (await import('open')).default;
-            await open(auth_url);
-            let output = `## Authentication Started\n\n`;
-            output += `✅ Opening browser for OAuth login...\n\n`;
-            output += `**Please:**\n`;
-            output += `1. Log in with your **@regen.network** email\n`;
-            output += `2. Grant the requested permissions (email, profile)\n`;
-            output += `3. The browser will show a success message when complete\n\n`;
-            output += `**After authenticating:**\n`;
-            output += `- Your token is saved on the server\n`;
-            output += `- Future queries will automatically include private Drive data\n`;
-            output += `- You won't need to authenticate again unless the token expires\n\n`;
-            output += `**Polling for authentication completion...**\n`;
-            // Poll for authentication status
-            const pollUrl = `${KOI_API_ENDPOINT}/auth/status?user_email=${encodeURIComponent(userEmail)}`;
-            const maxAttempts = 60; // 2 minutes
-            const pollInterval = 2000; // 2 seconds
-            for (let attempt = 0; attempt < maxAttempts; attempt++) {
-                await new Promise(resolve => setTimeout(resolve, pollInterval));
+            // Check 2: Have pending device code? Check its status
+            if (hasValidDeviceCode(state)) {
+                console.error(`[${SERVER_NAME}] Tool=regen_koi_authenticate Event=check_status UserCode=${state.userCode}`);
                 try {
-                    const statusResponse = await axios.get(pollUrl);
-                    if (statusResponse.data.authenticated) {
+                    const tokenResponse = await axios.post(`${KOI_API_ENDPOINT}/auth/token`, {
+                        device_code: state.deviceCode,
+                        grant_type: 'urn:ietf:params:oauth:grant-type:device_code'
+                    });
+                    const data = tokenResponse.data;
+                    // Still pending?
+                    if (data.error === 'authorization_pending') {
+                        const expiresInMin = Math.floor((state.deviceCodeExpiresAt - Date.now()) / 60000);
+                        const ACTIVATION_URL = 'https://regen.gaiaai.xyz/activate';
+                        return {
+                            content: [{
+                                    type: 'text',
+                                    text: `## Authentication Pending\n\n**Still waiting for you to complete authentication.**\n\n### Instructions:\n\n1. Go to: [${ACTIVATION_URL}](${ACTIVATION_URL})\n2. Enter code: **\`${state.userCode}\`**\n3. Sign in with your **@regen.network** email\n\n---\n\n*Code expires in ${expiresInMin} minutes.*\n\n**After completing authentication, run this tool again to retrieve your session token.**`
+                                }]
+                        };
+                    }
+                    // Expired or other error?
+                    if (data.error) {
+                        // Clear expired device code
+                        saveAuthState(clearDeviceCode(state));
+                        if (data.error === 'expired_token') {
+                            return {
+                                content: [{
+                                        type: 'text',
+                                        text: `## Authentication Expired\n\nYour authentication code has expired.\n\n**Run this tool again to get a new code.**`
+                                    }]
+                            };
+                        }
+                        if (data.error === 'access_denied') {
+                            return {
+                                content: [{
+                                        type: 'text',
+                                        text: `## Access Denied\n\n${data.error_description || 'Only @regen.network email addresses are permitted.'}`
+                                    }]
+                            };
+                        }
+                        throw new Error(data.error_description || data.error);
+                    }
+                    // Success!
+                    if (data.access_token) {
                         console.error(`[${SERVER_NAME}] Tool=regen_koi_authenticate Event=success Duration=${Date.now() - startTime}ms`);
-                        output += `\n✅ **Authentication Successful!**\n\n`;
-                        output += `Authenticated as: ${userEmail}\n\n`;
-                        output += `You now have access to internal Regen Network documentation.\n`;
-                        output += `Try asking questions that might reference internal documents!\n`;
+                        // Save token to file and in-memory cache
+                        const tokenExpiry = data.expires_in
+                            ? Date.now() + (data.expires_in * 1000)
+                            : Date.now() + 3600000; // Default 1 hour
+                        setAccessToken(data.access_token, tokenExpiry);
+                        saveAuthState({
+                            accessToken: data.access_token,
+                            accessTokenExpiresAt: tokenExpiry,
+                            userEmail: data.email
+                        });
                         return {
                             content: [{
                                     type: 'text',
-                                    text: output
+                                    text: `## ✅ Authentication Successful!\n\nYou now have access to internal Regen Network documentation.\n\nPrivate Notion data from the main Regen workspace is now accessible.\n\n**Session expires:** ${new Date(tokenExpiry).toLocaleString()}`
                                 }]
                         };
                     }
                 }
-                catch (pollError) {
-                    // Continue polling
+                catch (checkError) {
+                    console.error(`[${SERVER_NAME}] Error checking auth status:`, checkError);
+                    // Clear device code and let user try again
+                    saveAuthState(clearDeviceCode(state));
+                    throw checkError;
                 }
             }
-            // Timeout
-            throw new Error('Authentication timeout - please try again');
+            // Check 3: No state - start new auth flow
+            console.error(`[${SERVER_NAME}] Tool=regen_koi_authenticate Event=request_device_code`);
+            const deviceCodeResponse = await axios.post(`${KOI_API_ENDPOINT}/auth/device/code`, {});
+            const { device_code, user_code, expires_in } = deviceCodeResponse.data;
+            // Hardcode activation URL (don't trust server's verification_uri)
+            const ACTIVATION_URL = 'https://regen.gaiaai.xyz/activate';
+            console.error(`[${SERVER_NAME}] Tool=regen_koi_authenticate UserCode=${user_code} VerificationUri=${ACTIVATION_URL}`);
+            // Save device code state
+            saveAuthState({
+                deviceCode: device_code,
+                userCode: user_code,
+                verificationUri: ACTIVATION_URL,
+                deviceCodeExpiresAt: Date.now() + (expires_in * 1000)
+            });
+            // Auto-open browser to activation page
+            try {
+                const open = (await import('open')).default;
+                await open(ACTIVATION_URL);
+                console.error(`[${SERVER_NAME}] Opened browser to ${ACTIVATION_URL}`);
+            }
+            catch (err) {
+                console.error(`[${SERVER_NAME}] Failed to open browser:`, err);
+                // Continue anyway - user can click the link
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: `## Authentication Required\n\n🌐 **Your browser should open automatically.** If not, click the link below:\n\n### [Open Activation Page](${ACTIVATION_URL})\n\n---\n\n### Enter this code:\n\n\`\`\`\n${user_code}\n\`\`\`\n\n### Sign in with Google\n\nUse your **@regen.network** email address.\n\n---\n\n*Code expires in ${Math.floor(expires_in / 60)} minutes.*\n\n**After completing authentication, run this tool again to retrieve your session token.**`
+                    }]
+            };
         }
         catch (error) {
             console.error(`[${SERVER_NAME}] Tool=regen_koi_authenticate Event=error`, error);
@@ -1683,158 +1721,6 @@ class KOIServer {
         }
         return formatted;
     }
-    /**
-     * Handle hybrid search - intelligent routing based on query classification
-     */
-    async handleHybridSearch(args) {
-        const { query, limit = 10 } = args;
-        // Check if hybrid search is available
-        if (!this.queryRouter || !this.unifiedSearch) {
-            console.error(`[${SERVER_NAME}] Hybrid search not available - falling back to vector search`);
-            return await this.searchKnowledge({ query, limit });
-        }
-        try {
-            const startTime = Date.now();
-            // Step 1: Classify query
-            const classification = await this.queryRouter.classifyQuery(query);
-            console.error(`[${SERVER_NAME}] Query classified as: ${classification.intent} (route: ${classification.recommended_route})`);
-            let results = [];
-            let searchMetadata = {};
-            // Step 2: Execute appropriate search based on classification
-            if (classification.recommended_route === 'graph' && classification.detected_entities.length > 0) {
-                // Graph-only search for entity queries
-                const entityNames = classification.detected_entities.map(e => e.name);
-                const graphResults = await this.unifiedSearch.graphSearch(entityNames, limit);
-                results = graphResults.map(hit => ({
-                    id: hit.id,
-                    title: hit.title,
-                    content: hit.content || '',
-                    source: 'graph',
-                    entity_type: hit.entity_type,
-                    file_path: hit.file_path,
-                    line_number: hit.line_number,
-                    score: hit.final_score,
-                }));
-                searchMetadata = {
-                    route: 'graph',
-                    entities_detected: entityNames,
-                };
-            }
-            else if (classification.recommended_route === 'vector') {
-                // Vector-only search for conceptual queries - use KOI API
-                const response = await apiClient.post('/query', {
-                    question: query,
-                    limit: limit
-                });
-                const data = response.data;
-                results = (data.results || []).map((r) => ({
-                    id: r.rid || r.id,
-                    title: r.title || 'Document',
-                    content: r.content || '',
-                    source: 'vector',
-                    score: r.score || 0,
-                    metadata: r.metadata,
-                }));
-                searchMetadata = {
-                    route: 'vector',
-                };
-            }
-            else {
-                // Unified/hybrid search - combine graph and vector
-                // For now, use vector search as we don't have embedding service integrated
-                console.error(`[${SERVER_NAME}] Unified search requested but falling back to vector search (embedding service not integrated)`);
-                const response = await apiClient.post('/query', {
-                    question: query,
-                    limit: limit
-                });
-                const data = response.data;
-                results = (data.results || []).map((r) => ({
-                    id: r.rid || r.id,
-                    title: r.title || 'Document',
-                    content: r.content || '',
-                    source: 'vector',
-                    score: r.score || 0,
-                    metadata: r.metadata,
-                }));
-                searchMetadata = {
-                    route: 'hybrid_fallback_to_vector',
-                    entities_detected: classification.detected_entities.map(e => e.name),
-                    note: 'Embedding service not available - using vector search only',
-                };
-            }
-            const duration = Date.now() - startTime;
-            // Step 3: Format results
-            const markdown = this.formatHybridResults(results, classification, searchMetadata);
-            // MCP only supports type: 'text' - embed JSON as code block
-            const jsonData = JSON.stringify({
-                hits: results,
-                classification,
-                metadata: {
-                    query,
-                    route: classification.recommended_route,
-                    duration_ms: duration,
-                    total_results: results.length,
-                    ...searchMetadata,
-                },
-            }, null, 2);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: markdown + '\n\n---\n\n<details>\n<summary>Raw JSON (for eval harness)</summary>\n\n```json\n' + jsonData + '\n```\n</details>',
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            console.error(`[${SERVER_NAME}] Hybrid search error:`, error);
-            // Fallback to basic search
-            return await this.searchKnowledge({ query, limit });
-        }
-    }
-    /**
-     * Format hybrid search results as markdown
-     */
-    formatHybridResults(results, classification, metadata) {
-        let output = `## Hybrid Search Results\n\n`;
-        output += `**Query Route:** ${metadata.route} (intent: ${classification.intent})\n`;
-        if (classification.detected_entities.length > 0) {
-            output += `**Detected Entities:** ${classification.detected_entities.map((e) => e.name).join(', ')}\n`;
-        }
-        output += `**Confidence:** ${(classification.confidence * 100).toFixed(1)}%\n`;
-        output += `**Results:** ${results.length}\n\n`;
-        if (classification.reasoning) {
-            output += `*${classification.reasoning}*\n\n`;
-        }
-        if (metadata.note) {
-            output += `> **Note:** ${metadata.note}\n\n`;
-        }
-        output += `---\n\n`;
-        results.forEach((hit, i) => {
-            output += `### ${i + 1}. ${hit.title || hit.id}\n`;
-            if (hit.entity_type) {
-                output += `**Type:** ${hit.entity_type} | `;
-            }
-            output += `**Source:** ${hit.source}`;
-            if (hit.score !== undefined) {
-                output += ` | **Score:** ${hit.score.toFixed(3)}`;
-            }
-            output += `\n\n`;
-            if (hit.file_path) {
-                output += `📁 \`${hit.file_path}\``;
-                if (hit.line_number) {
-                    output += `:${hit.line_number}`;
-                }
-                output += `\n\n`;
-            }
-            if (hit.content) {
-                const preview = hit.content.substring(0, 300);
-                output += `${preview}${hit.content.length > 300 ? '...' : ''}\n\n`;
-            }
-            output += `---\n\n`;
-        });
-        return output;
-    }
     async run() {
         const transport = new StdioServerTransport();
         await this.server.connect(transport);