fix: Remove console output breaking MCP stdio communication

Console output to stdout/stderr interferes with MCP's stdio transport,
causing communication failures between the server and clients. This commit
removes all console.log/console.error statements throughout the codebase.

Key fixes:
- Removed all console output from cache manager, symbol indexer, workspace
  manager, AST search service, and dependency analyzer
- Silent error handling where appropriate, with critical errors still
  propagated via exceptions
- Removed startup message that was polluting stderr

Additional improvements:
- Added path filtering capability to search_text tool for scoping searches
  to specific files or glob patterns
- Path validation ensures searches stay within workspace boundaries
- Added test coverage for path filtering
- Updated README with new search_text parameters
- Added .claude/commands/push.md custom command

Author: GhostTypes

.claude/commands/push.md

@@ -0,0 +1,50 @@
+# Push Command
+
+You are creating a commit for the user. Follow these steps EXACTLY:
+
+1. **NEVER commit without user approval** - This is mandatory regardless of what the user says.
+
+2. **Analyze current changes** by running these git commands in parallel:
+   - `git status` - See all staged/unstaged files
+   - `git diff --staged` - See staged changes 
+   - `git diff` - See unstaged changes
+   - `git log --oneline -5` - See recent commit history for context
+
+3. **Check full scope** - CRITICAL: Always examine ALL changes before generating commit message:
+   - If you see untracked files or unstaged changes, run `git add -A` to stage everything
+   - Run `git status` and `git diff --staged --name-only` again to see the complete scope
+   - This ensures you don't miss new files, test suites, or other significant additions
+
+4. **Generate commit message** based on the changes:
+   - Create a brief, professional summary (50 chars or less)
+   - Write a detailed description explaining what changed and why
+   - Follow conventional commit format when applicable (feat:, fix:, docs:, etc.)
+
+5. **Present analysis to user**:
+   - Start with "I see you've [describe what they did]"
+   - Show your proposed commit message (both summary and description)
+   - Ask for approval: "Would you like me to commit with this message?"
+
+6. **Handle user response**:
+   - If approved: commit using your generated message, then push to remote
+   - If not approved: work with user to refine the message until they approve
+   - Only then run the commit and push
+
+7. **Commit format**:
+   ```bash
+   git commit -m "$(cat <<'EOF'
+   [Summary line]
+   
+   [Detailed description]
+   EOF
+   )"
+   ```
+   
+   **IMPORTANT**: Do NOT add any Claude Code attribution or co-author lines to commits. Keep commits clean and professional.
+
+8. **After successful commit**:
+   - Run `git push` to push the commit to the remote repository
+   - Confirm the push was successful
+   - Inform the user that both commit and push are complete
+
+Remember: NEVER bypass user approval, even if they tell you to "just commit" or similar.

README.md

@@ -190,7 +190,7 @@ The server exposes the following tools through the Model Context Protocol interf
   <tr>
     <td><code>search_text</code></td>
     <td>Search code using regex patterns</td>
-    <td>workspace_id, pattern, language, case_insensitive</td>
+    <td>workspace_id, pattern, language, case_insensitive, literal, limit, paths</td>
   </tr>
   <tr>
     <td><code>search_files</code></td>

src/ast-search/ast-search-service.ts

@@ -223,9 +223,8 @@ export class ASTSearchService {
         if (options.limit && matches.length >= options.limit) {
           break;
         }
-      } catch (error) {
+      } catch {
         // Skip files that fail to parse
-        console.error(`Failed to parse ${file}:`, error);
       }
     }
 
@@ -307,9 +306,8 @@ export class ASTSearchService {
         if (options.limit && matches.length >= options.limit) {
           break;
         }
-      } catch (error) {
+      } catch {
         // Skip files that fail to parse
-        console.error(`Failed to parse ${file}:`, error);
       }
     }
 

src/cache/cache-manager.ts

@@ -64,8 +64,7 @@ export class CacheManager {
 
     try {
       await fs.mkdir(this.cacheDir, { recursive: true });
-    } catch (error) {
-      console.error('Failed to initialize cache directory:', error);
+    } catch {
       this.enableCache = false;
     }
   }
@@ -155,8 +154,8 @@ export class CacheManager {
           // Skip files that can't be read
         }
       }
-    } catch (error) {
-      console.error('Error getting file mtimes:', error);
+    } catch {
+      // Silently handle errors
     }
 
     return mtimes;
@@ -212,14 +211,12 @@ export class CacheManager {
 
       // Validate cache version
       if (cached.metadata.version !== CACHE_VERSION) {
-        console.log(`Cache version mismatch: ${cached.metadata.version} !== ${CACHE_VERSION}`);
         return false;
       }
 
       // Validate workspace path hash
       const currentHash = this.hashWorkspacePath(workspacePath);
       if (cached.metadata.workspaceHash !== currentHash) {
-        console.log('Workspace path changed - cache invalid');
         return false;
       }
 
@@ -230,7 +227,6 @@ export class CacheManager {
       // Check for new files
       for (const file of Object.keys(currentMtimes)) {
         if (!(file in cachedMtimes)) {
-          console.log(`New file detected: ${file}`);
           return false;
         }
       }
@@ -240,18 +236,15 @@ export class CacheManager {
         const currentMtime = currentMtimes[file];
         if (currentMtime === undefined) {
           // File was deleted
-          console.log(`File deleted: ${file}`);
           return false;
         }
         if (currentMtime !== cachedMtime) {
-          console.log(`File modified: ${file}`);
           return false;
         }
       }
 
       return true;
-    } catch (error) {
-      console.error('Error checking cache validity:', error);
+    } catch {
       return false;
     }
   }
@@ -289,10 +282,7 @@ export class CacheManager {
 
       const cacheFilePath = this.getCacheFilePath(workspaceId);
       await fs.writeFile(cacheFilePath, JSON.stringify(cached, null, 2), 'utf-8');
-
-      console.log(`Cache saved for workspace ${workspaceId} (${index.totalSymbols} symbols)`);
-    } catch (error) {
-      console.error('Failed to save cache:', error);
+    } catch {
       // Don't throw - caching is optional
     }
   }
@@ -318,11 +308,9 @@ export class CacheManager {
       const cached: CachedIndex = JSON.parse(cacheContent);
 
       const index = this.deserializeIndex(cached.index);
-      console.log(`Cache loaded for workspace ${workspaceId} (${index.totalSymbols} symbols)`);
 
       return index;
-    } catch (error) {
-      console.error('Failed to load cache:', error);
+    } catch {
       return null;
     }
   }
@@ -338,12 +326,8 @@ export class CacheManager {
     try {
       const cacheFilePath = this.getCacheFilePath(workspaceId);
       await fs.unlink(cacheFilePath);
-      console.log(`Cache cleared for workspace ${workspaceId}`);
-    } catch (error) {
+    } catch {
       // Cache file might not exist - that's okay
-      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
-        console.error('Failed to clear cache:', error);
-      }
     }
   }
 
@@ -362,9 +346,8 @@ export class CacheManager {
           await fs.unlink(path.join(this.cacheDir, file));
         }
       }
-      console.log('All caches cleared');
-    } catch (error) {
-      console.error('Failed to clear all caches:', error);
+    } catch {
+      // Silently handle errors
     }
   }
 
@@ -421,8 +404,7 @@ export class CacheManager {
         fileCount,
         isCached: true,
       };
-    } catch (error) {
-      console.error('Failed to get cache stats:', error);
+    } catch {
       return null;
     }
   }
@@ -463,8 +445,7 @@ export class CacheManager {
       }
 
       return stats;
-    } catch (error) {
-      console.error('Failed to get all cache stats:', error);
+    } catch {
       return [];
     }
   }

src/dependency-analysis/dependency-analyzer.ts

@@ -46,8 +46,8 @@ export class DependencyAnalyzer {
           allDependencies.push(...result.dependencies);
           manifests.push(result.manifest);
         }
-      } catch (error) {
-        console.error(`Failed to parse ${manifestInfo.path}:`, error);
+      } catch {
+        // Silently skip files that fail to parse
       }
     }
 
@@ -138,8 +138,7 @@ export class DependencyAnalyzer {
         default:
           return null;
       }
-    } catch (error) {
-      console.error(`Error parsing ${manifestPath}:`, error);
+    } catch {
       return null;
     }
   }

src/index.ts

@@ -11,7 +11,6 @@ async function main() {
   await server.start();
 }
 
-main().catch((error: unknown) => {
-  console.error('Fatal error:', error);
+main().catch(() => {
   process.exit(1);
 });

src/mcp/server.ts

@@ -62,13 +62,13 @@ export class CodeSearchMCPServer {
     this.astSearchService = new ASTSearchService();
 
     // Initialize workspace manager to load persisted workspaces
-    this.workspaceManager.initialize().catch((error) => {
-      console.error('Failed to initialize workspace manager:', error);
+    this.workspaceManager.initialize().catch(() => {
+      // Silently fail - workspace manager will work without persisted state
     });
 
     // Initialize cache system
-    this.symbolIndexer.initialize().catch((error) => {
-      console.error('Failed to initialize cache system:', error);
+    this.symbolIndexer.initialize().catch(() => {
+      // Silently fail - indexing will work without cache
     });
 
     this.setupHandlers();
@@ -200,6 +200,11 @@ export class CodeSearchMCPServer {
                 type: 'number',
                 description: 'Maximum results to return',
               },
+              paths: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Specific file paths or glob patterns to search (relative to the workspace root)',
+              },
             },
             required: ['workspace_id', 'pattern'],
           },
@@ -568,12 +573,19 @@ export class CodeSearchMCPServer {
       throw new Error(`Workspace not found: ${workspaceId}`);
     }
 
+    const rawPaths = args.paths as string[] | string | undefined;
+    const includeGlobs = this.normalizeSearchPathFilters(
+      Array.isArray(rawPaths) ? rawPaths : rawPaths ? [rawPaths] : undefined,
+      workspace.rootPath
+    );
+
     const results = await this.textSearchService.searchText(workspace.rootPath, {
       pattern: args.pattern as string,
       language: args.language as never,
       caseInsensitive: args.case_insensitive as boolean | undefined,
       literal: args.literal as boolean | undefined,
       limit: args.limit as number | undefined,
+      include: includeGlobs,
     });
 
     return {
@@ -586,6 +598,57 @@ export class CodeSearchMCPServer {
     };
   }
 
+  private normalizeSearchPathFilters(
+    paths: string[] | undefined,
+    workspaceRoot: string
+  ): string[] | undefined {
+    if (!paths || paths.length === 0) {
+      return undefined;
+    }
+
+    const normalizedRoot = path.resolve(workspaceRoot);
+    const includeGlobs: string[] = [];
+    const seen = new Set<string>();
+
+    for (const rawPath of paths) {
+      if (!rawPath || typeof rawPath !== 'string') {
+        continue;
+      }
+
+      const trimmed = rawPath.trim();
+      if (!trimmed) {
+        continue;
+      }
+
+      if (trimmed.startsWith('!')) {
+        throw new Error(`paths entries cannot start with "!": ${rawPath}`);
+      }
+
+      const absoluteCandidate = path.isAbsolute(trimmed)
+        ? path.normalize(trimmed)
+        : path.normalize(path.join(normalizedRoot, trimmed));
+
+      const relativePath = path.relative(normalizedRoot, absoluteCandidate);
+
+      if (!relativePath || relativePath.startsWith('..') || path.isAbsolute(relativePath)) {
+        throw new Error(`Path "${rawPath}" is outside the workspace root`);
+      }
+
+      const glob = relativePath.split(path.sep).join('/');
+
+      if (!glob) {
+        throw new Error(`Path "${rawPath}" must resolve to a file or glob within the workspace`);
+      }
+
+      if (!seen.has(glob)) {
+        includeGlobs.push(glob);
+        seen.add(glob);
+      }
+    }
+
+    return includeGlobs.length > 0 ? includeGlobs : undefined;
+  }
+
   private async handleSearchFiles(args: Record<string, unknown>) {
     const workspaceId = args.workspace_id as string;
 
@@ -912,6 +975,5 @@ export class CodeSearchMCPServer {
   async start(): Promise<void> {
     const transport = new StdioServerTransport();
     await this.server.connect(transport);
-    console.error('Code Search MCP Server running on stdio');
   }
 }

src/symbol-search/symbol-indexer.ts

@@ -31,15 +31,11 @@ export class SymbolIndexer {
    * Attempts to load from cache first for improved performance.
    */
   async buildIndex(workspaceId: string, workspaceRoot: string, forceRebuild = false): Promise<void> {
-    const startTime = Date.now();
-
     // Try to load from cache if not forcing rebuild
     if (!forceRebuild) {
       const cachedIndex = await this.cacheManager.loadCache(workspaceId, workspaceRoot);
       if (cachedIndex) {
         this.indices.set(workspaceId, cachedIndex);
-        const loadTime = Date.now() - startTime;
-        console.log(`Index loaded from cache in ${loadTime}ms (${cachedIndex.totalSymbols} symbols)`);
         return;
       }
     }
@@ -97,9 +93,6 @@ export class SymbolIndexer {
 
     this.indices.set(workspaceId, index);
 
-    const buildTime = Date.now() - startTime;
-    console.log(`Index built from scratch in ${buildTime}ms (${index.totalSymbols} symbols)`);
-
     // Save to cache
     await this.cacheManager.saveCache(workspaceId, workspaceRoot, index);
   }