@stackmemoryai/stackmemory 0.8.1 → 1.0.0

package/scripts/testing/simple-effectiveness-test.js

@@ -1,310 +0,0 @@
-#!/usr/bin/env node
-
-import { spawn, execSync } from 'child_process';
-import fs from 'fs';
-import path from 'path';
-import { performance } from 'perf_hooks';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-// Colors for output
-const colors = {
-  green: '\x1b[32m',
-  yellow: '\x1b[33m',
-  red: '\x1b[31m',
-  reset: '\x1b[0m'
-};
-
-class SimpleEffectivenessTest {
-  constructor() {
-    this.results = {
-      withStackMemory: [],
-      withoutStackMemory: []
-    };
-    this.currentSessionId = null;
-  }
-
-  log(message, type = 'info') {
-    const prefix = {
-      success: `${colors.green}✓${colors.reset}`,
-      warning: `${colors.yellow}!${colors.reset}`,
-      error: `${colors.red}✗${colors.reset}`,
-      info: '→'
-    }[type] || '';
-    
-    console.log(`${prefix} ${message}`);
-  }
-
-  async checkStackMemory() {
-    try {
-      const version = execSync('stackmemory --version', { encoding: 'utf-8' }).trim();
-      this.log(`StackMemory found: ${version}`, 'success');
-      return true;
-    } catch (error) {
-      this.log('StackMemory not installed. Please run: npm install -g @stackmemoryai/stackmemory', 'error');
-      return false;
-    }
-  }
-
-  async measureContextRetrieval(withStackMemory = true) {
-    const start = performance.now();
-    
-    if (withStackMemory) {
-      try {
-        // Test actual context retrieval using status command
-        execSync('stackmemory context show', { encoding: 'utf-8' });
-        const duration = performance.now() - start;
-        this.log(`Context retrieved in ${(duration / 1000).toFixed(2)}s`, 'success');
-        return duration;
-      } catch (error) {
-        this.log('Context retrieval failed', 'warning');
-        return 30000; // Default to 30s if failed
-      }
-    } else {
-      // Simulate manual context reestablishment time
-      const simulatedTime = 300000; // 5 minutes
-      this.log(`Manual context reestablishment would take ~${(simulatedTime / 1000 / 60).toFixed(1)} minutes`, 'warning');
-      return simulatedTime;
-    }
-  }
-
-  async testScenario(name, withStackMemory = true) {
-    console.log('\n' + '='.repeat(60));
-    console.log(`Testing: ${name} (${withStackMemory ? 'WITH' : 'WITHOUT'} StackMemory)`);
-    console.log('='.repeat(60));
-
-    const sessionStart = Date.now();
-    const metrics = {
-      scenario: name,
-      withStackMemory,
-      contextTime: 0,
-      totalTime: 0,
-      frameCount: 0,
-      errors: 0
-    };
-
-    // Step 1: Context establishment
-    this.log('Step 1: Establishing context...');
-    metrics.contextTime = await this.measureContextRetrieval(withStackMemory);
-
-    // Step 2: Simulate work
-    this.log('Step 2: Simulating development work...');
-    if (withStackMemory) {
-      try {
-        // Push a context frame
-        execSync('stackmemory context push "test-task"', { encoding: 'utf-8' });
-        metrics.frameCount++;
-        this.log('Context frame pushed successfully', 'success');
-        
-        // Add a decision
-        execSync('stackmemory context add decision "Test decision: use TypeScript"', { encoding: 'utf-8' });
-        this.log('Decision added', 'success');
-        
-        // Add an observation
-        execSync('stackmemory context add observation "Code structure analyzed"', { encoding: 'utf-8' });
-        this.log('Observation recorded', 'success');
-        
-        // Pop frame
-        execSync('stackmemory context pop', { encoding: 'utf-8' });
-        this.log('Context frame popped', 'success');
-      } catch (error) {
-        metrics.errors++;
-        this.log(`Error during work simulation: ${error.message}`, 'error');
-      }
-    } else {
-      // Simulate work without StackMemory
-      this.log('Working without context persistence...', 'warning');
-      await this.sleep(2000); // Simulate work time
-    }
-
-    // Step 3: Simulate interruption and context recovery
-    this.log('Step 3: Simulating interruption...');
-    await this.sleep(1000);
-    
-    this.log('Step 4: Recovering from interruption...');
-    const recoveryTime = await this.measureContextRetrieval(withStackMemory);
-    
-    metrics.totalTime = Date.now() - sessionStart;
-    
-    // Store results
-    if (withStackMemory) {
-      this.results.withStackMemory.push(metrics);
-    } else {
-      this.results.withoutStackMemory.push(metrics);
-    }
-
-    // Summary
-    console.log('\nScenario Summary:');
-    console.log(`  Context Time: ${(metrics.contextTime / 1000).toFixed(2)}s`);
-    console.log(`  Total Time: ${(metrics.totalTime / 1000).toFixed(2)}s`);
-    console.log(`  Frames Created: ${metrics.frameCount}`);
-    console.log(`  Errors: ${metrics.errors}`);
-    
-    return metrics;
-  }
-
-  sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-  }
-
-  async runComparison() {
-    console.log('\n' + '='.repeat(60));
-    console.log('STACKMEMORY EFFECTIVENESS TEST');
-    console.log('='.repeat(60));
-
-    // Check if StackMemory is installed
-    const hasStackMemory = await this.checkStackMemory();
-    if (!hasStackMemory) {
-      process.exit(1);
-    }
-
-    // Test scenarios
-    const scenarios = [
-      'Feature Development',
-      'Bug Fix',
-      'Code Review'
-    ];
-
-    for (const scenario of scenarios) {
-      // Test WITHOUT StackMemory
-      await this.testScenario(scenario, false);
-      
-      // Test WITH StackMemory
-      await this.testScenario(scenario, true);
-    }
-
-    // Generate report
-    this.generateReport();
-  }
-
-  calculateImprovement(withMetrics, withoutMetrics) {
-    const avgWith = this.average(withMetrics, 'contextTime');
-    const avgWithout = this.average(withoutMetrics, 'contextTime');
-    
-    const improvement = ((avgWithout - avgWith) / avgWithout) * 100;
-    return improvement;
-  }
-
-  average(metrics, field) {
-    if (metrics.length === 0) return 0;
-    return metrics.reduce((sum, m) => sum + m[field], 0) / metrics.length;
-  }
-
-  generateReport() {
-    console.log('\n' + '='.repeat(60));
-    console.log('EFFECTIVENESS REPORT');
-    console.log('='.repeat(60));
-
-    const contextImprovement = this.calculateImprovement(
-      this.results.withStackMemory,
-      this.results.withoutStackMemory
-    );
-
-    console.log('\n📊 Results Summary:');
-    console.log('─'.repeat(40));
-    
-    // Context reestablishment comparison
-    const avgWithContext = this.average(this.results.withStackMemory, 'contextTime');
-    const avgWithoutContext = this.average(this.results.withoutStackMemory, 'contextTime');
-    
-    console.log('\nContext Reestablishment Time:');
-    console.log(`  Without StackMemory: ${(avgWithoutContext / 1000 / 60).toFixed(1)} minutes`);
-    console.log(`  With StackMemory: ${(avgWithContext / 1000).toFixed(1)}s`);
-    console.log(`  ${colors.green}Improvement: ${contextImprovement.toFixed(1)}%${colors.reset}`);
-    
-    // Total time comparison
-    const avgWithTotal = this.average(this.results.withStackMemory, 'totalTime');
-    const avgWithoutTotal = this.average(this.results.withoutStackMemory, 'totalTime');
-    const totalImprovement = ((avgWithoutTotal - avgWithTotal) / avgWithoutTotal) * 100;
-    
-    console.log('\nTotal Task Time:');
-    console.log(`  Without StackMemory: ${(avgWithoutTotal / 1000).toFixed(1)}s`);
-    console.log(`  With StackMemory: ${(avgWithTotal / 1000).toFixed(1)}s`);
-    console.log(`  ${colors.green}Improvement: ${totalImprovement.toFixed(1)}%${colors.reset}`);
-    
-    // Frame management
-    const totalFrames = this.results.withStackMemory.reduce((sum, m) => sum + m.frameCount, 0);
-    console.log('\nFrame Management:');
-    console.log(`  Frames Created: ${totalFrames}`);
-    console.log(`  Average per scenario: ${(totalFrames / this.results.withStackMemory.length).toFixed(1)}`);
-    
-    // Success criteria evaluation
-    console.log('\n✅ Success Criteria Evaluation:');
-    console.log('─'.repeat(40));
-    
-    const criteria = [
-      {
-        name: 'Context Reestablishment <30s',
-        target: 30000,
-        actual: avgWithContext,
-        met: avgWithContext < 30000
-      },
-      {
-        name: 'Context Speed Improvement >90%',
-        target: 90,
-        actual: contextImprovement,
-        met: contextImprovement > 90
-      },
-      {
-        name: 'Total Time Improvement >30%',
-        target: 30,
-        actual: totalImprovement,
-        met: totalImprovement > 30
-      }
-    ];
-    
-    criteria.forEach(c => {
-      const status = c.met ? `${colors.green}✓ PASSED${colors.reset}` : `${colors.red}✗ FAILED${colors.reset}`;
-      console.log(`  ${c.name}: ${status}`);
-      if (c.name.includes('%')) {
-        console.log(`    Target: >${c.target}% | Actual: ${c.actual.toFixed(1)}%`);
-      } else {
-        console.log(`    Target: <${(c.target / 1000).toFixed(1)}s | Actual: ${(c.actual / 1000).toFixed(1)}s`);
-      }
-    });
-    
-    // Save report to file
-    const reportPath = path.join(process.cwd(), 'scripts', 'testing', 'results', 'simple-effectiveness-report.json');
-    const reportDir = path.dirname(reportPath);
-    
-    if (!fs.existsSync(reportDir)) {
-      fs.mkdirSync(reportDir, { recursive: true });
-    }
-    
-    const report = {
-      timestamp: new Date().toISOString(),
-      results: this.results,
-      summary: {
-        contextImprovement: contextImprovement.toFixed(1),
-        totalTimeImprovement: totalImprovement.toFixed(1),
-        avgContextTimeWith: avgWithContext,
-        avgContextTimeWithout: avgWithoutContext,
-        successCriteria: criteria
-      }
-    };
-    
-    fs.writeFileSync(reportPath, JSON.stringify(report, null, 2));
-    console.log(`\n📄 Full report saved to: ${reportPath}`);
-    
-    // Final verdict
-    console.log('\n' + '='.repeat(60));
-    const allCriteriaMet = criteria.every(c => c.met);
-    if (allCriteriaMet) {
-      console.log(`${colors.green}🎉 STACKMEMORY SIGNIFICANTLY IMPROVES CLAUDE SESSIONS${colors.reset}`);
-      console.log(`${colors.green}   All success criteria met!${colors.reset}`);
-    } else {
-      console.log(`${colors.yellow}⚠️  PARTIAL SUCCESS${colors.reset}`);
-      console.log(`${colors.yellow}   Some improvements detected, optimization needed${colors.reset}`);
-    }
-    console.log('='.repeat(60));
-  }
-}
-
-// Run the test
-const tester = new SimpleEffectivenessTest();
-tester.runComparison().catch(error => {
-  console.error('Test failed:', error);
-  process.exit(1);
-});

package/scripts/testing/test-tier-migration.js

@@ -1,100 +0,0 @@
-#!/usr/bin/env node
-import 'dotenv/config';
-import Database from 'better-sqlite3';
-import { RailwayOptimizedStorage } from './dist/core/storage/railway-optimized-storage.js';
-import { ConfigManager } from './dist/core/config/config-manager.js';
-import { v4 as uuidv4 } from 'uuid';
-
-async function testTierMigration() {
-  const db = new Database('.stackmemory/context.db');
-  const configManager = new ConfigManager();
-  
-  // Create storage with shorter tier durations for testing
-  const storage = new RailwayOptimizedStorage(db, configManager, {
-    tiers: {
-      hotHours: 0.001, // Very short for testing (3.6 seconds)
-      warmDays: 0.0001, // Very short for testing (8.64 seconds)
-      compressionScore: 0.5
-    }
-  });
-  
-  // Create a test trace
-  const traceId = `test_${uuidv4()}`;
-  const testTrace = {
-    id: traceId,
-    type: 'test',
-    score: 0.7,
-    summary: 'Test trace for tier migration',
-    metadata: {
-      startTime: Date.now() - 1000, // 1 second ago
-      endTime: Date.now(),
-      filesModified: ['test.js'],
-      errorsEncountered: [],
-      decisionsRecorded: [],
-      causalChain: []
-    },
-    tools: [
-      { tool: 'test', input: 'test input', output: 'test output' }
-    ],
-    compressed: false
-  };
-  
-  console.log('📝 Creating test trace:', testTrace.id);
-  
-  // First, insert the trace into the traces table to satisfy foreign key
-  db.prepare(`
-    INSERT INTO traces (id, type, score, summary, start_time, end_time, 
-                       files_modified, errors_encountered, decisions_recorded, 
-                       causal_chain, compressed_data, created_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `).run(
-    traceId,
-    'test',
-    0.7,
-    'Test trace for tier migration',
-    testTrace.metadata.startTime,
-    testTrace.metadata.endTime,
-    JSON.stringify(testTrace.metadata.filesModified),
-    JSON.stringify(testTrace.metadata.errorsEncountered),
-    JSON.stringify(testTrace.metadata.decisionsRecorded),
-    testTrace.metadata.causalChain.length,
-    JSON.stringify(testTrace),
-    Date.now()
-  );
-  
-  // Store the trace in storage tiers
-  const tier = await storage.storeTrace(testTrace);
-  console.log(`✅ Stored in ${tier} tier`);
-  
-  // Check storage location
-  const location = db.prepare('SELECT * FROM storage_tiers WHERE trace_id = ?').get(testTrace.id);
-  console.log('📍 Initial location:', location);
-  
-  // Wait a moment for the trace to age
-  console.log('⏳ Waiting 5 seconds for trace to age...');
-  await new Promise(resolve => setTimeout(resolve, 5000));
-  
-  // Trigger migration
-  console.log('🔄 Triggering migration...');
-  const results = await storage.migrateTiers();
-  console.log('Migration results:', results);
-  
-  // Check new location
-  const newLocation = db.prepare('SELECT * FROM storage_tiers WHERE trace_id = ?').get(testTrace.id);
-  console.log('📍 New location:', newLocation);
-  
-  // Try to retrieve the trace
-  console.log('🔍 Retrieving trace after migration...');
-  const retrieved = await storage.retrieveTrace(testTrace.id);
-  console.log('✅ Retrieved:', retrieved ? 'Success' : 'Failed');
-  
-  if (retrieved) {
-    console.log('  ID matches:', retrieved.id === testTrace.id);
-    console.log('  Summary matches:', retrieved.summary === testTrace.summary);
-  }
-  
-  db.close();
-  console.log('✨ Test complete!');
-}
-
-testTierMigration().catch(console.error);

package/scripts/update-linear-status.js

@@ -1,268 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Update Linear task status based on actual implementation status
- */
-
-import 'dotenv/config';
-
-const API_KEY = process.env.LINEAR_OAUTH_TOKEN || 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');
-  process.exit(1);
-}
-
-// Tasks that should be marked as DONE based on commits and documentation
-const COMPLETED_TASKS = {
-  // Phase 1: Core Runtime - COMPLETE
-  'STA-279': 'Implement LLM-Driven Context Retrieval', // Implemented in llm-context-retrieval.ts
-  
-  // Phase 2: Intelligence Layer - COMPLETE  
-  'STA-280': 'Complete Hybrid Digest Generation (60/40)', // Implemented in hybrid-digest-generator.ts
-  'STA-281': 'Implement Smart Trace Detection and Bundling', // Implemented in trace detection
-  'STA-282': 'Implement Configurable Tool Scoring System', // Implemented with weight profiles
-  
-  // Phase 3: Collaboration - COMPLETE
-  'STA-283': 'Implement Dual Stack Architecture', // Implemented in dual-stack-manager.ts
-  'STA-284': 'Build Frame Handoff Mechanism', // Implemented in frame-handoff-manager.ts (v0.3.4)
-  'STA-271': '[STA-99] Phase 3: Dual Stack Architecture', // Completed in commit 111e51b
-  'STA-275': '[STA-100] Phase 3: Frame Handoff Mechanism', // Completed in commit b21574c
-  'STA-285': 'Implement Merge Conflict Resolution', // Implemented in stack-merge-resolver.ts
-  'STA-286': 'Build Team Analytics', // Basic analytics implemented
-  
-  // Additional completed features
-  'STA-276': '[STA-91] Finalize Session Persistence Design', // Implemented and documented
-  'STA-277': '[STA-90] Complete Linear MCP Integration Documentation', // MCP integration complete
-  'STA-155': '[STA-89] Complete Context Frame Manager Tests', // Tests completed
-};
-
-// Tasks in progress
-const IN_PROGRESS_TASKS = {
-  'STA-287': 'Implement Remote Infinite Storage System', // Railway storage partially done
-  'STA-288': 'Build Incremental Garbage Collection', // Basic GC implemented, needs enhancement
-};
-
-// Tasks to cancel (duplicates or no longer needed)
-const CANCEL_TASKS = {
-  'STA-272': 'Engineering x Marketing Team', // Meeting task
-  'STA-273': 'Engineering x Operations Team', // Meeting task  
-  'STA-274': 'Engineering x Success Team', // Meeting task
-  'STA-268': 'Task Analytics Dashboard', // Duplicate/outdated
-  'STA-264': 'Complete Documentation TODOs', // Low priority cleanup
-};
-
-async function getStateId(stateName) {
-  const query = `
-    query GetStates {
-      workflowStates {
-        nodes {
-          id
-          name
-          type
-        }
-      }
-    }
-  `;
-  
-  const response = await fetch('https://api.linear.app/graphql', {
-    method: 'POST',
-    headers: {
-      'Authorization': `Bearer ${API_KEY}`,
-      'Content-Type': 'application/json'
-    },
-    body: JSON.stringify({ query })
-  });
-  
-  const result = await response.json();
-  const state = result.data.workflowStates.nodes.find(s => 
-    s.name.toLowerCase() === stateName.toLowerCase() ||
-    (stateName === 'Done' && s.type === 'completed') ||
-    (stateName === 'In Progress' && s.type === 'started') ||
-    (stateName === 'Canceled' && s.type === 'canceled')
-  );
-  
-  return state?.id;
-}
-
-async function updateTaskStatus(taskId, stateId, description = null) {
-  const mutation = `
-    mutation UpdateIssue($id: String!, $stateId: String!, $description: String) {
-      issueUpdate(
-        id: $id,
-        input: { 
-          stateId: $stateId
-          ${description ? ', description: $description' : ''}
-        }
-      ) {
-        success
-        issue {
-          identifier
-          title
-          state {
-            name
-          }
-        }
-      }
-    }
-  `;
-  
-  const variables = { id: taskId, stateId };
-  if (description) variables.description = description;
-  
-  const response = await fetch('https://api.linear.app/graphql', {
-    method: 'POST',
-    headers: {
-      'Authorization': `Bearer ${API_KEY}`,
-      'Content-Type': 'application/json'
-    },
-    body: JSON.stringify({ query: mutation, variables })
-  });
-  
-  return response.json();
-}
-
-async function getTaskByIdentifier(identifier) {
-  const query = `
-    query GetIssue($identifier: String!) {
-      issue(id: $identifier) {
-        id
-        identifier
-        title
-        state {
-          name
-          type
-        }
-        description
-      }
-    }
-  `;
-  
-  const response = await fetch('https://api.linear.app/graphql', {
-    method: 'POST',
-    headers: {
-      'Authorization': `Bearer ${API_KEY}`,
-      'Content-Type': 'application/json'
-    },
-    body: JSON.stringify({ 
-      query,
-      variables: { identifier }
-    })
-  });
-  
-  const result = await response.json();
-  return result.data?.issue;
-}
-
-async function updateLinearTasks() {
-  console.log('📊 Updating Linear task states based on actual implementation...\n');
-  
-  // Get state IDs
-  const doneStateId = await getStateId('Done');
-  const inProgressStateId = await getStateId('In Progress');
-  const canceledStateId = await getStateId('Canceled');
-  
-  if (!doneStateId || !inProgressStateId) {
-    console.error('❌ Could not find required workflow states');
-    return;
-  }
-  
-  let updated = 0;
-  let failed = 0;
-  
-  // Update completed tasks
-  console.log('✅ Marking completed tasks as Done:\n');
-  for (const [identifier, title] of Object.entries(COMPLETED_TASKS)) {
-    const task = await getTaskByIdentifier(identifier);
-    if (!task) {
-      console.log(`  ⚠️  ${identifier} not found`);
-      continue;
-    }
-    
-    if (task.state.type === 'completed') {
-      console.log(`  ✓ ${identifier} already Done`);
-      continue;
-    }
-    
-    const result = await updateTaskStatus(task.id, doneStateId);
-    if (result.data?.issueUpdate?.success) {
-      console.log(`  ✅ ${identifier}: ${title.substring(0, 40)}... → Done`);
-      updated++;
-    } else {
-      console.log(`  ❌ ${identifier}: Failed to update`);
-      failed++;
-    }
-    
-    // Small delay to avoid rate limits
-    await new Promise(r => setTimeout(r, 500));
-  }
-  
-  // Update in-progress tasks
-  console.log('\n🔄 Marking in-progress tasks:\n');
-  for (const [identifier, title] of Object.entries(IN_PROGRESS_TASKS)) {
-    const task = await getTaskByIdentifier(identifier);
-    if (!task) {
-      console.log(`  ⚠️  ${identifier} not found`);
-      continue;
-    }
-    
-    if (task.state.type === 'started') {
-      console.log(`  ✓ ${identifier} already In Progress`);
-      continue;
-    }
-    
-    const result = await updateTaskStatus(task.id, inProgressStateId);
-    if (result.data?.issueUpdate?.success) {
-      console.log(`  🔄 ${identifier}: ${title.substring(0, 40)}... → In Progress`);
-      updated++;
-    } else {
-      console.log(`  ❌ ${identifier}: Failed to update`);
-      failed++;
-    }
-    
-    await new Promise(r => setTimeout(r, 500));
-  }
-  
-  // Cancel obsolete tasks
-  if (canceledStateId) {
-    console.log('\n❌ Canceling obsolete tasks:\n');
-    for (const [identifier, title] of Object.entries(CANCEL_TASKS)) {
-      const task = await getTaskByIdentifier(identifier);
-      if (!task) {
-        console.log(`  ⚠️  ${identifier} not found`);
-        continue;
-      }
-      
-      if (task.state.type === 'canceled') {
-        console.log(`  ✓ ${identifier} already Canceled`);
-        continue;
-      }
-      
-      const result = await updateTaskStatus(task.id, canceledStateId);
-      if (result.data?.issueUpdate?.success) {
-        console.log(`  ❌ ${identifier}: ${title.substring(0, 40)}... → Canceled`);
-        updated++;
-      } else {
-        console.log(`  ❌ ${identifier}: Failed to update`);
-        failed++;
-      }
-      
-      await new Promise(r => setTimeout(r, 500));
-    }
-  }
-  
-  // Summary
-  console.log('\n' + '='.repeat(60));
-  console.log('📊 UPDATE SUMMARY');
-  console.log('='.repeat(60));
-  console.log(`✅ Successfully updated: ${updated} tasks`);
-  console.log(`❌ Failed: ${failed} tasks`);
-  console.log('\nLinear backlog now reflects actual implementation status.');
-}
-
-// Run if called directly
-if (import.meta.url === `file://${process.argv[1]}`) {
-  updateLinearTasks().catch(console.error);
-}
-
-export { updateLinearTasks };