@stackmemoryai/stackmemory 0.3.17 → 0.3.19

package/scripts/test-hooks-persistence.sh

@@ -0,0 +1,220 @@
+#!/bin/bash
+
+# Test StackMemory hooks persistence and data handling
+# This script tests all hooks to ensure they're properly capturing and persisting data
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+echo -e "${BLUE}=== StackMemory Hooks Persistence Test ===${NC}"
+echo
+
+# Function to print test results
+print_result() {
+    if [ $1 -eq 0 ]; then
+        echo -e "${GREEN}✓${NC} $2"
+    else
+        echo -e "${RED}✗${NC} $2"
+        return 1
+    fi
+}
+
+# Function to check if stackmemory is running
+check_stackmemory() {
+    if ~/.stackmemory/bin/stackmemory status --json 2>/dev/null | grep -q '"running":true'; then
+        return 0
+    else
+        return 1
+    fi
+}
+
+# Function to get latest frame ID
+get_latest_frame() {
+    ~/.stackmemory/bin/stackmemory context list --limit 1 --json 2>/dev/null | grep -o '"id":"[^"]*"' | head -1 | cut -d'"' -f4
+}
+
+# Function to check frame data
+check_frame_data() {
+    local frame_id=$1
+    local expected_pattern=$2
+    local frame_data=$(~/.stackmemory/bin/stackmemory context show "$frame_id" --json 2>/dev/null)
+    
+    if echo "$frame_data" | grep -q "$expected_pattern"; then
+        return 0
+    else
+        echo -e "${YELLOW}Frame data:${NC}"
+        echo "$frame_data" | jq '.' 2>/dev/null || echo "$frame_data"
+        return 1
+    fi
+}
+
+# Start stackmemory if not running
+echo -e "${BLUE}1. Checking StackMemory daemon...${NC}"
+if ! check_stackmemory; then
+    echo "Starting StackMemory daemon..."
+    ~/.stackmemory/bin/stackmemory-daemon start &
+    sleep 2
+fi
+print_result $? "StackMemory daemon is running"
+echo
+
+# Test on-clear hook
+echo -e "${BLUE}2. Testing on-clear hook (context preservation)...${NC}"
+echo "Creating test context..."
+~/.stackmemory/bin/stackmemory context add observation "test-context-$(date +%s)"
+FRAME_BEFORE=$(get_latest_frame)
+echo "Frame ID before clear: $FRAME_BEFORE"
+
+# Trigger on-clear
+~/.claude/hooks/on-clear 2>/dev/null || true
+sleep 1
+
+# Check if frame was preserved
+FRAME_AFTER=$(get_latest_frame)
+if check_frame_data "$FRAME_AFTER" "clear_survival"; then
+    print_result 0 "on-clear hook preserved context"
+else
+    print_result 1 "on-clear hook failed to preserve context"
+fi
+echo
+
+# Test on-task-complete hook
+echo -e "${BLUE}3. Testing on-task-complete hook...${NC}"
+export CLAUDE_TASK_SUMMARY="Test task completion: Fixed bug in shared context layer"
+export CLAUDE_TASK_STATUS="completed"
+
+# Run the hook
+~/.claude/hooks/on-task-complete 2>/dev/null || true
+sleep 1
+
+# Check if task was recorded
+TASK_FRAME=$(get_latest_frame)
+if check_frame_data "$TASK_FRAME" "task.*completion\|completed"; then
+    print_result 0 "on-task-complete hook recorded task"
+else
+    print_result 1 "on-task-complete hook failed to record task"
+fi
+unset CLAUDE_TASK_SUMMARY CLAUDE_TASK_STATUS
+echo
+
+# Test quality gate hook
+echo -e "${BLUE}4. Testing quality gate (pre-commit style)...${NC}"
+# Create a test file with issues
+TEST_FILE="$PROJECT_ROOT/test-quality-check.ts"
+cat > "$TEST_FILE" << 'EOF'
+export function testFunction() {
+    console.log("test");
+    const unusedVar = "test";
+    return true;
+}
+EOF
+
+# Run quality check
+export CLAUDE_ACTION="commit"
+export CLAUDE_FILES="$TEST_FILE"
+if ~/.claude/hooks/on-action-blocked 2>/dev/null; then
+    echo -e "${YELLOW}Quality gate blocked action (expected for test file)${NC}"
+else
+    echo -e "${GREEN}Quality gate passed or not enforced${NC}"
+fi
+unset CLAUDE_ACTION CLAUDE_FILES
+
+# Clean up test file
+rm -f "$TEST_FILE"
+echo
+
+# Test shared context persistence
+echo -e "${BLUE}5. Testing shared context layer persistence...${NC}"
+
+# Add context through shared layer
+cat << 'EOF' | node -
+const { SharedContextLayer } = require('./dist/src/core/context/shared-context-layer.js');
+
+async function test() {
+    const layer = new SharedContextLayer();
+    await layer.initialize();
+    
+    // Add test context
+    await layer.addSharedContext({
+        type: 'test',
+        name: 'Hook persistence test',
+        tags: ['test', 'persistence'],
+        data: {
+            timestamp: new Date().toISOString(),
+            test_id: 'hook-test-' + Date.now()
+        }
+    });
+    
+    // Query to ensure it's persisted
+    const results = await layer.querySharedContext({ tags: ['test', 'persistence'] });
+    console.log('Frames found:', results.length);
+    
+    // Get full context
+    const context = await layer.getSharedContext();
+    console.log('Total frames:', context.frames.length);
+    console.log('Patterns detected:', Object.keys(context.patterns).length);
+    console.log('Recently accessed:', context.referenceIndex.recentlyAccessed.length);
+}
+
+test().catch(console.error);
+EOF
+
+sleep 1
+print_result $? "Shared context layer persisted data"
+echo
+
+# Test monitoring hook
+echo -e "${BLUE}6. Testing monitoring hook (auto-checkpoint)...${NC}"
+echo "Simulating work session..."
+
+# Create some activity
+for i in {1..3}; do
+    ~/.stackmemory/bin/stackmemory context add observation "Activity $i"
+    sleep 0.5
+done
+
+# Check monitoring
+~/.stackmemory/bin/stackmemory monitor status --json 2>/dev/null | jq '.last_checkpoint' || echo "No monitoring data"
+print_result $? "Monitoring hook tracked activity"
+echo
+
+# Test handoff generation
+echo -e "${BLUE}7. Testing handoff generation...${NC}"
+HANDOFF=$(~/.stackmemory/bin/stackmemory context handoff 2>/dev/null)
+if [ -n "$HANDOFF" ]; then
+    echo -e "${GREEN}Handoff generated successfully${NC}"
+    echo "Preview (first 200 chars):"
+    echo "$HANDOFF" | head -c 200
+    echo "..."
+else
+    echo -e "${YELLOW}No handoff generated (may need more context)${NC}"
+fi
+echo
+
+# Summary
+echo -e "${BLUE}=== Test Summary ===${NC}"
+echo "Persistence location: ~/.stackmemory/data/"
+echo "Shared context: ~/.stackmemory/data/shared-context.json"
+echo "Project context: ./.stackmemory/context/"
+echo
+
+# Show recent frames
+echo -e "${BLUE}Recent frames captured:${NC}"
+~/.stackmemory/bin/stackmemory context list --limit 5 --format table
+
+echo
+echo -e "${GREEN}Testing complete!${NC}"
+echo "To inspect data manually:"
+echo "  - View frames: stackmemory context list"
+echo "  - Show frame: stackmemory context show <frame-id>"
+echo "  - Monitor status: stackmemory monitor status"
+echo "  - Shared context: cat ~/.stackmemory/data/shared-context.json | jq"

package/scripts/test-installation-scenarios.sh

@@ -0,0 +1,359 @@
+#!/bin/bash
+# StackMemory Installation Scenario Tests
+# Tests different installation scenarios that users might encounter
+
+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_scenario_test() {
+    local test_name="$1"
+    local test_function="$2"
+    
+    ((TEST_COUNT++))
+    log_info "Scenario $TEST_COUNT: $test_name"
+    
+    if $test_function; then
+        log_success "$test_name"
+        ((PASS_COUNT++))
+        return 0
+    else
+        log_error "$test_name"
+        return 1
+    fi
+}
+
+# Scenario test functions
+test_fresh_global_install() {
+    local temp_dir="/tmp/stackmemory-global-test"
+    local user_home="/tmp/stackmemory-fake-home"
+    
+    # Setup fake environment
+    rm -rf "$temp_dir" "$user_home"
+    mkdir -p "$temp_dir" "$user_home"
+    
+    cd "$PROJECT_ROOT"
+    local tarball=$(npm pack)
+    
+    cd "$temp_dir"
+    
+    # Simulate fresh global install
+    HOME="$user_home" npm install -g "$PROJECT_ROOT/$tarball" > install.log 2>&1
+    
+    # Test that CLI is available
+    if ! HOME="$user_home" PATH="$user_home/.npm/bin:$PATH" stackmemory --version > /dev/null 2>&1; then
+        cat install.log
+        echo "Global install failed - CLI not available"
+        rm -rf "$temp_dir" "$user_home"
+        rm -f "$PROJECT_ROOT/$tarball"
+        return 1
+    fi
+    
+    # Cleanup
+    rm -rf "$temp_dir" "$user_home"
+    rm -f "$PROJECT_ROOT/$tarball"
+    return 0
+}
+
+test_local_project_install() {
+    local temp_dir="/tmp/stackmemory-local-test"
+    
+    # Setup test project
+    rm -rf "$temp_dir"
+    mkdir -p "$temp_dir"
+    cd "$temp_dir"
+    
+    npm init -y > /dev/null 2>&1
+    
+    cd "$PROJECT_ROOT"
+    local tarball=$(npm pack)
+    
+    cd "$temp_dir"
+    
+    # Install as project dependency
+    npm install "$PROJECT_ROOT/$tarball" > install.log 2>&1
+    
+    # Test that CLI is available via npx
+    if ! npx stackmemory --version > /dev/null 2>&1; then
+        cat install.log
+        echo "Local install failed - CLI not available via npx"
+        rm -rf "$temp_dir"
+        rm -f "$PROJECT_ROOT/$tarball"
+        return 1
+    fi
+    
+    # Test direct bin execution
+    if ! ./node_modules/.bin/stackmemory --version > /dev/null 2>&1; then
+        echo "Local install failed - CLI not available via node_modules/.bin"
+        rm -rf "$temp_dir"
+        rm -f "$PROJECT_ROOT/$tarball"
+        return 1
+    fi
+    
+    # Cleanup
+    rm -rf "$temp_dir"
+    rm -f "$PROJECT_ROOT/$tarball"
+    return 0
+}
+
+test_missing_dependencies() {
+    # Test what happens with missing Node.js features
+    local temp_script=$(mktemp)
+    
+    cat > "$temp_script" << 'EOF'
+#!/bin/bash
+cd "$1"
+# Test CLI can handle missing features gracefully
+if node dist/cli/index.js --help 2>&1 | grep -q "Lossless memory"; then
+    echo "CLI loads successfully even with potential missing deps"
+    exit 0
+else
+    echo "CLI failed to load"
+    exit 1
+fi
+EOF
+    
+    if bash "$temp_script" "$PROJECT_ROOT"; then
+        rm -f "$temp_script"
+        return 0
+    else
+        rm -f "$temp_script"
+        return 1
+    fi
+}
+
+test_permission_scenarios() {
+    # Test installation with restricted permissions
+    local temp_dir="/tmp/stackmemory-permission-test"
+    local restricted_home="/tmp/stackmemory-restricted-home"
+    
+    rm -rf "$temp_dir" "$restricted_home"
+    mkdir -p "$temp_dir" "$restricted_home"
+    
+    # Make .stackmemory directory read-only to simulate permission issues
+    mkdir -p "$restricted_home/.stackmemory"
+    chmod 444 "$restricted_home/.stackmemory"
+    
+    cd "$temp_dir"
+    npm init -y > /dev/null 2>&1
+    
+    cd "$PROJECT_ROOT"
+    local tarball=$(npm pack)
+    
+    cd "$temp_dir"
+    npm install "$PROJECT_ROOT/$tarball" > install.log 2>&1
+    
+    # Test CLI still works even with permission issues
+    if HOME="$restricted_home" ./node_modules/.bin/stackmemory --version > /dev/null 2>&1; then
+        # Cleanup
+        chmod 755 "$restricted_home/.stackmemory"
+        rm -rf "$temp_dir" "$restricted_home"
+        rm -f "$PROJECT_ROOT/$tarball"
+        return 0
+    else
+        echo "CLI failed with permission restrictions"
+        chmod 755 "$restricted_home/.stackmemory"
+        rm -rf "$temp_dir" "$restricted_home"
+        rm -f "$PROJECT_ROOT/$tarball"
+        return 1
+    fi
+}
+
+test_multiple_node_versions() {
+    # Test compatibility with different Node.js versions
+    local node_version=$(node --version)
+    
+    # Just test that current version works - in real scenarios you'd test multiple versions
+    if node --version | grep -E "^v(18|20|21|22)"; then
+        log_info "Testing with Node.js $node_version"
+        
+        cd "$PROJECT_ROOT"
+        if node dist/cli/index.js --version > /dev/null 2>&1; then
+            return 0
+        else
+            echo "CLI failed with Node.js $node_version"
+            return 1
+        fi
+    else
+        log_warn "Unsupported Node.js version for testing: $node_version"
+        return 0  # Skip test for unsupported versions
+    fi
+}
+
+test_package_integrity() {
+    cd "$PROJECT_ROOT"
+    
+    # Create package and verify contents
+    local tarball=$(npm pack)
+    local extract_dir="/tmp/stackmemory-integrity-test"
+    
+    rm -rf "$extract_dir"
+    mkdir -p "$extract_dir"
+    cd "$extract_dir"
+    
+    tar -xf "$PROJECT_ROOT/$tarball"
+    cd package
+    
+    # Verify required files exist in package
+    local required_files=("dist/cli/index.js" "package.json" "README.md")
+    for file in "${required_files[@]}"; do
+        if [ ! -f "$file" ]; then
+            echo "Required file missing from package: $file"
+            rm -rf "$extract_dir"
+            rm -f "$PROJECT_ROOT/$tarball"
+            return 1
+        fi
+    done
+    
+    # Verify package.json has correct structure
+    if ! node -e "
+        const pkg = require('./package.json');
+        if (!pkg.bin || !pkg.bin.stackmemory) {
+            console.log('Invalid bin configuration');
+            process.exit(1);
+        }
+        if (!pkg.dependencies) {
+            console.log('Missing dependencies');
+            process.exit(1);
+        }
+    "; then
+        rm -rf "$extract_dir"
+        rm -f "$PROJECT_ROOT/$tarball"
+        return 1
+    fi
+    
+    # Cleanup
+    rm -rf "$extract_dir"
+    rm -f "$PROJECT_ROOT/$tarball"
+    return 0
+}
+
+test_postinstall_setup() {
+    local temp_dir="/tmp/stackmemory-postinstall-test"
+    
+    rm -rf "$temp_dir"
+    mkdir -p "$temp_dir"
+    cd "$temp_dir"
+    
+    npm init -y > /dev/null 2>&1
+    
+    cd "$PROJECT_ROOT"
+    local tarball=$(npm pack)
+    
+    cd "$temp_dir"
+    
+    # Install and check postinstall ran
+    npm install "$PROJECT_ROOT/$tarball" > install.log 2>&1
+    
+    # Check if postinstall script effects are present
+    # (This would check for setup-alias.js effects if that script sets up aliases)
+    
+    if grep -q "postinstall" install.log || echo "Postinstall test passed"; then
+        rm -rf "$temp_dir"
+        rm -f "$PROJECT_ROOT/$tarball"
+        return 0
+    else
+        echo "Postinstall script may not have run correctly"
+        cat install.log
+        rm -rf "$temp_dir"
+        rm -f "$PROJECT_ROOT/$tarball"
+        return 1
+    fi
+}
+
+test_upgrade_scenario() {
+    # Simulate upgrading from an older version
+    local temp_dir="/tmp/stackmemory-upgrade-test"
+    
+    rm -rf "$temp_dir"
+    mkdir -p "$temp_dir"
+    cd "$temp_dir"
+    
+    npm init -y > /dev/null 2>&1
+    
+    # Install current version
+    cd "$PROJECT_ROOT"
+    local tarball=$(npm pack)
+    
+    cd "$temp_dir"
+    npm install "$PROJECT_ROOT/$tarball" > install.log 2>&1
+    
+    # Verify CLI works after "upgrade"
+    if npx stackmemory --version > /dev/null 2>&1; then
+        rm -rf "$temp_dir"
+        rm -f "$PROJECT_ROOT/$tarball"
+        return 0
+    else
+        echo "Upgrade scenario failed"
+        cat install.log
+        rm -rf "$temp_dir"
+        rm -f "$PROJECT_ROOT/$tarball"
+        return 1
+    fi
+}
+
+# Main test execution
+main() {
+    echo "============================================"
+    echo "  StackMemory Installation Scenario Tests"
+    echo "============================================"
+    echo
+    
+    log_info "Testing real-world installation scenarios..."
+    echo
+    
+    # Package integrity
+    run_scenario_test "Package integrity and structure" "test_package_integrity"
+    echo
+    
+    # Installation methods
+    run_scenario_test "Fresh global installation" "test_fresh_global_install"
+    run_scenario_test "Local project installation" "test_local_project_install"
+    echo
+    
+    # Edge cases
+    run_scenario_test "Missing dependencies handling" "test_missing_dependencies"
+    run_scenario_test "Permission restrictions" "test_permission_scenarios"
+    run_scenario_test "Node.js version compatibility" "test_multiple_node_versions"
+    echo
+    
+    # Lifecycle scenarios
+    run_scenario_test "Postinstall setup execution" "test_postinstall_setup"
+    run_scenario_test "Package upgrade scenario" "test_upgrade_scenario"
+    echo
+    
+    # Results
+    echo "============================================"
+    echo "  Installation Scenario Test Results"
+    echo "============================================"
+    echo "Total scenarios: $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 installation scenarios passed!${NC}"
+        return 0
+    else
+        echo -e "${RED}❌ Some installation scenarios failed.${NC}"
+        return 1
+    fi
+}
+
+main "$@"