@stackmemoryai/stackmemory 0.8.0 → 1.0.0

package/scripts/recreate-frames-db.js

@@ -1,89 +0,0 @@
-#!/usr/bin/env node
-import 'dotenv/config';
-import Database from 'better-sqlite3';
-import { mkdirSync } from 'fs';
-import { dirname, join } from 'path';
-import { homedir } from 'os';
-
-// Create the database directory if it doesn't exist
-const dbPath = join(homedir(), '.stackmemory', 'context.db');
-mkdirSync(dirname(dbPath), { recursive: true });
-
-// Connect to the database
-const db = new Database(dbPath);
-
-// Create frames table with proper schema
-db.exec(`
-  CREATE TABLE IF NOT EXISTS frames (
-    frame_id TEXT PRIMARY KEY,
-    run_id TEXT NOT NULL,
-    project_id TEXT NOT NULL,
-    parent_frame_id TEXT REFERENCES frames(frame_id),
-    depth INTEGER NOT NULL DEFAULT 0,
-    type TEXT NOT NULL,
-    name TEXT NOT NULL,
-    state TEXT DEFAULT 'active',
-    inputs TEXT DEFAULT '{}',
-    outputs TEXT DEFAULT '{}',
-    digest_text TEXT,
-    digest_json TEXT DEFAULT '{}',
-    created_at INTEGER DEFAULT (unixepoch()),
-    closed_at INTEGER
-  );
-
-  CREATE TABLE IF NOT EXISTS events (
-    event_id TEXT PRIMARY KEY,
-    run_id TEXT NOT NULL,
-    frame_id TEXT NOT NULL,
-    seq INTEGER NOT NULL,
-    event_type TEXT NOT NULL,
-    payload TEXT NOT NULL,
-    ts INTEGER DEFAULT (unixepoch()),
-    FOREIGN KEY(frame_id) REFERENCES frames(frame_id)
-  );
-
-  CREATE TABLE IF NOT EXISTS anchors (
-    anchor_id TEXT PRIMARY KEY,
-    frame_id TEXT NOT NULL,
-    project_id TEXT NOT NULL,
-    type TEXT NOT NULL,
-    text TEXT NOT NULL,
-    priority INTEGER DEFAULT 0,
-    created_at INTEGER DEFAULT (unixepoch()),
-    metadata TEXT DEFAULT '{}',
-    FOREIGN KEY(frame_id) REFERENCES frames(frame_id)
-  );
-
-  CREATE TABLE IF NOT EXISTS handoff_requests (
-    request_id TEXT PRIMARY KEY,
-    source_stack_id TEXT NOT NULL,
-    target_stack_id TEXT NOT NULL,
-    frame_ids TEXT NOT NULL,
-    status TEXT NOT NULL DEFAULT 'pending',
-    created_at INTEGER DEFAULT (unixepoch()),
-    expires_at INTEGER,
-    target_user_id TEXT,
-    message TEXT
-  );
-
-  CREATE INDEX IF NOT EXISTS idx_frames_run ON frames(run_id);
-  CREATE INDEX IF NOT EXISTS idx_frames_parent ON frames(parent_frame_id);
-  CREATE INDEX IF NOT EXISTS idx_frames_state ON frames(state);
-  CREATE INDEX IF NOT EXISTS idx_events_frame ON events(frame_id);
-  CREATE INDEX IF NOT EXISTS idx_events_seq ON events(frame_id, seq);
-  CREATE INDEX IF NOT EXISTS idx_anchors_frame ON anchors(frame_id);
-  CREATE INDEX IF NOT EXISTS idx_handoff_requests_status ON handoff_requests(status);
-  CREATE INDEX IF NOT EXISTS idx_handoff_requests_target ON handoff_requests(target_stack_id);
-`);
-
-console.log('✅ Frames database recreated at:', dbPath);
-
-// Verify tables exist
-const tables = db.prepare("SELECT name FROM sqlite_master WHERE type='table'").all();
-console.log('📊 Tables created:', tables.map(t => t.name).join(', '));
-
-// Check if we have any existing frames
-const frameCount = db.prepare('SELECT COUNT(*) as count FROM frames').get();
-console.log('📈 Existing frames:', frameCount.count);
-
-db.close();

package/scripts/setup-notify-webhook.sh

@@ -1,103 +0,0 @@
-#!/bin/bash
-# Auto-setup for StackMemory WhatsApp/SMS webhook loop
-
-set -e
-
-WEBHOOK_PORT="${1:-3456}"
-TWILIO_ACCOUNT_SID="${TWILIO_ACCOUNT_SID}"
-TWILIO_AUTH_TOKEN="${TWILIO_AUTH_TOKEN}"
-
-echo "=== StackMemory Webhook Setup ==="
-echo ""
-
-# Check dependencies
-if ! command -v ngrok &> /dev/null; then
-  echo "Installing ngrok..."
-  if command -v brew &> /dev/null; then
-    brew install ngrok
-  else
-    echo "Please install ngrok: https://ngrok.com/download"
-    exit 1
-  fi
-fi
-
-# Check Twilio credentials
-if [ -z "$TWILIO_ACCOUNT_SID" ] || [ -z "$TWILIO_AUTH_TOKEN" ]; then
-  echo "Error: Set TWILIO_ACCOUNT_SID and TWILIO_AUTH_TOKEN"
-  exit 1
-fi
-
-# Kill any existing processes
-pkill -f "notify webhook" 2>/dev/null || true
-pkill -f "ngrok http $WEBHOOK_PORT" 2>/dev/null || true
-sleep 1
-
-# Start webhook server in background
-echo "Starting webhook server on port $WEBHOOK_PORT..."
-stackmemory notify webhook -p "$WEBHOOK_PORT" > /tmp/webhook.log 2>&1 &
-WEBHOOK_PID=$!
-sleep 2
-
-# Start ngrok in background
-echo "Starting ngrok tunnel..."
-ngrok http "$WEBHOOK_PORT" --log=stdout > /tmp/ngrok.log 2>&1 &
-NGROK_PID=$!
-sleep 3
-
-# Get ngrok public URL
-NGROK_URL=$(curl -s http://localhost:4040/api/tunnels | grep -o '"public_url":"https://[^"]*' | head -1 | cut -d'"' -f4)
-
-if [ -z "$NGROK_URL" ]; then
-  echo "Error: Could not get ngrok URL. Check /tmp/ngrok.log"
-  exit 1
-fi
-
-WEBHOOK_URL="${NGROK_URL}/sms/incoming"
-echo ""
-echo "Webhook URL: $WEBHOOK_URL"
-
-# Configure Twilio WhatsApp sandbox webhook
-echo ""
-echo "Configuring Twilio WhatsApp sandbox..."
-
-# Get sandbox configuration
-SANDBOX_RESPONSE=$(curl -s "https://api.twilio.com/2010-04-01/Accounts/${TWILIO_ACCOUNT_SID}/Sandbox.json" \
-  -u "${TWILIO_ACCOUNT_SID}:${TWILIO_AUTH_TOKEN}" 2>/dev/null)
-
-if echo "$SANDBOX_RESPONSE" | grep -q "sms_url"; then
-  # Update sandbox webhook URL
-  curl -s -X POST "https://api.twilio.com/2010-04-01/Accounts/${TWILIO_ACCOUNT_SID}/Sandbox.json" \
-    -u "${TWILIO_ACCOUNT_SID}:${TWILIO_AUTH_TOKEN}" \
-    -d "SmsUrl=${WEBHOOK_URL}" \
-    -d "SmsMethod=POST" > /dev/null
-  echo "Sandbox webhook configured!"
-else
-  echo "Note: Configure webhook manually in Twilio console:"
-  echo "  URL: $WEBHOOK_URL"
-  echo "  https://console.twilio.com/us1/develop/sms/try-it-out/whatsapp-learn"
-fi
-
-# Install Claude hook
-echo ""
-echo "Installing Claude response hook..."
-stackmemory notify install-response-hook 2>/dev/null || true
-
-# Save PIDs for cleanup
-echo "$WEBHOOK_PID" > /tmp/stackmemory-webhook.pid
-echo "$NGROK_PID" > /tmp/stackmemory-ngrok.pid
-
-echo ""
-echo "=== Setup Complete ==="
-echo ""
-echo "Webhook server: http://localhost:$WEBHOOK_PORT (PID: $WEBHOOK_PID)"
-echo "Ngrok tunnel:   $NGROK_URL (PID: $NGROK_PID)"
-echo "Webhook URL:    $WEBHOOK_URL"
-echo ""
-echo "The loop is now active:"
-echo "  1. Send notification: stackmemory notify review 'Task'"
-echo "  2. User replies via WhatsApp"
-echo "  3. Response queued for action"
-echo "  4. Claude hook processes it"
-echo ""
-echo "To stop: ./scripts/stop-notify-webhook.sh"
-echo "Logs: /tmp/webhook.log, /tmp/ngrok.log"

package/scripts/show-linear-summary.ts

@@ -1,172 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Show Linear task summary with all statuses
- */
-
-import { readFileSync } from 'fs';
-import { join } from 'path';
-
-interface LinearIssue {
-  identifier: string;
-  title: string;
-  state: {
-    name: string;
-    type: string;
-  };
-  createdAt: string;
-  updatedAt: string;
-}
-
-async function showLinearSummary() {
-  // Load Linear tokens
-  const tokensPath = join(process.cwd(), '.stackmemory', 'linear-tokens.json');
-  let accessToken: string;
-
-  try {
-    const tokensData = readFileSync(tokensPath, 'utf8');
-    const tokens = JSON.parse(tokensData);
-    accessToken = tokens.accessToken;
-  } catch {
-    console.error(
-      '❌ Failed to load Linear tokens. Please run: stackmemory linear setup'
-    );
-    process.exit(1);
-  }
-
-  // GraphQL helper
-  const linearApiUrl = 'https://api.linear.app/graphql';
-
-  async function graphqlRequest(
-    query: string,
-    variables: Record<string, unknown> = {}
-  ) {
-    const response = await fetch(linearApiUrl, {
-      method: 'POST',
-      headers: {
-        Authorization: `Bearer ${accessToken}`,
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify({ query, variables }),
-    });
-
-    if (!response.ok) {
-      throw new Error(
-        `Linear API error: ${response.status} ${response.statusText}`
-      );
-    }
-
-    const result = (await response.json()) as {
-      errors?: unknown[];
-      data: unknown;
-    };
-    if (result.errors) {
-      throw new Error(`GraphQL errors: ${JSON.stringify(result.errors)}`);
-    }
-
-    return result.data;
-  }
-
-  // Get issues grouped by state
-  const issuesQuery = `
-    query {
-      issues(first: 250) {
-        nodes {
-          identifier
-          title
-          state {
-            name
-            type
-          }
-          createdAt
-          updatedAt
-        }
-      }
-    }
-  `;
-
-  const data = (await graphqlRequest(issuesQuery)) as {
-    issues: { nodes: LinearIssue[] };
-  };
-  const issues = data.issues.nodes;
-
-  // Group by state type
-  const grouped = new Map<string, LinearIssue[]>();
-
-  for (const issue of issues) {
-    const stateType = issue.state.type;
-    if (!grouped.has(stateType)) {
-      grouped.set(stateType, []);
-    }
-    const stateIssues = grouped.get(stateType);
-    if (stateIssues) {
-      stateIssues.push(issue);
-    }
-  }
-
-  // Display summary
-  console.log('\n📊 Linear Task Summary\n');
-  console.log('='.repeat(60));
-
-  const stateOrder = [
-    'backlog',
-    'unstarted',
-    'started',
-    'completed',
-    'canceled',
-  ];
-
-  for (const state of stateOrder) {
-    const stateIssues = grouped.get(state) || [];
-    if (stateIssues.length === 0) continue;
-
-    const emoji =
-      {
-        backlog: '📋',
-        unstarted: '⏳',
-        started: '🔄',
-        completed: '✅',
-        canceled: '❌',
-      }[state] || '⚪';
-
-    console.log(
-      `\n${emoji} ${state.toUpperCase()} (${stateIssues.length} tasks)`
-    );
-    console.log('-'.repeat(40));
-
-    // Show recent items (last 5)
-    const recent = stateIssues
-      .sort(
-        (a, b) =>
-          new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()
-      )
-      .slice(0, state === 'canceled' ? 20 : 5);
-
-    for (const issue of recent) {
-      const updatedDate = new Date(issue.updatedAt).toLocaleDateString();
-      console.log(
-        `  ${issue.identifier.padEnd(10)} ${issue.title.slice(0, 50).padEnd(50)} ${updatedDate}`
-      );
-    }
-
-    if (stateIssues.length > recent.length) {
-      console.log(`  ... and ${stateIssues.length - recent.length} more`);
-    }
-  }
-
-  console.log('\n' + '='.repeat(60));
-  console.log('\n📈 Total Issues: ' + issues.length);
-  const activeCount =
-    (grouped.get('started')?.length ?? 0) +
-    (grouped.get('unstarted')?.length ?? 0) +
-    (grouped.get('backlog')?.length ?? 0);
-  console.log('   Active: ' + activeCount);
-  console.log('   Completed: ' + (grouped.get('completed')?.length ?? 0));
-  console.log('   Canceled: ' + (grouped.get('canceled')?.length ?? 0));
-}
-
-// Run
-showLinearSummary().catch((error) => {
-  console.error('❌ Error:', error);
-  process.exit(1);
-});

package/scripts/simple-swarm-demo.ts

@@ -1,114 +0,0 @@
-#!/usr/bin/env npx tsx
-
-/**
- * Simple Ralph Swarm Demo - Minimal database dependencies
- * Demonstrates basic swarm coordination without complex SessionManager setup
- */
-
-import 'dotenv/config';
-import { SwarmCoordinator } from '../src/integrations/ralph/swarm/swarm-coordinator.js';
-import { SwarmRegistry } from '../src/integrations/ralph/monitoring/swarm-registry.js';
-import { logger } from '../src/core/monitoring/logger.js';
-
-async function runSimpleSwarm() {
-  try {
-    console.log('🦾 Starting Simple Ralph Swarm Demo...');
-
-    // Initialize registry
-    const registry = SwarmRegistry.getInstance();
-
-    // Create a basic swarm coordinator without complex dependencies
-    const coordinator = new SwarmCoordinator({
-      maxAgents: 2,
-      timeout: 30000,
-      enableGitWorkflow: false, // Disable git workflow to avoid branch conflicts
-      enableStackMemoryBridge: false, // Disable StackMemory integration temporarily
-    });
-
-    // Initialize coordinator
-    await coordinator.initialize();
-
-    console.log('✅ Swarm coordinator initialized');
-
-    // Define a simple task
-    const task = {
-      id: 'simple-demo-task',
-      description:
-        'Demonstrate basic swarm functionality without database dependencies',
-      type: 'demonstration' as const,
-      priority: 'medium' as const,
-      estimatedDuration: 30000,
-      requirements: [
-        'Show swarm initialization',
-        'Demonstrate agent coordination',
-        'Validate basic functionality',
-      ],
-    };
-
-    console.log('📋 Task defined:', task.description);
-
-    // Register the swarm
-    const swarmId = registry.registerSwarm(
-      coordinator,
-      'Simple Demo Swarm - No Database Dependencies'
-    );
-
-    console.log('🆔 Swarm registered:', swarmId);
-
-    // Launch with minimal configuration
-    const result = await coordinator.launchSwarm(
-      task.description,
-      [
-        {
-          role: 'developer',
-          specialization: 'basic-functionality',
-        },
-      ],
-      {
-        enableRalphBridge: false, // Disable Ralph bridge to avoid database issues
-        enableGitWorkflow: false, // Already disabled in coordinator init
-      }
-    );
-
-    console.log('🚀 Swarm launched successfully!');
-    console.log('📊 Result:', {
-      swarmId: result.swarmId,
-      agentCount: result.agents?.length || 0,
-      status: result.status,
-    });
-
-    // Show registry status
-    const activeSwarms = registry.listActiveSwarms();
-    console.log('📈 Active swarms:', activeSwarms.length);
-
-    // Simulate some work
-    console.log('⏳ Simulating swarm work for 5 seconds...');
-    await new Promise((resolve) => setTimeout(resolve, 5000));
-
-    // Stop the swarm
-    console.log('🛑 Stopping swarm...');
-    await coordinator.stopSwarm();
-
-    console.log('');
-    console.log('🎉 Simple swarm demo completed successfully!');
-    console.log('');
-    console.log('✅ Demonstrated:');
-    console.log('   - Basic swarm coordinator initialization');
-    console.log('   - Swarm registry management');
-    console.log('   - Agent configuration without database dependencies');
-    console.log('   - Simple task execution workflow');
-    console.log('');
-    console.log('🔧 This approach bypasses:');
-    console.log('   - Complex SessionManager database setup');
-    console.log('   - StackMemory FrameManager initialization');
-    console.log('   - Git workflow branch conflicts');
-    console.log('   - Ralph-StackMemory bridge complications');
-  } catch (error: unknown) {
-    console.error('❌ Simple swarm demo failed:', (error as Error).message);
-    logger.error('Simple swarm demo error', error as Error);
-    process.exit(1);
-  }
-}
-
-// Run the demo
-runSimpleSwarm();

package/scripts/stackmemory-auto-handoff.sh

@@ -1,231 +0,0 @@
-#!/bin/bash
-# StackMemory Auto-Handoff Wrapper
-# Wraps any command and captures context on termination
-
-set -e
-
-# Configuration
-STACKMEMORY_BIN="${STACKMEMORY_BIN:-stackmemory}"
-HANDOFF_DIR="${HOME}/.stackmemory/handoffs"
-LOG_FILE="${HANDOFF_DIR}/auto-handoff.log"
-
-# Colors
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-BLUE='\033[0;34m'
-NC='\033[0m'
-
-# Ensure directories exist
-mkdir -p "$HANDOFF_DIR"
-
-# Log function
-log() {
-    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" >> "$LOG_FILE"
-}
-
-# Function to capture handoff
-capture_handoff() {
-    local reason="$1"
-    local exit_code="${2:-0}"
-    
-    echo -e "${YELLOW}📸 Capturing handoff context...${NC}"
-    log "Capturing handoff: reason=$reason, exit_code=$exit_code"
-    
-    # Run stackmemory capture command
-    if command -v "$STACKMEMORY_BIN" &> /dev/null; then
-        # Capture the handoff
-        "$STACKMEMORY_BIN" capture --no-commit 2>&1 | tee -a "$LOG_FILE"
-        
-        # Save additional metadata
-        local metadata_file="${HANDOFF_DIR}/last-handoff-meta.json"
-        cat > "$metadata_file" << EOF
-{
-    "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
-    "reason": "$reason",
-    "exit_code": $exit_code,
-    "command": "$WRAPPED_COMMAND",
-    "pid": $$,
-    "cwd": "$(pwd)",
-    "user": "$USER",
-    "session_duration": $(($(date +%s) - SESSION_START))
-}
-EOF
-        
-        echo -e "${GREEN}✅ Handoff captured successfully${NC}"
-        log "Handoff captured: $metadata_file"
-        
-        # Show quick summary
-        echo -e "${BLUE}📋 Session Summary:${NC}"
-        echo "  Duration: $(($(date +%s) - SESSION_START)) seconds"
-        echo "  Exit reason: $reason"
-        
-        # Check for uncommitted changes
-        if git status --short 2>/dev/null | grep -q .; then
-            echo -e "${YELLOW}⚠️  You have uncommitted changes${NC}"
-            echo "  Run 'git status' to review"
-        fi
-        
-        # Check for active tasks
-        local active_tasks=$("$STACKMEMORY_BIN" task list --state in_progress --format json 2>/dev/null | jq -r '.[].title' 2>/dev/null)
-        if [ -n "$active_tasks" ]; then
-            echo -e "${BLUE}📝 Active tasks:${NC}"
-            echo "$active_tasks" | while read -r task; do
-                echo "  • $task"
-            done
-        fi
-        
-        echo -e "${GREEN}✨ Run 'stackmemory restore' in your next session${NC}"
-    else
-        echo -e "${RED}❌ StackMemory not found${NC}"
-        log "ERROR: StackMemory binary not found"
-    fi
-}
-
-# Signal handlers
-handle_sigint() {
-    echo -e "\n${YELLOW}⚠️  Interrupted (Ctrl+C)${NC}"
-    capture_handoff "SIGINT" 130
-    exit 130
-}
-
-handle_sigterm() {
-    echo -e "\n${YELLOW}⚠️  Terminated${NC}"
-    capture_handoff "SIGTERM" 143
-    exit 143
-}
-
-handle_sighup() {
-    echo -e "\n${YELLOW}⚠️  Hangup signal${NC}"
-    capture_handoff "SIGHUP" 129
-    exit 129
-}
-
-handle_exit() {
-    local exit_code=$?
-    if [ $exit_code -ne 0 ] && [ $exit_code -ne 130 ] && [ $exit_code -ne 143 ] && [ $exit_code -ne 129 ]; then
-        echo -e "${YELLOW}⚠️  Unexpected exit (code: $exit_code)${NC}"
-        capture_handoff "unexpected_exit" $exit_code
-    elif [ $exit_code -eq 0 ]; then
-        # Normal exit - ask if user wants to capture handoff
-        if [ "$AUTO_CAPTURE_ON_EXIT" = "true" ]; then
-            capture_handoff "normal_exit" 0
-        else
-            echo -e "${BLUE}💡 Session ending normally. Create handoff? (y/N):${NC} \c"
-            read -t 5 -n 1 response || response="n"
-            echo
-            if [[ "$response" =~ ^[Yy]$ ]]; then
-                capture_handoff "normal_exit" 0
-            fi
-        fi
-    fi
-}
-
-# Usage information
-usage() {
-    cat << EOF
-Usage: $0 [OPTIONS] COMMAND [ARGS...]
-
-Wraps a command with automatic handoff capture on termination.
-
-Options:
-    -h, --help              Show this help message
-    -a, --auto              Auto-capture on normal exit (no prompt)
-    -q, --quiet             Suppress output
-    -t, --tag TAG           Tag this session
-    
-Examples:
-    $0 claude                          # Wrap Claude session
-    $0 -a npm run dev                  # Auto-capture on exit
-    $0 -t "feature-work" vim          # Tagged session
-    
-Environment Variables:
-    STACKMEMORY_BIN         Path to stackmemory binary
-    AUTO_CAPTURE_ON_EXIT    Set to 'true' for auto-capture
-
-Without arguments, enables handoff mode for current shell session.
-EOF
-}
-
-# Parse arguments
-AUTO_CAPTURE_ON_EXIT="${AUTO_CAPTURE_ON_EXIT:-false}"
-SESSION_TAG=""
-QUIET_MODE="false"
-
-while [[ $# -gt 0 ]]; do
-    case "$1" in
-        -h|--help)
-            usage
-            exit 0
-            ;;
-        -a|--auto)
-            AUTO_CAPTURE_ON_EXIT="true"
-            shift
-            ;;
-        -q|--quiet)
-            QUIET_MODE="true"
-            shift
-            ;;
-        -t|--tag)
-            SESSION_TAG="$2"
-            shift 2
-            ;;
-        *)
-            break
-            ;;
-    esac
-done
-
-# If no command provided, just set up handlers for current session
-if [ $# -eq 0 ]; then
-    echo -e "${BLUE}🛡️  StackMemory Auto-Handoff Enabled${NC}"
-    echo -e "${GRAY}Context will be captured on session termination${NC}"
-    echo -e "${YELLOW}Press Ctrl+C to test or exit normally to continue${NC}"
-    
-    # Set up signal handlers
-    trap handle_sigint SIGINT
-    trap handle_sigterm SIGTERM
-    trap handle_sighup SIGHUP
-    trap handle_exit EXIT
-    
-    # Record session start
-    export SESSION_START=$(date +%s)
-    export WRAPPED_COMMAND="interactive_shell"
-    
-    # Keep running
-    while true; do
-        sleep 1
-    done
-else
-    # Wrap the provided command
-    WRAPPED_COMMAND="$*"
-    
-    if [ "$QUIET_MODE" = "false" ]; then
-        echo -e "${BLUE}🛡️  StackMemory Auto-Handoff Wrapper${NC}"
-        echo -e "Wrapping: $WRAPPED_COMMAND"
-        if [ -n "$SESSION_TAG" ]; then
-            echo -e "Tag: $SESSION_TAG"
-        fi
-        echo -e "${GRAY}Handoff will be captured on termination${NC}"
-        echo
-    fi
-    
-    # Set up signal handlers
-    trap handle_sigint SIGINT
-    trap handle_sigterm SIGTERM
-    trap handle_sighup SIGHUP
-    trap handle_exit EXIT
-    
-    # Record session start
-    export SESSION_START=$(date +%s)
-    
-    log "Starting wrapped session: $WRAPPED_COMMAND"
-    
-    # Execute the wrapped command
-    "$@"
-    
-    # Command completed normally
-    exit_code=$?
-    log "Command completed with exit code: $exit_code"
-    exit $exit_code
-fi