@stackmemoryai/stackmemory 0.5.51 → 0.5.53

package/dist/core/context/context-bridge.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/core/context/context-bridge.ts"],
-  "sourcesContent": ["/**\n * Context Bridge - Automatic synchronization between sessions and shared context\n *\n * This bridge automatically:\n * - Syncs important frames to shared context\n * - Loads relevant context on session start\n * - Maintains consistency across sessions\n */\n\nimport { FrameManager, type Frame } from './index.js';\nimport { sharedContextLayer } from './shared-context-layer.js';\nimport { sessionManager } from '../session/session-manager.js';\nimport { logger } from '../monitoring/logger.js';\n\nexport interface BridgeOptions {\n  autoSync: boolean;\n  syncInterval: number;\n  minFrameScore: number;\n  importantTags: string[];\n}\n\nexport class ContextBridge {\n  private static instance: ContextBridge;\n  private frameManager: FrameManager | null = null;\n  private syncTimer: NodeJS.Timeout | null = null;\n  private lastSyncTime: number = 0;\n  private options: BridgeOptions = {\n    autoSync: true,\n    syncInterval: 60000, // 1 minute\n    minFrameScore: 0.5, // Include frames with score above 0.5\n    importantTags: ['decision', 'error', 'milestone', 'learning'],\n  };\n\n  private constructor() {}\n\n  static getInstance(): ContextBridge {\n    if (!ContextBridge.instance) {\n      ContextBridge.instance = new ContextBridge();\n    }\n    return ContextBridge.instance;\n  }\n\n  /**\n   * Initialize the bridge with a frame manager\n   */\n  async initialize(\n    frameManager: FrameManager,\n    options?: Partial<BridgeOptions>\n  ): Promise<void> {\n    this.frameManager = frameManager;\n    this.options = { ...this.options, ...options };\n\n    // Load shared context on initialization\n    await this.loadSharedContext();\n\n    // Start auto-sync if enabled\n    if (this.options.autoSync) {\n      this.startAutoSync();\n    }\n\n    logger.info('Context bridge initialized', {\n      autoSync: this.options.autoSync,\n      syncInterval: this.options.syncInterval,\n    });\n  }\n\n  /**\n   * Load relevant shared context into current session\n   */\n  async loadSharedContext(): Promise<void> {\n    try {\n      const session = sessionManager.getCurrentSession();\n      if (!session) return;\n\n      // Get context discovery\n      const discovery = await sharedContextLayer.autoDiscoverContext();\n\n      if (!discovery.hasSharedContext) {\n        logger.info('No shared context available to load');\n        return;\n      }\n\n      // Load recent patterns as metadata\n      if (discovery.recentPatterns.length > 0) {\n        logger.info('Loaded recent patterns from shared context', {\n          patternCount: discovery.recentPatterns.length,\n        });\n      }\n\n      // Load last decisions for reference\n      if (discovery.lastDecisions.length > 0) {\n        logger.info('Loaded recent decisions from shared context', {\n          decisionCount: discovery.lastDecisions.length,\n        });\n      }\n\n      // Store suggested frames in metadata for quick reference\n      if (discovery.suggestedFrames.length > 0) {\n        const metadata = {\n          suggestedFrames: discovery.suggestedFrames,\n          loadedAt: Date.now(),\n        };\n\n        // Store in frame manager's context\n        if (this.frameManager) {\n          await this.frameManager.addContext(\n            'shared-context-suggestions',\n            metadata\n          );\n        }\n\n        logger.info('Loaded suggested frames from shared context', {\n          frameCount: discovery.suggestedFrames.length,\n        });\n      }\n    } catch (error: unknown) {\n      logger.error('Failed to load shared context', error as Error);\n    }\n  }\n\n  /**\n   * Sync current session's important frames to shared context\n   */\n  async syncToSharedContext(): Promise<void> {\n    try {\n      if (!this.frameManager) return;\n\n      const session = sessionManager.getCurrentSession();\n      if (!session) return;\n\n      // Get all active frames (filter out any nulls from missing frames)\n      const activeFrames = this.frameManager\n        .getActiveFramePath()\n        .filter(Boolean);\n\n      // Get recent closed frames (last 100)\n      const recentFrames = await this.frameManager.getRecentFrames(100);\n\n      // Combine and filter important frames\n      const allFrames = [...activeFrames, ...recentFrames].filter(Boolean);\n      const importantFrames = this.filterImportantFrames(allFrames);\n\n      if (importantFrames.length === 0) {\n        logger.debug('No important frames to sync');\n        return;\n      }\n\n      // Add to shared context\n      await sharedContextLayer.addToSharedContext(importantFrames, {\n        minScore: this.options.minFrameScore,\n        tags: this.options.importantTags,\n      });\n\n      this.lastSyncTime = Date.now();\n\n      logger.info('Synced frames to shared context', {\n        frameCount: importantFrames.length,\n        sessionId: session.sessionId,\n      });\n    } catch (error: unknown) {\n      logger.error('Failed to sync to shared context', error as Error);\n    }\n  }\n\n  /**\n   * Query shared context for relevant frames\n   */\n  async querySharedFrames(query: {\n    tags?: string[];\n    type?: string;\n    limit?: number;\n  }): Promise<any[]> {\n    try {\n      const results = await sharedContextLayer.querySharedContext({\n        ...query,\n        minScore: this.options.minFrameScore,\n      });\n\n      logger.info('Queried shared context', {\n        query,\n        resultCount: results.length,\n      });\n\n      return results;\n    } catch (error: unknown) {\n      logger.error('Failed to query shared context', error as Error);\n      return [];\n    }\n  }\n\n  /**\n   * Add a decision to shared context\n   */\n  async addDecision(decision: string, reasoning: string): Promise<void> {\n    try {\n      await sharedContextLayer.addDecision({\n        decision,\n        reasoning,\n        outcome: 'pending',\n      });\n\n      logger.info('Added decision to shared context', { decision });\n    } catch (error: unknown) {\n      logger.error('Failed to add decision', error as Error);\n    }\n  }\n\n  /**\n   * Start automatic synchronization\n   */\n  private startAutoSync(): void {\n    if (this.syncTimer) {\n      clearInterval(this.syncTimer);\n    }\n\n    this.syncTimer = setInterval(() => {\n      this.syncToSharedContext().catch((error) => {\n        logger.error('Auto-sync failed', error as Error);\n      });\n    }, this.options.syncInterval);\n\n    // Also sync on important events\n    this.setupEventListeners();\n  }\n\n  /**\n   * Stop automatic synchronization\n   */\n  stopAutoSync(): void {\n    if (this.syncTimer) {\n      clearInterval(this.syncTimer);\n      this.syncTimer = null;\n    }\n  }\n\n  /**\n   * Filter frames that are important enough to share\n   */\n  private filterImportantFrames(frames: Frame[]): Frame[] {\n    return frames.filter((frame) => {\n      // Check if frame has important tags\n      const hasImportantTag = this.options.importantTags.some((tag) =>\n        frame.metadata?.tags?.includes(tag)\n      );\n\n      // Check frame type importance\n      const isImportantType = [\n        'task',\n        'milestone',\n        'error',\n        'resolution',\n        'decision',\n      ].includes(frame.type);\n\n      // Check metadata importance flag\n      const markedImportant = frame.metadata?.importance === 'high';\n\n      return hasImportantTag || isImportantType || markedImportant;\n    });\n  }\n\n  /**\n   * Setup event listeners for automatic syncing\n   */\n  private setupEventListeners(): void {\n    if (!this.frameManager) return;\n\n    // Sync when a frame is closed\n    const originalClose = this.frameManager.closeFrame.bind(this.frameManager);\n    this.frameManager.closeFrame = async (frameId: string, metadata?: any) => {\n      const result = await originalClose(frameId, metadata);\n\n      // Sync if it was an important frame\n      const frame = await this.frameManager!.getFrame(frameId);\n      if (frame && this.filterImportantFrames([frame]).length > 0) {\n        await this.syncToSharedContext();\n      }\n\n      return result;\n    };\n\n    // Sync when a milestone is reached\n    const originalMilestone = this.frameManager.createFrame.bind(\n      this.frameManager\n    );\n    this.frameManager.createFrame = async (params: any) => {\n      const result = await originalMilestone(params);\n\n      if (params.type === 'milestone') {\n        await this.syncToSharedContext();\n      }\n\n      return result;\n    };\n  }\n\n  /**\n   * Get sync statistics\n   */\n  getSyncStats(): {\n    lastSyncTime: number;\n    autoSyncEnabled: boolean;\n    syncInterval: number;\n  } {\n    return {\n      lastSyncTime: this.lastSyncTime,\n      autoSyncEnabled: this.options.autoSync,\n      syncInterval: this.options.syncInterval,\n    };\n  }\n\n  /**\n   * Manual trigger for immediate sync\n   */\n  async forceSyncNow(): Promise<void> {\n    logger.info('Force sync triggered');\n    await this.syncToSharedContext();\n  }\n}\n\nexport const contextBridge = ContextBridge.getInstance();\n\n// Export for testing\nexport { BridgeOptions };\n"],
-  "mappings": "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",
-  "names": []
-}

package/scripts/testing/scripts/testing/ab-test-runner.js

@@ -1,363 +0,0 @@
-#!/usr/bin/env node
-import { MetricsCollector } from './collect-metrics.js';
-import { spawn } from 'child_process';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-export class ABTestRunner {
-    constructor() {
-        this.scenarios = new Map();
-        this.runs = [];
-        this.stackMemoryEnabled = false;
-        this.collector = new MetricsCollector();
-        this.loadScenarios();
-    }
-    loadScenarios() {
-        // Define test scenarios
-        const scenarios = [
-            {
-                id: 'multi_session_feature',
-                name: 'E-commerce checkout flow',
-                type: 'feature_dev',
-                description: 'Implement a complete checkout flow with payment integration',
-                complexity: 'high',
-                expectedDuration: 180,
-                steps: [
-                    { action: 'Design checkout flow architecture', requiresContext: false },
-                    { action: 'Implement cart validation', requiresContext: true },
-                    { action: 'Add payment gateway integration', requiresContext: true },
-                    { action: 'Create checkout UI components', requiresContext: true },
-                    { action: 'Add order confirmation', requiresContext: true },
-                    { action: 'Write integration tests', requiresContext: true }
-                ],
-                contextBreaks: [
-                    { afterStep: 2, duration: 480, type: 'session_end' }, // Overnight
-                    { afterStep: 4, duration: 60, type: 'interruption' } // Lunch break
-                ]
-            },
-            {
-                id: 'complex_debugging',
-                name: 'Performance issue in production',
-                type: 'complex_debug',
-                description: 'Debug and fix a memory leak causing performance degradation',
-                complexity: 'high',
-                expectedDuration: 120,
-                steps: [
-                    { action: 'Analyze performance metrics', requiresContext: false },
-                    { action: 'Profile memory usage', requiresContext: true },
-                    { action: 'Identify memory leak source', requiresContext: true },
-                    { action: 'Implement fix', requiresContext: true },
-                    { action: 'Verify fix with tests', requiresContext: true }
-                ],
-                contextBreaks: [
-                    { afterStep: 3, duration: 30, type: 'team_handoff' }
-                ]
-            },
-            {
-                id: 'large_refactoring',
-                name: 'Migrate authentication system',
-                type: 'refactor',
-                description: 'Refactor from session-based to JWT authentication',
-                complexity: 'very_high',
-                expectedDuration: 360,
-                steps: [
-                    { action: 'Analyze current auth implementation', requiresContext: false },
-                    { action: 'Design JWT architecture', requiresContext: true },
-                    { action: 'Implement JWT service', requiresContext: true },
-                    { action: 'Migrate user sessions', requiresContext: true },
-                    { action: 'Update API endpoints', requiresContext: true },
-                    { action: 'Migrate frontend auth', requiresContext: true },
-                    { action: 'Add refresh token logic', requiresContext: true },
-                    { action: 'Update tests', requiresContext: true },
-                    { action: 'Performance testing', requiresContext: true }
-                ],
-                contextBreaks: [
-                    { afterStep: 2, duration: 480, type: 'session_end' },
-                    { afterStep: 4, duration: 480, type: 'session_end' },
-                    { afterStep: 6, duration: 60, type: 'interruption' },
-                    { afterStep: 7, duration: 480, type: 'session_end' }
-                ]
-            },
-            {
-                id: 'rapid_bug_fixes',
-                name: 'Fix 5 related bugs',
-                type: 'bug_fix',
-                description: 'Fix multiple related bugs in the user registration flow',
-                complexity: 'medium',
-                expectedDuration: 90,
-                steps: [
-                    { action: 'Fix email validation bug', requiresContext: false },
-                    { action: 'Fix password strength checker', requiresContext: true },
-                    { action: 'Fix duplicate user check', requiresContext: true },
-                    { action: 'Fix confirmation email sending', requiresContext: true },
-                    { action: 'Fix redirect after registration', requiresContext: true }
-                ],
-                contextBreaks: [
-                    { afterStep: 1, duration: 15, type: 'interruption' },
-                    { afterStep: 2, duration: 15, type: 'interruption' },
-                    { afterStep: 3, duration: 15, type: 'interruption' },
-                    { afterStep: 4, duration: 15, type: 'interruption' }
-                ]
-            }
-        ];
-        scenarios.forEach(scenario => {
-            this.scenarios.set(scenario.id, scenario);
-        });
-    }
-    async initialize() {
-        await this.collector.initialize();
-    }
-    async enableStackMemory() {
-        console.log('Enabling StackMemory...');
-        this.stackMemoryEnabled = true;
-        // Start StackMemory daemon if not running
-        try {
-            await this.executeCommand('stackmemory-daemon status');
-        }
-        catch {
-            await this.executeCommand('stackmemory-daemon start');
-        }
-    }
-    async disableStackMemory() {
-        console.log('Disabling StackMemory...');
-        this.stackMemoryEnabled = false;
-        // Stop StackMemory daemon
-        try {
-            await this.executeCommand('stackmemory-daemon stop');
-        }
-        catch {
-            // Ignore if already stopped
-        }
-    }
-    executeCommand(command) {
-        return new Promise((resolve, reject) => {
-            const child = spawn(command, { shell: true });
-            let output = '';
-            let error = '';
-            child.stdout.on('data', (data) => {
-                output += data.toString();
-            });
-            child.stderr.on('data', (data) => {
-                error += data.toString();
-            });
-            child.on('close', (code) => {
-                if (code === 0) {
-                    resolve(output);
-                }
-                else {
-                    reject(new Error(error || `Command failed with code ${code}`));
-                }
-            });
-        });
-    }
-    async runScenario(scenarioId, variant) {
-        const scenario = this.scenarios.get(scenarioId);
-        if (!scenario) {
-            throw new Error(`Scenario ${scenarioId} not found`);
-        }
-        console.log(`\nRunning scenario: ${scenario.name} (${variant})`);
-        console.log(`Expected duration: ${scenario.expectedDuration} minutes`);
-        console.log(`Complexity: ${scenario.complexity}`);
-        console.log(`Context breaks: ${scenario.contextBreaks.length}`);
-        // Enable/disable StackMemory based on variant
-        if (variant === 'with_stackmemory') {
-            await this.enableStackMemory();
-        }
-        else {
-            await this.disableStackMemory();
-        }
-        const runId = `${scenarioId}-${variant}-${Date.now()}`;
-        const sessionId = await this.collector.startSession(variant);
-        const run = {
-            id: runId,
-            scenario,
-            variant,
-            startTime: new Date(),
-            metrics: {},
-            recordings: [],
-            success: false,
-            errors: []
-        };
-        try {
-            // Execute scenario steps
-            for (let i = 0; i < scenario.steps.length; i++) {
-                const step = scenario.steps[i];
-                console.log(`\nStep ${i + 1}/${scenario.steps.length}: ${step.action}`);
-                // Simulate step execution
-                await this.executeStep(step, sessionId, run);
-                // Check for context break
-                const contextBreak = scenario.contextBreaks.find(cb => cb.afterStep === i + 1);
-                if (contextBreak) {
-                    console.log(`\nContext break: ${contextBreak.type} for ${contextBreak.duration} minutes`);
-                    await this.simulateContextBreak(contextBreak, sessionId);
-                }
-            }
-            run.success = true;
-        }
-        catch (error) {
-            console.error(`Scenario failed: ${error.message}`);
-            run.errors.push(error.message);
-            this.collector.trackError(sessionId, error);
-        }
-        // Collect final metrics
-        run.endTime = new Date();
-        run.metrics = await this.collector.endSession(sessionId);
-        // Save run results
-        this.runs.push(run);
-        await this.saveRun(run);
-        return run;
-    }
-    async executeStep(step, sessionId, run) {
-        const startTime = Date.now();
-        // Track tool call
-        this.collector.trackToolCall(sessionId, 'execute_step');
-        // If step requires context and we're testing with StackMemory
-        if (step.requiresContext && this.stackMemoryEnabled) {
-            const contextTime = await this.collector.measureContextReestablishment(sessionId);
-            console.log(`  Context retrieved in ${(contextTime / 1000).toFixed(2)}s`);
-        }
-        // Simulate step execution with command if provided
-        if (step.command) {
-            try {
-                const output = await this.executeCommand(step.command);
-                // Record tool call
-                run.recordings.push({
-                    timestamp: new Date(),
-                    tool: 'command',
-                    parameters: { command: step.command },
-                    result: output,
-                    duration: Date.now() - startTime
-                });
-            }
-            catch (error) {
-                this.collector.trackError(sessionId, error);
-                throw error;
-            }
-        }
-        else {
-            // Simulate work being done
-            await this.simulateWork(2000 + Math.random() * 3000);
-        }
-        // Randomly simulate decisions and frame creation
-        if (Math.random() > 0.5) {
-            this.collector.trackFrameCreation(sessionId, `frame-${Date.now()}`);
-        }
-        if (Math.random() > 0.7) {
-            this.collector.trackDecision(sessionId, `Decision for ${step.action}`);
-        }
-        console.log(`  Step completed in ${((Date.now() - startTime) / 1000).toFixed(2)}s`);
-    }
-    async simulateContextBreak(contextBreak, sessionId) {
-        // Simulate time passing
-        console.log(`  Simulating ${contextBreak.duration} minute break...`);
-        if (contextBreak.type === 'session_end' && this.stackMemoryEnabled) {
-            // Simulate session end with StackMemory
-            this.collector.trackFrameClosure(sessionId, 'session-frame', true);
-        }
-        // In real testing, we would actually wait or simulate the time passing
-        await this.simulateWork(1000);
-        // After break, measure context reestablishment
-        if (this.stackMemoryEnabled) {
-            const reestablishTime = await this.collector.measureContextReestablishment(sessionId);
-            console.log(`  Context reestablished in ${(reestablishTime / 1000).toFixed(2)}s`);
-        }
-        else {
-            // Without StackMemory, simulate manual context reestablishment
-            console.log(`  Manual context reestablishment required (est. 5 minutes)`);
-            this.collector.trackRework(sessionId);
-        }
-    }
-    simulateWork(ms) {
-        return new Promise(resolve => setTimeout(resolve, ms));
-    }
-    async runAllScenarios() {
-        console.log('='.repeat(60));
-        console.log('Starting A/B Test Suite');
-        console.log('='.repeat(60));
-        for (const scenario of this.scenarios.values()) {
-            // Run without StackMemory
-            await this.runScenario(scenario.id, 'without_stackmemory');
-            // Run with StackMemory
-            await this.runScenario(scenario.id, 'with_stackmemory');
-        }
-        await this.generateComparison();
-    }
-    async generateComparison() {
-        const withStackMemory = this.runs.filter(r => r.variant === 'with_stackmemory');
-        const withoutStackMemory = this.runs.filter(r => r.variant === 'without_stackmemory');
-        console.log('\n' + '='.repeat(60));
-        console.log('A/B Test Results Summary');
-        console.log('='.repeat(60));
-        for (const scenario of this.scenarios.values()) {
-            const withRun = withStackMemory.find(r => r.scenario.id === scenario.id);
-            const withoutRun = withoutStackMemory.find(r => r.scenario.id === scenario.id);
-            if (withRun && withoutRun) {
-                console.log(`\n${scenario.name}:`);
-                console.log(`  Without StackMemory: ${((withoutRun.metrics.completionTime || 0) / 1000 / 60).toFixed(2)} min`);
-                console.log(`  With StackMemory: ${((withRun.metrics.completionTime || 0) / 1000 / 60).toFixed(2)} min`);
-                const improvement = ((withoutRun.metrics.completionTime - withRun.metrics.completionTime) /
-                    withoutRun.metrics.completionTime) * 100;
-                console.log(`  Improvement: ${improvement.toFixed(1)}%`);
-            }
-        }
-        // Generate detailed report
-        await this.collector.generateReport('./test-results/ab-test-report.md');
-    }
-    async saveRun(run) {
-        const outputDir = './test-results/runs';
-        await fs.mkdir(outputDir, { recursive: true });
-        const filename = path.join(outputDir, `${run.id}.json`);
-        await fs.writeFile(filename, JSON.stringify(run, null, 2));
-        console.log(`Run saved to: ${filename}`);
-    }
-    async runSpecificScenario(scenarioId) {
-        if (!this.scenarios.has(scenarioId)) {
-            console.error(`Scenario '${scenarioId}' not found`);
-            console.log('Available scenarios:');
-            for (const [id, scenario] of this.scenarios) {
-                console.log(`  - ${id}: ${scenario.name}`);
-            }
-            return;
-        }
-        // Run both variants
-        await this.runScenario(scenarioId, 'without_stackmemory');
-        await this.runScenario(scenarioId, 'with_stackmemory');
-        await this.generateComparison();
-    }
-}
-// CLI interface
-if (import.meta.url === `file://${process.argv[1]}`) {
-    const runner = new ABTestRunner();
-    async function main() {
-        await runner.initialize();
-        const command = process.argv[2];
-        const scenarioId = process.argv[3];
-        switch (command) {
-            case 'all':
-                await runner.runAllScenarios();
-                break;
-            case 'scenario':
-                if (!scenarioId) {
-                    console.error('Please specify a scenario ID');
-                    process.exit(1);
-                }
-                await runner.runSpecificScenario(scenarioId);
-                break;
-            case 'list':
-                console.log('Available scenarios:');
-                console.log('  - multi_session_feature: E-commerce checkout flow');
-                console.log('  - complex_debugging: Performance issue in production');
-                console.log('  - large_refactoring: Migrate authentication system');
-                console.log('  - rapid_bug_fixes: Fix 5 related bugs');
-                break;
-            default:
-                console.log('Usage: ab-test-runner.ts [all|scenario|list] [scenario-id]');
-                console.log('');
-                console.log('Commands:');
-                console.log('  all      - Run all test scenarios');
-                console.log('  scenario - Run a specific scenario');
-                console.log('  list     - List available scenarios');
-        }
-        process.exit(0);
-    }
-    main().catch(console.error);
-}