claude-brain 0.27.1 → 0.27.2

package/VERSION

@@ -1 +1 @@
-0.27.1
+0.27.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-brain",
-  "version": "0.27.1",
+  "version": "0.27.2",
   "description": "Local development assistant bridging Obsidian vaults with Claude Code via MCP",
   "type": "module",
   "main": "src/index.ts",

package/src/hooks/brain-hook.ts

@@ -52,10 +52,10 @@ export async function main(): Promise<void> {
     return
   }
 
-  // BUG-006: Read port from --port arg (cross-platform) or env var fallback
+  // BUG-006: Read port from --port arg (cross-platform). Env var fallback removed — breaks Windows cmd.exe.
   const portIdx = process.argv.indexOf('--port')
   const portArg = portIdx >= 0 ? process.argv[portIdx + 1] : undefined
-  const port = parseInt(portArg || process.env.CLAUDE_BRAIN_PORT || '3000', 10)
+  const port = parseInt(portArg || '3000', 10)
 
   // For Stop events: trigger session-end summarization regardless of classification
   if (input.hook_event_name === 'Stop' && input.session_id) {

package/src/hooks/context-hook.ts

@@ -85,10 +85,10 @@ async function main(): Promise<void> {
     return
   }
 
-  // BUG-006: Read port from --port arg (cross-platform) or env var fallback
+  // BUG-006: Read port from --port arg (cross-platform). Env var fallback removed — breaks Windows cmd.exe.
   const portIdx = process.argv.indexOf('--port')
   const portArg = portIdx >= 0 ? process.argv[portIdx + 1] : undefined
-  const port = parseInt(portArg || process.env.CLAUDE_BRAIN_PORT || '3000', 10)
+  const port = parseInt(portArg || '3000', 10)
   const baseUrl = `http://localhost:${port}`
 
   let brainContext = ''

package/src/hooks/interceptor-hook.ts

@@ -51,10 +51,10 @@ async function main(): Promise<void> {
   const project = detectProject(input.cwd)
   if (!project) { process.exit(0); return }
 
-  // Read port from --port arg or env
+  // BUG-006: Read port from --port arg (cross-platform). Env var fallback removed — breaks Windows cmd.exe.
   const portIdx = process.argv.indexOf('--port')
   const portArg = portIdx >= 0 ? process.argv[portIdx + 1] : undefined
-  const port = parseInt(portArg || process.env.CLAUDE_BRAIN_PORT || '3000', 10)
+  const port = parseInt(portArg || '3000', 10)
 
   try {
     const params = new URLSearchParams({

package/src/server/handlers/call-tool.ts

@@ -34,6 +34,9 @@ import { handleInitProject } from './tools/init-project'
 // Phase 16 Unified Brain Tool
 import { handleBrain } from './tools/brain'
 
+// Code Intelligence
+import { handleSearchCode } from './tools/search-code'
+
 /**
  * Handle tools/call request
  * Validates that tool exists and routes to the appropriate handler
@@ -122,6 +125,10 @@ export async function handleCallTool(
       case 'brain':
         return await handleBrain(args, logger)
 
+      // Code Intelligence
+      case 'search_code':
+        return await handleSearchCode(args, logger)
+
       default:
         // This should never happen if validateToolExists works correctly
         throw new McpError(

package/src/server/handlers/tools/index.ts

@@ -25,3 +25,6 @@ export { handleCreateProject } from './create-project'
 export { handleInitProject } from './init-project'
 
 // Phase 19: Redundant tools absorbed into brain(). Handler files removed.
+
+// Code Intelligence
+export { handleSearchCode } from './search-code'

package/src/server/handlers/tools/schemas.ts

@@ -141,6 +141,18 @@ export const BrainSchema = z.object({
   action: z.enum(['auto', 'store', 'recall', 'update', 'delete']).optional()
 })
 
+// ============================================================================
+// Code Intelligence
+// ============================================================================
+
+export const SearchCodeSchema = z.object({
+  query: z.string().min(1, 'query is required'),
+  project: z.string().min(1, 'project is required'),
+  type: z.enum(['symbols', 'files', 'dependencies']).optional().default('symbols'),
+  file_path: z.string().optional(),
+  limit: z.number().int().min(1).max(100).optional().default(20)
+})
+
 // ============================================================================
 // Type exports for validated inputs
 // ============================================================================
@@ -162,3 +174,6 @@ export type ValidatedGetCorrections = z.infer<typeof GetCorrectionsSchema>
 
 // Phase 16
 export type ValidatedBrain = z.infer<typeof BrainSchema>
+
+// Code Intelligence
+export type ValidatedSearchCode = z.infer<typeof SearchCodeSchema>

package/src/server/handlers/tools/search-code.ts

@@ -0,0 +1,122 @@
+/**
+ * Search Code Handler
+ * Exposes code intelligence (symbol/file/dependency search) as a direct MCP tool
+ */
+
+import type { Logger } from 'pino'
+import type { ToolResponse } from '@/tools/types'
+import { getCodeQuery, isServicesInitialized } from '@/server/services'
+import { ToolValidator } from '@/server/utils/validators'
+import { ResponseFormatter } from '@/server/utils/response-formatter'
+import { ErrorHandler } from '@/server/utils/error-handler'
+import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js'
+import { SearchCodeSchema } from './schemas'
+
+export async function handleSearchCode(
+  args: unknown,
+  logger: Logger
+): Promise<ToolResponse> {
+  try {
+    const input = ToolValidator.validate(args, SearchCodeSchema)
+    const { query, project, type, file_path, limit } = input
+
+    logger.debug({ query, project, type, limit }, 'Searching code index')
+
+    if (!isServicesInitialized()) {
+      throw new McpError(
+        ErrorCode.InternalError,
+        'Services not initialized. The server may still be starting up.'
+      )
+    }
+
+    const codeQuery = getCodeQuery()
+    if (!codeQuery) {
+      return ResponseFormatter.text(
+        'Code intelligence is not available. Run `claude-brain reindex` to index your project first.'
+      )
+    }
+
+    if (type === 'files') {
+      const results = codeQuery.findFiles(query, project)
+      if (results.length === 0) {
+        return ResponseFormatter.text(
+          `No files found matching "${query}" in project "${project}". Try \`claude-brain reindex\` if the project hasn't been indexed.`
+        )
+      }
+
+      const lines = results.map(r => {
+        const parts = [r.filePath]
+        if (r.language) parts.push(`(${r.language})`)
+        if (r.summary) parts.push(`— ${r.summary}`)
+        parts.push(`[${r.symbolCount} symbols, ${r.lineCount} lines]`)
+        return parts.join(' ')
+      })
+
+      return ResponseFormatter.text(
+        `Found ${results.length} file${results.length === 1 ? '' : 's'} matching "${query}":\n\n${lines.join('\n')}`
+      )
+    }
+
+    if (type === 'dependencies') {
+      const targetPath = file_path || query
+      const deps = codeQuery.getDependencies(targetPath, project)
+
+      const parts: string[] = [`Dependencies for ${deps.file}:\n`]
+
+      if (deps.imports.length > 0) {
+        parts.push('**Imports:**')
+        for (const imp of deps.imports) {
+          const names = imp.names.length > 0 ? ` { ${imp.names.join(', ')} }` : ''
+          parts.push(`  → ${imp.file}${names}`)
+        }
+      } else {
+        parts.push('**Imports:** none')
+      }
+
+      parts.push('')
+
+      if (deps.importedBy.length > 0) {
+        parts.push('**Imported by:**')
+        for (const dep of deps.importedBy) {
+          const names = dep.names.length > 0 ? ` { ${dep.names.join(', ')} }` : ''
+          parts.push(`  ← ${dep.file}${names}`)
+        }
+      } else {
+        parts.push('**Imported by:** none')
+      }
+
+      return ResponseFormatter.text(parts.join('\n'))
+    }
+
+    // Default: symbols
+    const results = codeQuery.findSymbols(query, project, limit)
+    if (results.length === 0) {
+      return ResponseFormatter.text(
+        `No symbols found matching "${query}" in project "${project}". Try \`claude-brain reindex\` if the project hasn't been indexed.`
+      )
+    }
+
+    const lines = results.map(r => {
+      const sig = r.signature ? ` ${r.signature}` : ''
+      const lineRange = r.lineEnd ? `${r.lineStart}-${r.lineEnd}` : `${r.lineStart}`
+      const conf = r.confidence < 1.0 ? ` (${(r.confidence * 100).toFixed(0)}%)` : ''
+      return `${r.symbol} (${r.type})${sig} → ${r.filePath}:${lineRange}${conf}`
+    })
+
+    return ResponseFormatter.text(
+      `Found ${results.length} symbol${results.length === 1 ? '' : 's'} matching "${query}":\n\n${lines.join('\n')}`
+    )
+
+  } catch (error) {
+    ErrorHandler.logError(logger, error, { tool: 'search_code', args })
+
+    if (error instanceof McpError) {
+      throw error
+    }
+
+    throw new McpError(
+      ErrorCode.InternalError,
+      `Failed to search code: ${error instanceof Error ? error.message : 'Unknown error'}`
+    )
+  }
+}

package/src/tools/schemas.ts

@@ -610,6 +610,50 @@ export const TOOLS = {
       },
       required: ['message']
     }
+  },
+
+  /**
+   * SEARCH_CODE
+   * Search indexed code symbols, files, and dependencies
+   *
+   * Use this when:
+   * - Looking for a function, class, or type definition
+   * - Need to find which file contains a symbol
+   * - Want to see imports/dependencies of a file
+   * - Faster than grep for known symbol names
+   */
+  SEARCH_CODE: {
+    name: 'search_code',
+    description: 'Search indexed code for symbols (functions, classes, types), files, or dependencies. Faster than grep when the project is indexed. Run `claude-brain reindex` first if no results.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        query: {
+          type: 'string',
+          description: 'Symbol name, file name, or search term'
+        },
+        project: {
+          type: 'string',
+          description: 'Project name (usually the directory name, e.g. "claude-brain")'
+        },
+        type: {
+          type: 'string',
+          enum: ['symbols', 'files', 'dependencies'],
+          description: 'What to search for: symbols (functions/classes/types), files, or dependencies of a file',
+          default: 'symbols'
+        },
+        file_path: {
+          type: 'string',
+          description: 'File path (required when type is "dependencies")'
+        },
+        limit: {
+          type: 'number',
+          description: 'Maximum results to return',
+          default: 20
+        }
+      },
+      required: ['query', 'project']
+    }
   }
 } as const satisfies Record<string, ToolDefinition>