@contextstream/mcp-server 0.2.5 → 0.2.7

package/src/tools.ts

@@ -1,1040 +0,0 @@
-import { z } from 'zod';
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { ContextStreamClient } from './client.js';
-import { readFilesFromDirectory, readAllFilesInBatches } from './files.js';
-
-type StructuredContent = { [x: string]: unknown } | undefined;
-
-function formatContent(data: unknown) {
-  return JSON.stringify(data, null, 2);
-}
-
-function toStructured(data: unknown): StructuredContent {
-  if (data && typeof data === 'object' && !Array.isArray(data)) {
-    return data as { [x: string]: unknown };
-  }
-  return undefined;
-}
-
-export function registerTools(server: McpServer, client: ContextStreamClient) {
-  // Auth
-  server.registerTool(
-    'auth_me',
-    {
-      title: 'Get current user',
-      description: 'Fetch authenticated user profile',
-      inputSchema: z.object({}),
-    },
-    async () => {
-      const result = await client.me();
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  // Workspaces
-  server.registerTool(
-    'workspaces_list',
-    {
-      title: 'List workspaces',
-      description: 'List accessible workspaces',
-      inputSchema: z.object({ page: z.number().optional(), page_size: z.number().optional() }),
-    },
-    async (input) => {
-      const result = await client.listWorkspaces(input);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'workspaces_create',
-    {
-      title: 'Create workspace',
-      description: 'Create a new workspace',
-      inputSchema: z.object({
-        name: z.string(),
-        description: z.string().optional(),
-        visibility: z.enum(['private', 'team', 'org']).optional(),
-      }),
-    },
-    async (input) => {
-      const result = await client.createWorkspace(input);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  // Projects
-  server.registerTool(
-    'projects_list',
-    {
-      title: 'List projects',
-      description: 'List projects (optionally by workspace)',
-      inputSchema: z.object({ workspace_id: z.string().uuid().optional(), page: z.number().optional(), page_size: z.number().optional() }),
-    },
-    async (input) => {
-      const result = await client.listProjects(input);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'projects_create',
-    {
-      title: 'Create project',
-      description: 'Create a project within a workspace',
-      inputSchema: z.object({
-        name: z.string(),
-        description: z.string().optional(),
-        workspace_id: z.string().uuid().optional(),
-      }),
-    },
-    async (input) => {
-      const result = await client.createProject(input);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'projects_index',
-    {
-      title: 'Index project',
-      description: 'Trigger indexing for a project',
-      inputSchema: z.object({ project_id: z.string().uuid() }),
-    },
-    async (input) => {
-      const result = await client.indexProject(input.project_id);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  // Search
-  const searchSchema = z.object({
-    query: z.string(),
-    workspace_id: z.string().uuid().optional(),
-    project_id: z.string().uuid().optional(),
-    limit: z.number().optional(),
-  });
-
-  server.registerTool(
-    'search_semantic',
-    { title: 'Semantic search', description: 'Semantic vector search', inputSchema: searchSchema },
-    async (input) => {
-      const result = await client.searchSemantic(input);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'search_hybrid',
-    { title: 'Hybrid search', description: 'Hybrid search (semantic + keyword)', inputSchema: searchSchema },
-    async (input) => {
-      const result = await client.searchHybrid(input);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'search_keyword',
-    { title: 'Keyword search', description: 'Keyword search', inputSchema: searchSchema },
-    async (input) => {
-      const result = await client.searchKeyword(input);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'search_pattern',
-    { title: 'Pattern search', description: 'Pattern/regex search', inputSchema: searchSchema },
-    async (input) => {
-      const result = await client.searchPattern(input);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  // Memory / Knowledge
-  server.registerTool(
-    'memory_create_event',
-    {
-      title: 'Create memory event',
-      description: 'Create a memory event for a workspace/project',
-      inputSchema: z.object({
-        workspace_id: z.string().uuid().optional(),
-        project_id: z.string().uuid().optional(),
-        event_type: z.string(),
-        title: z.string(),
-        content: z.string(),
-        metadata: z.record(z.any()).optional(),
-      }),
-    },
-    async (input) => {
-      const result = await client.createMemoryEvent(input);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'memory_bulk_ingest',
-    {
-      title: 'Bulk ingest events',
-      description: 'Bulk ingest multiple memory events',
-      inputSchema: z.object({
-        workspace_id: z.string().uuid().optional(),
-        project_id: z.string().uuid().optional(),
-        events: z.array(z.record(z.any())),
-      }),
-    },
-    async (input) => {
-      const result = await client.bulkIngestEvents(input);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'memory_list_events',
-    {
-      title: 'List memory events',
-      description: 'List memory events (optionally scoped)',
-      inputSchema: z.object({
-        workspace_id: z.string().uuid().optional(),
-        project_id: z.string().uuid().optional(),
-        limit: z.number().optional(),
-      }),
-    },
-    async (input) => {
-      const result = await client.listMemoryEvents(input);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'memory_create_node',
-    {
-      title: 'Create knowledge node',
-      description: 'Create a knowledge node with optional relations',
-      inputSchema: z.object({
-        workspace_id: z.string().uuid().optional(),
-        project_id: z.string().uuid().optional(),
-        node_type: z.string(),
-        title: z.string(),
-        content: z.string(),
-        relations: z
-          .array(
-            z.object({
-              type: z.string(),
-              target_id: z.string().uuid(),
-            })
-          )
-          .optional(),
-      }),
-    },
-    async (input) => {
-      const result = await client.createKnowledgeNode(input);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'memory_list_nodes',
-    {
-      title: 'List knowledge nodes',
-      description: 'List knowledge graph nodes',
-      inputSchema: z.object({
-        workspace_id: z.string().uuid().optional(),
-        project_id: z.string().uuid().optional(),
-        limit: z.number().optional(),
-      }),
-    },
-    async (input) => {
-      const result = await client.listKnowledgeNodes(input);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'memory_search',
-    {
-      title: 'Memory-aware search',
-      description: 'Search memory events/notes',
-      inputSchema: z.object({
-        query: z.string(),
-        workspace_id: z.string().uuid().optional(),
-        project_id: z.string().uuid().optional(),
-        limit: z.number().optional(),
-      }),
-    },
-    async (input) => {
-      const result = await client.memorySearch(input);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'memory_decisions',
-    {
-      title: 'Decision summaries',
-      description: 'List decision summaries from workspace memory',
-      inputSchema: z.object({
-        workspace_id: z.string().uuid().optional(),
-        project_id: z.string().uuid().optional(),
-        limit: z.number().optional(),
-      }),
-    },
-    async (input) => {
-      const result = await client.memoryDecisions(input);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  // Graph
-  server.registerTool(
-    'graph_related',
-    {
-      title: 'Related knowledge nodes',
-      description: 'Find related nodes in the knowledge graph',
-      inputSchema: z.object({
-        node_id: z.string(),
-        workspace_id: z.string().uuid().optional(),
-        project_id: z.string().uuid().optional(),
-        limit: z.number().optional(),
-      }),
-    },
-    async (input) => {
-      const result = await client.graphRelated(input);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'graph_path',
-    {
-      title: 'Knowledge path',
-      description: 'Find path between two nodes',
-      inputSchema: z.object({
-        source_id: z.string(),
-        target_id: z.string(),
-        workspace_id: z.string().uuid().optional(),
-        project_id: z.string().uuid().optional(),
-      }),
-    },
-    async (input) => {
-      const result = await client.graphPath(input);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'graph_decisions',
-    {
-      title: 'Decision graph',
-      description: 'Decision history in the knowledge graph',
-      inputSchema: z.object({
-        workspace_id: z.string().uuid().optional(),
-        project_id: z.string().uuid().optional(),
-        limit: z.number().optional(),
-      }),
-    },
-    async (input) => {
-      const result = await client.graphDecisions(input);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'graph_dependencies',
-    {
-      title: 'Code dependencies',
-      description: 'Dependency graph query',
-      inputSchema: z.object({
-        target: z.object({ type: z.string(), id: z.string() }),
-        max_depth: z.number().optional(),
-        include_transitive: z.boolean().optional(),
-      }),
-    },
-    async (input) => {
-      const result = await client.graphDependencies(input);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'graph_call_path',
-    {
-      title: 'Call path',
-      description: 'Find call path between two targets',
-      inputSchema: z.object({
-        source: z.object({ type: z.string(), id: z.string() }),
-        target: z.object({ type: z.string(), id: z.string() }),
-        max_depth: z.number().optional(),
-      }),
-    },
-    async (input) => {
-      const result = await client.graphCallPath(input);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'graph_impact',
-    {
-      title: 'Impact analysis',
-      description: 'Analyze impact of a target node',
-      inputSchema: z.object({ target: z.object({ type: z.string(), id: z.string() }), max_depth: z.number().optional() }),
-    },
-    async (input) => {
-      const result = await client.graphImpact(input);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  // AI
-  server.registerTool(
-    'ai_context',
-    {
-      title: 'Build AI context',
-      description: 'Build LLM context (docs/memory/code) for a query',
-      inputSchema: z.object({
-        query: z.string(),
-        workspace_id: z.string().uuid().optional(),
-        project_id: z.string().uuid().optional(),
-        include_code: z.boolean().optional(),
-        include_docs: z.boolean().optional(),
-        include_memory: z.boolean().optional(),
-        limit: z.number().optional(),
-      }),
-    },
-    async (input) => {
-      const result = await client.aiContext(input);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'ai_embeddings',
-    {
-      title: 'Generate embeddings',
-      description: 'Generate embeddings for a text',
-      inputSchema: z.object({ text: z.string() }),
-    },
-    async (input) => {
-      const result = await client.aiEmbeddings(input);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'ai_plan',
-    {
-      title: 'Generate dev plan',
-      description: 'Generate development plan from description',
-      inputSchema: z.object({
-        description: z.string(),
-        project_id: z.string().uuid().optional(),
-        complexity: z.string().optional(),
-      }),
-    },
-    async (input) => {
-      const result = await client.aiPlan(input);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'ai_tasks',
-    {
-      title: 'Generate tasks',
-      description: 'Generate tasks from plan or description',
-      inputSchema: z.object({
-        plan_id: z.string().optional(),
-        description: z.string().optional(),
-        project_id: z.string().uuid().optional(),
-        granularity: z.string().optional(),
-      }),
-    },
-    async (input) => {
-      const result = await client.aiTasks(input);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'ai_enhanced_context',
-    {
-      title: 'Enhanced AI context',
-      description: 'Build enhanced LLM context with deeper analysis',
-      inputSchema: z.object({
-        query: z.string(),
-        workspace_id: z.string().uuid().optional(),
-        project_id: z.string().uuid().optional(),
-        include_code: z.boolean().optional(),
-        include_docs: z.boolean().optional(),
-        include_memory: z.boolean().optional(),
-        limit: z.number().optional(),
-      }),
-    },
-    async (input) => {
-      const result = await client.aiEnhancedContext(input);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  // Extended project operations
-  server.registerTool(
-    'projects_get',
-    {
-      title: 'Get project',
-      description: 'Get project details by ID',
-      inputSchema: z.object({ project_id: z.string().uuid() }),
-    },
-    async (input) => {
-      const result = await client.getProject(input.project_id);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'projects_overview',
-    {
-      title: 'Project overview',
-      description: 'Get project overview with summary information',
-      inputSchema: z.object({ project_id: z.string().uuid() }),
-    },
-    async (input) => {
-      const result = await client.projectOverview(input.project_id);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'projects_statistics',
-    {
-      title: 'Project statistics',
-      description: 'Get project statistics (files, lines, complexity)',
-      inputSchema: z.object({ project_id: z.string().uuid() }),
-    },
-    async (input) => {
-      const result = await client.projectStatistics(input.project_id);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'projects_files',
-    {
-      title: 'List project files',
-      description: 'List all indexed files in a project',
-      inputSchema: z.object({ project_id: z.string().uuid() }),
-    },
-    async (input) => {
-      const result = await client.projectFiles(input.project_id);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'projects_index_status',
-    {
-      title: 'Index status',
-      description: 'Get project indexing status',
-      inputSchema: z.object({ project_id: z.string().uuid() }),
-    },
-    async (input) => {
-      const result = await client.projectIndexStatus(input.project_id);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'projects_ingest_local',
-    {
-      title: 'Ingest local files',
-      description: `Read ALL files from a local directory and ingest them for indexing.
-This indexes your entire project by reading files in batches.
-Automatically detects code files and skips ignored directories like node_modules, target, dist, etc.`,
-      inputSchema: z.object({
-        project_id: z.string().uuid().describe('Project to ingest files into'),
-        path: z.string().describe('Local directory path to read files from'),
-      }),
-    },
-    async (input) => {
-      // Start ingestion in background to avoid blocking the agent
-      (async () => {
-        try {
-          let totalIndexed = 0;
-          let batchCount = 0;
-          
-          console.error(`[ContextStream] Starting background ingestion for project ${input.project_id} from ${input.path}`);
-          
-          for await (const batch of readAllFilesInBatches(input.path, { batchSize: 50 })) {
-            const result = await client.ingestFiles(input.project_id, batch) as { data?: { files_indexed: number } };
-            totalIndexed += result.data?.files_indexed ?? batch.length;
-            batchCount++;
-          }
-          
-          console.error(`[ContextStream] Completed background ingestion: ${totalIndexed} files in ${batchCount} batches`);
-        } catch (error) {
-          console.error(`[ContextStream] Ingestion failed:`, error);
-        }
-      })();
-
-      const summary = {
-        status: 'started',
-        message: 'Ingestion running in background',
-        project_id: input.project_id,
-        path: input.path,
-        note: "Use 'projects_index_status' to monitor progress."
-      };
-      
-      return { 
-        content: [{ 
-          type: 'text' as const, 
-          text: `Ingestion started in background for directory: ${input.path}. Use 'projects_index_status' to monitor progress.` 
-        }],
-        structuredContent: toStructured(summary)
-      };
-    }
-  );
-
-  // Extended workspace operations
-  server.registerTool(
-    'workspaces_get',
-    {
-      title: 'Get workspace',
-      description: 'Get workspace details by ID',
-      inputSchema: z.object({ workspace_id: z.string().uuid() }),
-    },
-    async (input) => {
-      const result = await client.getWorkspace(input.workspace_id);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'workspaces_overview',
-    {
-      title: 'Workspace overview',
-      description: 'Get workspace overview with summary information',
-      inputSchema: z.object({ workspace_id: z.string().uuid() }),
-    },
-    async (input) => {
-      const result = await client.workspaceOverview(input.workspace_id);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'workspaces_analytics',
-    {
-      title: 'Workspace analytics',
-      description: 'Get workspace usage analytics',
-      inputSchema: z.object({ workspace_id: z.string().uuid() }),
-    },
-    async (input) => {
-      const result = await client.workspaceAnalytics(input.workspace_id);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'workspaces_content',
-    {
-      title: 'Workspace content',
-      description: 'List content in a workspace',
-      inputSchema: z.object({ workspace_id: z.string().uuid() }),
-    },
-    async (input) => {
-      const result = await client.workspaceContent(input.workspace_id);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  // Extended memory operations
-  server.registerTool(
-    'memory_get_event',
-    {
-      title: 'Get memory event',
-      description: 'Get a specific memory event by ID',
-      inputSchema: z.object({ event_id: z.string().uuid() }),
-    },
-    async (input) => {
-      const result = await client.getMemoryEvent(input.event_id);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'memory_update_event',
-    {
-      title: 'Update memory event',
-      description: 'Update a memory event',
-      inputSchema: z.object({
-        event_id: z.string().uuid(),
-        title: z.string().optional(),
-        content: z.string().optional(),
-        metadata: z.record(z.any()).optional(),
-      }),
-    },
-    async (input) => {
-      const { event_id, ...body } = input;
-      const result = await client.updateMemoryEvent(event_id, body);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'memory_delete_event',
-    {
-      title: 'Delete memory event',
-      description: 'Delete a memory event',
-      inputSchema: z.object({ event_id: z.string().uuid() }),
-    },
-    async (input) => {
-      const result = await client.deleteMemoryEvent(input.event_id);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'memory_distill_event',
-    {
-      title: 'Distill memory event',
-      description: 'Extract and condense key insights from a memory event',
-      inputSchema: z.object({ event_id: z.string().uuid() }),
-    },
-    async (input) => {
-      const result = await client.distillMemoryEvent(input.event_id);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'memory_get_node',
-    {
-      title: 'Get knowledge node',
-      description: 'Get a specific knowledge node by ID',
-      inputSchema: z.object({ node_id: z.string().uuid() }),
-    },
-    async (input) => {
-      const result = await client.getKnowledgeNode(input.node_id);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'memory_update_node',
-    {
-      title: 'Update knowledge node',
-      description: 'Update a knowledge node',
-      inputSchema: z.object({
-        node_id: z.string().uuid(),
-        title: z.string().optional(),
-        content: z.string().optional(),
-        relations: z.array(z.object({ type: z.string(), target_id: z.string().uuid() })).optional(),
-      }),
-    },
-    async (input) => {
-      const { node_id, ...body } = input;
-      const result = await client.updateKnowledgeNode(node_id, body);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'memory_delete_node',
-    {
-      title: 'Delete knowledge node',
-      description: 'Delete a knowledge node',
-      inputSchema: z.object({ node_id: z.string().uuid() }),
-    },
-    async (input) => {
-      const result = await client.deleteKnowledgeNode(input.node_id);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'memory_supersede_node',
-    {
-      title: 'Supersede knowledge node',
-      description: 'Replace a knowledge node with updated information (maintains history)',
-      inputSchema: z.object({
-        node_id: z.string().uuid(),
-        new_content: z.string(),
-        reason: z.string().optional(),
-      }),
-    },
-    async (input) => {
-      const { node_id, ...body } = input;
-      const result = await client.supersedeKnowledgeNode(node_id, body);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'memory_timeline',
-    {
-      title: 'Memory timeline',
-      description: 'Get chronological timeline of memory events for a workspace',
-      inputSchema: z.object({ workspace_id: z.string().uuid() }),
-    },
-    async (input) => {
-      const result = await client.memoryTimeline(input.workspace_id);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'memory_summary',
-    {
-      title: 'Memory summary',
-      description: 'Get condensed summary of workspace memory',
-      inputSchema: z.object({ workspace_id: z.string().uuid() }),
-    },
-    async (input) => {
-      const result = await client.memorySummary(input.workspace_id);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  // Extended graph operations
-  server.registerTool(
-    'graph_circular_dependencies',
-    {
-      title: 'Find circular dependencies',
-      description: 'Detect circular dependencies in project code',
-      inputSchema: z.object({ project_id: z.string().uuid() }),
-    },
-    async (input) => {
-      const result = await client.findCircularDependencies(input.project_id);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'graph_unused_code',
-    {
-      title: 'Find unused code',
-      description: 'Detect unused code in project',
-      inputSchema: z.object({ project_id: z.string().uuid() }),
-    },
-    async (input) => {
-      const result = await client.findUnusedCode(input.project_id);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'graph_contradictions',
-    {
-      title: 'Find contradictions',
-      description: 'Find contradicting information related to a knowledge node',
-      inputSchema: z.object({ node_id: z.string().uuid() }),
-    },
-    async (input) => {
-      const result = await client.findContradictions(input.node_id);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  // Search suggestions
-  server.registerTool(
-    'search_suggestions',
-    {
-      title: 'Search suggestions',
-      description: 'Get search suggestions based on partial query',
-      inputSchema: z.object({
-        query: z.string(),
-        workspace_id: z.string().uuid().optional(),
-        project_id: z.string().uuid().optional(),
-      }),
-    },
-    async (input) => {
-      const result = await client.searchSuggestions(input);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  // ============================================
-  // Session & Auto-Context Tools (CORE-like)
-  // ============================================
-
-  server.registerTool(
-    'session_init',
-    {
-      title: 'Initialize conversation session',
-      description: `Initialize a new conversation session and automatically retrieve relevant context.
-This is the FIRST tool AI assistants should call when starting a conversation.
-Returns: workspace info, project info, recent memory, recent decisions, and relevant context.
-Automatically detects the IDE workspace/project path and can auto-index code.
-IMPORTANT: If you know the current workspace folder path, pass it as folder_path for accurate context resolution.`,
-      inputSchema: z.object({
-        folder_path: z.string().optional().describe('Current workspace/project folder path (absolute). Use this when IDE roots are not available.'),
-        workspace_id: z.string().uuid().optional().describe('Workspace to initialize context for'),
-        project_id: z.string().uuid().optional().describe('Project to initialize context for'),
-        session_id: z.string().optional().describe('Custom session ID (auto-generated if not provided)'),
-        context_hint: z.string().optional().describe('Hint about what the user wants to work on (used for context search)'),
-        include_recent_memory: z.boolean().optional().describe('Include recent memory events (default: true)'),
-        include_decisions: z.boolean().optional().describe('Include recent decisions (default: true)'),
-        auto_index: z.boolean().optional().describe('Automatically create and index project from IDE workspace (default: true)'),
-      }),
-    },
-    async (input) => {
-      // Get IDE workspace roots if available
-      let ideRoots: string[] = [];
-      try {
-        const rootsResponse = await server.server.listRoots();
-        if (rootsResponse?.roots) {
-          ideRoots = rootsResponse.roots.map((r: { uri: string; name?: string }) => r.uri.replace('file://', ''));
-        }
-      } catch {
-        // IDE may not support roots - that's okay
-      }
-      
-      // Fallback to explicit folder_path if IDE roots not available
-      if (ideRoots.length === 0 && input.folder_path) {
-        ideRoots = [input.folder_path];
-      }
-      
-      const result = await client.initSession(input, ideRoots);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'session_get_user_context',
-    {
-      title: 'Get user context and preferences',
-      description: `Retrieve user preferences, coding style, and persona from memory.
-Use this to understand how the user likes to work and adapt your responses accordingly.`,
-      inputSchema: z.object({
-        workspace_id: z.string().uuid().optional().describe('Workspace to get user context from'),
-      }),
-    },
-    async (input) => {
-      const result = await client.getUserContext(input);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'workspace_associate',
-    {
-      title: 'Associate folder with workspace',
-      description: `Associate a folder/repo with a workspace after user selection.
-Call this after session_init returns status='requires_workspace_selection' and the user has chosen a workspace.
-This persists the selection to .contextstream/config.json so future sessions auto-connect.
-Optionally creates a parent folder mapping (e.g., all repos under /dev/company/* map to the same workspace).`,
-      inputSchema: z.object({
-        folder_path: z.string().describe('Absolute path to the folder/repo to associate'),
-        workspace_id: z.string().uuid().describe('Workspace ID to associate with'),
-        workspace_name: z.string().optional().describe('Workspace name for reference'),
-        create_parent_mapping: z.boolean().optional().describe('Also create a parent folder mapping (e.g., /dev/maker/* -> workspace)'),
-      }),
-    },
-    async (input) => {
-      const result = await client.associateWorkspace(input);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'session_capture',
-    {
-      title: 'Capture context to memory',
-      description: `Automatically capture and store important context from the conversation.
-Use this to persist decisions, insights, preferences, or important information.`,
-      inputSchema: z.object({
-        workspace_id: z.string().uuid().optional(),
-        project_id: z.string().uuid().optional(),
-        session_id: z.string().optional().describe('Session ID to associate with this capture'),
-        event_type: z.enum(['conversation', 'decision', 'insight', 'preference', 'task', 'bug', 'feature']).describe('Type of context being captured'),
-        title: z.string().describe('Brief title for the captured context'),
-        content: z.string().describe('Full content/details to capture'),
-        tags: z.array(z.string()).optional().describe('Tags for categorization'),
-        importance: z.enum(['low', 'medium', 'high', 'critical']).optional().describe('Importance level'),
-      }),
-    },
-    async (input) => {
-      const result = await client.captureContext(input);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'session_smart_search',
-    {
-      title: 'Smart context search',
-      description: `Search memory with automatic context enrichment.
-Returns memory matches, relevant code, and related decisions in one call.`,
-      inputSchema: z.object({
-        query: z.string().describe('What to search for'),
-        workspace_id: z.string().uuid().optional(),
-        project_id: z.string().uuid().optional(),
-        include_related: z.boolean().optional().describe('Include related context (default: true)'),
-        include_decisions: z.boolean().optional().describe('Include related decisions (default: true)'),
-      }),
-    },
-    async (input) => {
-      const result = await client.smartSearch(input);
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'session_remember',
-    {
-      title: 'Remember this',
-      description: `Quick way to store something in memory. Use natural language.
-Example: "Remember that I prefer TypeScript strict mode" or "Remember we decided to use PostgreSQL"`,
-      inputSchema: z.object({
-        content: z.string().describe('What to remember (natural language)'),
-        workspace_id: z.string().uuid().optional(),
-        project_id: z.string().uuid().optional(),
-        importance: z.enum(['low', 'medium', 'high']).optional(),
-      }),
-    },
-    async (input) => {
-      // Auto-detect type from content
-      const lowerContent = input.content.toLowerCase();
-      let eventType: 'preference' | 'decision' | 'insight' | 'task' = 'insight';
-      if (lowerContent.includes('prefer') || lowerContent.includes('like') || lowerContent.includes('always')) {
-        eventType = 'preference';
-      } else if (lowerContent.includes('decided') || lowerContent.includes('decision') || lowerContent.includes('chose')) {
-        eventType = 'decision';
-      } else if (lowerContent.includes('todo') || lowerContent.includes('task') || lowerContent.includes('need to')) {
-        eventType = 'task';
-      }
-
-      const result = await client.captureContext({
-        workspace_id: input.workspace_id,
-        project_id: input.project_id,
-        event_type: eventType,
-        title: input.content.slice(0, 100),
-        content: input.content,
-        importance: input.importance || 'medium',
-      });
-      return { content: [{ type: 'text' as const, text: `Remembered: ${input.content.slice(0, 100)}...` }], structuredContent: toStructured(result) };
-    }
-  );
-
-  server.registerTool(
-    'session_recall',
-    {
-      title: 'Recall from memory',
-      description: `Quick way to recall relevant context. Use natural language.
-Example: "What were the auth decisions?" or "What are my TypeScript preferences?"`,
-      inputSchema: z.object({
-        query: z.string().describe('What to recall (natural language)'),
-        workspace_id: z.string().uuid().optional(),
-        project_id: z.string().uuid().optional(),
-      }),
-    },
-    async (input) => {
-      const result = await client.smartSearch({
-        query: input.query,
-        workspace_id: input.workspace_id,
-        project_id: input.project_id,
-        include_decisions: true,
-      });
-      return { content: [{ type: 'text' as const, text: formatContent(result) }], structuredContent: toStructured(result) };
-    }
-  );
-}