@stackmemoryai/stackmemory 0.3.21 → 0.3.24

package/scripts/swarm-monitor.js

@@ -0,0 +1,509 @@
+#!/usr/bin/env node
+
+/**
+ * Real-time Swarm Monitoring Utility
+ * Provides live monitoring and metrics for running swarms
+ */
+
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { createServer } from 'http';
+import { WebSocketServer } from 'ws';
+import blessed from 'blessed';
+
+class SwarmMonitor {
+  constructor() {
+    this.swarmDir = '.swarm';
+    this.statusDir = path.join(this.swarmDir, 'status');
+    this.logsDir = path.join(this.swarmDir, 'logs');
+    this.metricsHistory = [];
+    this.maxHistorySize = 100;
+    this.updateInterval = 2000; // 2 seconds
+    this.wsPort = 3456;
+  }
+
+  async startMonitoring() {
+    console.log('🔍 Starting Swarm Monitor...');
+    
+    // Check if we should use terminal UI or web interface
+    const mode = process.argv[2] || 'terminal';
+    
+    if (mode === 'web') {
+      await this.startWebMonitor();
+    } else {
+      await this.startTerminalMonitor();
+    }
+  }
+
+  async startTerminalMonitor() {
+    // Create blessed screen
+    const screen = blessed.screen({
+      smartCSR: true,
+      title: 'Ralph Swarm Monitor'
+    });
+
+    // Create layout boxes
+    const header = blessed.box({
+      parent: screen,
+      top: 0,
+      left: 0,
+      width: '100%',
+      height: 3,
+      content: ' RALPH SWARM MONITOR ',
+      align: 'center',
+      style: {
+        fg: 'white',
+        bg: 'blue',
+        bold: true
+      }
+    });
+
+    const swarmList = blessed.list({
+      parent: screen,
+      top: 3,
+      left: 0,
+      width: '50%',
+      height: '40%',
+      label: ' Active Swarms ',
+      border: {
+        type: 'line'
+      },
+      style: {
+        fg: 'white',
+        border: {
+          fg: 'cyan'
+        },
+        selected: {
+          bg: 'blue'
+        }
+      },
+      mouse: true,
+      keys: true,
+      vi: true
+    });
+
+    const metricsBox = blessed.box({
+      parent: screen,
+      top: 3,
+      left: '50%',
+      width: '50%',
+      height: '40%',
+      label: ' Performance Metrics ',
+      border: {
+        type: 'line'
+      },
+      style: {
+        fg: 'white',
+        border: {
+          fg: 'yellow'
+        }
+      }
+    });
+
+    const logBox = blessed.log({
+      parent: screen,
+      bottom: 3,
+      left: 0,
+      width: '100%',
+      height: '55%',
+      label: ' Live Logs ',
+      border: {
+        type: 'line'
+      },
+      style: {
+        fg: 'white',
+        border: {
+          fg: 'green'
+        }
+      },
+      scrollable: true,
+      alwaysScroll: true,
+      mouse: true
+    });
+
+    const statusBar = blessed.box({
+      parent: screen,
+      bottom: 0,
+      left: 0,
+      width: '100%',
+      height: 3,
+      style: {
+        fg: 'white',
+        bg: 'black'
+      }
+    });
+
+    // Handle exit
+    screen.key(['q', 'C-c'], () => {
+      return process.exit(0);
+    });
+
+    // Update function
+    const updateDisplay = async () => {
+      try {
+        // Get swarm status
+        const swarms = await this.getActiveSwarms();
+        
+        // Update swarm list
+        const swarmItems = swarms.map(s => {
+          const status = s.status === 'running' ? '🟢' : '🔴';
+          return `${status} ${s.id} - ${s.project}`;
+        });
+        swarmList.setItems(swarmItems);
+
+        // Update metrics
+        const metrics = await this.collectMetrics(swarms);
+        const metricsContent = this.formatMetrics(metrics);
+        metricsBox.setContent(metricsContent);
+
+        // Update status bar
+        const now = new Date().toLocaleTimeString();
+        statusBar.setContent(
+          ` Active: ${swarms.filter(s => s.status === 'running').length} | ` +
+          `Total: ${swarms.length} | ` +
+          `Updated: ${now} | ` +
+          `Press 'q' to quit`
+        );
+
+        screen.render();
+      } catch (error) {
+        logBox.log(`Error: ${error.message}`);
+      }
+    };
+
+    // Handle swarm selection
+    swarmList.on('select', async (item, index) => {
+      const swarms = await this.getActiveSwarms();
+      if (swarms[index]) {
+        await this.tailSwarmLogs(swarms[index], logBox);
+      }
+    });
+
+    // Start update loop
+    await updateDisplay();
+    setInterval(updateDisplay, this.updateInterval);
+
+    screen.render();
+  }
+
+  async startWebMonitor() {
+    // Create HTTP server for web interface
+    const server = createServer((req, res) => {
+      if (req.url === '/') {
+        res.writeHead(200, { 'Content-Type': 'text/html' });
+        res.end(this.getWebInterface());
+      } else if (req.url === '/api/swarms') {
+        this.handleApiRequest(res);
+      } else {
+        res.writeHead(404);
+        res.end('Not Found');
+      }
+    });
+
+    // Create WebSocket server for real-time updates
+    const wss = new WebSocketServer({ server });
+
+    wss.on('connection', (ws) => {
+      console.log('Client connected to monitor');
+      
+      // Send initial data
+      this.sendSwarmUpdate(ws);
+
+      // Set up periodic updates
+      const updateInterval = setInterval(() => {
+        this.sendSwarmUpdate(ws);
+      }, this.updateInterval);
+
+      ws.on('close', () => {
+        clearInterval(updateInterval);
+        console.log('Client disconnected from monitor');
+      });
+    });
+
+    server.listen(this.wsPort, () => {
+      console.log(`📡 Web monitor running at http://localhost:${this.wsPort}`);
+      console.log('Open in browser to view real-time swarm status');
+    });
+  }
+
+  async getActiveSwarms() {
+    const swarms = [];
+    
+    try {
+      const files = await fs.readdir(this.statusDir);
+      
+      for (const file of files) {
+        if (file.endsWith('.json')) {
+          const filePath = path.join(this.statusDir, file);
+          const content = await fs.readFile(filePath, 'utf-8');
+          const swarm = JSON.parse(content);
+          
+          // Check if process is still running
+          if (swarm.pid) {
+            try {
+              process.kill(swarm.pid, 0);
+              swarm.status = 'running';
+            } catch {
+              swarm.status = 'stopped';
+            }
+          }
+          
+          swarms.push(swarm);
+        }
+      }
+    } catch (error) {
+      // Directory might not exist
+    }
+    
+    return swarms;
+  }
+
+  async collectMetrics(swarms) {
+    const metrics = {
+      timestamp: Date.now(),
+      activeSwarms: swarms.filter(s => s.status === 'running').length,
+      totalSwarms: swarms.length,
+      agentCount: 0,
+      taskCompletion: 0,
+      memoryUsage: process.memoryUsage(),
+      cpuUsage: process.cpuUsage()
+    };
+
+    // Count total agents
+    for (const swarm of swarms) {
+      if (swarm.agents) {
+        metrics.agentCount += swarm.agents.split(',').length;
+      }
+    }
+
+    // Calculate average task completion (mock for now)
+    metrics.taskCompletion = Math.round(Math.random() * 100);
+
+    // Store in history
+    this.metricsHistory.push(metrics);
+    if (this.metricsHistory.length > this.maxHistorySize) {
+      this.metricsHistory.shift();
+    }
+
+    return metrics;
+  }
+
+  formatMetrics(metrics) {
+    const memoryMB = (metrics.memoryUsage.heapUsed / 1024 / 1024).toFixed(2);
+    
+    return `
+ Active Swarms: ${metrics.activeSwarms}/${metrics.totalSwarms}
+ Total Agents: ${metrics.agentCount}
+ Task Completion: ${metrics.taskCompletion}%
+ 
+ Memory Usage: ${memoryMB} MB
+ CPU Time: ${metrics.cpuUsage.user / 1000}ms
+ 
+ Performance Trend:
+ ${this.getPerformanceTrend()}
+    `;
+  }
+
+  getPerformanceTrend() {
+    if (this.metricsHistory.length < 2) return 'Collecting data...';
+    
+    const recent = this.metricsHistory.slice(-10);
+    let trend = '';
+    
+    for (let i = 0; i < recent.length; i++) {
+      const value = recent[i].taskCompletion;
+      if (value > 80) trend += '█';
+      else if (value > 60) trend += '▓';
+      else if (value > 40) trend += '▒';
+      else if (value > 20) trend += '░';
+      else trend += ' ';
+    }
+    
+    return trend;
+  }
+
+  async tailSwarmLogs(swarm, logBox) {
+    const logFile = swarm.logFile || path.join(this.logsDir, `${swarm.id}.log`);
+    
+    try {
+      const content = await fs.readFile(logFile, 'utf-8');
+      const lines = content.split('\n');
+      const recentLines = lines.slice(-20);
+      
+      logBox.log(`\n=== Logs for ${swarm.id} ===`);
+      recentLines.forEach(line => {
+        if (line.trim()) {
+          logBox.log(line);
+        }
+      });
+    } catch (error) {
+      logBox.log(`Could not read logs for ${swarm.id}: ${error.message}`);
+    }
+  }
+
+  async sendSwarmUpdate(ws) {
+    try {
+      const swarms = await this.getActiveSwarms();
+      const metrics = await this.collectMetrics(swarms);
+      
+      ws.send(JSON.stringify({
+        type: 'update',
+        swarms,
+        metrics,
+        history: this.metricsHistory.slice(-20)
+      }));
+    } catch (error) {
+      console.error('Failed to send update:', error);
+    }
+  }
+
+  async handleApiRequest(res) {
+    try {
+      const swarms = await this.getActiveSwarms();
+      const metrics = await this.collectMetrics(swarms);
+      
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ swarms, metrics }));
+    } catch (error) {
+      res.writeHead(500);
+      res.end(JSON.stringify({ error: error.message }));
+    }
+  }
+
+  getWebInterface() {
+    return `
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Ralph Swarm Monitor</title>
+  <style>
+    body {
+      font-family: 'Monaco', 'Menlo', monospace;
+      background: #1e1e1e;
+      color: #d4d4d4;
+      margin: 0;
+      padding: 20px;
+    }
+    h1 {
+      color: #569cd6;
+      text-align: center;
+    }
+    .container {
+      display: grid;
+      grid-template-columns: 1fr 1fr;
+      gap: 20px;
+      margin-top: 20px;
+    }
+    .panel {
+      background: #2d2d30;
+      border: 1px solid #3e3e42;
+      border-radius: 5px;
+      padding: 15px;
+    }
+    .panel h2 {
+      color: #4ec9b0;
+      margin-top: 0;
+    }
+    .swarm-item {
+      padding: 8px;
+      margin: 5px 0;
+      background: #1e1e1e;
+      border-radius: 3px;
+    }
+    .status-running {
+      border-left: 3px solid #4ec9b0;
+    }
+    .status-stopped {
+      border-left: 3px solid #f44747;
+    }
+    .metrics {
+      font-size: 14px;
+    }
+    .metric-label {
+      color: #9cdcfe;
+    }
+    .metric-value {
+      color: #d4d4d4;
+      font-weight: bold;
+    }
+    #logs {
+      background: #1e1e1e;
+      padding: 10px;
+      height: 200px;
+      overflow-y: auto;
+      font-size: 12px;
+      white-space: pre-wrap;
+    }
+  </style>
+</head>
+<body>
+  <h1>🚀 Ralph Swarm Monitor</h1>
+  
+  <div class="container">
+    <div class="panel">
+      <h2>Active Swarms</h2>
+      <div id="swarms"></div>
+    </div>
+    
+    <div class="panel">
+      <h2>Performance Metrics</h2>
+      <div id="metrics" class="metrics"></div>
+    </div>
+  </div>
+  
+  <div class="panel" style="margin-top: 20px;">
+    <h2>Live Logs</h2>
+    <div id="logs"></div>
+  </div>
+
+  <script>
+    const ws = new WebSocket('ws://localhost:${this.wsPort}');
+    
+    ws.onmessage = (event) => {
+      const data = JSON.parse(event.data);
+      updateDisplay(data);
+    };
+    
+    function updateDisplay(data) {
+      // Update swarms
+      const swarmsDiv = document.getElementById('swarms');
+      swarmsDiv.innerHTML = data.swarms.map(s => \`
+        <div class="swarm-item status-\${s.status}">
+          <strong>\${s.id}</strong><br>
+          Project: \${s.project}<br>
+          Agents: \${s.agents}<br>
+          Status: \${s.status}
+        </div>
+      \`).join('');
+      
+      // Update metrics
+      const metricsDiv = document.getElementById('metrics');
+      metricsDiv.innerHTML = \`
+        <p><span class="metric-label">Active Swarms:</span> <span class="metric-value">\${data.metrics.activeSwarms}/\${data.metrics.totalSwarms}</span></p>
+        <p><span class="metric-label">Total Agents:</span> <span class="metric-value">\${data.metrics.agentCount}</span></p>
+        <p><span class="metric-label">Task Completion:</span> <span class="metric-value">\${data.metrics.taskCompletion}%</span></p>
+        <p><span class="metric-label">Memory Usage:</span> <span class="metric-value">\${(data.metrics.memoryUsage.heapUsed / 1024 / 1024).toFixed(2)} MB</span></p>
+      \`;
+      
+      // Update logs (mock for now)
+      const logsDiv = document.getElementById('logs');
+      if (Math.random() > 0.7) {
+        const logEntry = new Date().toLocaleTimeString() + ' - Swarm activity detected\\n';
+        logsDiv.textContent += logEntry;
+        logsDiv.scrollTop = logsDiv.scrollHeight;
+      }
+    }
+  </script>
+</body>
+</html>
+    `;
+  }
+}
+
+// Run monitor if executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const monitor = new SwarmMonitor();
+  monitor.startMonitoring().catch(console.error);
+}
+
+export { SwarmMonitor };

package/scripts/sync-and-clean-tasks.js

@@ -10,7 +10,7 @@ import path from 'path';
 import { fileURLToPath } from 'url';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const API_KEY = process.env.LINEAR_OAUTH_TOKEN || process.env.LINEAR_API_KEY;
+const API_KEY = process.env.LINEAR_OAUTH_TOKEN || process.env.STACKMEMORY_LINEAR_API_KEY || process.env.LINEAR_API_KEY;
 if (!API_KEY) {
   console.error('❌ LINEAR_OAUTH_TOKEN or LINEAR_API_KEY environment variable not set');
   console.log('Please set LINEAR_OAUTH_TOKEN or LINEAR_API_KEY in your .env file or export it in your shell');

package/scripts/sync-linear-graphql.js

@@ -16,14 +16,14 @@ dotenv.config({
 });
 
 // Debug: Check if key is loaded
-console.log(`API Key loaded: ${process.env.LINEAR_API_KEY ? 'Yes' : 'No'} (length: ${process.env.LINEAR_API_KEY?.length || 0})`);
+console.log(`API Key loaded: ${(process.env.STACKMEMORY_LINEAR_API_KEY || process.env.LINEAR_API_KEY) ? 'Yes' : 'No'} (length: ${(process.env.STACKMEMORY_LINEAR_API_KEY || process.env.LINEAR_API_KEY)?.length || 0})`);
 
 async function queryLinear(query, variables = {}) {
   const response = await fetch('https://api.linear.app/graphql', {
     method: 'POST',
     headers: {
       'Content-Type': 'application/json',
-      'Authorization': process.env.LINEAR_API_KEY
+      'Authorization': process.env.STACKMEMORY_LINEAR_API_KEY || process.env.LINEAR_API_KEY
     },
     body: JSON.stringify({ query, variables })
   });
@@ -36,7 +36,7 @@ async function queryLinear(query, variables = {}) {
 }
 
 async function syncLinearTasks() {
-  const apiKey = process.env.LINEAR_API_KEY;
+  const apiKey = process.env.STACKMEMORY_LINEAR_API_KEY || process.env.LINEAR_API_KEY;
   
   if (!apiKey) {
     console.error('❌ LINEAR_API_KEY not found in environment');

package/scripts/sync-linear-tasks.js

@@ -12,7 +12,7 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 dotenv.config({ path: path.join(__dirname, '..', '.env') });
 
 async function syncLinearTasks() {
-  const apiKey = process.env.LINEAR_API_KEY;
+  const apiKey = process.env.STACKMEMORY_LINEAR_API_KEY || process.env.LINEAR_API_KEY;
   
   if (!apiKey) {
     console.error('❌ LINEAR_API_KEY not found in environment');

package/scripts/test-code-execution.js

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+
+/**
+ * Test code execution MCP handler
+ */
+
+import { CodeExecutionHandler } from '../dist/integrations/mcp/handlers/code-execution-handlers.js';
+
+async function testPythonExecution() {
+  console.log('🐍 Testing Python Code Execution\n');
+  
+  const handler = new CodeExecutionHandler();
+  
+  // Test 1: Simple Python code
+  console.log('Test 1: Simple calculation');
+  const result1 = await handler.executeCode({
+    language: 'python',
+    code: `
+import math
+
+def calculate_circle_area(radius):
+    return math.pi * radius ** 2
+
+# Test the function
+radius = 5
+area = calculate_circle_area(radius)
+print(f"Circle with radius {radius} has area: {area:.2f}")
+
+# Generate some data
+data = [i**2 for i in range(10)]
+print(f"Squares: {data}")
+`,
+  });
+  
+  console.log('Success:', result1.success);
+  console.log('Output:', result1.stdout);
+  if (result1.stderr) console.log('Errors:', result1.stderr);
+  console.log('---\n');
+  
+  // Test 2: Code with warnings
+  console.log('Test 2: Code with security warnings');
+  const code2 = `
+import os
+import subprocess
+
+# This should trigger warnings
+print("Current directory:", os.getcwd())
+`;
+  
+  const validation = handler.validateCode(code2);
+  console.log('Validation result:', validation);
+  
+  if (!validation.safe) {
+    console.log('Executing anyway with force flag...');
+    const result2 = await handler.executeCode({
+      language: 'python',
+      code: code2,
+    });
+    console.log('Output:', result2.stdout);
+  }
+  console.log('---\n');
+  
+  // Test 3: JavaScript execution
+  console.log('Test 3: JavaScript code');
+  const result3 = await handler.executeCode({
+    language: 'javascript',
+    code: `
+// Calculate fibonacci
+function fibonacci(n) {
+  if (n <= 1) return n;
+  return fibonacci(n - 1) + fibonacci(n - 2);
+}
+
+for (let i = 0; i < 10; i++) {
+  console.log(\`fibonacci(\${i}) = \${fibonacci(i)}\`);
+}
+
+// Test async operation
+setTimeout(() => {
+  console.log('Async operation completed');
+}, 100);
+
+// Wait a bit for async
+new Promise(resolve => setTimeout(resolve, 200)).then(() => {
+  console.log('Promise resolved');
+});
+`,
+  });
+  
+  console.log('Success:', result3.success);
+  console.log('Output:', result3.stdout);
+  console.log('---\n');
+  
+  // Test 4: Long-running code with timeout
+  console.log('Test 4: Timeout test');
+  const result4 = await handler.executeCode({
+    language: 'python',
+    code: `
+import time
+print("Starting long operation...")
+time.sleep(5)  # This should timeout if timeout is < 5 seconds
+print("This should not print")
+`,
+    timeout: 2000, // 2 second timeout
+  });
+  
+  console.log('Success:', result4.success);
+  console.log('Output:', result4.stdout);
+  console.log('Errors:', result4.stderr);
+  console.log('---\n');
+  
+  // Test 5: Large output truncation
+  console.log('Test 5: Large output handling');
+  const result5 = await handler.executeCode({
+    language: 'python',
+    code: `
+# Generate large output
+for i in range(10000):
+    print(f"Line {i}: {'=' * 50}")
+`,
+  });
+  
+  console.log('Success:', result5.success);
+  console.log('Truncated:', result5.truncated);
+  if (result5.truncated) {
+    console.log('Output file:', result5.outputFile);
+  }
+  console.log('Output length:', result5.stdout.length);
+  console.log('---\n');
+  
+  // Get sandbox status
+  const status = await handler.getSandboxStatus();
+  console.log('📊 Sandbox Status:', status);
+  
+  // Clean sandbox
+  console.log('\n🧹 Cleaning sandbox...');
+  await handler.cleanSandbox();
+  const statusAfter = await handler.getSandboxStatus();
+  console.log('Sandbox after cleanup:', statusAfter);
+}
+
+// Run tests
+testPythonExecution().catch(console.error);