@stackmemoryai/stackmemory 0.5.14 → 0.5.16

package/scripts/testing/results/real-performance-results.json

@@ -0,0 +1,90 @@
+{
+  "timestamp": "2026-01-06T15:16:51.046Z",
+  "tests": [
+    {
+      "test": "status_command",
+      "iterations": 3,
+      "measurements": [
+        393.8040000000001,
+        396.434667,
+        393.71524999999997
+      ],
+      "average": 394.6513056666667,
+      "unit": "ms"
+    },
+    {
+      "test": "context_operations",
+      "operations": [
+        {
+          "operation": "version_check",
+          "duration": 398.65762500000005,
+          "success": true
+        },
+        {
+          "operation": "tasks_list",
+          "duration": 518.715792,
+          "success": true
+        }
+      ],
+      "totalTime": 917.373417,
+      "unit": "ms"
+    },
+    {
+      "test": "task_operations",
+      "operations": [
+        {
+          "operation": "add_task",
+          "duration": 518.383875,
+          "success": true,
+          "outputSize": 245
+        },
+        {
+          "operation": "list_tasks",
+          "duration": 526.2628340000001,
+          "success": true,
+          "outputSize": 2751
+        },
+        {
+          "operation": "show_task",
+          "duration": 395.6398339999996,
+          "success": true,
+          "outputSize": 92
+        }
+      ],
+      "unit": "ms"
+    },
+    {
+      "test": "storage_performance",
+      "results": {
+        "database": {
+          "exists": true,
+          "size": 602112,
+          "sizeFormatted": "588.00 KB",
+          "modified": "2026-01-06T15:16:54.814Z"
+        },
+        "tasks": {
+          "exists": true,
+          "size": 219410,
+          "sizeFormatted": "214.27 KB",
+          "lineCount": 249,
+          "modified": "2026-01-06T15:16:54.286Z"
+        }
+      }
+    },
+    {
+      "test": "baseline_comparison",
+      "baseline": {
+        "taskListing": {
+          "withStackMemory": 501.72233400000005,
+          "withoutStackMemory": 5000,
+          "unit": "ms"
+        },
+        "taskCreation": {
+          "withStackMemory": 500.09279100000003,
+          "withoutStackMemory": 30000,
+          "unit": "ms"
+        }
+      }
+    }
+  ]
+}

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

@@ -0,0 +1,100 @@
+#!/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/templates/claude-hooks/notify-review-hook.js

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 /**
- * Claude Code hook for SMS notifications on review-ready events
+ * Claude Code hook for WhatsApp/SMS notifications
  *
  * Triggers notifications when:
+ * - AskUserQuestion tool is used (allows remote response)
  * - PR is created
  * - Task is marked complete
  * - User explicitly requests notification
@@ -15,7 +16,35 @@ const path = require('path');
 const os = require('os');
 const https = require('https');
 
+// Load .env files (check multiple locations)
+const envPaths = [
+  path.join(process.cwd(), '.env'),
+  path.join(os.homedir(), 'Dev/stackmemory/.env'),
+  path.join(os.homedir(), '.stackmemory/.env'),
+  path.join(os.homedir(), '.env'),
+];
+for (const envPath of envPaths) {
+  if (fs.existsSync(envPath)) {
+    try {
+      const content = fs.readFileSync(envPath, 'utf8');
+      for (const line of content.split('\n')) {
+        const match = line.match(/^([^#=]+)=(.*)$/);
+        if (match && !process.env[match[1].trim()]) {
+          process.env[match[1].trim()] = match[2]
+            .trim()
+            .replace(/^["']|["']$/g, '');
+        }
+      }
+    } catch {}
+  }
+}
+
 const CONFIG_PATH = path.join(os.homedir(), '.stackmemory', 'sms-notify.json');
+const DEBUG_LOG = path.join(
+  os.homedir(),
+  '.stackmemory',
+  'claude-session-debug.log'
+);
 
 function loadConfig() {
   try {
@@ -23,13 +52,103 @@ function loadConfig() {
       return JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
     }
   } catch {}
-  return { enabled: false };
+  return { enabled: false, pendingPrompts: [] };
+}
+
+function saveConfig(config) {
+  try {
+    const dir = path.join(os.homedir(), '.stackmemory');
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+  } catch (err) {
+    console.error('[notify-hook] Failed to save config:', err.message);
+  }
+}
+
+function logDebug(event, data) {
+  try {
+    const entry = `[${new Date().toISOString()}] ${event}: ${typeof data === 'string' ? data : JSON.stringify(data)}\n`;
+    fs.appendFileSync(DEBUG_LOG, entry);
+  } catch {}
+}
+
+function savePendingPrompt(prompt) {
+  try {
+    const config = loadConfig();
+    if (!config.pendingPrompts) {
+      config.pendingPrompts = [];
+    }
+    config.pendingPrompts.push(prompt);
+    // Keep only last 10 prompts
+    if (config.pendingPrompts.length > 10) {
+      config.pendingPrompts = config.pendingPrompts.slice(-10);
+    }
+    saveConfig(config);
+    logDebug('PENDING_PROMPT', {
+      id: prompt.id,
+      options: prompt.options.length,
+    });
+  } catch (err) {
+    console.error('[notify-hook] Failed to save pending prompt:', err.message);
+  }
 }
 
 function shouldNotify(toolName, toolInput, output) {
   const config = loadConfig();
   if (!config.enabled) return null;
 
+  // AskUserQuestion - send question via WhatsApp for remote response
+  if (toolName === 'AskUserQuestion') {
+    const questions = toolInput?.questions || [];
+    if (questions.length === 0) return null;
+
+    // Take first question (most common case)
+    const q = questions[0];
+    const promptId = Math.random().toString(36).substring(2, 10);
+
+    // Build message text
+    let messageText = q.question;
+    const options = [];
+
+    if (q.options && q.options.length > 0) {
+      messageText += '\n';
+      q.options.forEach((opt, i) => {
+        const key = String(i + 1);
+        messageText += `${key}. ${opt.label}`;
+        if (opt.description) {
+          messageText += ` - ${opt.description}`;
+        }
+        messageText += '\n';
+        options.push({ key, label: opt.label });
+      });
+      // Add "Other" option
+      const otherKey = String(q.options.length + 1);
+      messageText += `${otherKey}. Other (type your answer)`;
+      options.push({ key: otherKey, label: 'Other' });
+    }
+
+    // Store pending prompt in format webhook expects
+    const pendingPrompt = {
+      id: promptId,
+      timestamp: new Date().toISOString(),
+      message: q.question,
+      options: options,
+      type: options.length > 0 ? 'options' : 'freeform',
+      expiresAt: new Date(Date.now() + 60 * 60 * 1000).toISOString(), // 1 hour
+    };
+    savePendingPrompt(pendingPrompt);
+
+    return {
+      type: 'custom',
+      title: 'Claude needs your input',
+      message: messageText,
+      promptId: promptId,
+      isQuestion: true,
+    };
+  }
+
   // Check for PR creation
   if (toolName === 'Bash') {
     const cmd = toolInput?.command || '';
@@ -73,30 +192,71 @@ function shouldNotify(toolName, toolInput, output) {
   return null;
 }
 
-function sendNotification(notification) {
-  const config = loadConfig();
+function getChannelNumbers(config) {
+  const channel = config.channel || 'whatsapp';
 
-  if (
-    !config.accountSid ||
-    !config.authToken ||
-    !config.fromNumber ||
-    !config.toNumber
-  ) {
-    // Try env vars
-    const sid = process.env.TWILIO_ACCOUNT_SID;
-    const token = process.env.TWILIO_AUTH_TOKEN;
-    const from = process.env.TWILIO_FROM_NUMBER;
-    const to = process.env.TWILIO_TO_NUMBER;
-
-    if (!sid || !token || !from || !to) {
-      console.error('[notify-hook] Missing Twilio credentials');
-      return;
+  if (channel === 'whatsapp') {
+    const from = config.whatsappFromNumber || config.fromNumber;
+    const to = config.whatsappToNumber || config.toNumber;
+    if (from && to) {
+      return {
+        from: from.startsWith('whatsapp:') ? from : `whatsapp:${from}`,
+        to: to.startsWith('whatsapp:') ? to : `whatsapp:${to}`,
+        channel: 'whatsapp',
+      };
     }
+  }
 
-    config.accountSid = sid;
-    config.authToken = token;
-    config.fromNumber = from;
-    config.toNumber = to;
+  // Fallback to SMS
+  const from = config.smsFromNumber || config.fromNumber;
+  const to = config.smsToNumber || config.toNumber;
+  if (from && to) {
+    return { from, to, channel: 'sms' };
+  }
+
+  return null;
+}
+
+function sendNotification(notification) {
+  let config = loadConfig();
+
+  // Apply env vars
+  config.accountSid = config.accountSid || process.env.TWILIO_ACCOUNT_SID;
+  config.authToken = config.authToken || process.env.TWILIO_AUTH_TOKEN;
+  config.channel = config.channel || process.env.TWILIO_CHANNEL || 'whatsapp';
+
+  // WhatsApp numbers
+  config.whatsappFromNumber =
+    config.whatsappFromNumber || process.env.TWILIO_WHATSAPP_FROM;
+  config.whatsappToNumber =
+    config.whatsappToNumber || process.env.TWILIO_WHATSAPP_TO;
+
+  // SMS numbers (fallback)
+  config.smsFromNumber =
+    config.smsFromNumber ||
+    process.env.TWILIO_SMS_FROM ||
+    process.env.TWILIO_FROM_NUMBER;
+  config.smsToNumber =
+    config.smsToNumber ||
+    process.env.TWILIO_SMS_TO ||
+    process.env.TWILIO_TO_NUMBER;
+
+  // Legacy support
+  config.fromNumber = config.fromNumber || process.env.TWILIO_FROM_NUMBER;
+  config.toNumber = config.toNumber || process.env.TWILIO_TO_NUMBER;
+
+  if (!config.accountSid || !config.authToken) {
+    console.error('[notify-hook] Missing Twilio credentials');
+    return;
+  }
+
+  const numbers = getChannelNumbers(config);
+  if (!numbers) {
+    console.error(
+      '[notify-hook] Missing phone numbers for channel:',
+      config.channel
+    );
+    return;
   }
 
   let message = `${notification.title}\n\n${notification.message}`;
@@ -109,9 +269,22 @@ function sendNotification(notification) {
     message += '\nReply with number to select';
   }
 
+  // For questions, add reply instruction
+  if (notification.isQuestion) {
+    message += '\n\nReply with your choice number or type your answer.';
+    if (notification.promptId) {
+      message += `\n[ID: ${notification.promptId}]`;
+    }
+  }
+
+  // Add session link if available
+  if (notification.sessionId) {
+    message += `\n\nSession: https://claude.ai/share/${notification.sessionId}`;
+  }
+
   const postData = new URLSearchParams({
-    From: config.fromNumber,
-    To: config.toNumber,
+    From: numbers.from,
+    To: numbers.to,
     Body: message,
   }).toString();
 
@@ -132,11 +305,23 @@ function sendNotification(notification) {
   };
 
   const req = https.request(options, (res) => {
-    if (res.statusCode === 201) {
-      console.error(`[notify-hook] Sent: ${notification.title}`);
-    } else {
-      console.error(`[notify-hook] Failed: ${res.statusCode}`);
-    }
+    let body = '';
+    res.on('data', (chunk) => (body += chunk));
+    res.on('end', () => {
+      if (res.statusCode === 201) {
+        console.error(
+          `[notify-hook] Sent via ${numbers.channel}: ${notification.title}`
+        );
+        logDebug('MESSAGE_SENT', {
+          channel: numbers.channel,
+          title: notification.title,
+          promptId: notification.promptId,
+        });
+      } else {
+        console.error(`[notify-hook] Failed (${res.statusCode}): ${body}`);
+        logDebug('MESSAGE_FAILED', { status: res.statusCode, error: body });
+      }
+    });
   });
 
   req.on('error', (e) => {
@@ -156,15 +341,19 @@ process.stdin.on('end', () => {
     const hookData = JSON.parse(input);
     const { tool_name, tool_input, tool_output } = hookData;
 
+    logDebug('PostToolUse', { tool: tool_name, session: hookData.session_id });
+
     const notification = shouldNotify(tool_name, tool_input, tool_output);
 
     if (notification) {
+      notification.sessionId = hookData.session_id;
       sendNotification(notification);
     }
 
     // Always allow (post-tool hooks don't block)
     console.log(JSON.stringify({ status: 'ok' }));
   } catch (err) {
+    logDebug('ERROR', err.message);
     console.error('[notify-hook] Error:', err.message);
     console.log(JSON.stringify({ status: 'ok' }));
   }