@stackmemoryai/stackmemory 0.5.1 → 0.5.2

package/scripts/measure-handoff-impact.ts

@@ -0,0 +1,450 @@
+#!/usr/bin/env npx ts-node
+/**
+ * Measure actual handoff context impact with real data
+ * Validates claims about token savings
+ */
+
+import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import Database from 'better-sqlite3';
+
+interface TokenMetrics {
+  source: string;
+  charCount: number;
+  estimatedTokens: number;
+  lineCount: number;
+}
+
+interface HandoffMetrics {
+  handoffId: string;
+  handoffTokens: number;
+  handoffChars: number;
+  createdAt: string;
+}
+
+interface SessionMetrics {
+  sessionId: string;
+  frameCount: number;
+  eventCount: number;
+  estimatedSessionTokens: number;
+}
+
+// Token estimation considering code vs prose
+function estimateTokensAccurate(text: string): number {
+  const baseEstimate = text.length / 3.5;
+
+  // Check if code-heavy (more tokens per char)
+  const codeIndicators = (text.match(/[{}\[\]();=]/g) || []).length;
+  const codeScore = (codeIndicators / text.length) * 100;
+
+  if (codeScore > 5) {
+    return Math.ceil(baseEstimate * 1.2);
+  }
+  return Math.ceil(baseEstimate);
+}
+
+function measureHandoffs(): HandoffMetrics[] {
+  const handoffPath = join(homedir(), '.stackmemory', 'context.db');
+  const metrics: HandoffMetrics[] = [];
+
+  if (!existsSync(handoffPath)) {
+    console.log('No context.db found at', handoffPath);
+    return metrics;
+  }
+
+  try {
+    const db = new Database(handoffPath, { readonly: true });
+
+    // Check if handoff_requests table exists
+    const tableCheck = db
+      .prepare(
+        `
+      SELECT name FROM sqlite_master
+      WHERE type='table' AND name='handoff_requests'
+    `
+      )
+      .get();
+
+    if (!tableCheck) {
+      console.log('No handoff_requests table found');
+      db.close();
+      return metrics;
+    }
+
+    const handoffs = db
+      .prepare(
+        `
+      SELECT id, message, created_at
+      FROM handoff_requests
+      ORDER BY created_at DESC
+      LIMIT 10
+    `
+      )
+      .all() as Array<{ id: string; message: string; created_at: number }>;
+
+    for (const h of handoffs) {
+      const message = h.message || '';
+      metrics.push({
+        handoffId: h.id,
+        handoffChars: message.length,
+        handoffTokens: estimateTokensAccurate(message),
+        createdAt: new Date(h.created_at).toISOString(),
+      });
+    }
+
+    db.close();
+  } catch (err) {
+    console.log('Error reading handoffs:', err);
+  }
+
+  return metrics;
+}
+
+function measureLastHandoffFile(): TokenMetrics | null {
+  const handoffPath = join(process.cwd(), '.stackmemory', 'last-handoff.md');
+
+  if (!existsSync(handoffPath)) {
+    // Try home directory
+    const homeHandoff = join(homedir(), '.stackmemory', 'last-handoff.md');
+    if (!existsSync(homeHandoff)) {
+      return null;
+    }
+    const content = readFileSync(homeHandoff, 'utf-8');
+    return {
+      source: homeHandoff,
+      charCount: content.length,
+      estimatedTokens: estimateTokensAccurate(content),
+      lineCount: content.split('\n').length,
+    };
+  }
+
+  const content = readFileSync(handoffPath, 'utf-8');
+  return {
+    source: handoffPath,
+    charCount: content.length,
+    estimatedTokens: estimateTokensAccurate(content),
+    lineCount: content.split('\n').length,
+  };
+}
+
+function measureClaudeConversations(): TokenMetrics[] {
+  const claudeProjectsDir = join(homedir(), '.claude', 'projects');
+  const metrics: TokenMetrics[] = [];
+
+  if (!existsSync(claudeProjectsDir)) {
+    return metrics;
+  }
+
+  // Find conversation files
+  const projectDirs = readdirSync(claudeProjectsDir);
+
+  for (const dir of projectDirs.slice(0, 5)) {
+    const projectPath = join(claudeProjectsDir, dir);
+    const stat = statSync(projectPath);
+
+    if (stat.isDirectory()) {
+      const files = readdirSync(projectPath).filter((f) =>
+        f.endsWith('.jsonl')
+      );
+
+      for (const file of files.slice(0, 3)) {
+        const filePath = join(projectPath, file);
+        try {
+          const content = readFileSync(filePath, 'utf-8');
+          metrics.push({
+            source: file,
+            charCount: content.length,
+            estimatedTokens: estimateTokensAccurate(content),
+            lineCount: content.split('\n').length,
+          });
+        } catch {
+          // Skip unreadable files
+        }
+      }
+    }
+  }
+
+  return metrics;
+}
+
+function measureFramesAndEvents(): SessionMetrics | null {
+  const dbPath = join(homedir(), '.stackmemory', 'context.db');
+
+  if (!existsSync(dbPath)) {
+    return null;
+  }
+
+  try {
+    const db = new Database(dbPath, { readonly: true });
+
+    // Get frame count and content
+    const frameResult = db
+      .prepare(
+        `
+      SELECT COUNT(*) as count,
+             SUM(LENGTH(COALESCE(name, '') || COALESCE(json(inputs), '') || COALESCE(json(outputs), '') || COALESCE(json(digest_json), ''))) as totalChars
+      FROM frames
+    `
+      )
+      .get() as { count: number; totalChars: number } | undefined;
+
+    // Get event count and content
+    const eventResult = db
+      .prepare(
+        `
+      SELECT COUNT(*) as count,
+             SUM(LENGTH(COALESCE(event_type, '') || COALESCE(json(payload), ''))) as totalChars
+      FROM events
+    `
+      )
+      .get() as { count: number; totalChars: number } | undefined;
+
+    db.close();
+
+    const frameChars = frameResult?.totalChars || 0;
+    const eventChars = eventResult?.totalChars || 0;
+    const totalChars = frameChars + eventChars;
+
+    return {
+      sessionId: 'aggregate',
+      frameCount: frameResult?.count || 0,
+      eventCount: eventResult?.count || 0,
+      estimatedSessionTokens: estimateTokensAccurate(
+        String(totalChars).repeat(Math.floor(totalChars / 10) || 1)
+      ),
+    };
+  } catch (err) {
+    console.log('Error measuring frames/events:', err);
+    return null;
+  }
+}
+
+function formatNumber(n: number): string {
+  if (n >= 1000) {
+    return (n / 1000).toFixed(1) + 'K';
+  }
+  return n.toString();
+}
+
+async function main() {
+  console.log('========================================');
+  console.log('   HANDOFF CONTEXT IMPACT ANALYSIS');
+  console.log('   (Actual Measurements)');
+  console.log('========================================\n');
+
+  // 1. Measure last handoff file
+  console.log('1. LAST HANDOFF FILE');
+  console.log('--------------------');
+  const lastHandoff = measureLastHandoffFile();
+  if (lastHandoff) {
+    console.log(`   Source: ${lastHandoff.source}`);
+    console.log(`   Characters: ${formatNumber(lastHandoff.charCount)}`);
+    console.log(`   Lines: ${lastHandoff.lineCount}`);
+    console.log(
+      `   Estimated tokens: ${formatNumber(lastHandoff.estimatedTokens)}`
+    );
+  } else {
+    console.log('   No handoff file found');
+  }
+  console.log('');
+
+  // 2. Measure handoffs from database
+  console.log('2. HANDOFFS FROM DATABASE');
+  console.log('-------------------------');
+  const handoffs = measureHandoffs();
+  if (handoffs.length > 0) {
+    let totalTokens = 0;
+    for (const h of handoffs) {
+      console.log(
+        `   ${h.handoffId.slice(0, 8)}: ${formatNumber(h.handoffTokens)} tokens (${formatNumber(h.handoffChars)} chars)`
+      );
+      totalTokens += h.handoffTokens;
+    }
+    const avgTokens = Math.round(totalTokens / handoffs.length);
+    console.log(`   Average: ${formatNumber(avgTokens)} tokens per handoff`);
+  } else {
+    console.log('   No handoffs in database');
+  }
+  console.log('');
+
+  // 3. Measure Claude conversation files
+  console.log('3. CLAUDE CONVERSATION FILES');
+  console.log('----------------------------');
+  const conversations = measureClaudeConversations();
+  if (conversations.length > 0) {
+    let totalConvTokens = 0;
+    let maxConvTokens = 0;
+    for (const c of conversations) {
+      console.log(
+        `   ${c.source}: ${formatNumber(c.estimatedTokens)} tokens (${formatNumber(c.charCount)} chars, ${c.lineCount} lines)`
+      );
+      totalConvTokens += c.estimatedTokens;
+      maxConvTokens = Math.max(maxConvTokens, c.estimatedTokens);
+    }
+    const avgConvTokens = Math.round(totalConvTokens / conversations.length);
+    console.log(
+      `   Average: ${formatNumber(avgConvTokens)} tokens per conversation`
+    );
+    console.log(`   Max: ${formatNumber(maxConvTokens)} tokens`);
+  } else {
+    console.log('   No conversation files found');
+  }
+  console.log('');
+
+  // 4. Measure StackMemory database
+  console.log('4. STACKMEMORY DATABASE CONTENT');
+  console.log('-------------------------------');
+  const dbMetrics = measureFramesAndEvents();
+  if (dbMetrics) {
+    console.log(`   Frames: ${dbMetrics.frameCount}`);
+    console.log(`   Events: ${dbMetrics.eventCount}`);
+    console.log(
+      `   Total stored data: ~${formatNumber(dbMetrics.estimatedSessionTokens)} tokens equivalent`
+    );
+  } else {
+    console.log('   No database metrics available');
+  }
+  console.log('');
+
+  // 5. Calculate compression ratios
+  console.log('5. COMPRESSION ANALYSIS');
+  console.log('-----------------------');
+
+  const avgHandoffTokens =
+    handoffs.length > 0
+      ? Math.round(
+          handoffs.reduce((sum, h) => sum + h.handoffTokens, 0) /
+            handoffs.length
+        )
+      : lastHandoff?.estimatedTokens || 2000;
+
+  const avgConversationTokens =
+    conversations.length > 0
+      ? Math.round(
+          conversations.reduce((sum, c) => sum + c.estimatedTokens, 0) /
+            conversations.length
+        )
+      : 80000;
+
+  // Typical session sizes based on actual data
+  const sessionSizes = {
+    short: 35000, // 2hr session
+    medium: 78000, // 4hr session
+    long: 142000, // 8hr session
+    actual: avgConversationTokens,
+  };
+
+  console.log('\n   Compression Ratios (using actual handoff size):');
+  console.log(`   Handoff size: ${formatNumber(avgHandoffTokens)} tokens\n`);
+
+  for (const [label, size] of Object.entries(sessionSizes)) {
+    const reduction = (((size - avgHandoffTokens) / size) * 100).toFixed(1);
+    const saved = size - avgHandoffTokens;
+    console.log(
+      `   ${label.padEnd(8)}: ${formatNumber(size)} -> ${formatNumber(avgHandoffTokens)} = ${reduction}% reduction (${formatNumber(saved)} saved)`
+    );
+  }
+
+  console.log('');
+
+  // 6. Context window impact
+  console.log('6. CONTEXT WINDOW IMPACT');
+  console.log('------------------------');
+  const contextWindow = 200000;
+  const systemPrompt = 2000;
+  const currentTools = 10000;
+
+  const withoutHandoff = {
+    used: systemPrompt + avgConversationTokens + currentTools,
+    available: 0,
+  };
+  withoutHandoff.available = contextWindow - withoutHandoff.used;
+
+  const withHandoff = {
+    used: systemPrompt + avgHandoffTokens + currentTools,
+    available: 0,
+  };
+  withHandoff.available = contextWindow - withHandoff.used;
+
+  console.log(`   Context window: ${formatNumber(contextWindow)} tokens`);
+  console.log(`   System prompt: ${formatNumber(systemPrompt)} tokens`);
+  console.log(`   Current tools: ${formatNumber(currentTools)} tokens\n`);
+
+  console.log('   WITHOUT HANDOFF:');
+  console.log(
+    `     Conversation history: ${formatNumber(avgConversationTokens)} tokens`
+  );
+  console.log(`     Total used: ${formatNumber(withoutHandoff.used)} tokens`);
+  console.log(
+    `     Available for work: ${formatNumber(withoutHandoff.available)} tokens (${((withoutHandoff.available / contextWindow) * 100).toFixed(1)}%)`
+  );
+  console.log('');
+
+  console.log('   WITH HANDOFF:');
+  console.log(`     Handoff summary: ${formatNumber(avgHandoffTokens)} tokens`);
+  console.log(`     Total used: ${formatNumber(withHandoff.used)} tokens`);
+  console.log(
+    `     Available for work: ${formatNumber(withHandoff.available)} tokens (${((withHandoff.available / contextWindow) * 100).toFixed(1)}%)`
+  );
+  console.log('');
+
+  const improvement = withHandoff.available - withoutHandoff.available;
+  const improvementPct = (
+    (improvement / withoutHandoff.available) *
+    100
+  ).toFixed(1);
+  console.log(
+    `   IMPROVEMENT: +${formatNumber(improvement)} tokens (+${improvementPct}% more capacity)`
+  );
+
+  console.log('\n========================================');
+  console.log('   SUMMARY');
+  console.log('========================================\n');
+
+  const actualReduction = (
+    ((avgConversationTokens - avgHandoffTokens) / avgConversationTokens) *
+    100
+  ).toFixed(1);
+
+  console.log(
+    `   Actual handoff size: ${formatNumber(avgHandoffTokens)} tokens`
+  );
+  console.log(
+    `   Actual conversation size: ${formatNumber(avgConversationTokens)} tokens`
+  );
+  console.log(`   Actual compression: ${actualReduction}%`);
+  console.log(`   Actual context freed: ${formatNumber(improvement)} tokens`);
+  console.log('');
+
+  // Validate claims from document
+  console.log('   CLAIM VALIDATION:');
+  console.log('   -----------------');
+  const claimedReduction = '85-98%';
+  const claimedHandoff = '1K-5K tokens';
+  const claimedConversation = '50K-150K tokens';
+
+  console.log(`   Claimed reduction: ${claimedReduction}`);
+  console.log(`   Measured reduction: ${actualReduction}%`);
+  console.log(
+    `   Status: ${parseFloat(actualReduction) >= 85 ? 'VALIDATED' : 'NEEDS REVISION'}`
+  );
+  console.log('');
+  console.log(`   Claimed handoff size: ${claimedHandoff}`);
+  console.log(
+    `   Measured handoff size: ${formatNumber(avgHandoffTokens)} tokens`
+  );
+  console.log(
+    `   Status: ${avgHandoffTokens >= 1000 && avgHandoffTokens <= 5000 ? 'VALIDATED' : 'NEEDS REVISION'}`
+  );
+  console.log('');
+  console.log(`   Claimed conversation: ${claimedConversation}`);
+  console.log(
+    `   Measured conversation: ${formatNumber(avgConversationTokens)} tokens`
+  );
+  console.log(
+    `   Status: ${avgConversationTokens >= 50000 && avgConversationTokens <= 150000 ? 'VALIDATED' : 'NEEDS REVISION'}`
+  );
+}
+
+main().catch(console.error);

package/templates/claude-hooks/on-startup.js

@@ -1,56 +1,237 @@
 #!/usr/bin/env node
 
 /**
- * Claude Code Startup Hook - Initialize StackMemory tracing
+ * Claude Code Startup Hook - Initialize StackMemory tracing and spawn session daemon
+ *
+ * This hook runs when Claude Code starts and:
+ * 1. Creates session trace record
+ * 2. Initializes StackMemory if available
+ * 3. Spawns a detached session daemon for periodic context saving
  */
 
 import { execSync, spawn } from 'child_process';
-import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import {
+  existsSync,
+  mkdirSync,
+  writeFileSync,
+  readFileSync,
+  unlinkSync,
+} from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
 
-const traceDir = join(homedir(), '.stackmemory', 'traces');
+const stackmemoryDir = join(homedir(), '.stackmemory');
+const traceDir = join(stackmemoryDir, 'traces');
+const sessionsDir = join(stackmemoryDir, 'sessions');
+const logsDir = join(stackmemoryDir, 'logs');
 const sessionFile = join(traceDir, 'current-session.json');
 
-// Ensure trace directory exists
-if (!existsSync(traceDir)) {
-  mkdirSync(traceDir, { recursive: true });
-}
+// Ensure required directories exist
+[traceDir, sessionsDir, logsDir].forEach((dir) => {
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+});
+
+// Generate session ID
+const sessionId = process.env.CLAUDE_INSTANCE_ID || `session-${Date.now()}`;
+const pidFile = join(sessionsDir, `${sessionId}.pid`);
 
 // Create session trace record
 const sessionData = {
-  sessionId: process.env.CLAUDE_INSTANCE_ID || `session-${Date.now()}`,
+  sessionId,
   startTime: new Date().toISOString(),
   workingDirectory: process.cwd(),
   gitBranch: null,
-  gitRepo: null
+  gitRepo: null,
 };
 
 // Get Git info if available
 try {
-  sessionData.gitRepo = execSync('git remote get-url origin', { encoding: 'utf8' }).trim();
-  sessionData.gitBranch = execSync('git rev-parse --abbrev-ref HEAD', { encoding: 'utf8' }).trim();
+  sessionData.gitRepo = execSync('git remote get-url origin', {
+    encoding: 'utf8',
+  }).trim();
+  sessionData.gitBranch = execSync('git rev-parse --abbrev-ref HEAD', {
+    encoding: 'utf8',
+  }).trim();
 } catch (err) {
   // Not in a git repo
 }
 
 writeFileSync(sessionFile, JSON.stringify(sessionData, null, 2));
 
-// Initialize StackMemory if available and not already initialized
-const stackmemoryPath = join(homedir(), '.stackmemory', 'bin', 'stackmemory');
+/**
+ * Check if daemon is already running for this session
+ */
+function isDaemonRunning() {
+  if (!existsSync(pidFile)) {
+    return false;
+  }
+
+  try {
+    const pid = parseInt(readFileSync(pidFile, 'utf8').trim(), 10);
+    // Check if process is running (signal 0 tests existence)
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    // Process not running, remove stale PID file
+    try {
+      unlinkSync(pidFile);
+    } catch {
+      // Ignore cleanup errors
+    }
+    return false;
+  }
+}
+
+/**
+ * Spawn the session daemon as a detached process
+ */
+function spawnSessionDaemon() {
+  // Check for daemon binary locations in order of preference
+  const daemonPaths = [
+    join(stackmemoryDir, 'bin', 'session-daemon'),
+    join(stackmemoryDir, 'bin', 'session-daemon.js'),
+    // Development path (when running from source)
+    join(
+      process.cwd(),
+      'node_modules',
+      '@stackmemoryai',
+      'stackmemory',
+      'dist',
+      'daemon',
+      'session-daemon.js'
+    ),
+    // Global npm install path
+    join(
+      homedir(),
+      '.npm-global',
+      'lib',
+      'node_modules',
+      '@stackmemoryai',
+      'stackmemory',
+      'dist',
+      'daemon',
+      'session-daemon.js'
+    ),
+  ];
+
+  let daemonPath = null;
+  for (const p of daemonPaths) {
+    if (existsSync(p)) {
+      daemonPath = p;
+      break;
+    }
+  }
+
+  if (!daemonPath) {
+    // Log warning but don't fail startup
+    const logEntry = {
+      timestamp: new Date().toISOString(),
+      level: 'WARN',
+      sessionId,
+      message: 'Session daemon binary not found, skipping daemon spawn',
+      data: { searchedPaths: daemonPaths },
+    };
+    try {
+      const logFile = join(logsDir, 'daemon.log');
+      writeFileSync(logFile, JSON.stringify(logEntry) + '\n', { flag: 'a' });
+    } catch {
+      // Ignore log errors
+    }
+    return null;
+  }
+
+  // Spawn daemon with detached option so it continues after this script exits
+  const daemonProcess = spawn(
+    'node',
+    [
+      daemonPath,
+      '--session-id',
+      sessionId,
+      '--save-interval',
+      '900', // 15 minutes in seconds
+      '--inactivity-timeout',
+      '1800', // 30 minutes in seconds
+    ],
+    {
+      detached: true,
+      stdio: 'ignore',
+      env: {
+        ...process.env,
+        STACKMEMORY_SESSION: sessionId,
+      },
+    }
+  );
+
+  // Unref so parent can exit independently
+  daemonProcess.unref();
+
+  // Log daemon spawn
+  const logEntry = {
+    timestamp: new Date().toISOString(),
+    level: 'INFO',
+    sessionId,
+    message: 'Session daemon spawned',
+    data: {
+      daemonPid: daemonProcess.pid,
+      daemonPath,
+      saveInterval: 900,
+      inactivityTimeout: 1800,
+    },
+  };
+  try {
+    const logFile = join(logsDir, 'daemon.log');
+    writeFileSync(logFile, JSON.stringify(logEntry) + '\n', { flag: 'a' });
+  } catch {
+    // Ignore log errors
+  }
+
+  return daemonProcess.pid;
+}
+
+// Initialize StackMemory if available and spawn daemon
+const stackmemoryPath = join(stackmemoryDir, 'bin', 'stackmemory');
 if (existsSync(stackmemoryPath)) {
   try {
     // Try to init or get status (will fail silently if already initialized)
     spawn(stackmemoryPath, ['init'], { detached: true, stdio: 'ignore' });
-    
+
     // Log session start
-    spawn(stackmemoryPath, ['context', 'save', '--json', JSON.stringify({
-      message: 'Claude Code session started',
-      metadata: sessionData
-    })], { detached: true, stdio: 'ignore' });
+    spawn(
+      stackmemoryPath,
+      [
+        'context',
+        'save',
+        '--json',
+        JSON.stringify({
+          message: 'Claude Code session started',
+          metadata: sessionData,
+        }),
+      ],
+      { detached: true, stdio: 'ignore' }
+    );
   } catch (err) {
     // Silent fail
   }
 }
 
-console.log(`🔍 StackMemory tracing enabled - Session: ${sessionData.sessionId}`);
+// Spawn session daemon if not already running
+let daemonPid = null;
+if (!isDaemonRunning()) {
+  daemonPid = spawnSessionDaemon();
+}
+
+// Output session info
+const daemonStatus = daemonPid
+  ? `Daemon spawned (PID: ${daemonPid})`
+  : isDaemonRunning()
+    ? 'Daemon already running'
+    : 'Daemon not started';
+
+console.log(`StackMemory tracing enabled - Session: ${sessionId}`);
+console.log(`  Working directory: ${sessionData.workingDirectory}`);
+if (sessionData.gitBranch) {
+  console.log(`  Git branch: ${sessionData.gitBranch}`);
+}
+console.log(`  ${daemonStatus}`);