@crowley/rag-mcp 1.0.1 → 1.0.2

package/dist/tool-registry.d.ts

@@ -7,8 +7,16 @@ export declare class ToolRegistry {
     private tools;
     private handlers;
     private enricher?;
+    private autoSessionPromise;
     /** Set the context enricher */
     setEnricher(enricher: ContextEnricher): void;
+    /**
+     * Ensure an active session exists before handling a tool call.
+     * Skips for session management tools. Handles post-end_session restart.
+     */
+    private ensureSession;
+    /** Start an auto-session via the RAG API */
+    private doAutoStartSession;
     /** Register a tool module */
     register(module: ToolModule): void;
     /** Get all registered tool definitions */

package/dist/tool-registry.js

@@ -12,6 +12,12 @@ const TRACKING_EXCLUDE = new Set([
     "get_prediction_stats",
     "get_rag_guidelines",
 ]);
+/** Session management tools — skip auto-session to avoid recursion */
+const SESSION_TOOLS = new Set([
+    "start_session",
+    "end_session",
+    "get_session_context",
+]);
 /** Summarize tool args into a short string for analytics */
 function summarizeInput(name, args) {
     // Common patterns: query, question, content, feature, code, file
@@ -48,10 +54,54 @@ export class ToolRegistry {
     tools = [];
     handlers = new Map();
     enricher;
+    autoSessionPromise = null;
     /** Set the context enricher */
     setEnricher(enricher) {
         this.enricher = enricher;
     }
+    /**
+     * Ensure an active session exists before handling a tool call.
+     * Skips for session management tools. Handles post-end_session restart.
+     */
+    async ensureSession(ctx) {
+        if (ctx.activeSessionId)
+            return;
+        // If already starting, wait for it
+        if (this.autoSessionPromise) {
+            await this.autoSessionPromise;
+            return;
+        }
+        this.autoSessionPromise = this.doAutoStartSession(ctx);
+        try {
+            await this.autoSessionPromise;
+        }
+        finally {
+            this.autoSessionPromise = null;
+        }
+    }
+    /** Start an auto-session via the RAG API */
+    async doAutoStartSession(ctx) {
+        try {
+            const response = await ctx.api.post("/api/session/start", {
+                projectName: ctx.projectName,
+                initialContext: "auto-started by MCP tool call",
+            });
+            const session = response.data?.session;
+            const sid = session?.sessionId || response.data?.sessionId;
+            if (sid) {
+                ctx.activeSessionId = sid;
+            }
+            // Fire-and-forget: ensure critical collections exist
+            ctx.api
+                .post("/api/ensure-collections", { projectName: ctx.projectName })
+                .catch(() => {
+                // Silent — must never break tool execution
+            });
+        }
+        catch {
+            // Silent — auto-session must never block tool execution
+        }
+    }
     /** Register a tool module */
     register(module) {
         this.tools.push(...module.tools);
@@ -88,6 +138,10 @@ export class ToolRegistry {
         if (!handler) {
             return `Unknown tool: ${name}`;
         }
+        // Auto-start session on first tool call (skip for session management tools)
+        if (!SESSION_TOOLS.has(name)) {
+            await this.ensureSession(ctx);
+        }
         const startTime = Date.now();
         try {
             // Before: auto-enrich context

package/dist/tools/session.js

@@ -270,26 +270,32 @@ export function createSessionTools(projectName, sharedCtx) {
                 resumeFrom,
             });
             const data = response.data;
+            const session = data.session;
+            // Extract fields — API returns { session: { sessionId, startedAt, ... } }
+            const sid = session?.sessionId || data.sessionId;
+            const started = session?.startedAt || data.started;
+            const resumedFrom = session?.metadata?.resumedFrom || data.resumedFrom;
+            const initialFiles = session?.currentFiles || data.initialFiles;
             // Update shared context with active session ID
-            if (sharedCtx && data.sessionId) {
-                sharedCtx.activeSessionId = data.sessionId;
+            if (sharedCtx && sid) {
+                sharedCtx.activeSessionId = sid;
             }
             let result = `**Session Started**\n\n`;
-            result += `- **Session ID:** ${data.sessionId}\n`;
-            result += `- **Started:** ${data.started}\n`;
-            if (data.resumedFrom) {
-                result += `- **Resumed From:** ${data.resumedFrom}\n`;
+            result += `- **Session ID:** ${sid}\n`;
+            result += `- **Started:** ${started}\n`;
+            if (resumedFrom) {
+                result += `- **Resumed From:** ${resumedFrom}\n`;
             }
-            if (data.initialFiles && data.initialFiles.length > 0) {
+            if (initialFiles && initialFiles.length > 0) {
                 result += `\n**Initial Files:**\n`;
-                result += data.initialFiles
+                result += initialFiles
                     .map((f) => `- ${f}`)
                     .join("\n");
                 result += "\n";
             }
             // Include prefetch stats if available
-            if (data.session?.metadata?.prefetchStats) {
-                const pf = data.session.metadata.prefetchStats;
+            if (session?.metadata?.prefetchStats) {
+                const pf = session.metadata.prefetchStats;
                 result += `\n**Predictive Prefetch:** ${pf.prefetchedCount ?? 0} resources prefetched\n`;
             }
             // Include briefing if available (Sprint E)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crowley/rag-mcp",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Universal RAG MCP Server for any project",
   "type": "module",
   "main": "dist/index.js",