@stackmemoryai/stackmemory 0.3.17 → 0.3.18

package/scripts/test-rlm.js

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+
+import 'dotenv/config';
+import { RecursiveAgentOrchestrator } from '../dist/skills/recursive-agent-orchestrator.js';
+import { FrameManager } from '../dist/core/context/frame-manager.js';
+import { DualStackManager } from '../dist/core/context/dual-stack-manager.js';
+import { ContextRetriever } from '../dist/core/retrieval/context-retriever.js';
+import { PebblesTaskStore } from '../dist/features/tasks/pebbles-task-store.js';
+import { SQLiteAdapter } from '../dist/core/database/sqlite-adapter.js';
+import { ClaudeCodeSubagentClient } from '../dist/integrations/claude-code/subagent-client.js';
+import * as path from 'path';
+import * as os from 'os';
+
+async function testRLM() {
+  console.log('🚀 Testing RLM Orchestrator...\n');
+  
+  try {
+    // Initialize dependencies
+    const projectId = 'test-project';
+    const userId = 'test-user';
+    const dbPath = path.join(os.tmpdir(), 'test-rlm.db');
+    
+    console.log('📦 Initializing components...');
+    const database = new SQLiteAdapter(projectId, { dbPath });
+    await database.connect();
+    
+    const dualStackManager = new DualStackManager(database, projectId, userId);
+    const frameManager = dualStackManager.getActiveStack();
+    const contextRetriever = new ContextRetriever(database);
+    
+    // Initialize task store with projectId
+    const taskStorePath = path.join(os.tmpdir(), 'test-tasks');
+    const taskStore = new PebblesTaskStore(projectId, taskStorePath);
+    
+    // Initialize RLM Orchestrator
+    console.log('🤖 Creating RLM Orchestrator...');
+    const rlm = new RecursiveAgentOrchestrator(
+      frameManager,
+      dualStackManager,
+      contextRetriever,
+      taskStore
+    );
+    
+    // Test with a simple task
+    const task = 'Create a simple hello world function in JavaScript';
+    console.log(`\n📝 Task: "${task}"\n`);
+    
+    const options = {
+      maxParallel: 2,
+      maxRecursionDepth: 2,
+      reviewStages: 1,
+      qualityThreshold: 0.7,
+      testGenerationMode: 'unit',
+      verboseLogging: true,
+    };
+    
+    console.log('⚙️  Options:', JSON.stringify(options, null, 2));
+    console.log('\n🔄 Executing RLM...\n');
+    
+    const result = await rlm.execute(task, options);
+    
+    if (result.success) {
+      console.log('✅ RLM Execution Successful!\n');
+      console.log('📊 Results:');
+      console.log(`  - Total tokens: ${result.data.totalTokens}`);
+      console.log(`  - Estimated cost: $${result.data.totalCost.toFixed(4)}`);
+      console.log(`  - Duration: ${result.data.duration}ms`);
+      console.log(`  - Tests generated: ${result.data.testsGenerated}`);
+      console.log(`  - Issues found: ${result.data.issuesFound}`);
+      console.log(`  - Issues fixed: ${result.data.issuesFixed}`);
+      
+      if (result.data.improvements?.length > 0) {
+        console.log('\n🔧 Improvements:');
+        result.data.improvements.forEach(imp => {
+          console.log(`  • ${imp}`);
+        });
+      }
+      
+      console.log('\n🌳 Execution Tree:');
+      printTaskTree(result.data.rootNode, 0);
+    } else {
+      console.log('❌ RLM Execution Failed');
+      console.log('Error:', result.message);
+    }
+    
+    // Cleanup
+    await database.disconnect();
+    console.log('\n✨ Test complete!');
+    
+  } catch (error) {
+    console.error('💥 Test failed:', error);
+    process.exit(1);
+  }
+}
+
+function printTaskTree(node, depth = 0) {
+  const indent = '  '.repeat(depth);
+  const status = node.status === 'completed' ? '✓' : 
+                 node.status === 'failed' ? '✗' : 
+                 node.status === 'running' ? '⟳' : '○';
+  
+  console.log(`${indent}${status} ${node.description} [${node.agent}]`);
+  
+  if (node.children) {
+    node.children.forEach(child => printTaskTree(child, depth + 1));
+  }
+}
+
+// Run the test
+testRLM().catch(console.error);

package/scripts/test-session-handoff.sh

@@ -0,0 +1,165 @@
+#!/bin/bash
+
+# Test session handoff and memory persistence between Claude sessions
+# This script validates the full lifecycle of context preservation
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
+
+# Colors
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m'
+
+echo -e "${BLUE}=== Session Handoff & Memory Test ===${NC}"
+echo
+
+# 1. Create context in current session
+echo -e "${BLUE}1. Creating session context...${NC}"
+stackmemory context add observation "Session starting - testing handoff"
+stackmemory context add decision "Using shared context for persistence"
+stackmemory context add observation "Progress checkpoint 1"
+echo -e "${GREEN}✓ Context created${NC}"
+echo
+
+# 2. Save progress to shared context
+echo -e "${BLUE}2. Saving progress to shared context...${NC}"
+cat << 'EOF' | node -
+const fs = require('fs');
+const path = require('path');
+
+const progressData = {
+  sessionId: 'test-' + Date.now(),
+  timestamp: new Date().toISOString(),
+  project: 'stackmemory',
+  branch: 'main',
+  progress: {
+    tasksCompleted: [
+      'Setup session context',
+      'Test persistence mechanism'
+    ],
+    currentTask: 'Validate handoff process',
+    pendingTasks: [
+      'Verify retrieval in new session',
+      'Test hook integration'
+    ],
+    decisions: [
+      'Use shared context for inter-session persistence',
+      'Implement checkpoint-based recovery'
+    ],
+    blockers: [],
+    lastCheckpoint: new Date().toISOString(),
+    contextFrames: 3,
+    sessionDuration: '15 minutes'
+  }
+};
+
+const sharedDir = path.join(process.env.HOME, '.stackmemory/shared-context/projects');
+if (!fs.existsSync(sharedDir)) {
+  fs.mkdirSync(sharedDir, { recursive: true });
+}
+
+const filePath = path.join(sharedDir, 'stackmemory_main.json');
+fs.writeFileSync(filePath, JSON.stringify(progressData, null, 2));
+console.log('✓ Progress saved to shared context');
+console.log('  Path:', filePath);
+console.log('  Session:', progressData.sessionId);
+console.log('  Tasks completed:', progressData.progress.tasksCompleted.length);
+EOF
+echo
+
+# 3. Generate handoff
+echo -e "${BLUE}3. Generating handoff summary...${NC}"
+stackmemory handoff > /tmp/handoff-test.md
+echo -e "${GREEN}✓ Handoff generated${NC}"
+echo "  Saved to: /tmp/handoff-test.md"
+echo
+
+# 4. Save with clear command
+echo -e "${BLUE}4. Testing clear --save...${NC}"
+stackmemory clear --save
+echo -e "${GREEN}✓ Context saved for clear survival${NC}"
+echo
+
+# 5. Simulate new session retrieval
+echo -e "${BLUE}5. Simulating new session context load...${NC}"
+cat << 'EOF' | node -
+const fs = require('fs');
+const path = require('path');
+
+console.log('\n--- NEW SESSION START ---\n');
+
+// Load saved context
+const filePath = path.join(process.env.HOME, '.stackmemory/shared-context/projects/stackmemory_main.json');
+
+if (fs.existsSync(filePath)) {
+  const data = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+  
+  console.log('📚 Restored Context from Previous Session:');
+  console.log('━'.repeat(50));
+  console.log('Previous session:', data.sessionId);
+  console.log('Last active:', data.timestamp);
+  console.log('');
+  console.log('✅ Completed Tasks:');
+  data.progress.tasksCompleted.forEach(task => {
+    console.log('  •', task);
+  });
+  console.log('');
+  console.log('🔄 Current Task:');
+  console.log('  •', data.progress.currentTask);
+  console.log('');
+  console.log('📋 Pending Tasks:');
+  data.progress.pendingTasks.forEach(task => {
+    console.log('  •', task);
+  });
+  console.log('');
+  console.log('💡 Key Decisions:');
+  data.progress.decisions.forEach(decision => {
+    console.log('  •', decision);
+  });
+  console.log('━'.repeat(50));
+  
+  // Calculate session gap
+  const lastTime = new Date(data.progress.lastCheckpoint);
+  const gap = Math.round((Date.now() - lastTime.getTime()) / 1000);
+  console.log(`\nSession gap: ${gap} seconds`);
+  console.log('Ready to continue from checkpoint ✨');
+} else {
+  console.log('❌ No previous session context found');
+}
+EOF
+echo
+
+# 6. Restore from clear
+echo -e "${BLUE}6. Testing clear --restore...${NC}"
+stackmemory clear --restore
+echo -e "${GREEN}✓ Context restored${NC}"
+echo
+
+# 7. Verify restoration
+echo -e "${BLUE}7. Verifying restored context...${NC}"
+stackmemory context show
+echo
+
+# Summary
+echo -e "${BLUE}=== Test Summary ===${NC}"
+echo -e "${GREEN}✓ Session context created and saved${NC}"
+echo -e "${GREEN}✓ Progress persisted to shared context${NC}"
+echo -e "${GREEN}✓ Handoff generated successfully${NC}"
+echo -e "${GREEN}✓ Clear/restore cycle working${NC}"
+echo -e "${GREEN}✓ New session can retrieve context${NC}"
+echo
+echo "Key locations:"
+echo "  • Shared context: ~/.stackmemory/shared-context/projects/"
+echo "  • Continuity ledger: ./.stackmemory/continuity.json"
+echo "  • Last handoff: ./.stackmemory/last-handoff.md"
+echo "  • Session data: ~/.stackmemory/sessions/"
+echo
+echo -e "${YELLOW}💡 To use in new Claude session:${NC}"
+echo "  1. Run: stackmemory handoff"
+echo "  2. Copy the handoff summary"
+echo "  3. Paste at start of new session"
+echo "  4. Context will be automatically loaded"

package/scripts/test-shell-integration.sh

@@ -0,0 +1,275 @@
+#!/bin/bash
+# StackMemory Shell Integration Test Suite
+# Tests shell integration components in isolation
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(dirname "$SCRIPT_DIR")"
+
+# Colors
+GREEN='\033[0;32m'
+RED='\033[0;31m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m'
+
+log_info() { echo -e "${BLUE}[INFO]${NC} $1"; }
+log_success() { echo -e "${GREEN}[PASS]${NC} $1"; }
+log_error() { echo -e "${RED}[FAIL]${NC} $1"; }
+log_warn() { echo -e "${YELLOW}[WARN]${NC} $1"; }
+
+TEST_COUNT=0
+PASS_COUNT=0
+
+run_shell_test() {
+    local test_name="$1"
+    local test_function="$2"
+    
+    ((TEST_COUNT++))
+    log_info "Test $TEST_COUNT: $test_name"
+    
+    if $test_function; then
+        log_success "$test_name"
+        ((PASS_COUNT++))
+        return 0
+    else
+        log_error "$test_name"
+        return 1
+    fi
+}
+
+# Test functions
+test_binaries_directory_exists() {
+    [ -d "$HOME/.stackmemory/bin" ]
+}
+
+test_all_binaries_exist() {
+    local binaries=("stackmemory" "stackmemory-daemon" "stackmemory-monitor" "sm-review")
+    for binary in "${binaries[@]}"; do
+        if [ ! -f "$HOME/.stackmemory/bin/$binary" ]; then
+            echo "Missing binary: $binary"
+            return 1
+        fi
+        if [ ! -x "$HOME/.stackmemory/bin/$binary" ]; then
+            echo "Binary not executable: $binary"
+            return 1
+        fi
+    done
+    return 0
+}
+
+test_stackmemory_daemon() {
+    local output
+    
+    # Test help/usage (should fail and show usage for invalid args)
+    if output=$("$HOME/.stackmemory/bin/stackmemory-daemon" invalid 2>&1); then
+        if ! echo "$output" | grep -q "Usage:"; then
+            echo "Should show usage for invalid args"
+            return 1
+        fi
+    fi
+    
+    # Test status command (should succeed)
+    if ! output=$("$HOME/.stackmemory/bin/stackmemory-daemon" status 2>&1); then
+        echo "Status command failed: $output"
+        return 1
+    fi
+    
+    return 0
+}
+
+test_stackmemory_monitor() {
+    local output
+    
+    # Test config command
+    if ! output=$("$HOME/.stackmemory/bin/stackmemory-monitor" config 2>&1); then
+        echo "Config command failed: $output"
+        return 1
+    fi
+    
+    # Should show current configuration
+    if ! echo "$output" | grep -qi "monitor\|configuration\|interval"; then
+        echo "Config output doesn't contain expected text: $output"
+        return 1
+    fi
+    
+    return 0
+}
+
+test_sm_review() {
+    local output
+    
+    # Test recent command (should not fail even if no context)
+    if ! output=$(timeout 10s "$HOME/.stackmemory/bin/sm-review" recent 1 2>&1); then
+        echo "Recent command failed: $output"
+        return 1
+    fi
+    
+    # Test default command
+    if ! output=$(timeout 10s "$HOME/.stackmemory/bin/sm-review" 2>&1); then
+        echo "Default command failed: $output"
+        return 1
+    fi
+    
+    return 0
+}
+
+test_stackmemory_wrapper() {
+    local output
+    
+    # Test version command
+    if ! output=$(timeout 10s "$HOME/.stackmemory/bin/stackmemory" --version 2>&1); then
+        echo "Version command failed: $output"
+        return 1
+    fi
+    
+    # Should return version number
+    if ! echo "$output" | grep -E "^[0-9]+\.[0-9]+\.[0-9]+"; then
+        echo "Version output doesn't match expected pattern: $output"
+        return 1
+    fi
+    
+    return 0
+}
+
+test_shell_integration_files_exist() {
+    [ -f "$HOME/.stackmemory/shell-integration.sh" ] && 
+    [ -f "$HOME/.stackmemory/shell-integration-consolidated.sh" ]
+}
+
+test_shell_integration_syntax() {
+    # Test basic shell integration syntax
+    if ! bash -n "$HOME/.stackmemory/shell-integration.sh"; then
+        echo "Basic shell integration has syntax errors"
+        return 1
+    fi
+    
+    # Test consolidated integration syntax
+    if ! bash -n "$HOME/.stackmemory/shell-integration-consolidated.sh"; then
+        echo "Consolidated shell integration has syntax errors"
+        return 1
+    fi
+    
+    return 0
+}
+
+test_shell_integration_loading() {
+    # Test that shell integration can be sourced without errors
+    local temp_script=$(mktemp)
+    cat > "$temp_script" << 'EOF'
+#!/bin/bash
+set -e
+# Temporarily disable the problematic parts and test basic loading
+export STACKMEMORY_HOME="$HOME/.stackmemory"
+source "$HOME/.stackmemory/shell-integration.sh" || exit 1
+echo "Basic integration loaded successfully"
+EOF
+    
+    if bash "$temp_script"; then
+        rm -f "$temp_script"
+        return 0
+    else
+        rm -f "$temp_script"
+        echo "Shell integration loading failed"
+        return 1
+    fi
+}
+
+test_path_configuration() {
+    # Test that PATH includes stackmemory bin directory
+    if ! echo "$PATH" | grep -q "$HOME/.stackmemory/bin"; then
+        echo "PATH doesn't include ~/.stackmemory/bin"
+        return 1
+    fi
+    
+    # Test that stackmemory command is found in PATH
+    if ! command -v stackmemory > /dev/null; then
+        echo "stackmemory command not found in PATH"
+        return 1
+    fi
+    
+    return 0
+}
+
+test_no_startup_errors() {
+    # Test that sourcing shell integration doesn't produce errors
+    local temp_script=$(mktemp)
+    cat > "$temp_script" << 'EOF'
+#!/bin/bash
+# Capture any error output when sourcing
+exec 2> /tmp/shell_integration_errors.log
+set -e
+source ~/.stackmemory/shell-integration-consolidated.sh
+EOF
+    
+    # Run in a timeout to prevent hanging
+    if timeout 30s bash "$temp_script" > /dev/null 2>&1; then
+        # Check if any errors were logged
+        if [ -f /tmp/shell_integration_errors.log ] && [ -s /tmp/shell_integration_errors.log ]; then
+            echo "Shell integration produced errors:"
+            cat /tmp/shell_integration_errors.log
+            rm -f /tmp/shell_integration_errors.log "$temp_script"
+            return 1
+        fi
+        rm -f /tmp/shell_integration_errors.log "$temp_script"
+        return 0
+    else
+        rm -f /tmp/shell_integration_errors.log "$temp_script"
+        echo "Shell integration timed out or failed"
+        return 1
+    fi
+}
+
+# Main test execution
+main() {
+    echo "============================================"
+    echo "  StackMemory Shell Integration Test Suite"
+    echo "============================================"
+    echo
+    
+    log_info "Testing shell integration components..."
+    echo
+    
+    # Directory and file tests
+    run_shell_test "Binaries directory exists" "test_binaries_directory_exists"
+    run_shell_test "All required binaries exist and are executable" "test_all_binaries_exist"
+    run_shell_test "Shell integration files exist" "test_shell_integration_files_exist"
+    echo
+    
+    # Syntax tests
+    run_shell_test "Shell integration syntax is valid" "test_shell_integration_syntax"
+    echo
+    
+    # Functionality tests
+    run_shell_test "stackmemory-daemon functionality" "test_stackmemory_daemon"
+    run_shell_test "stackmemory-monitor functionality" "test_stackmemory_monitor"
+    run_shell_test "sm-review functionality" "test_sm_review"
+    run_shell_test "stackmemory wrapper functionality" "test_stackmemory_wrapper"
+    echo
+    
+    # Integration tests
+    run_shell_test "Shell integration can be loaded" "test_shell_integration_loading"
+    run_shell_test "PATH configuration is correct" "test_path_configuration"
+    run_shell_test "No startup errors in shell integration" "test_no_startup_errors"
+    echo
+    
+    # Results
+    echo "============================================"
+    echo "  Shell Integration Test Results"
+    echo "============================================"
+    echo "Total tests: $TEST_COUNT"
+    echo -e "${GREEN}Passed: $PASS_COUNT${NC}"
+    echo -e "${RED}Failed: $((TEST_COUNT - PASS_COUNT))${NC}"
+    echo
+    
+    if [ $PASS_COUNT -eq $TEST_COUNT ]; then
+        echo -e "${GREEN}✅ All shell integration tests passed!${NC}"
+        return 0
+    else
+        echo -e "${RED}❌ Some shell integration tests failed.${NC}"
+        return 1
+    fi
+}
+
+main "$@"