claude-brain 0.30.2 → 0.30.3

package/src/server/handlers/tools/auto-remember.ts

@@ -1,165 +1,165 @@
-/**
- * Auto Remember Handler
- * Automatically detects and saves decisions from text
- */
-
-import type { Logger } from 'pino'
-import type { ToolResponse } from '@/tools/types'
-import { getPhase12Service, getVaultService, 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 { AutoRememberSchema } from './schemas'
-import { formatDecisionEntry } from './remember-decision'
-
-export async function handleAutoRemember(
-  args: unknown,
-  logger: Logger
-): Promise<ToolResponse> {
-  try {
-    const input = ToolValidator.validate(args, AutoRememberSchema)
-    const { project_name, text, confidence_threshold } = input
-
-    logger.debug({
-      project_name,
-      textLength: text.length,
-      confidence_threshold
-    }, 'Auto-remember request')
-
-    if (!isServicesInitialized()) {
-      throw new McpError(
-        ErrorCode.InternalError,
-        'Services not initialized'
-      )
-    }
-
-    const phase12 = getPhase12Service()
-    const vault = getVaultService()
-
-    // Verify project exists
-    const projectPaths = vault.getProjectPaths(project_name)
-    try {
-      await vault.reader.readMarkdownFile(projectPaths.decisions)
-    } catch {
-      throw new McpError(
-        ErrorCode.InvalidParams,
-        `Project "${project_name}" not found. Use list_projects to see available projects.`
-      )
-    }
-
-    // Detect decision in text
-    const detectedDecision = phase12.decisionDetector.detectDecision(text, project_name)
-
-    if (!detectedDecision) {
-      return ResponseFormatter.text(
-        `## No Decision Detected\n\n` +
-        `Analyzed ${text.length} characters but no clear decision was found.\n\n` +
-        `**Tips for auto-detection:**\n` +
-        `- Use phrases like "I recommend X because Y"\n` +
-        `- Include reasoning: "We should use X because..."\n` +
-        `- Be explicit: "The best approach is X"\n\n` +
-        `**Alternatively:** Use \`remember_decision\` to manually save a decision.`
-      )
-    }
-
-    const parts: string[] = []
-    parts.push('## Decision Detected\n')
-    parts.push(`**Confidence:** ${Math.round(detectedDecision.confidence * 100)}%\n`)
-    parts.push(`**Decision:** ${detectedDecision.decision}\n`)
-
-    if (detectedDecision.context) {
-      parts.push(`**Context:** ${detectedDecision.context}\n`)
-    }
-    if (detectedDecision.reasoning) {
-      parts.push(`**Reasoning:** ${detectedDecision.reasoning}\n`)
-    }
-    if (detectedDecision.alternatives) {
-      parts.push(`**Alternatives:** ${detectedDecision.alternatives}\n`)
-    }
-
-    // Check if confidence meets threshold
-    if (detectedDecision.confidence < confidence_threshold) {
-      parts.push(`\n---\n`)
-      parts.push(`⚠️ **Not Auto-Saved** (confidence ${Math.round(detectedDecision.confidence * 100)}% < threshold ${Math.round(confidence_threshold * 100)}%)\n`)
-      parts.push(`\nTo save anyway, use \`remember_decision\` manually or lower the confidence_threshold.`)
-
-      logger.info({
-        project_name,
-        confidence: detectedDecision.confidence,
-        threshold: confidence_threshold,
-        saved: false
-      }, 'Decision detected but below threshold')
-
-      return ResponseFormatter.text(parts.join('\n'))
-    }
-
-    // Auto-save the decision to memory
-    const decisionId = await phase12.decisionDetector.autoSaveDecision(
-      detectedDecision,
-      project_name
-    )
-
-    if (decisionId) {
-      // Also write to vault decisions.md
-      try {
-        const decisionEntry = formatDecisionEntry({
-          id: decisionId,
-          project: project_name,
-          title: detectedDecision.decision,
-          context: detectedDecision.context,
-          decision: detectedDecision.decision,
-          reasoning: detectedDecision.reasoning,
-          alternatives: detectedDecision.alternatives,
-          tags: detectedDecision.tags || ['auto-detected'],
-          timestamp: new Date(),
-          autoDetected: true
-        })
-
-        await vault.writer.appendContent(projectPaths.decisions, decisionEntry, '\n')
-
-        // Update frontmatter
-        const decisionsFile = await vault.reader.readMarkdownFile(projectPaths.decisions)
-        const currentCount = (decisionsFile.frontmatter.decision_count as number) || 0
-        await vault.writer.updateFrontmatter(projectPaths.decisions, {
-          decision_count: currentCount + 1,
-          last_updated: new Date().toISOString().split('T')[0]
-        })
-      } catch (vaultError) {
-        logger.warn({ vaultError }, 'Failed to write to vault, but memory save succeeded')
-      }
-
-      parts.push(`\n---\n`)
-      parts.push(`✅ **Auto-Saved Successfully!**\n`)
-      parts.push(`**ID:** ${decisionId}\n`)
-      parts.push(`**Project:** ${project_name}\n\n`)
-      parts.push(`This decision has been:\n`)
-      parts.push(`- Stored in semantic memory (searchable via \`recall_similar\`)\n`)
-      parts.push(`- Added to ${project_name}/decisions.md in your vault\n`)
-
-      logger.info({
-        project_name,
-        decisionId,
-        confidence: detectedDecision.confidence
-      }, 'Decision auto-saved')
-    } else {
-      parts.push(`\n---\n`)
-      parts.push(`⚠️ Failed to save decision. Check logs for details.`)
-    }
-
-    return ResponseFormatter.text(parts.join('\n'))
-
-  } catch (error) {
-    ErrorHandler.logError(logger, error, { tool: 'auto_remember', args })
-
-    if (error instanceof McpError) {
-      throw error
-    }
-
-    throw new McpError(
-      ErrorCode.InternalError,
-      `Auto-remember failed: ${error instanceof Error ? error.message : 'Unknown error'}`
-    )
-  }
-}
-
+/**
+ * Auto Remember Handler
+ * Automatically detects and saves decisions from text
+ */
+
+import type { Logger } from 'pino'
+import type { ToolResponse } from '@/tools/types'
+import { getPhase12Service, getVaultService, 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 { AutoRememberSchema } from './schemas'
+import { formatDecisionEntry } from './remember-decision'
+
+export async function handleAutoRemember(
+  args: unknown,
+  logger: Logger
+): Promise<ToolResponse> {
+  try {
+    const input = ToolValidator.validate(args, AutoRememberSchema)
+    const { project_name, text, confidence_threshold } = input
+
+    logger.debug({
+      project_name,
+      textLength: text.length,
+      confidence_threshold
+    }, 'Auto-remember request')
+
+    if (!isServicesInitialized()) {
+      throw new McpError(
+        ErrorCode.InternalError,
+        'Services not initialized'
+      )
+    }
+
+    const phase12 = getPhase12Service()
+    const vault = getVaultService()
+
+    // Verify project exists
+    const projectPaths = vault.getProjectPaths(project_name)
+    try {
+      await vault.reader.readMarkdownFile(projectPaths.decisions)
+    } catch {
+      throw new McpError(
+        ErrorCode.InvalidParams,
+        `Project "${project_name}" not found. Use list_projects to see available projects.`
+      )
+    }
+
+    // Detect decision in text
+    const detectedDecision = phase12.decisionDetector.detectDecision(text, project_name)
+
+    if (!detectedDecision) {
+      return ResponseFormatter.text(
+        `## No Decision Detected\n\n` +
+        `Analyzed ${text.length} characters but no clear decision was found.\n\n` +
+        `**Tips for auto-detection:**\n` +
+        `- Use phrases like "I recommend X because Y"\n` +
+        `- Include reasoning: "We should use X because..."\n` +
+        `- Be explicit: "The best approach is X"\n\n` +
+        `**Alternatively:** Use \`remember_decision\` to manually save a decision.`
+      )
+    }
+
+    const parts: string[] = []
+    parts.push('## Decision Detected\n')
+    parts.push(`**Confidence:** ${Math.round(detectedDecision.confidence * 100)}%\n`)
+    parts.push(`**Decision:** ${detectedDecision.decision}\n`)
+
+    if (detectedDecision.context) {
+      parts.push(`**Context:** ${detectedDecision.context}\n`)
+    }
+    if (detectedDecision.reasoning) {
+      parts.push(`**Reasoning:** ${detectedDecision.reasoning}\n`)
+    }
+    if (detectedDecision.alternatives) {
+      parts.push(`**Alternatives:** ${detectedDecision.alternatives}\n`)
+    }
+
+    // Check if confidence meets threshold
+    if (detectedDecision.confidence < confidence_threshold) {
+      parts.push(`\n---\n`)
+      parts.push(`⚠️ **Not Auto-Saved** (confidence ${Math.round(detectedDecision.confidence * 100)}% < threshold ${Math.round(confidence_threshold * 100)}%)\n`)
+      parts.push(`\nTo save anyway, use \`remember_decision\` manually or lower the confidence_threshold.`)
+
+      logger.info({
+        project_name,
+        confidence: detectedDecision.confidence,
+        threshold: confidence_threshold,
+        saved: false
+      }, 'Decision detected but below threshold')
+
+      return ResponseFormatter.text(parts.join('\n'))
+    }
+
+    // Auto-save the decision to memory
+    const decisionId = await phase12.decisionDetector.autoSaveDecision(
+      detectedDecision,
+      project_name
+    )
+
+    if (decisionId) {
+      // Also write to vault decisions.md
+      try {
+        const decisionEntry = formatDecisionEntry({
+          id: decisionId,
+          project: project_name,
+          title: detectedDecision.decision,
+          context: detectedDecision.context,
+          decision: detectedDecision.decision,
+          reasoning: detectedDecision.reasoning,
+          alternatives: detectedDecision.alternatives,
+          tags: detectedDecision.tags || ['auto-detected'],
+          timestamp: new Date(),
+          autoDetected: true
+        })
+
+        await vault.writer.appendContent(projectPaths.decisions, decisionEntry, '\n')
+
+        // Update frontmatter
+        const decisionsFile = await vault.reader.readMarkdownFile(projectPaths.decisions)
+        const currentCount = (decisionsFile.frontmatter.decision_count as number) || 0
+        await vault.writer.updateFrontmatter(projectPaths.decisions, {
+          decision_count: currentCount + 1,
+          last_updated: new Date().toISOString().split('T')[0]
+        })
+      } catch (vaultError) {
+        logger.warn({ vaultError }, 'Failed to write to vault, but memory save succeeded')
+      }
+
+      parts.push(`\n---\n`)
+      parts.push(`✅ **Auto-Saved Successfully!**\n`)
+      parts.push(`**ID:** ${decisionId}\n`)
+      parts.push(`**Project:** ${project_name}\n\n`)
+      parts.push(`This decision has been:\n`)
+      parts.push(`- Stored in semantic memory (searchable via \`recall_similar\`)\n`)
+      parts.push(`- Added to ${project_name}/decisions.md in your vault\n`)
+
+      logger.info({
+        project_name,
+        decisionId,
+        confidence: detectedDecision.confidence
+      }, 'Decision auto-saved')
+    } else {
+      parts.push(`\n---\n`)
+      parts.push(`⚠️ Failed to save decision. Check logs for details.`)
+    }
+
+    return ResponseFormatter.text(parts.join('\n'))
+
+  } catch (error) {
+    ErrorHandler.logError(logger, error, { tool: 'auto_remember', args })
+
+    if (error instanceof McpError) {
+      throw error
+    }
+
+    throw new McpError(
+      ErrorCode.InternalError,
+      `Auto-remember failed: ${error instanceof Error ? error.message : 'Unknown error'}`
+    )
+  }
+}
+

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

@@ -1,86 +1,86 @@
-/**
- * Brain Tool Handler
- * Phase 16: Unified single tool that replaces all 25 MCP tools
- *
- * Accepts natural language, classifies intent server-side,
- * routes internally, and returns a unified response.
- */
-
-import type { Logger } from 'pino'
-import type { ToolResponse } from '@/tools/types'
-import { ToolValidator } from '@/server/utils/validators'
-import { ResponseFormatter } from '@/server/utils/response-formatter'
-import { withMemoryIndicator } from '@/server/utils/memory-indicator'
-import { ErrorHandler } from '@/server/utils/error-handler'
-import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js'
-import { BrainSchema } from './schemas'
-import { getBrainRouter } from '@/routing/router'
-
-export async function handleBrain(
-  args: unknown,
-  logger: Logger
-): Promise<ToolResponse> {
-  try {
-    const input = ToolValidator.validate(args, BrainSchema)
-    const { message, project, action } = input
-
-    logger.debug(
-      {
-        messageLength: message.length,
-        project,
-        action,
-        messagePreview: message.slice(0, 80)
-      },
-      'Brain tool called'
-    )
-
-    const router = getBrainRouter(logger)
-    const response = await router.route({ message, project, action })
-
-    logger.info(
-      {
-        action: response.action,
-        summary: response.summary,
-        relevantItems: response.relevantItems
-      },
-      'Brain tool response'
-    )
-
-    // Format response
-    if (response.action === 'none' && !response.content) {
-      return ResponseFormatter.text(response.summary || 'No action needed.')
-    }
-
-    const parts: string[] = []
-
-    if (response.summary) {
-      parts.push(`**${response.summary}**`)
-      parts.push('')
-    }
-
-    if (response.content) {
-      parts.push(response.content)
-    }
-
-    const content = parts.join('\n')
-
-    // Add memory indicator if we found relevant items
-    if (response.relevantItems > 0 && response.action === 'retrieved') {
-      return ResponseFormatter.text(withMemoryIndicator(content, response.relevantItems))
-    }
-
-    return ResponseFormatter.text(content)
-
-  } catch (error) {
-    ErrorHandler.logError(logger, error, { tool: 'brain', args })
-
-    if (error instanceof McpError) {
-      throw error
-    }
-
-    throw new McpError(
-      ErrorCode.InternalError,
-      `Brain tool failed: ${error instanceof Error ? error.message : 'Unknown error'}`
-    )
-  }
-}
+/**
+ * Brain Tool Handler
+ * Phase 16: Unified single tool that replaces all 25 MCP tools
+ *
+ * Accepts natural language, classifies intent server-side,
+ * routes internally, and returns a unified response.
+ */
+
+import type { Logger } from 'pino'
+import type { ToolResponse } from '@/tools/types'
+import { ToolValidator } from '@/server/utils/validators'
+import { ResponseFormatter } from '@/server/utils/response-formatter'
+import { withMemoryIndicator } from '@/server/utils/memory-indicator'
+import { ErrorHandler } from '@/server/utils/error-handler'
+import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js'
+import { BrainSchema } from './schemas'
+import { getBrainRouter } from '@/routing/router'
+
+export async function handleBrain(
+  args: unknown,
+  logger: Logger
+): Promise<ToolResponse> {
+  try {
+    const input = ToolValidator.validate(args, BrainSchema)
+    const { message, project, action } = input
+
+    logger.debug(
+      {
+        messageLength: message.length,
+        project,
+        action,
+        messagePreview: message.slice(0, 80)
+      },
+      'Brain tool called'
+    )
+
+    const router = getBrainRouter(logger)
+    const response = await router.route({ message, project, action })
+
+    logger.info(
+      {
+        action: response.action,
+        summary: response.summary,
+        relevantItems: response.relevantItems
+      },
+      'Brain tool response'
+    )
+
+    // Format response
+    if (response.action === 'none' && !response.content) {
+      return ResponseFormatter.text(response.summary || 'No action needed.')
+    }
+
+    const parts: string[] = []
+
+    if (response.summary) {
+      parts.push(`**${response.summary}**`)
+      parts.push('')
+    }
+
+    if (response.content) {
+      parts.push(response.content)
+    }
+
+    const content = parts.join('\n')
+
+    // Add memory indicator if we found relevant items
+    if (response.relevantItems > 0 && response.action === 'retrieved') {
+      return ResponseFormatter.text(withMemoryIndicator(content, response.relevantItems))
+    }
+
+    return ResponseFormatter.text(content)
+
+  } catch (error) {
+    ErrorHandler.logError(logger, error, { tool: 'brain', args })
+
+    if (error instanceof McpError) {
+      throw error
+    }
+
+    throw new McpError(
+      ErrorCode.InternalError,
+      `Brain tool failed: ${error instanceof Error ? error.message : 'Unknown error'}`
+    )
+  }
+}