@stackmemoryai/stackmemory 0.2.6 → 0.2.8

package/dist/src/integrations/mcp/server.js

@@ -12,11 +12,13 @@ import { join, dirname } from 'path';
 import { execSync } from 'child_process';
 import { FrameManager } from '../../core/context/frame-manager.js';
 import { PebblesTaskStore, } from '../../features/tasks/pebbles-task-store.js';
-// TODO: Temporarily disabled due to TypeScript errors
-// import { LinearAuthManager, LinearOAuthSetup } from '../integrations/linear/auth.js';
-// import { LinearSyncEngine, DEFAULT_SYNC_CONFIG } from '../integrations/linear/sync.js';
+import { LinearAuthManager } from '../linear/auth.js';
+import { LinearSyncEngine, DEFAULT_SYNC_CONFIG } from '../linear/sync.js';
 import { logger } from '../../core/monitoring/logger.js';
 import { BrowserMCPIntegration } from '../../features/browser/browser-mcp.js';
+import { TraceDetector } from '../../core/trace/trace-detector.js';
+import { LLMContextRetrieval } from '../../core/retrieval/index.js';
+import { v4 as uuidv4 } from 'uuid';
 // ============================================
 // Simple Local MCP Server
 // ============================================
@@ -26,12 +28,13 @@ class LocalStackMemoryMCP {
     projectRoot;
     frameManager;
     taskStore;
-    // TODO: Temporarily disabled
-    // private linearAuthManager: LinearAuthManager;
-    // private linearSync: LinearSyncEngine;
+    linearAuthManager;
+    linearSync;
     projectId;
     contexts = new Map();
     browserMCP;
+    traceDetector;
+    contextRetrieval;
     constructor() {
         // Find project root (where .git is)
         this.projectRoot = this.findProjectRoot();
@@ -49,13 +52,9 @@ class LocalStackMemoryMCP {
         this.frameManager = new FrameManager(this.db, this.projectId);
         // Initialize task store
         this.taskStore = new PebblesTaskStore(this.projectRoot, this.db);
-        // TODO: Initialize Linear integration (temporarily disabled)
-        // this.linearAuthManager = new LinearAuthManager(this.projectRoot);
-        // this.linearSync = new LinearSyncEngine(
-        //   this.taskStore,
-        //   this.linearAuthManager,
-        //   DEFAULT_SYNC_CONFIG
-        // );
+        // Initialize Linear integration
+        this.linearAuthManager = new LinearAuthManager(this.projectRoot);
+        this.linearSync = new LinearSyncEngine(this.taskStore, this.linearAuthManager, DEFAULT_SYNC_CONFIG);
         // Initialize MCP server
         this.server = new Server({
             name: 'stackmemory-local',
@@ -70,6 +69,10 @@ class LocalStackMemoryMCP {
             headless: process.env.BROWSER_HEADLESS !== 'false',
             defaultViewport: { width: 1280, height: 720 },
         });
+        // Initialize Trace Detector with database persistence
+        this.traceDetector = new TraceDetector({}, undefined, this.db);
+        // Initialize LLM Context Retrieval
+        this.contextRetrieval = new LLMContextRetrieval(this.db, this.frameManager, this.projectId);
         this.setupHandlers();
         this.loadInitialContext();
         // Initialize Browser MCP with this server
@@ -92,6 +95,8 @@ class LocalStackMemoryMCP {
         return process.cwd();
     }
     initDB() {
+        // Note: Don't create frames table here - FrameManager handles the schema
+        // with the full run_id, project_id, parent_frame_id columns
         this.db.exec(`
       CREATE TABLE IF NOT EXISTS contexts (
         id TEXT PRIMARY KEY,
@@ -103,13 +108,6 @@ class LocalStackMemoryMCP {
         access_count INTEGER DEFAULT 1
       );
 
-      CREATE TABLE IF NOT EXISTS frames (
-        frame_id TEXT PRIMARY KEY,
-        task TEXT NOT NULL,
-        status TEXT DEFAULT 'active',
-        created_at INTEGER DEFAULT (unixepoch())
-      );
-
       CREATE TABLE IF NOT EXISTS attention_log (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
         context_id TEXT,
@@ -388,7 +386,7 @@ class LocalStackMemoryMCP {
                     },
                     {
                         name: 'get_active_tasks',
-                        description: 'Get currently active tasks',
+                        description: 'Get currently active tasks synced from Linear',
                         inputSchema: {
                             type: 'object',
                             properties: {
@@ -396,6 +394,30 @@ class LocalStackMemoryMCP {
                                     type: 'string',
                                     description: 'Filter by specific frame ID',
                                 },
+                                status: {
+                                    type: 'string',
+                                    enum: [
+                                        'pending',
+                                        'in_progress',
+                                        'completed',
+                                        'blocked',
+                                        'cancelled',
+                                    ],
+                                    description: 'Filter by status',
+                                },
+                                priority: {
+                                    type: 'string',
+                                    enum: ['low', 'medium', 'high', 'urgent'],
+                                    description: 'Filter by priority',
+                                },
+                                search: {
+                                    type: 'string',
+                                    description: 'Search in task title or description',
+                                },
+                                limit: {
+                                    type: 'number',
+                                    description: 'Max number of tasks to return (default: 20)',
+                                },
                             },
                         },
                     },
@@ -425,6 +447,175 @@ class LocalStackMemoryMCP {
                             required: ['taskId', 'dependsOnId'],
                         },
                     },
+                    {
+                        name: 'linear_sync',
+                        description: 'Sync tasks with Linear',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                direction: {
+                                    type: 'string',
+                                    enum: ['bidirectional', 'to_linear', 'from_linear'],
+                                    description: 'Sync direction',
+                                },
+                            },
+                        },
+                    },
+                    {
+                        name: 'linear_update_task',
+                        description: 'Update a Linear task status',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                issueId: {
+                                    type: 'string',
+                                    description: 'Linear issue ID or identifier (e.g., STA-34)',
+                                },
+                                status: {
+                                    type: 'string',
+                                    enum: ['todo', 'in-progress', 'done', 'canceled'],
+                                    description: 'New status for the task',
+                                },
+                                title: {
+                                    type: 'string',
+                                    description: 'Update task title (optional)',
+                                },
+                                description: {
+                                    type: 'string',
+                                    description: 'Update task description (optional)',
+                                },
+                                priority: {
+                                    type: 'number',
+                                    enum: [1, 2, 3, 4],
+                                    description: 'Priority (1=urgent, 2=high, 3=medium, 4=low)',
+                                },
+                            },
+                            required: ['issueId'],
+                        },
+                    },
+                    {
+                        name: 'linear_get_tasks',
+                        description: 'Get Linear tasks',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                status: {
+                                    type: 'string',
+                                    enum: ['todo', 'in-progress', 'done', 'all'],
+                                    description: 'Filter by status',
+                                },
+                                limit: {
+                                    type: 'number',
+                                    description: 'Maximum number of tasks to return',
+                                },
+                            },
+                        },
+                    },
+                    {
+                        name: 'linear_status',
+                        description: 'Get Linear integration status',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {},
+                        },
+                    },
+                    {
+                        name: 'get_traces',
+                        description: 'Get detected traces (bundled tool call sequences)',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                type: {
+                                    type: 'string',
+                                    enum: [
+                                        'search_driven',
+                                        'error_recovery',
+                                        'feature_implementation',
+                                        'refactoring',
+                                        'testing',
+                                        'exploration',
+                                        'debugging',
+                                        'documentation',
+                                        'build_deploy',
+                                        'unknown',
+                                    ],
+                                    description: 'Filter by trace type',
+                                },
+                                minScore: {
+                                    type: 'number',
+                                    description: 'Minimum importance score (0-1)',
+                                },
+                                limit: {
+                                    type: 'number',
+                                    description: 'Maximum number of traces to return',
+                                },
+                            },
+                        },
+                    },
+                    {
+                        name: 'get_trace_statistics',
+                        description: 'Get statistics about detected traces',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {},
+                        },
+                    },
+                    {
+                        name: 'flush_traces',
+                        description: 'Flush any pending trace and finalize detection',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {},
+                        },
+                    },
+                    {
+                        name: 'compress_old_traces',
+                        description: 'Compress traces older than specified hours',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                ageHours: {
+                                    type: 'number',
+                                    description: 'Age threshold in hours (default: 24)',
+                                },
+                            },
+                        },
+                    },
+                    {
+                        name: 'smart_context',
+                        description: 'LLM-driven context retrieval - intelligently selects relevant frames based on query',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                query: {
+                                    type: 'string',
+                                    description: 'Natural language query describing what context you need',
+                                },
+                                tokenBudget: {
+                                    type: 'number',
+                                    description: 'Maximum tokens to use for context (default: 4000)',
+                                },
+                                forceRefresh: {
+                                    type: 'boolean',
+                                    description: 'Force refresh of cached summaries',
+                                },
+                            },
+                            required: ['query'],
+                        },
+                    },
+                    {
+                        name: 'get_summary',
+                        description: 'Get compressed summary of project memory for analysis',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                forceRefresh: {
+                                    type: 'boolean',
+                                    description: 'Force refresh of cached summary',
+                                },
+                            },
+                        },
+                    },
                 ],
             };
         });
@@ -437,32 +628,132 @@ class LocalStackMemoryMCP {
             }),
         }), async (request) => {
             const { name, arguments: args } = request.params;
-            switch (name) {
-                case 'get_context':
-                    return this.handleGetContext(args);
-                case 'add_decision':
-                    return this.handleAddDecision(args);
-                case 'start_frame':
-                    return this.handleStartFrame(args);
-                case 'close_frame':
-                    return this.handleCloseFrame(args);
-                case 'add_anchor':
-                    return this.handleAddAnchor(args);
-                case 'get_hot_stack':
-                    return this.handleGetHotStack(args);
-                case 'create_task':
-                    return this.handleCreateTask(args);
-                case 'update_task_status':
-                    return this.handleUpdateTaskStatus(args);
-                case 'get_active_tasks':
-                    return this.handleGetActiveTasks(args);
-                case 'get_task_metrics':
-                    return this.handleGetTaskMetrics(args);
-                case 'add_task_dependency':
-                    return this.handleAddTaskDependency(args);
-                default:
-                    throw new Error(`Unknown tool: ${name}`);
+            const callId = uuidv4();
+            const startTime = Date.now();
+            // Log tool call event before execution
+            const currentFrameId = this.frameManager.getCurrentFrameId();
+            if (currentFrameId) {
+                this.frameManager.addEvent('tool_call', {
+                    tool_name: name,
+                    arguments: args,
+                    timestamp: startTime,
+                });
             }
+            // Create ToolCall for trace detection
+            const toolCall = {
+                id: callId,
+                tool: name,
+                arguments: args,
+                timestamp: startTime,
+            };
+            let result;
+            let error;
+            try {
+                switch (name) {
+                    case 'get_context':
+                        result = await this.handleGetContext(args);
+                        break;
+                    case 'add_decision':
+                        result = await this.handleAddDecision(args);
+                        break;
+                    case 'start_frame':
+                        result = await this.handleStartFrame(args);
+                        break;
+                    case 'close_frame':
+                        result = await this.handleCloseFrame(args);
+                        break;
+                    case 'add_anchor':
+                        result = await this.handleAddAnchor(args);
+                        break;
+                    case 'get_hot_stack':
+                        result = await this.handleGetHotStack(args);
+                        break;
+                    case 'create_task':
+                        result = await this.handleCreateTask(args);
+                        break;
+                    case 'update_task_status':
+                        result = await this.handleUpdateTaskStatus(args);
+                        break;
+                    case 'get_active_tasks':
+                        result = await this.handleGetActiveTasks(args);
+                        break;
+                    case 'get_task_metrics':
+                        result = await this.handleGetTaskMetrics(args);
+                        break;
+                    case 'add_task_dependency':
+                        result = await this.handleAddTaskDependency(args);
+                        break;
+                    case 'linear_sync':
+                        result = await this.handleLinearSync(args);
+                        break;
+                    case 'linear_update_task':
+                        result = await this.handleLinearUpdateTask(args);
+                        break;
+                    case 'linear_get_tasks':
+                        result = await this.handleLinearGetTasks(args);
+                        break;
+                    case 'linear_status':
+                        result = await this.handleLinearStatus(args);
+                        break;
+                    case 'get_traces':
+                        result = await this.handleGetTraces(args);
+                        break;
+                    case 'get_trace_statistics':
+                        result = await this.handleGetTraceStatistics(args);
+                        break;
+                    case 'flush_traces':
+                        result = await this.handleFlushTraces(args);
+                        break;
+                    case 'compress_old_traces':
+                        result = await this.handleCompressOldTraces(args);
+                        break;
+                    case 'smart_context':
+                        result = await this.handleSmartContext(args);
+                        break;
+                    case 'get_summary':
+                        result = await this.handleGetSummary(args);
+                        break;
+                    default:
+                        throw new Error(`Unknown tool: ${name}`);
+                }
+            }
+            catch (err) {
+                error = err;
+                toolCall.error = err.message || String(err);
+                throw err;
+            }
+            finally {
+                const endTime = Date.now();
+                // Log tool result event after execution (success or failure)
+                // Skip for close_frame since the frame no longer exists after closing
+                if (currentFrameId && name !== 'close_frame') {
+                    try {
+                        this.frameManager.addEvent('tool_result', {
+                            tool_name: name,
+                            success: !error,
+                            result: error ? { error: error.message } : result,
+                            timestamp: endTime,
+                        });
+                    }
+                    catch {
+                        // Frame may have been closed, ignore logging error
+                    }
+                }
+                // Update tool call with results and add to trace detector
+                toolCall.result = error ? undefined : result;
+                toolCall.duration = endTime - startTime;
+                // Extract files affected if available from result or args
+                if (args.file_path || args.path) {
+                    toolCall.filesAffected = [args.file_path || args.path].filter(Boolean);
+                }
+                else if (result?.files) {
+                    const files = result.files;
+                    toolCall.filesAffected = Array.isArray(files) ? files : [files];
+                }
+                // Add to trace detector
+                this.traceDetector.addToolCall(toolCall);
+            }
+            return result;
         });
     }
     async handleGetContext(args) {
@@ -712,31 +1003,70 @@ class LocalStackMemoryMCP {
         }
     }
     async handleGetActiveTasks(args) {
-        const { frameId } = args;
-        const activeTasks = this.taskStore.getActiveTasks(frameId);
-        if (activeTasks.length === 0) {
+        const { frameId, status, priority, search, limit = 20 } = args;
+        let tasks = this.taskStore.getActiveTasks(frameId);
+        // Apply filters
+        if (status) {
+            tasks = tasks.filter((t) => t.status === status);
+        }
+        if (priority) {
+            tasks = tasks.filter((t) => t.priority === priority);
+        }
+        if (search) {
+            const searchLower = search.toLowerCase();
+            tasks = tasks.filter((t) => t.title.toLowerCase().includes(searchLower) ||
+                (t.description && t.description.toLowerCase().includes(searchLower)));
+        }
+        // Sort by priority (urgent first) then by created_at
+        const priorityOrder = { urgent: 0, high: 1, medium: 2, low: 3 };
+        tasks.sort((a, b) => {
+            const pa = priorityOrder[a.priority] ?? 2;
+            const pb = priorityOrder[b.priority] ?? 2;
+            if (pa !== pb)
+                return pa - pb;
+            return b.created_at - a.created_at;
+        });
+        // Limit results
+        tasks = tasks.slice(0, limit);
+        if (tasks.length === 0) {
             return {
                 content: [
                     {
                         type: 'text',
-                        text: frameId
-                            ? `📝 No active tasks in frame ${frameId}`
-                            : '📝 No active tasks in project',
+                        text: search
+                            ? `📝 No tasks matching "${search}"`
+                            : '📝 No active tasks found',
                     },
                 ],
             };
         }
-        let response = '📝 **Active Tasks**\n\n';
-        activeTasks.forEach((task) => {
-            const priority = task.priority.toUpperCase();
-            const status = task.status.replace('_', ' ').toUpperCase();
+        let response = `📝 **Tasks** (${tasks.length} found)\n\n`;
+        tasks.forEach((task) => {
+            const priorityIcon = { urgent: '🔴', high: '🟠', medium: '🟡', low: '🟢' }[task.priority] ||
+                '⚪';
+            const statusIcon = {
+                pending: '⏳',
+                in_progress: '🔄',
+                completed: '✅',
+                blocked: '🚫',
+                cancelled: '❌',
+            }[task.status] || '⚪';
             const effort = task.estimated_effort
-                ? ` (${task.estimated_effort}m)`
+                ? ` (~${task.estimated_effort}m)`
                 : '';
-            response += `- **[${status}]** ${task.title}${effort}\n`;
-            response += `  Priority: ${priority} | ID: ${task.id}\n`;
-            if (task.depends_on.length > 0) {
-                response += `  Depends on: ${task.depends_on.join(', ')}\n`;
+            // Extract Linear ID from title if present
+            const linearMatch = task.title.match(/\[ENG-\d+\]/);
+            const linearId = linearMatch ? linearMatch[0] : '';
+            const title = linearId
+                ? task.title.replace(linearId, '').trim()
+                : task.title;
+            response += `${statusIcon} ${priorityIcon} **${linearId || task.id}** ${title}${effort}\n`;
+            if (task.description) {
+                const desc = task.description.split('\n')[0].slice(0, 100);
+                response += `   ${desc}${task.description.length > 100 ? '...' : ''}\n`;
+            }
+            if (task.tags && task.tags.length > 0) {
+                response += `   🏷️ ${task.tags.join(', ')}\n`;
             }
             response += '\n';
         });
@@ -807,6 +1137,464 @@ class LocalStackMemoryMCP {
             };
         }
     }
+    // Linear Integration Handlers
+    async handleLinearSync(args) {
+        try {
+            const tokens = this.linearAuthManager.loadTokens();
+            if (!tokens) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: '❌ Linear not authenticated. Run: stackmemory linear setup',
+                        },
+                    ],
+                };
+            }
+            const syncConfig = { ...DEFAULT_SYNC_CONFIG, enabled: true };
+            if (args.direction) {
+                syncConfig.direction = args.direction;
+            }
+            // Update sync engine configuration for this sync
+            this.linearSync.updateConfig(syncConfig);
+            const result = await this.linearSync.sync();
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `✅ Linear sync completed\n- To Linear: ${result.synced.toLinear} tasks\n- From Linear: ${result.synced.fromLinear} tasks\n- Updated: ${result.synced.updated} tasks`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `❌ Linear sync failed: ${error.message}`,
+                    },
+                ],
+            };
+        }
+    }
+    async handleLinearUpdateTask(args) {
+        try {
+            const { LinearClient } = await import('../linear/client.js');
+            const tokens = this.linearAuthManager.loadTokens();
+            if (!tokens) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: '❌ Linear not authenticated. Run: stackmemory linear setup',
+                        },
+                    ],
+                };
+            }
+            const client = new LinearClient({
+                apiKey: tokens.accessToken,
+            });
+            // Find the issue
+            let issue = await client.getIssue(args.issueId);
+            if (!issue) {
+                issue = await client.findIssueByIdentifier(args.issueId);
+            }
+            if (!issue) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `❌ Linear issue ${args.issueId} not found`,
+                        },
+                    ],
+                };
+            }
+            const updates = {};
+            // Handle status update
+            if (args.status) {
+                const team = await client.getTeam();
+                const states = await client.getWorkflowStates(team.id);
+                const statusMap = {
+                    todo: 'unstarted',
+                    'in-progress': 'started',
+                    done: 'completed',
+                    canceled: 'cancelled',
+                };
+                const targetType = statusMap[args.status] || args.status;
+                const targetState = states.find((s) => s.type === targetType);
+                if (!targetState) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `❌ Invalid status: ${args.status}`,
+                            },
+                        ],
+                    };
+                }
+                updates.stateId = targetState.id;
+            }
+            if (args.title)
+                updates.title = args.title;
+            if (args.description)
+                updates.description = args.description;
+            if (args.priority)
+                updates.priority = args.priority;
+            const updatedIssue = await client.updateIssue(issue.id, updates);
+            // Auto-sync to local tasks after update
+            this.linearSync.updateConfig({
+                ...DEFAULT_SYNC_CONFIG,
+                enabled: true,
+                direction: 'from_linear',
+            });
+            const syncResult = await this.linearSync.sync();
+            let response = `✅ Updated ${updatedIssue.identifier}: ${updatedIssue.title}\n`;
+            if (args.status) {
+                response += `Status: ${updatedIssue.state.name}\n`;
+            }
+            response += `URL: ${updatedIssue.url}\n`;
+            response += `\n🔄 Local sync: ${syncResult.synced.fromLinear} new, ${syncResult.synced.updated} updated`;
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: response,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `❌ Failed to update Linear task: ${error.message}`,
+                    },
+                ],
+            };
+        }
+    }
+    async handleLinearGetTasks(args) {
+        try {
+            const { LinearClient } = await import('../linear/client.js');
+            const tokens = this.linearAuthManager.loadTokens();
+            if (!tokens) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: '❌ Linear not authenticated. Run: stackmemory linear setup',
+                        },
+                    ],
+                };
+            }
+            const client = new LinearClient({
+                apiKey: tokens.accessToken,
+            });
+            let stateType = undefined;
+            if (args.status && args.status !== 'all') {
+                const statusMap = {
+                    todo: 'unstarted',
+                    'in-progress': 'started',
+                    done: 'completed',
+                };
+                stateType = statusMap[args.status] || args.status;
+            }
+            const issues = await client.getIssues({
+                stateType,
+                limit: args.limit || 20,
+            });
+            if (!issues || issues.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: 'No Linear tasks found',
+                        },
+                    ],
+                };
+            }
+            let response = `📋 **Linear Tasks** (${issues.length} items)\n\n`;
+            issues.forEach((issue) => {
+                const priority = issue.priority ? `P${issue.priority}` : '-';
+                response += `- **${issue.identifier}**: ${issue.title}\n`;
+                response += `  Status: ${issue.state.name} | Priority: ${priority}\n`;
+                if (issue.assignee) {
+                    response += `  Assignee: ${issue.assignee.name}\n`;
+                }
+                response += `  ${issue.url}\n\n`;
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: response,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `❌ Failed to get Linear tasks: ${error.message}`,
+                    },
+                ],
+            };
+        }
+    }
+    async handleLinearStatus(_args) {
+        try {
+            const { LinearClient } = await import('../linear/client.js');
+            const tokens = this.linearAuthManager.loadTokens();
+            if (!tokens) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: '❌ Linear integration not configured\nRun: stackmemory linear setup',
+                        },
+                    ],
+                };
+            }
+            try {
+                const client = new LinearClient({
+                    apiKey: tokens.accessToken,
+                });
+                const viewer = await client.getViewer();
+                const team = await client.getTeam();
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `✅ **Linear Integration Status**\n\nConnected as: ${viewer.name} (${viewer.email})\nTeam: ${team.name} (${team.key})\nTokens: Valid`,
+                        },
+                    ],
+                };
+            }
+            catch (error) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `⚠️ Linear configured but connection failed: ${error.message}`,
+                        },
+                    ],
+                };
+            }
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `❌ Linear status check failed: ${error.message}`,
+                    },
+                ],
+            };
+        }
+    }
+    async handleGetTraces(args) {
+        const { type, minScore, limit = 20 } = args;
+        // Flush pending traces first
+        this.traceDetector.flush();
+        let traces = this.traceDetector.getTraces();
+        // Apply filters
+        if (type) {
+            traces = traces.filter((t) => t.type === type);
+        }
+        if (minScore !== undefined) {
+            traces = traces.filter((t) => t.score >= minScore);
+        }
+        // Sort by score and limit
+        traces = traces.sort((a, b) => b.score - a.score).slice(0, limit);
+        // Format traces for display
+        const formattedTraces = traces.map((trace) => ({
+            id: trace.id,
+            type: trace.type,
+            score: trace.score.toFixed(2),
+            summary: trace.summary,
+            toolCount: trace.tools.length,
+            duration: `${((trace.metadata.endTime - trace.metadata.startTime) / 1000).toFixed(1)}s`,
+            filesModified: trace.metadata.filesModified.length,
+            hasErrors: trace.metadata.errorsEncountered.length > 0,
+            compressed: !!trace.compressed,
+        }));
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Found ${formattedTraces.length} traces:\n\n${formattedTraces
+                        .map((t) => `[${t.type}] Score: ${t.score} | Tools: ${t.toolCount} | Duration: ${t.duration}\n  ${t.summary}`)
+                        .join('\n\n')}`,
+                },
+            ],
+        };
+    }
+    async handleGetTraceStatistics(args) {
+        this.traceDetector.flush();
+        const stats = this.traceDetector.getStatistics();
+        const typeBreakdown = Object.entries(stats.tracesByType)
+            .map(([type, count]) => `  ${type}: ${count}`)
+            .join('\n');
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `**Trace Statistics**\n\nTotal Traces: ${stats.totalTraces}
+Average Score: ${stats.averageScore.toFixed(2)}
+Average Length: ${stats.averageLength.toFixed(1)} tools
+High Importance (>0.7): ${stats.highImportanceCount}
+Compressed: ${stats.compressedCount}
+
+**Trace Types:**
+${typeBreakdown}`,
+                },
+            ],
+        };
+    }
+    async handleFlushTraces(args) {
+        this.traceDetector.flush();
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: 'Pending traces have been flushed and finalized.',
+                },
+            ],
+        };
+    }
+    async handleCompressOldTraces(args) {
+        const { ageHours = 24 } = args;
+        const compressedCount = this.traceDetector.compressOldTraces(ageHours);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Compressed ${compressedCount} traces older than ${ageHours} hours.`,
+                },
+            ],
+        };
+    }
+    async handleSmartContext(args) {
+        const { query, tokenBudget = 4000, forceRefresh = false } = args;
+        try {
+            const result = await this.contextRetrieval.retrieveContext(query, {
+                tokenBudget,
+                forceRefresh,
+            });
+            // Log the retrieval
+            const currentFrameId = this.frameManager.getCurrentFrameId();
+            if (currentFrameId) {
+                this.frameManager.addEvent('observation', {
+                    action: 'smart_context',
+                    query,
+                    framesRetrieved: result.frames.length,
+                    tokenUsage: result.tokenUsage,
+                    confidence: result.analysis.confidenceScore,
+                });
+            }
+            // Build response with metadata
+            let response = result.context;
+            response += `\n\n---\n📊 **Retrieval Stats**\n`;
+            response += `- Frames included: ${result.frames.length}\n`;
+            response += `- Tokens used: ${result.tokenUsage.used}/${result.tokenUsage.budget}\n`;
+            response += `- Confidence: ${(result.analysis.confidenceScore * 100).toFixed(0)}%\n`;
+            response += `- Time: ${result.metadata.retrievalTimeMs}ms`;
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: response,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `❌ Context retrieval failed: ${error.message}`,
+                    },
+                ],
+            };
+        }
+    }
+    async handleGetSummary(args) {
+        const { forceRefresh = false } = args;
+        try {
+            const summary = this.contextRetrieval.getSummary(forceRefresh);
+            // Format the summary for display
+            let response = '📋 **Compressed Memory Summary**\n\n';
+            // Recent session
+            response += '## Recent Session\n';
+            response += `- Frames: ${summary.recentSession.frames.length}\n`;
+            response += `- Time range: ${new Date(summary.recentSession.timeRange.start).toLocaleString()} - ${new Date(summary.recentSession.timeRange.end).toLocaleString()}\n`;
+            if (summary.recentSession.dominantOperations.length > 0) {
+                response += `- Dominant ops: ${summary.recentSession.dominantOperations
+                    .slice(0, 5)
+                    .map((o) => `${o.operation}(${o.count})`)
+                    .join(', ')}\n`;
+            }
+            if (summary.recentSession.filesTouched.length > 0) {
+                response += `- Files touched: ${summary.recentSession.filesTouched
+                    .slice(0, 5)
+                    .map((f) => f.path)
+                    .join(', ')}\n`;
+            }
+            if (summary.recentSession.errorsEncountered.length > 0) {
+                response += `- Errors: ${summary.recentSession.errorsEncountered.length}\n`;
+            }
+            // Historical patterns
+            response += '\n## Historical Patterns\n';
+            response += `- Topic counts: ${Object.keys(summary.historicalPatterns.topicFrameCounts).length} topics\n`;
+            if (summary.historicalPatterns.keyDecisions.length > 0) {
+                response += `\n### Key Decisions (${summary.historicalPatterns.keyDecisions.length})\n`;
+                summary.historicalPatterns.keyDecisions.slice(0, 5).forEach((d) => {
+                    response += `- ${d.text.substring(0, 80)}${d.text.length > 80 ? '...' : ''}\n`;
+                });
+            }
+            if (summary.historicalPatterns.recurringIssues.length > 0) {
+                response += `\n### Recurring Issues (${summary.historicalPatterns.recurringIssues.length})\n`;
+                summary.historicalPatterns.recurringIssues.slice(0, 3).forEach((i) => {
+                    response += `- ${i.issueType} (${i.occurrenceCount} times)\n`;
+                });
+            }
+            // Queryable indices
+            response += '\n## Available Indices\n';
+            response += `- By time: ${Object.keys(summary.queryableIndices.byTimeframe).length} periods\n`;
+            response += `- By file: ${Object.keys(summary.queryableIndices.byFile).length} files\n`;
+            response += `- By topic: ${Object.keys(summary.queryableIndices.byTopic).length} topics\n`;
+            response += `- By error: ${Object.keys(summary.queryableIndices.byErrorType).length} error types\n`;
+            // Stats
+            response += `\n## Stats\n`;
+            response += `- Total frames: ${summary.stats.totalFrames}\n`;
+            response += `- Total anchors: ${summary.stats.totalAnchors}\n`;
+            response += `- Total events: ${summary.stats.totalEvents}\n`;
+            response += `- Generated: ${new Date(summary.generatedAt).toLocaleString()}`;
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: response,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `❌ Failed to get summary: ${error.message}`,
+                    },
+                ],
+            };
+        }
+    }
     async start() {
         const transport = new StdioServerTransport();
         await this.server.connect(transport);