@stackmemoryai/stackmemory 0.3.16 → 0.3.18

package/scripts/background-sync-manager.js

@@ -0,0 +1,416 @@
+#!/usr/bin/env node
+
+/**
+ * StackMemory Background Sync Manager
+ * Handles all background synchronization tasks:
+ * - Linear task sync
+ * - Frame and context backup
+ * - Cross-session sync
+ * - Cloud backup (S3/GCS)
+ * - Redis cache sync
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import dotenv from 'dotenv';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// Load environment variables from .env file (check .env first as per user preference)
+dotenv.config({ 
+  path: path.join(__dirname, '..', '.env'),
+  override: true,
+  silent: true
+});
+
+// Sync intervals (in milliseconds)
+const SYNC_INTERVALS = {
+  linear: 60 * 60 * 1000,        // 1 hour - Linear task sync
+  context: 15 * 60 * 1000,        // 15 minutes - Context and frame sync
+  backup: 4 * 60 * 60 * 1000,    // 4 hours - Cloud backup
+  redis: 5 * 60 * 1000,           // 5 minutes - Redis cache sync
+  crossSession: 10 * 60 * 1000,   // 10 minutes - Cross-session sync
+};
+
+class BackgroundSyncManager {
+  constructor() {
+    this.syncTasks = new Map();
+    this.stats = {
+      linear: { count: 0, lastSync: null, errors: 0 },
+      context: { count: 0, lastSync: null, errors: 0 },
+      backup: { count: 0, lastSync: null, errors: 0 },
+      redis: { count: 0, lastSync: null, errors: 0 },
+      crossSession: { count: 0, lastSync: null, errors: 0 }
+    };
+    this.logFile = path.join(__dirname, '..', '.stackmemory', 'sync-manager.log');
+    this.isRunning = false;
+  }
+
+  log(message, level = 'INFO') {
+    const timestamp = new Date().toISOString();
+    const logMessage = `[${timestamp}] [${level}] ${message}\n`;
+    
+    console.log(logMessage.trim());
+    
+    try {
+      fs.appendFileSync(this.logFile, logMessage);
+    } catch (error) {
+      console.error('Failed to write to log file:', error.message);
+    }
+  }
+
+  /**
+   * Sync Linear tasks
+   */
+  async syncLinear() {
+    if (!process.env.LINEAR_API_KEY) {
+      this.log('Linear sync skipped - no API key', 'WARN');
+      return;
+    }
+
+    this.log('Starting Linear sync...');
+    try {
+      const { stdout, stderr } = await execAsync(
+        `node ${path.join(__dirname, 'sync-linear-graphql.js')}`
+      );
+      
+      // Parse output for summary
+      const addedMatch = stdout.match(/Added to local: (\d+)/);
+      const added = addedMatch ? addedMatch[1] : '0';
+      
+      this.stats.linear.count++;
+      this.stats.linear.lastSync = new Date();
+      this.log(`Linear sync completed - added ${added} tasks`);
+    } catch (error) {
+      this.stats.linear.errors++;
+      this.log(`Linear sync failed: ${error.message}`, 'ERROR');
+    }
+  }
+
+  /**
+   * Sync context and frames
+   */
+  async syncContext() {
+    this.log('Starting context sync...');
+    try {
+      const homeDir = process.env.HOME;
+      const stackMemoryDir = path.join(homeDir, '.stackmemory');
+      
+      // Get all session directories
+      const sessionsDir = path.join(stackMemoryDir, 'sessions');
+      const sharedContextDir = path.join(stackMemoryDir, 'shared-context');
+      
+      // Count items to sync
+      let sessionCount = 0;
+      let contextCount = 0;
+      
+      if (fs.existsSync(sessionsDir)) {
+        sessionCount = fs.readdirSync(sessionsDir).length;
+      }
+      
+      if (fs.existsSync(sharedContextDir)) {
+        const projects = fs.readdirSync(path.join(sharedContextDir, 'projects')).filter(f => f.endsWith('.json'));
+        contextCount = projects.length;
+        
+        // Consolidate shared contexts
+        for (const projectFile of projects) {
+          const projectPath = path.join(sharedContextDir, 'projects', projectFile);
+          const data = JSON.parse(fs.readFileSync(projectPath, 'utf8'));
+          
+          // Remove old/stale entries (older than 30 days)
+          const thirtyDaysAgo = Date.now() - (30 * 24 * 60 * 60 * 1000);
+          if (data.contexts) {
+            data.contexts = data.contexts.filter(c => 
+              c.timestamp && c.timestamp > thirtyDaysAgo
+            );
+            fs.writeFileSync(projectPath, JSON.stringify(data, null, 2));
+          }
+        }
+      }
+      
+      this.stats.context.count++;
+      this.stats.context.lastSync = new Date();
+      this.log(`Context sync completed - ${sessionCount} sessions, ${contextCount} shared contexts`);
+    } catch (error) {
+      this.stats.context.errors++;
+      this.log(`Context sync failed: ${error.message}`, 'ERROR');
+    }
+  }
+
+  /**
+   * Backup to cloud storage (S3/GCS)
+   */
+  async syncBackup() {
+    this.log('Starting cloud backup...');
+    try {
+      const homeDir = process.env.HOME;
+      const stackMemoryDir = path.join(homeDir, '.stackmemory');
+      const backupDir = path.join(__dirname, '..', 'backups');
+      
+      // Create backup directory
+      if (!fs.existsSync(backupDir)) {
+        fs.mkdirSync(backupDir, { recursive: true });
+      }
+      
+      // Create timestamp for backup
+      const timestamp = new Date().toISOString().replace(/:/g, '-').split('.')[0];
+      const backupFile = path.join(backupDir, `stackmemory-backup-${timestamp}.tar.gz`);
+      
+      // Create tar archive of important data
+      const { stdout, stderr } = await execAsync(
+        `tar -czf ${backupFile} -C ${homeDir} .stackmemory/sessions .stackmemory/shared-context .stackmemory/projects.db 2>/dev/null || true`
+      );
+      
+      const stats = fs.statSync(backupFile);
+      const sizeMB = (stats.size / (1024 * 1024)).toFixed(2);
+      
+      // Upload to cloud if configured
+      if (process.env.AWS_S3_BUCKET) {
+        await execAsync(
+          `aws s3 cp ${backupFile} s3://${process.env.AWS_S3_BUCKET}/stackmemory-backups/ --storage-class GLACIER_IR`
+        );
+        this.log(`Backup uploaded to S3: ${sizeMB}MB`);
+      } else if (process.env.GCS_BUCKET) {
+        await execAsync(
+          `gsutil cp ${backupFile} gs://${process.env.GCS_BUCKET}/stackmemory-backups/`
+        );
+        this.log(`Backup uploaded to GCS: ${sizeMB}MB`);
+      } else {
+        this.log(`Local backup created: ${sizeMB}MB (no cloud storage configured)`);
+      }
+      
+      // Clean up old local backups (keep last 5)
+      const backups = fs.readdirSync(backupDir)
+        .filter(f => f.startsWith('stackmemory-backup-'))
+        .sort()
+        .reverse();
+      
+      for (let i = 5; i < backups.length; i++) {
+        fs.unlinkSync(path.join(backupDir, backups[i]));
+      }
+      
+      this.stats.backup.count++;
+      this.stats.backup.lastSync = new Date();
+      this.log(`Backup completed - ${sizeMB}MB`);
+    } catch (error) {
+      this.stats.backup.errors++;
+      this.log(`Backup failed: ${error.message}`, 'ERROR');
+    }
+  }
+
+  /**
+   * Sync with Redis cache
+   */
+  async syncRedis() {
+    if (!process.env.REDIS_URL) {
+      return; // Skip if Redis not configured
+    }
+
+    this.log('Starting Redis sync...');
+    try {
+      // Import Redis client dynamically
+      const { default: Redis } = await import('ioredis');
+      const redis = new Redis(process.env.REDIS_URL);
+      
+      // Sync recent frames to Redis for fast access
+      const homeDir = process.env.HOME;
+      const projectsDb = path.join(homeDir, '.stackmemory', 'projects.db');
+      
+      if (fs.existsSync(projectsDb)) {
+        // Get recent frames from SQLite
+        const { stdout } = await execAsync(
+          `sqlite3 ${projectsDb} "SELECT frame_id, title, created_at FROM frames WHERE created_at > datetime('now', '-7 days') ORDER BY created_at DESC LIMIT 100"`
+        );
+        
+        const frames = stdout.trim().split('\n').filter(Boolean);
+        
+        // Store in Redis with expiry
+        for (const frame of frames) {
+          const [id, title, created] = frame.split('|');
+          await redis.setex(
+            `frame:${id}`,
+            7 * 24 * 60 * 60, // 7 days TTL
+            JSON.stringify({ id, title, created })
+          );
+        }
+        
+        this.log(`Redis sync completed - ${frames.length} frames cached`);
+      }
+      
+      await redis.quit();
+      
+      this.stats.redis.count++;
+      this.stats.redis.lastSync = new Date();
+    } catch (error) {
+      this.stats.redis.errors++;
+      this.log(`Redis sync failed: ${error.message}`, 'ERROR');
+    }
+  }
+
+  /**
+   * Sync across sessions
+   */
+  async syncCrossSession() {
+    this.log('Starting cross-session sync...');
+    try {
+      const homeDir = process.env.HOME;
+      const sharedContextDir = path.join(homeDir, '.stackmemory', 'shared-context');
+      const projectsDir = path.join(sharedContextDir, 'projects');
+      
+      if (!fs.existsSync(projectsDir)) {
+        fs.mkdirSync(projectsDir, { recursive: true });
+      }
+      
+      // Get current project
+      const projectName = path.basename(process.cwd());
+      const projectFile = path.join(projectsDir, `${projectName}.json`);
+      
+      let projectData = { 
+        name: projectName, 
+        sessions: [],
+        lastSync: null,
+        contexts: []
+      };
+      
+      if (fs.existsSync(projectFile)) {
+        projectData = JSON.parse(fs.readFileSync(projectFile, 'utf8'));
+      }
+      
+      // Update sync timestamp
+      projectData.lastSync = new Date().toISOString();
+      
+      // Add current session info
+      const sessionId = process.env.STACKMEMORY_SESSION_ID || 'unknown';
+      const existingSession = projectData.sessions.find(s => s.id === sessionId);
+      
+      if (existingSession) {
+        existingSession.lastActive = new Date().toISOString();
+      } else {
+        projectData.sessions.push({
+          id: sessionId,
+          startTime: new Date().toISOString(),
+          lastActive: new Date().toISOString()
+        });
+      }
+      
+      // Keep only recent sessions (last 30 days)
+      const thirtyDaysAgo = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);
+      projectData.sessions = projectData.sessions.filter(s => 
+        new Date(s.lastActive) > thirtyDaysAgo
+      );
+      
+      fs.writeFileSync(projectFile, JSON.stringify(projectData, null, 2));
+      
+      this.stats.crossSession.count++;
+      this.stats.crossSession.lastSync = new Date();
+      this.log(`Cross-session sync completed - ${projectData.sessions.length} active sessions`);
+    } catch (error) {
+      this.stats.crossSession.errors++;
+      this.log(`Cross-session sync failed: ${error.message}`, 'ERROR');
+    }
+  }
+
+  /**
+   * Run all sync tasks
+   */
+  async runSync(taskName) {
+    switch (taskName) {
+      case 'linear':
+        await this.syncLinear();
+        break;
+      case 'context':
+        await this.syncContext();
+        break;
+      case 'backup':
+        await this.syncBackup();
+        break;
+      case 'redis':
+        await this.syncRedis();
+        break;
+      case 'crossSession':
+        await this.syncCrossSession();
+        break;
+    }
+  }
+
+  /**
+   * Start the sync manager
+   */
+  async start() {
+    if (this.isRunning) {
+      this.log('Sync manager already running', 'WARN');
+      return;
+    }
+
+    this.isRunning = true;
+    this.log('🚀 StackMemory Background Sync Manager starting...');
+    this.log(`📅 Sync intervals:`);
+    this.log(`  Linear: every ${SYNC_INTERVALS.linear / 60000} minutes`);
+    this.log(`  Context: every ${SYNC_INTERVALS.context / 60000} minutes`);
+    this.log(`  Backup: every ${SYNC_INTERVALS.backup / 3600000} hours`);
+    this.log(`  Redis: every ${SYNC_INTERVALS.redis / 60000} minutes`);
+    this.log(`  Cross-session: every ${SYNC_INTERVALS.crossSession / 60000} minutes`);
+    
+    // Run initial sync for all tasks
+    await this.syncLinear();
+    await this.syncContext();
+    await this.syncCrossSession();
+    
+    // Schedule recurring syncs
+    this.syncTasks.set('linear', setInterval(() => this.runSync('linear'), SYNC_INTERVALS.linear));
+    this.syncTasks.set('context', setInterval(() => this.runSync('context'), SYNC_INTERVALS.context));
+    this.syncTasks.set('backup', setInterval(() => this.runSync('backup'), SYNC_INTERVALS.backup));
+    this.syncTasks.set('redis', setInterval(() => this.runSync('redis'), SYNC_INTERVALS.redis));
+    this.syncTasks.set('crossSession', setInterval(() => this.runSync('crossSession'), SYNC_INTERVALS.crossSession));
+    
+    this.log('⏰ All sync tasks scheduled');
+    
+    // Handle graceful shutdown
+    process.on('SIGINT', () => this.stop());
+    process.on('SIGTERM', () => this.stop());
+  }
+
+  /**
+   * Stop the sync manager
+   */
+  stop() {
+    this.log('🛑 Stopping Background Sync Manager...');
+    
+    // Clear all intervals
+    for (const [name, interval] of this.syncTasks) {
+      clearInterval(interval);
+    }
+    this.syncTasks.clear();
+    
+    // Log final stats
+    this.log('📊 Final statistics:');
+    for (const [name, stats] of Object.entries(this.stats)) {
+      if (stats.count > 0) {
+        this.log(`  ${name}: ${stats.count} syncs, ${stats.errors} errors`);
+      }
+    }
+    
+    this.isRunning = false;
+    this.log('👋 Sync manager stopped');
+    process.exit(0);
+  }
+
+  /**
+   * Get status
+   */
+  getStatus() {
+    return {
+      running: this.isRunning,
+      stats: this.stats,
+      tasks: Array.from(this.syncTasks.keys())
+    };
+  }
+}
+
+// Start the manager
+const manager = new BackgroundSyncManager();
+manager.start();

package/scripts/benchmark-performance.ts

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+/**
+ * Run performance benchmarks
+ */
+
+import Database from 'better-sqlite3';
+import { join } from 'path';
+import { existsSync } from 'fs';
+import { PerformanceBenchmark } from '../src/core/performance/performance-benchmark.js';
+import { logger } from '../src/core/monitoring/logger.js';
+
+async function runBenchmarks() {
+  const projectRoot = process.cwd();
+  const dbPath = join(projectRoot, '.stackmemory', 'context.db');
+
+  if (!existsSync(dbPath)) {
+    console.error(
+      '❌ StackMemory not initialized. Run "stackmemory init" first.'
+    );
+    process.exit(1);
+  }
+
+  const db = new Database(dbPath, { readonly: false });
+  const projectId = 'benchmark-test';
+
+  console.log('🚀 Starting Performance Benchmarks...\n');
+
+  const benchmark = new PerformanceBenchmark();
+
+  try {
+    const suite = await benchmark.runFullSuite(projectRoot, db, projectId);
+
+    console.log('\n✅ Benchmarks completed successfully!');
+
+    // Summary
+    if (suite.averageImprovement > 0) {
+      console.log(
+        `\n🎉 Overall performance improved by ${suite.averageImprovement.toFixed(1)}%`
+      );
+    }
+
+    process.exit(0);
+  } catch (error: unknown) {
+    console.error('\n❌ Benchmark failed:', error);
+    logger.error('Benchmark error', error as Error);
+    process.exit(1);
+  } finally {
+    db.close();
+  }
+}
+
+// Run if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  runBenchmarks().catch(console.error);
+}
+
+export { runBenchmarks };

package/scripts/check-redis.ts

@@ -0,0 +1,48 @@
+#!/usr/bin/env tsx
+
+import { createClient } from 'redis';
+import dotenv from 'dotenv';
+// Type-safe environment variable access
+function getEnv(key: string, defaultValue?: string): string {
+  const value = process.env[key];
+  if (value === undefined) {
+    if (defaultValue !== undefined) return defaultValue;
+    throw new Error(`Environment variable ${key} is required`);
+  }
+  return value;
+}
+
+function getOptionalEnv(key: string): string | undefined {
+  return process.env[key];
+}
+
+dotenv.config();
+
+async function checkRedis() {
+  const client = createClient({ url: process.env['REDIS_URL'] });
+  await client.connect();
+
+  const keys = await client.keys('trace:*');
+  console.log('Redis trace keys:', keys.length);
+
+  if (keys.length > 0) {
+    console.log('Sample keys:', keys.slice(0, 3));
+    // Using hGetAll since we store as hash
+    const sample = await client.hGetAll(keys[0]);
+    console.log('Sample trace fields:', Object.keys(sample));
+    console.log('Sample trace data size:', sample.data?.length || 0, 'bytes');
+    console.log(
+      'Sample trace compressed:',
+      sample.compressed === 'true' ? 'yes' : 'no'
+    );
+  }
+
+  const scoreIndex = await client.zCard('traces:by_score');
+  const timeIndex = await client.zCard('traces:by_time');
+  console.log('Score index entries:', scoreIndex);
+  console.log('Time index entries:', timeIndex);
+
+  await client.quit();
+}
+
+checkRedis().catch(console.error);

package/scripts/chromadb-auto-loader.sh

@@ -0,0 +1,128 @@
+#!/bin/bash
+
+# ChromaDB Auto-Loader for Claude
+# Automatically loads context from ChromaDB every 15 minutes
+# and when Claude starts a new session
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_DIR="$(dirname "$SCRIPT_DIR")"
+LOG_DIR="$HOME/.stackmemory/logs"
+PID_FILE="$HOME/.stackmemory/chromadb-loader.pid"
+
+# Create log directory
+mkdir -p "$LOG_DIR"
+
+# Function to load context
+load_context() {
+    echo "[$(date)] Loading context from ChromaDB..."
+    
+    # Load recent context
+    cd "$PROJECT_DIR"
+    node scripts/chromadb-context-loader.js load 1 >> "$LOG_DIR/chromadb-loader.log" 2>&1
+    
+    # Track changes
+    node scripts/chromadb-context-loader.js changes >> "$LOG_DIR/chromadb-loader.log" 2>&1
+    
+    # Sync with StackMemory
+    node scripts/chromadb-context-loader.js sync >> "$LOG_DIR/chromadb-loader.log" 2>&1
+    
+    echo "[$(date)] Context loaded successfully"
+}
+
+# Function to start the loader daemon
+start_daemon() {
+    # Check if already running
+    if [ -f "$PID_FILE" ]; then
+        OLD_PID=$(cat "$PID_FILE")
+        if kill -0 "$OLD_PID" 2>/dev/null; then
+            echo "ChromaDB loader already running (PID: $OLD_PID)"
+            exit 0
+        fi
+    fi
+    
+    echo "Starting ChromaDB auto-loader daemon..."
+    
+    # Initial load
+    load_context
+    
+    # Start background loop
+    (
+        while true; do
+            # Wait 15 minutes
+            sleep 900
+            
+            # Load context
+            load_context
+        done
+    ) &
+    
+    # Save PID
+    echo $! > "$PID_FILE"
+    echo "ChromaDB auto-loader started (PID: $!)"
+}
+
+# Function to stop the daemon
+stop_daemon() {
+    if [ -f "$PID_FILE" ]; then
+        PID=$(cat "$PID_FILE")
+        if kill "$PID" 2>/dev/null; then
+            echo "ChromaDB auto-loader stopped"
+            rm -f "$PID_FILE"
+        else
+            echo "ChromaDB auto-loader not running"
+            rm -f "$PID_FILE"
+        fi
+    else
+        echo "ChromaDB auto-loader not running"
+    fi
+}
+
+# Function to check status
+check_status() {
+    if [ -f "$PID_FILE" ]; then
+        PID=$(cat "$PID_FILE")
+        if kill -0 "$PID" 2>/dev/null; then
+            echo "✅ ChromaDB auto-loader running (PID: $PID)"
+            echo ""
+            echo "Recent activity:"
+            tail -5 "$LOG_DIR/chromadb-loader.log" 2>/dev/null
+        else
+            echo "❌ ChromaDB auto-loader not running (stale PID file)"
+            rm -f "$PID_FILE"
+        fi
+    else
+        echo "❌ ChromaDB auto-loader not running"
+    fi
+}
+
+# Handle commands
+case "$1" in
+    start)
+        start_daemon
+        ;;
+    stop)
+        stop_daemon
+        ;;
+    status)
+        check_status
+        ;;
+    load)
+        # Manual load
+        load_context
+        ;;
+    restart)
+        stop_daemon
+        sleep 1
+        start_daemon
+        ;;
+    *)
+        echo "Usage: $0 {start|stop|status|load|restart}"
+        echo ""
+        echo "  start   - Start auto-loader daemon (loads every 15 min)"
+        echo "  stop    - Stop auto-loader daemon"
+        echo "  status  - Check daemon status"
+        echo "  load    - Manually load context now"
+        echo "  restart - Restart daemon"
+        exit 1
+        ;;
+esac