@contextstream/mcp-server 0.2.5 → 0.2.7

package/src/client.ts

@@ -1,764 +0,0 @@
-import { z } from 'zod';
-import type { Config } from './config.js';
-import { request } from './http.js';
-import { readFilesFromDirectory, readAllFilesInBatches } from './files.js';
-import { 
-  resolveWorkspace, 
-  readLocalConfig, 
-  writeLocalConfig, 
-  addGlobalMapping,
-  type WorkspaceConfig 
-} from './workspace-config.js';
-
-const uuidSchema = z.string().uuid();
-
-export class ContextStreamClient {
-  constructor(private config: Config) {}
-
-  private withDefaults<T extends { workspace_id?: string; project_id?: string }>(
-    input: T
-  ): T {
-    const { defaultWorkspaceId, defaultProjectId } = this.config;
-    return {
-      ...input,
-      workspace_id: input.workspace_id || defaultWorkspaceId,
-      project_id: input.project_id || defaultProjectId,
-    } as T;
-  }
-
-  // Auth
-  me() {
-    return request(this.config, '/auth/me');
-  }
-
-  // Workspaces & Projects
-  listWorkspaces(params?: { page?: number; page_size?: number }) {
-    const query = new URLSearchParams();
-    if (params?.page) query.set('page', String(params.page));
-    if (params?.page_size) query.set('page_size', String(params.page_size));
-    const suffix = query.toString() ? `?${query.toString()}` : '';
-    return request(this.config, `/workspaces${suffix}`);
-  }
-
-  createWorkspace(input: { name: string; description?: string; visibility?: string }) {
-    return request(this.config, '/workspaces', { body: input });
-  }
-
-  listProjects(params?: { workspace_id?: string; page?: number; page_size?: number }) {
-    const withDefaults = this.withDefaults(params || {});
-    const query = new URLSearchParams();
-    if (withDefaults.workspace_id) query.set('workspace_id', withDefaults.workspace_id);
-    if (params?.page) query.set('page', String(params.page));
-    if (params?.page_size) query.set('page_size', String(params.page_size));
-    const suffix = query.toString() ? `?${query.toString()}` : '';
-    return request(this.config, `/projects${suffix}`);
-  }
-
-  createProject(input: { name: string; description?: string; workspace_id?: string }) {
-    const payload = this.withDefaults(input);
-    return request(this.config, '/projects', { body: payload });
-  }
-
-  indexProject(projectId: string) {
-    uuidSchema.parse(projectId);
-    return request(this.config, `/projects/${projectId}/index`, { body: {} });
-  }
-
-  // Search
-  searchSemantic(body: { query: string; workspace_id?: string; project_id?: string; limit?: number }) {
-    return request(this.config, '/search/semantic', { body: this.withDefaults(body) });
-  }
-
-  searchHybrid(body: { query: string; workspace_id?: string; project_id?: string; limit?: number }) {
-    return request(this.config, '/search/hybrid', { body: this.withDefaults(body) });
-  }
-
-  searchKeyword(body: { query: string; workspace_id?: string; project_id?: string; limit?: number }) {
-    return request(this.config, '/search/keyword', { body: this.withDefaults(body) });
-  }
-
-  searchPattern(body: { query: string; workspace_id?: string; project_id?: string; limit?: number }) {
-    return request(this.config, '/search/pattern', { body: this.withDefaults(body) });
-  }
-
-  // Memory / Knowledge
-  createMemoryEvent(body: {
-    workspace_id?: string;
-    project_id?: string;
-    event_type: string;
-    title: string;
-    content: string;
-    metadata?: Record<string, any>;
-  }) {
-    return request(this.config, '/memory/events', { body: this.withDefaults(body) });
-  }
-
-  bulkIngestEvents(body: { workspace_id?: string; project_id?: string; events: any[] }) {
-    return request(this.config, '/memory/events/ingest', { body: this.withDefaults(body) });
-  }
-
-  listMemoryEvents(params?: { workspace_id?: string; project_id?: string; limit?: number }) {
-    const withDefaults = this.withDefaults(params || {});
-    if (!withDefaults.workspace_id) {
-      throw new Error('workspace_id is required for listing memory events');
-    }
-    const query = new URLSearchParams();
-    if (params?.limit) query.set('limit', String(params.limit));
-    if (withDefaults.project_id) query.set('project_id', withDefaults.project_id);
-    const suffix = query.toString() ? `?${query.toString()}` : '';
-    return request(this.config, `/memory/events/workspace/${withDefaults.workspace_id}${suffix}`, { method: 'GET' });
-  }
-
-  createKnowledgeNode(body: {
-    workspace_id?: string;
-    project_id?: string;
-    node_type: string;
-    title: string;
-    content: string;
-    relations?: Array<{ type: string; target_id: string }>;
-  }) {
-    return request(this.config, '/memory/nodes', { body: this.withDefaults(body) });
-  }
-
-  listKnowledgeNodes(params?: { workspace_id?: string; project_id?: string; limit?: number }) {
-    const withDefaults = this.withDefaults(params || {});
-    if (!withDefaults.workspace_id) {
-      throw new Error('workspace_id is required for listing knowledge nodes');
-    }
-    const query = new URLSearchParams();
-    if (params?.limit) query.set('limit', String(params.limit));
-    if (withDefaults.project_id) query.set('project_id', withDefaults.project_id);
-    const suffix = query.toString() ? `?${query.toString()}` : '';
-    return request(this.config, `/memory/nodes/workspace/${withDefaults.workspace_id}${suffix}`, { method: 'GET' });
-  }
-
-  memorySearch(body: { query: string; workspace_id?: string; project_id?: string; limit?: number }) {
-    return request(this.config, '/memory/search', { body: this.withDefaults(body) });
-  }
-
-  memoryDecisions(params?: { workspace_id?: string; project_id?: string; limit?: number }) {
-    const query = new URLSearchParams();
-    const withDefaults = this.withDefaults(params || {});
-    if (withDefaults.workspace_id) query.set('workspace_id', withDefaults.workspace_id);
-    if (withDefaults.project_id) query.set('project_id', withDefaults.project_id);
-    if (params?.limit) query.set('limit', String(params.limit));
-    const suffix = query.toString() ? `?${query.toString()}` : '';
-    return request(this.config, `/memory/search/decisions${suffix}`, { method: 'GET' });
-  }
-
-  // Graph
-  graphRelated(body: { workspace_id?: string; project_id?: string; node_id: string; limit?: number }) {
-    return request(this.config, '/graph/knowledge/related', { body: this.withDefaults(body) });
-  }
-
-  graphPath(body: { workspace_id?: string; project_id?: string; source_id: string; target_id: string }) {
-    return request(this.config, '/graph/knowledge/path', { body: this.withDefaults(body) });
-  }
-
-  graphDecisions(body?: { workspace_id?: string; project_id?: string; limit?: number }) {
-    return request(this.config, '/graph/knowledge/decisions', { body: this.withDefaults(body || {}) });
-  }
-
-  graphDependencies(body: { target: { type: string; id: string }; max_depth?: number; include_transitive?: boolean }) {
-    return request(this.config, '/graph/dependencies', { body });
-  }
-
-  graphCallPath(body: { source: { type: string; id: string }; target: { type: string; id: string }; max_depth?: number }) {
-    return request(this.config, '/graph/call-paths', { body });
-  }
-
-  graphImpact(body: { target: { type: string; id: string }; max_depth?: number }) {
-    return request(this.config, '/graph/impact-analysis', { body });
-  }
-
-  // AI
-  aiContext(body: {
-    query: string;
-    workspace_id?: string;
-    project_id?: string;
-    include_code?: boolean;
-    include_docs?: boolean;
-    include_memory?: boolean;
-    limit?: number;
-  }) {
-    return request(this.config, '/ai/context', { body: this.withDefaults(body) });
-  }
-
-  aiEmbeddings(body: { text: string }) {
-    return request(this.config, '/ai/embeddings', { body });
-  }
-
-  aiPlan(body: { description: string; project_id?: string; complexity?: string }) {
-    return request(this.config, '/ai/plan/generate', { body: this.withDefaults(body) });
-  }
-
-  aiTasks(body: { plan_id?: string; description?: string; project_id?: string; granularity?: string }) {
-    return request(this.config, '/ai/tasks/generate', { body: this.withDefaults(body) });
-  }
-
-  aiEnhancedContext(body: {
-    query: string;
-    workspace_id?: string;
-    project_id?: string;
-    include_code?: boolean;
-    include_docs?: boolean;
-    include_memory?: boolean;
-    limit?: number;
-  }) {
-    return request(this.config, '/ai/context/enhanced', { body: this.withDefaults(body) });
-  }
-
-  // Project extended operations
-  getProject(projectId: string) {
-    uuidSchema.parse(projectId);
-    return request(this.config, `/projects/${projectId}`, { method: 'GET' });
-  }
-
-  projectOverview(projectId: string) {
-    uuidSchema.parse(projectId);
-    return request(this.config, `/projects/${projectId}/overview`, { method: 'GET' });
-  }
-
-  projectStatistics(projectId: string) {
-    uuidSchema.parse(projectId);
-    return request(this.config, `/projects/${projectId}/statistics`, { method: 'GET' });
-  }
-
-  projectFiles(projectId: string) {
-    uuidSchema.parse(projectId);
-    return request(this.config, `/projects/${projectId}/files`, { method: 'GET' });
-  }
-
-  projectIndexStatus(projectId: string) {
-    uuidSchema.parse(projectId);
-    return request(this.config, `/projects/${projectId}/index/status`, { method: 'GET' });
-  }
-
-  /**
-   * Ingest files for indexing
-   * This uploads files to the API for indexing
-   */
-  ingestFiles(projectId: string, files: Array<{ path: string; content: string; language?: string }>) {
-    uuidSchema.parse(projectId);
-    return request(this.config, `/projects/${projectId}/files/ingest`, {
-      body: { files },
-    });
-  }
-
-  // Workspace extended operations
-  getWorkspace(workspaceId: string) {
-    uuidSchema.parse(workspaceId);
-    return request(this.config, `/workspaces/${workspaceId}`, { method: 'GET' });
-  }
-
-  workspaceOverview(workspaceId: string) {
-    uuidSchema.parse(workspaceId);
-    return request(this.config, `/workspaces/${workspaceId}/overview`, { method: 'GET' });
-  }
-
-  workspaceAnalytics(workspaceId: string) {
-    uuidSchema.parse(workspaceId);
-    return request(this.config, `/workspaces/${workspaceId}/analytics`, { method: 'GET' });
-  }
-
-  workspaceContent(workspaceId: string) {
-    uuidSchema.parse(workspaceId);
-    return request(this.config, `/workspaces/${workspaceId}/content`, { method: 'GET' });
-  }
-
-  // Memory extended operations
-  getMemoryEvent(eventId: string) {
-    uuidSchema.parse(eventId);
-    return request(this.config, `/memory/events/${eventId}`, { method: 'GET' });
-  }
-
-  updateMemoryEvent(eventId: string, body: { title?: string; content?: string; metadata?: Record<string, any> }) {
-    uuidSchema.parse(eventId);
-    return request(this.config, `/memory/events/${eventId}`, { method: 'PUT', body });
-  }
-
-  deleteMemoryEvent(eventId: string) {
-    uuidSchema.parse(eventId);
-    return request(this.config, `/memory/events/${eventId}`, { method: 'DELETE' });
-  }
-
-  distillMemoryEvent(eventId: string) {
-    uuidSchema.parse(eventId);
-    return request(this.config, `/memory/events/${eventId}/distill`, { body: {} });
-  }
-
-  getKnowledgeNode(nodeId: string) {
-    uuidSchema.parse(nodeId);
-    return request(this.config, `/memory/nodes/${nodeId}`, { method: 'GET' });
-  }
-
-  updateKnowledgeNode(nodeId: string, body: { title?: string; content?: string; relations?: Array<{ type: string; target_id: string }> }) {
-    uuidSchema.parse(nodeId);
-    return request(this.config, `/memory/nodes/${nodeId}`, { method: 'PUT', body });
-  }
-
-  deleteKnowledgeNode(nodeId: string) {
-    uuidSchema.parse(nodeId);
-    return request(this.config, `/memory/nodes/${nodeId}`, { method: 'DELETE' });
-  }
-
-  supersedeKnowledgeNode(nodeId: string, body: { new_content: string; reason?: string }) {
-    uuidSchema.parse(nodeId);
-    return request(this.config, `/memory/nodes/${nodeId}/supersede`, { body });
-  }
-
-  memoryTimeline(workspaceId: string) {
-    uuidSchema.parse(workspaceId);
-    return request(this.config, `/memory/search/timeline/${workspaceId}`, { method: 'GET' });
-  }
-
-  memorySummary(workspaceId: string) {
-    uuidSchema.parse(workspaceId);
-    return request(this.config, `/memory/search/summary/${workspaceId}`, { method: 'GET' });
-  }
-
-  // Graph extended operations
-  findCircularDependencies(projectId: string) {
-    uuidSchema.parse(projectId);
-    return request(this.config, `/graph/circular-dependencies/${projectId}`, { method: 'GET' });
-  }
-
-  findUnusedCode(projectId: string) {
-    uuidSchema.parse(projectId);
-    return request(this.config, `/graph/unused-code/${projectId}`, { method: 'GET' });
-  }
-
-  findContradictions(nodeId: string) {
-    uuidSchema.parse(nodeId);
-    return request(this.config, `/graph/knowledge/contradictions/${nodeId}`, { method: 'GET' });
-  }
-
-  // Search suggestions
-  searchSuggestions(body: { query: string; workspace_id?: string; project_id?: string }) {
-    return request(this.config, '/search/suggest', { body: this.withDefaults(body) });
-  }
-
-  // ============================================
-  // Session & Auto-Context Initialization
-  // ============================================
-
-  /**
-   * Initialize a conversation session and retrieve relevant context automatically.
-   * This is the key tool for AI assistants to get context at the start of a conversation.
-   * 
-   * Discovery chain:
-   * 1. Check local .contextstream/config.json in repo root
-   * 2. Check parent folder heuristic mappings (~/.contextstream-mappings.json)
-   * 3. If ambiguous, return workspace candidates for user/agent selection
-   * 
-   * Once workspace is resolved, loads WORKSPACE-LEVEL context (not just project),
-   * ensuring cross-project decisions and memory are available.
-   */
-  async initSession(params: {
-    workspace_id?: string;
-    project_id?: string;
-    session_id?: string;
-    context_hint?: string;
-    include_recent_memory?: boolean;
-    include_decisions?: boolean;
-    include_user_preferences?: boolean;
-    auto_index?: boolean;
-  }, ideRoots: string[] = []) {
-    let workspaceId = params.workspace_id || this.config.defaultWorkspaceId;
-    let projectId = params.project_id || this.config.defaultProjectId;
-    let workspaceName: string | undefined;
-    
-    // Build comprehensive initial context
-    const context: Record<string, unknown> = {
-      session_id: params.session_id || crypto.randomUUID(),
-      initialized_at: new Date().toISOString(),
-    };
-
-    const rootPath = ideRoots.length > 0 ? ideRoots[0] : undefined;
-
-    // ========================================
-    // STEP 1: Workspace Discovery Chain
-    // ========================================
-    if (!workspaceId && rootPath) {
-      // Try local config and parent mappings first
-      const resolved = resolveWorkspace(rootPath);
-      
-      if (resolved.config) {
-        workspaceId = resolved.config.workspace_id;
-        workspaceName = resolved.config.workspace_name;
-        projectId = resolved.config.project_id || projectId;
-        context.workspace_source = resolved.source;
-        context.workspace_resolved_from = resolved.source === 'local_config' 
-          ? `${rootPath}/.contextstream/config.json`
-          : 'parent_folder_mapping';
-      } else {
-        // Ambiguous - need user selection
-        // Fetch all workspaces as candidates
-        try {
-          const workspaces = await this.listWorkspaces({ page_size: 50 }) as { 
-            items?: Array<{ id: string; name: string; description?: string }> 
-          };
-          
-          if (workspaces.items && workspaces.items.length > 0) {
-            // Return ambiguous status with candidates
-            context.status = 'requires_workspace_selection';
-            context.workspace_candidates = workspaces.items.map(w => ({
-              id: w.id,
-              name: w.name,
-              description: w.description,
-            }));
-            context.message = `New folder detected: "${rootPath?.split('/').pop()}". Please select which workspace this belongs to, or create a new one.`;
-            context.ide_roots = ideRoots;
-            context.folder_name = rootPath?.split('/').pop();
-            
-            // Still return early - agent needs to ask user
-            return context;
-          } else {
-            // No workspaces exist - create default
-            const newWorkspace = await this.createWorkspace({
-              name: 'My Workspace',
-              description: 'Default workspace created by ContextStream',
-              visibility: 'private',
-            }) as { id?: string; name?: string };
-            if (newWorkspace.id) {
-              workspaceId = newWorkspace.id;
-              workspaceName = newWorkspace.name;
-              context.workspace_source = 'auto_created';
-              context.workspace_created = true;
-              
-              // Save to local config for next time
-              writeLocalConfig(rootPath, {
-                workspace_id: newWorkspace.id,
-                workspace_name: newWorkspace.name,
-                associated_at: new Date().toISOString(),
-              });
-            }
-          }
-        } catch (e) {
-          context.workspace_error = String(e);
-        }
-      }
-    }
-
-    // Fallback: if still no workspace and no IDE roots, pick first available
-    if (!workspaceId && !rootPath) {
-      try {
-        const workspaces = await this.listWorkspaces({ page_size: 1 }) as { items?: Array<{ id: string; name: string }> };
-        if (workspaces.items && workspaces.items.length > 0) {
-          workspaceId = workspaces.items[0].id;
-          workspaceName = workspaces.items[0].name;
-          context.workspace_source = 'fallback_first';
-        }
-      } catch (e) {
-        context.workspace_error = String(e);
-      }
-    }
-
-    // ========================================
-    // STEP 2: Project Discovery
-    // ========================================
-    if (!projectId && workspaceId && rootPath && params.auto_index !== false) {
-      const projectName = rootPath.split('/').pop() || 'My Project';
-      
-      try {
-        // Check if a project with this name already exists in this workspace
-        const projects = await this.listProjects({ workspace_id: workspaceId }) as { items?: Array<{ id: string; name: string }> };
-        const existingProject = projects.items?.find(p => p.name === projectName);
-        
-        if (existingProject) {
-          projectId = existingProject.id;
-          context.project_source = 'existing';
-        } else {
-          // Create project from IDE root
-          const newProject = await this.createProject({
-            name: projectName,
-            description: `Auto-created from ${rootPath}`,
-            workspace_id: workspaceId,
-          }) as { id?: string };
-          
-          if (newProject.id) {
-            projectId = newProject.id;
-            context.project_source = 'auto_created';
-            context.project_created = true;
-            context.project_path = rootPath;
-          }
-        }
-        
-        // Update local config with project info
-        if (projectId) {
-          const existingConfig = readLocalConfig(rootPath);
-          if (existingConfig || workspaceId) {
-            writeLocalConfig(rootPath, {
-              workspace_id: workspaceId!,
-              workspace_name: workspaceName,
-              project_id: projectId,
-              project_name: projectName,
-              associated_at: existingConfig?.associated_at || new Date().toISOString(),
-            });
-          }
-        }
-        
-        // Ingest files if auto_index is enabled (default: true)
-        // Runs in BACKGROUND - does not block session_init
-        if (projectId && (params.auto_index === undefined || params.auto_index === true)) {
-          context.indexing_status = 'started';
-          
-          // Fire-and-forget: start indexing in background
-          const projectIdCopy = projectId;
-          const rootPathCopy = rootPath;
-          (async () => {
-            try {
-              for await (const batch of readAllFilesInBatches(rootPathCopy, { batchSize: 50 })) {
-                await this.ingestFiles(projectIdCopy, batch);
-              }
-              console.error(`[ContextStream] Background indexing completed for ${rootPathCopy}`);
-            } catch (e) {
-              console.error(`[ContextStream] Background indexing failed:`, e);
-            }
-          })();
-        }
-      } catch (e) {
-        context.project_error = String(e);
-      }
-    }
-
-    context.status = 'connected';
-    context.workspace_id = workspaceId;
-    context.workspace_name = workspaceName;
-    context.project_id = projectId;
-    context.ide_roots = ideRoots;
-
-    // ========================================
-    // STEP 3: Load WORKSPACE-LEVEL Context
-    // (Cross-project memories and decisions)
-    // ========================================
-    if (workspaceId) {
-      try {
-        context.workspace = await this.workspaceOverview(workspaceId);
-      } catch { /* optional */ }
-    }
-
-    if (projectId) {
-      try {
-        context.project = await this.projectOverview(projectId);
-      } catch { /* optional */ }
-    }
-
-    // Fetch WORKSPACE-level memory (not filtered by project)
-    // This ensures cross-project context is available
-    if (params.include_recent_memory !== false && workspaceId) {
-      try {
-        context.recent_memory = await this.listMemoryEvents({
-          workspace_id: workspaceId,
-          // NOTE: Intentionally NOT filtering by project_id
-          // to get workspace-wide context
-          limit: 10,
-        });
-      } catch { /* optional */ }
-    }
-
-    // Fetch WORKSPACE-level decisions
-    if (params.include_decisions !== false && workspaceId) {
-      try {
-        context.recent_decisions = await this.memoryDecisions({
-          workspace_id: workspaceId,
-          // NOTE: Intentionally NOT filtering by project_id
-          limit: 5,
-        });
-      } catch { /* optional */ }
-    }
-
-    // Search for context hint if provided
-    if (params.context_hint && workspaceId) {
-      try {
-        context.relevant_context = await this.memorySearch({
-          query: params.context_hint,
-          workspace_id: workspaceId,
-          // Search workspace-wide first
-          limit: 5,
-        });
-      } catch { /* optional */ }
-    }
-
-    return context;
-  }
-
-  /**
-   * Associate a folder with a workspace (called after user selects from candidates).
-   * Persists the selection to .contextstream/config.json for future sessions.
-   */
-  async associateWorkspace(params: {
-    folder_path: string;
-    workspace_id: string;
-    workspace_name?: string;
-    create_parent_mapping?: boolean; // Also create a parent folder mapping
-  }) {
-    const { folder_path, workspace_id, workspace_name, create_parent_mapping } = params;
-    
-    // Save local config
-    const saved = writeLocalConfig(folder_path, {
-      workspace_id,
-      workspace_name,
-      associated_at: new Date().toISOString(),
-    });
-
-    // Optionally create parent folder mapping (e.g., /home/user/dev/company/* -> workspace)
-    if (create_parent_mapping) {
-      const parentDir = folder_path.split('/').slice(0, -1).join('/');
-      addGlobalMapping({
-        pattern: `${parentDir}/*`,
-        workspace_id,
-        workspace_name: workspace_name || 'Unknown',
-      });
-    }
-
-    return {
-      success: saved,
-      config_path: `${folder_path}/.contextstream/config.json`,
-      workspace_id,
-      workspace_name,
-      parent_mapping_created: create_parent_mapping || false,
-    };
-  }
-
-  /**
-   * Get user preferences and persona from memory.
-   * Useful for AI to understand user's coding style, preferences, etc.
-   */
-  async getUserContext(params: { workspace_id?: string }) {
-    const withDefaults = this.withDefaults(params);
-    
-    if (!withDefaults.workspace_id) {
-      throw new Error('workspace_id is required for getUserContext');
-    }
-
-    const context: Record<string, unknown> = {};
-
-    // Search for user preferences
-    try {
-      context.preferences = await this.memorySearch({
-        query: 'user preferences coding style settings',
-        workspace_id: withDefaults.workspace_id,
-        limit: 10,
-      });
-    } catch { /* optional */ }
-
-    // Get memory summary for overall context
-    try {
-      context.summary = await this.memorySummary(withDefaults.workspace_id);
-    } catch { /* optional */ }
-
-    return context;
-  }
-
-  /**
-   * Capture and store conversation context automatically.
-   * Call this to persist important context from the current conversation.
-   */
-  async captureContext(params: {
-    workspace_id?: string;
-    project_id?: string;
-    session_id?: string;
-    event_type: 'conversation' | 'decision' | 'insight' | 'preference' | 'task' | 'bug' | 'feature';
-    title: string;
-    content: string;
-    tags?: string[];
-    importance?: 'low' | 'medium' | 'high' | 'critical';
-  }) {
-    const withDefaults = this.withDefaults(params);
-    
-    // Map high-level types to API EventType
-    let apiEventType = 'manual_note';
-    const tags = params.tags || [];
-    
-    switch (params.event_type) {
-      case 'conversation':
-        apiEventType = 'chat';
-        break;
-      case 'task':
-        apiEventType = 'task_created';
-        break;
-      case 'bug':
-      case 'feature':
-        apiEventType = 'ticket';
-        tags.push(params.event_type);
-        break;
-      case 'decision':
-      case 'insight':
-      case 'preference':
-        apiEventType = 'manual_note';
-        tags.push(params.event_type);
-        break;
-      default:
-        apiEventType = 'manual_note';
-        tags.push(params.event_type);
-    }
-
-    return this.createMemoryEvent({
-      workspace_id: withDefaults.workspace_id,
-      project_id: withDefaults.project_id,
-      event_type: apiEventType,
-      title: params.title,
-      content: params.content,
-      metadata: {
-        original_type: params.event_type,
-        session_id: params.session_id,
-        tags: tags,
-        importance: params.importance || 'medium',
-        captured_at: new Date().toISOString(),
-        source: 'mcp_auto_capture',
-      },
-    });
-  }
-
-  /**
-   * Search memory with automatic context enrichment.
-   * Returns both direct matches and related context.
-   */
-  async smartSearch(params: {
-    query: string;
-    workspace_id?: string;
-    project_id?: string;
-    include_related?: boolean;
-    include_decisions?: boolean;
-  }) {
-    const withDefaults = this.withDefaults(params);
-    
-    const results: Record<string, unknown> = {};
-
-    // Primary memory search
-    try {
-      results.memory_results = await this.memorySearch({
-        query: params.query,
-        workspace_id: withDefaults.workspace_id,
-        project_id: withDefaults.project_id,
-        limit: 10,
-      });
-    } catch { /* optional */ }
-
-    // Semantic code search if project specified
-    if (withDefaults.project_id) {
-      try {
-        results.code_results = await this.searchSemantic({
-          query: params.query,
-          workspace_id: withDefaults.workspace_id,
-          project_id: withDefaults.project_id,
-          limit: 5,
-        });
-      } catch { /* optional */ }
-    }
-
-    // Include related decisions
-    if (params.include_decisions !== false && withDefaults.workspace_id) {
-      try {
-        results.related_decisions = await this.memoryDecisions({
-          workspace_id: withDefaults.workspace_id,
-          project_id: withDefaults.project_id,
-          limit: 3,
-        });
-      } catch { /* optional */ }
-    }
-
-    return results;
-  }
-}