@crowley/rag-mcp 1.0.4 → 1.0.6

package/dist/tools/indexing.d.ts

@@ -6,8 +6,8 @@
  * them to the RAG API in batches via POST /api/index/upload. This allows
  * remote MCP clients to index codebases that aren't on the server filesystem.
  */
-import type { ToolModule } from "../types.js";
+import type { ToolSpec } from "../types.js";
 /**
  * Create the indexing tools module with project-specific descriptions.
  */
-export declare function createIndexingTools(projectName: string): ToolModule;
+export declare function createIndexingTools(projectName: string): ToolSpec[];

package/dist/tools/indexing.js

@@ -9,6 +9,8 @@
 import * as fs from "fs";
 import * as path from "path";
 import { glob } from "glob";
+import { z } from "zod";
+import { TOOL_ANNOTATIONS } from "../annotations.js";
 const DEFAULT_PATTERNS = [
     "**/*.ts",
     "**/*.tsx",
@@ -100,128 +102,130 @@ async function uploadFiles(ctx, projectPath, opts) {
         duration: totalDuration,
     };
 }
+// In-memory cache for get_index_status (30 min TTL)
+let _statusCache = null;
+const STATUS_CACHE_TTL = 30 * 60 * 1000; // 30 minutes
 /**
  * Create the indexing tools module with project-specific descriptions.
  */
 export function createIndexingTools(projectName) {
-    const tools = [
+    return [
         {
             name: "index_codebase",
             description: `Index or re-index the ${projectName} codebase for RAG search.`,
-            inputSchema: {
-                type: "object",
-                properties: {
-                    path: {
-                        type: "string",
-                        description: "Path to index (default: entire project)",
-                    },
-                    force: {
-                        type: "boolean",
-                        description: "Force re-index even if already indexed",
-                        default: false,
-                    },
-                },
+            schema: z.object({
+                path: z.string().optional().describe("Path to index (default: entire project)"),
+                force: z.boolean().optional().describe("Force re-index even if already indexed"),
+            }),
+            annotations: TOOL_ANNOTATIONS["index_codebase"],
+            handler: async (args, ctx) => {
+                const { path: indexPath, force = false } = args;
+                const projectPath = indexPath || ctx.projectPath;
+                const stats = await uploadFiles(ctx, projectPath, { force });
+                _statusCache = null; // Invalidate status cache after indexing
+                let result = `## Indexing ${projectName}\n\n`;
+                result += `- **Total files found:** ${stats.totalFiles}\n`;
+                result += `- **Files indexed:** ${stats.indexedFiles}\n`;
+                result += `- **Chunks created:** ${stats.totalChunks}\n`;
+                result += `- **Errors:** ${stats.errors}\n`;
+                result += `- **Duration:** ${stats.duration}ms\n`;
+                return result;
             },
         },
         {
             name: "get_index_status",
-            description: `Get the indexing status for ${projectName} codebase.`,
-            inputSchema: {
-                type: "object",
-                properties: {},
+            description: `Get the indexing status for ${projectName} codebase. Results cached for 30 minutes.`,
+            schema: z.object({}),
+            outputSchema: z.object({
+                status: z.string(),
+                totalFiles: z.number().optional(),
+                indexedFiles: z.number().optional(),
+                lastUpdated: z.string().optional(),
+                vectorCount: z.number().optional(),
+                cached: z.boolean(),
+            }),
+            annotations: TOOL_ANNOTATIONS["get_index_status"],
+            handler: async (_args, ctx) => {
+                // Return cached result if still valid
+                if (_statusCache && Date.now() < _statusCache.expiresAt) {
+                    const remainingMin = Math.round((_statusCache.expiresAt - Date.now()) / 60000);
+                    return {
+                        text: _statusCache.data + `\n_Cached (expires in ${remainingMin}min)_`,
+                        structured: { ..._statusCache.structured, cached: true },
+                    };
+                }
+                const response = await ctx.api.get(`/api/index/status/${ctx.collectionPrefix}codebase`);
+                const data = response.data;
+                let text = `## Index Status: ${projectName}\n\n`;
+                text += `- **Status:** ${data.status || "unknown"}\n`;
+                text += `- **Total Files:** ${data.totalFiles ?? "N/A"}\n`;
+                text += `- **Indexed Files:** ${data.indexedFiles ?? "N/A"}\n`;
+                text += `- **Last Updated:** ${data.lastUpdated ? new Date(data.lastUpdated).toLocaleString() : "Never"}\n`;
+                text += `- **Vector Count:** ${data.vectorCount ?? "N/A"}\n`;
+                const structured = {
+                    status: data.status || "unknown",
+                    totalFiles: data.totalFiles,
+                    indexedFiles: data.indexedFiles,
+                    lastUpdated: data.lastUpdated,
+                    vectorCount: data.vectorCount,
+                    cached: false,
+                };
+                // Cache for 30 minutes
+                _statusCache = { data: text, expiresAt: Date.now() + STATUS_CACHE_TTL, structured };
+                return { text, structured };
             },
         },
         {
             name: "reindex_zero_downtime",
             description: `Reindex ${projectName} codebase with zero downtime using alias swap.`,
-            inputSchema: {
-                type: "object",
-                properties: {
-                    path: {
-                        type: "string",
-                        description: "Path to index (default: entire project)",
-                    },
-                    patterns: {
-                        type: "array",
-                        items: { type: "string" },
-                        description: "File patterns to include (e.g., ['**/*.ts', '**/*.py'])",
-                    },
-                    excludePatterns: {
-                        type: "array",
-                        items: { type: "string" },
-                        description: "File patterns to exclude (e.g., ['node_modules/**'])",
-                    },
-                },
+            schema: z.object({
+                path: z.string().optional().describe("Path to index (default: entire project)"),
+                patterns: z.array(z.string()).optional().describe("File patterns to include (e.g., ['**/*.ts', '**/*.py'])"),
+                excludePatterns: z.array(z.string()).optional().describe("File patterns to exclude (e.g., ['node_modules/**'])"),
+            }),
+            annotations: TOOL_ANNOTATIONS["reindex_zero_downtime"],
+            handler: async (args, ctx) => {
+                const { path: indexPath, patterns, excludePatterns } = args;
+                const projectPath = indexPath || ctx.projectPath;
+                const stats = await uploadFiles(ctx, projectPath, {
+                    patterns,
+                    excludePatterns,
+                    force: true,
+                });
+                _statusCache = null; // Invalidate status cache after reindex
+                let result = `## Reindex: ${projectName}\n\n`;
+                result += `- **Total files found:** ${stats.totalFiles}\n`;
+                result += `- **Files indexed:** ${stats.indexedFiles}\n`;
+                result += `- **Chunks created:** ${stats.totalChunks}\n`;
+                result += `- **Errors:** ${stats.errors}\n`;
+                result += `- **Duration:** ${stats.duration}ms\n`;
+                return result;
             },
         },
         {
             name: "list_aliases",
             description: "List all collection aliases and their mappings.",
-            inputSchema: {
-                type: "object",
-                properties: {},
-            },
-        },
-    ];
-    const handlers = {
-        index_codebase: async (args, ctx) => {
-            const { path: indexPath, force = false } = args;
-            const projectPath = indexPath || ctx.projectPath;
-            const stats = await uploadFiles(ctx, projectPath, { force });
-            let result = `## Indexing ${projectName}\n\n`;
-            result += `- **Total files found:** ${stats.totalFiles}\n`;
-            result += `- **Files indexed:** ${stats.indexedFiles}\n`;
-            result += `- **Chunks created:** ${stats.totalChunks}\n`;
-            result += `- **Errors:** ${stats.errors}\n`;
-            result += `- **Duration:** ${stats.duration}ms\n`;
-            return result;
-        },
-        get_index_status: async (_args, ctx) => {
-            const response = await ctx.api.get(`/api/index/status/${ctx.collectionPrefix}codebase`);
-            const data = response.data;
-            let result = `## Index Status: ${projectName}\n\n`;
-            result += `- **Status:** ${data.status || "unknown"}\n`;
-            result += `- **Total Files:** ${data.totalFiles ?? "N/A"}\n`;
-            result += `- **Indexed Files:** ${data.indexedFiles ?? "N/A"}\n`;
-            result += `- **Last Updated:** ${data.lastUpdated ? new Date(data.lastUpdated).toLocaleString() : "Never"}\n`;
-            result += `- **Vector Count:** ${data.vectorCount ?? "N/A"}\n`;
-            return result;
-        },
-        reindex_zero_downtime: async (args, ctx) => {
-            const { path: indexPath, patterns, excludePatterns } = args;
-            const projectPath = indexPath || ctx.projectPath;
-            const stats = await uploadFiles(ctx, projectPath, {
-                patterns,
-                excludePatterns,
-                force: true,
-            });
-            let result = `## Reindex: ${projectName}\n\n`;
-            result += `- **Total files found:** ${stats.totalFiles}\n`;
-            result += `- **Files indexed:** ${stats.indexedFiles}\n`;
-            result += `- **Chunks created:** ${stats.totalChunks}\n`;
-            result += `- **Errors:** ${stats.errors}\n`;
-            result += `- **Duration:** ${stats.duration}ms\n`;
-            return result;
-        },
-        list_aliases: async (_args, ctx) => {
-            const response = await ctx.api.get("/api/aliases");
-            const aliases = response.data.aliases || response.data;
-            if (!aliases || (Array.isArray(aliases) && aliases.length === 0)) {
-                return "No aliases configured.";
-            }
-            let result = `## Collection Aliases\n\n`;
-            if (Array.isArray(aliases)) {
-                for (const a of aliases) {
-                    result += `- **${a.alias}** -> ${a.collection}\n`;
+            schema: z.object({}),
+            annotations: TOOL_ANNOTATIONS["list_aliases"],
+            handler: async (_args, ctx) => {
+                const response = await ctx.api.get("/api/aliases");
+                const aliases = response.data.aliases || response.data;
+                if (!aliases || (Array.isArray(aliases) && aliases.length === 0)) {
+                    return "No aliases configured.";
                 }
-            }
-            else {
-                for (const [alias, collection] of Object.entries(aliases)) {
-                    result += `- **${alias}** -> ${collection}\n`;
+                let result = `## Collection Aliases\n\n`;
+                if (Array.isArray(aliases)) {
+                    for (const a of aliases) {
+                        result += `- **${a.alias}** -> ${a.collection}\n`;
+                    }
                 }
-            }
-            return result;
+                else {
+                    for (const [alias, collection] of Object.entries(aliases)) {
+                        result += `- **${alias}** -> ${collection}\n`;
+                    }
+                }
+                return result;
+            },
         },
-    };
-    return { tools, handlers };
+    ];
 }

package/dist/tools/memory.d.ts

@@ -5,5 +5,5 @@
  *        batch_remember, validate_memory, review_memories,
  *        promote_memory, run_quality_gates, memory_maintenance
  */
-import type { ToolModule } from "../types.js";
-export declare function createMemoryTools(projectName: string): ToolModule;
+import type { ToolSpec } from "../types.js";
+export declare function createMemoryTools(projectName: string): ToolSpec[];