@contextstream/mcp-server 0.4.34 → 0.4.35

package/dist/index.js

@@ -4297,7 +4297,7 @@ var RETRYABLE_STATUSES = /* @__PURE__ */ new Set([408, 429, 500, 502, 503, 504])
 var MAX_RETRIES = 3;
 var BASE_DELAY = 1e3;
 async function sleep(ms) {
-  return new Promise((resolve3) => setTimeout(resolve3, ms));
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 async function request(config, path8, options = {}) {
   const { apiUrl, userAgent } = config;
@@ -8925,13 +8925,21 @@ var PRETOOLUSE_HOOK_SCRIPT = `#!/usr/bin/env python3
 """
 ContextStream PreToolUse Hook for Claude Code
 Blocks Grep/Glob/Search/Task(Explore)/EnterPlanMode and redirects to ContextStream.
+
+Only blocks if the current project is indexed in ContextStream.
+If not indexed, allows local tools through with a suggestion to index.
 """
 
 import json
 import sys
 import os
+from pathlib import Path
+from datetime import datetime, timedelta
 
 ENABLED = os.environ.get("CONTEXTSTREAM_HOOK_ENABLED", "true").lower() == "true"
+INDEX_STATUS_FILE = Path.home() / ".contextstream" / "indexed-projects.json"
+# Consider index stale after 7 days
+STALE_THRESHOLD_DAYS = 7
 
 DISCOVERY_PATTERNS = ["**/*", "**/", "src/**", "lib/**", "app/**", "components/**"]
 
@@ -8953,6 +8961,44 @@ def is_discovery_grep(file_path):
         return True
     return False
 
+def is_project_indexed(cwd: str) -> tuple[bool, bool]:
+    """
+    Check if the current directory is in an indexed project.
+    Returns (is_indexed, is_stale).
+    """
+    if not INDEX_STATUS_FILE.exists():
+        return False, False
+
+    try:
+        with open(INDEX_STATUS_FILE, "r") as f:
+            data = json.load(f)
+    except:
+        return False, False
+
+    projects = data.get("projects", {})
+    cwd_path = Path(cwd).resolve()
+
+    # Check if cwd is within any indexed project
+    for project_path, info in projects.items():
+        try:
+            indexed_path = Path(project_path).resolve()
+            # Check if cwd is the project or a subdirectory
+            if cwd_path == indexed_path or indexed_path in cwd_path.parents:
+                # Check if stale
+                indexed_at = info.get("indexed_at")
+                if indexed_at:
+                    try:
+                        indexed_time = datetime.fromisoformat(indexed_at.replace("Z", "+00:00"))
+                        if datetime.now(indexed_time.tzinfo) - indexed_time > timedelta(days=STALE_THRESHOLD_DAYS):
+                            return True, True  # Indexed but stale
+                    except:
+                        pass
+                return True, False  # Indexed and fresh
+        except:
+            continue
+
+    return False, False
+
 def main():
     if not ENABLED:
         sys.exit(0)
@@ -8964,6 +9010,20 @@ def main():
 
     tool = data.get("tool_name", "")
     inp = data.get("tool_input", {})
+    cwd = data.get("cwd", os.getcwd())
+
+    # Check if project is indexed
+    is_indexed, is_stale = is_project_indexed(cwd)
+
+    if not is_indexed:
+        # Project not indexed - allow local tools but suggest indexing
+        # Don't block, just exit successfully
+        sys.exit(0)
+
+    if is_stale:
+        # Index is stale - allow with warning (printed but not blocking)
+        # Still allow the tool but remind about re-indexing
+        pass  # Continue to blocking logic but could add warning
 
     if tool == "Glob":
         pattern = inp.get("pattern", "")
@@ -8971,18 +9031,16 @@ def main():
             print(f"STOP: Use mcp__contextstream__search(mode=\\"hybrid\\", query=\\"{pattern}\\") instead of Glob.", file=sys.stderr)
             sys.exit(2)
 
-    elif tool == "Grep":
+    elif tool == "Grep" or tool == "Search":
+        # Block ALL Grep/Search operations - use ContextStream search or Read for specific files
         pattern = inp.get("pattern", "")
         path = inp.get("path", "")
-        if is_discovery_grep(path):
-            print(f"STOP: Use mcp__contextstream__search(mode=\\"keyword\\", query=\\"{pattern}\\") instead of Grep.", file=sys.stderr)
-            sys.exit(2)
-
-    elif tool == "Search":
-        # Block the Search tool which is Claude Code's default search
-        query = inp.get("pattern", "") or inp.get("query", "")
-        if query:
-            print(f"STOP: Use mcp__contextstream__search(mode=\\"hybrid\\", query=\\"{query}\\") instead of Search.", file=sys.stderr)
+        if pattern:
+            if path and not is_discovery_grep(path):
+                # Specific file - suggest Read instead
+                print(f"STOP: Use Read(\\"{path}\\") to view file content, or mcp__contextstream__search(mode=\\"keyword\\", query=\\"{pattern}\\") for codebase search.", file=sys.stderr)
+            else:
+                print(f"STOP: Use mcp__contextstream__search(mode=\\"hybrid\\", query=\\"{pattern}\\") instead of {tool}.", file=sys.stderr)
             sys.exit(2)
 
     elif tool == "Task":
@@ -9148,6 +9206,34 @@ async function installClaudeCodeHooks(options) {
   }
   return result;
 }
+function getIndexStatusPath() {
+  return path4.join(homedir2(), ".contextstream", "indexed-projects.json");
+}
+async function readIndexStatus() {
+  const statusPath = getIndexStatusPath();
+  try {
+    const content = await fs3.readFile(statusPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return { version: 1, projects: {} };
+  }
+}
+async function writeIndexStatus(status) {
+  const statusPath = getIndexStatusPath();
+  const dir = path4.dirname(statusPath);
+  await fs3.mkdir(dir, { recursive: true });
+  await fs3.writeFile(statusPath, JSON.stringify(status, null, 2));
+}
+async function markProjectIndexed(projectPath, options) {
+  const status = await readIndexStatus();
+  const resolvedPath = path4.resolve(projectPath);
+  status.projects[resolvedPath] = {
+    indexed_at: (/* @__PURE__ */ new Date()).toISOString(),
+    project_id: options?.project_id,
+    project_name: options?.project_name
+  };
+  await writeIndexStatus(status);
+}
 
 // src/tools.ts
 var LESSON_DEDUP_WINDOW_MS = 2 * 60 * 1e3;
@@ -11262,6 +11348,12 @@ Hint: Run session_init(folder_path="<your_project_path>") first to establish a s
         console.error(
           `[ContextStream] Completed background ingestion: ${totalIndexed} files in ${batchCount} batches`
         );
+        try {
+          await markProjectIndexed(resolvedPath, { project_id: projectId });
+          console.error(`[ContextStream] Marked project as indexed: ${resolvedPath}`);
+        } catch (markError) {
+          console.error(`[ContextStream] Failed to mark project as indexed:`, markError);
+        }
       } catch (error) {
         console.error(`[ContextStream] Ingestion failed:`, error);
       }
@@ -13007,6 +13099,12 @@ ${benefitsList}` : "",
         noticeLines.push(
           `[INGEST_STATUS] Background indexing started. Codebase will be searchable shortly.`
         );
+      } else if (folderPathForRules && !ingestRec?.recommended) {
+        const projectId = typeof result.project_id === "string" ? result.project_id : void 0;
+        const projectName = typeof result.project_name === "string" ? result.project_name : void 0;
+        markProjectIndexed(folderPathForRules, { project_id: projectId, project_name: projectName }).catch(
+          (err) => console.error("[ContextStream] Failed to mark project as indexed:", err)
+        );
       }
       if (noticeLines.length > 0) {
         text = `${text}
@@ -19569,10 +19667,10 @@ Code: ${device.user_code}`);
           if (poll && poll.status === "pending") {
             const intervalSeconds = typeof poll.interval === "number" ? poll.interval : 5;
             const waitMs = Math.max(1, intervalSeconds) * 1e3;
-            await new Promise((resolve3) => setTimeout(resolve3, waitMs));
+            await new Promise((resolve4) => setTimeout(resolve4, waitMs));
             continue;
           }
-          await new Promise((resolve3) => setTimeout(resolve3, 1e3));
+          await new Promise((resolve4) => setTimeout(resolve4, 1e3));
         }
         if (!accessToken) {
           throw new Error(

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@contextstream/mcp-server",
   "mcpName": "io.github.contextstreamio/mcp-server",
-  "version": "0.4.34",
+  "version": "0.4.35",
   "description": "ContextStream MCP server - v0.4.x with consolidated domain tools (~11 tools, ~75% token reduction). Code context, memory, search, and AI tools.",
   "type": "module",
   "license": "MIT",