@stackmemoryai/stackmemory 0.3.17 → 0.3.19

package/scripts/test-redis-storage.ts

@@ -0,0 +1,490 @@
+#!/usr/bin/env tsx
+/**
+ * Test script for Redis trace storage
+ * Tests the 3-tier storage system with Redis hot tier
+ */
+
+import { createClient } from 'redis';
+import Database from 'better-sqlite3';
+import { v4 as uuidv4 } from 'uuid';
+import chalk from 'chalk';
+import ora from 'ora';
+import { join } from 'path';
+import { existsSync, mkdirSync } from 'fs';
+import { RailwayOptimizedStorage } from '../src/core/storage/railway-optimized-storage.js';
+import { ConfigManager } from '../src/core/config/config-manager.js';
+import { Trace, TraceType, ToolCall } from '../src/core/trace/types.js';
+
+// Load environment variables
+import dotenv from 'dotenv';
+// Type-safe environment variable access
+function getEnv(key: string, defaultValue?: string): string {
+  const value = process.env[key];
+  if (value === undefined) {
+    if (defaultValue !== undefined) return defaultValue;
+    throw new Error(`Environment variable ${key} is required`);
+  }
+  return value;
+}
+
+function getOptionalEnv(key: string): string | undefined {
+  return process.env[key];
+}
+
+dotenv.config();
+
+async function testRedisConnection() {
+  const spinner = ora('Testing Redis connection...').start();
+
+  try {
+    const redisUrl = process.env['REDIS_URL'] || 'redis://localhost:6379';
+    console.log(
+      chalk.gray(
+        `  Using Redis URL: ${redisUrl.replace(/:[^:@]+@/, ':****@')})`
+      )
+    );
+    const client = createClient({ url: redisUrl });
+
+    await client.connect();
+
+    // Test basic operations
+    const testKey = 'test:connection';
+    await client.set(testKey, 'connected');
+    const result = await client.get(testKey);
+    await client.del(testKey);
+
+    if (result === 'connected') {
+      spinner.succeed(`Redis connected successfully at ${redisUrl}`);
+
+      // Get Redis info
+      const info = await client.info('memory');
+      const memoryUsed = info.match(/used_memory_human:(\S+)/)?.[1];
+      console.log(chalk.gray(`  Memory used: ${memoryUsed || 'unknown'}`));
+    } else {
+      spinner.fail('Redis connection test failed');
+      return false;
+    }
+
+    await client.quit();
+    return true;
+  } catch (error: unknown) {
+    spinner.fail(`Redis connection failed: ${error}`);
+    return false;
+  }
+}
+
+function createMockTrace(index: number): Trace {
+  const now = Date.now() - index * 60 * 60 * 1000; // Offset by hours
+  const tools: ToolCall[] = [
+    {
+      id: uuidv4(),
+      tool: 'search',
+      timestamp: now,
+      arguments: { query: `test query ${index}` },
+      filesAffected: ['src/test.ts', 'src/index.ts'],
+    },
+    {
+      id: uuidv4(),
+      tool: 'read',
+      timestamp: now + 1000,
+      arguments: { file: 'src/test.ts' },
+      result: 'file contents',
+    },
+    {
+      id: uuidv4(),
+      tool: 'edit',
+      timestamp: now + 2000,
+      arguments: { file: 'src/test.ts', changes: 'some changes' },
+      filesAffected: ['src/test.ts'],
+    },
+    {
+      id: uuidv4(),
+      tool: 'test',
+      timestamp: now + 3000,
+      arguments: { command: 'npm test' },
+      result: 'tests passed',
+    },
+  ];
+
+  const trace: Trace = {
+    id: uuidv4(),
+    type: TraceType.SEARCH_DRIVEN,
+    tools,
+    score: 0.5 + Math.random() * 0.5, // Random score 0.5-1.0
+    summary: `Test trace #${index}: Search-driven modification`,
+    metadata: {
+      startTime: now,
+      endTime: now + 4000,
+      filesModified: ['src/test.ts'],
+      errorsEncountered: index % 3 === 0 ? ['Test error'] : [],
+      decisionsRecorded: index % 2 === 0 ? ['Use async pattern'] : [],
+      causalChain: index % 3 === 0,
+    },
+  };
+
+  return trace;
+}
+
+async function testStorageOperations() {
+  console.log(chalk.blue('\n📦 Testing Storage Operations'));
+  console.log(chalk.gray('━'.repeat(50)));
+
+  // Setup database
+  const dbDir = join(process.cwd(), '.stackmemory');
+  if (!existsSync(dbDir)) {
+    mkdirSync(dbDir, { recursive: true });
+  }
+
+  const dbPath = join(dbDir, 'test-context.db');
+  const db = new Database(dbPath);
+
+  // Initialize trace tables
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS traces (
+      id TEXT PRIMARY KEY,
+      type TEXT NOT NULL,
+      score REAL NOT NULL,
+      summary TEXT NOT NULL,
+      start_time INTEGER NOT NULL,
+      end_time INTEGER NOT NULL,
+      frame_id TEXT,
+      user_id TEXT,
+      files_modified TEXT,
+      errors_encountered TEXT,
+      decisions_recorded TEXT,
+      causal_chain INTEGER,
+      compressed_data TEXT,
+      created_at INTEGER DEFAULT (unixepoch())
+    )
+  `);
+
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS tool_calls (
+      id TEXT PRIMARY KEY,
+      trace_id TEXT NOT NULL,
+      tool TEXT NOT NULL,
+      arguments TEXT,
+      timestamp INTEGER NOT NULL,
+      result TEXT,
+      error TEXT,
+      files_affected TEXT,
+      duration INTEGER,
+      sequence_number INTEGER NOT NULL,
+      FOREIGN KEY (trace_id) REFERENCES traces(id) ON DELETE CASCADE
+    )
+  `);
+
+  // Create storage_tiers table required by RailwayOptimizedStorage
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS storage_tiers (
+      trace_id TEXT PRIMARY KEY,
+      tier TEXT NOT NULL,
+      location TEXT NOT NULL,
+      original_size INTEGER,
+      compressed_size INTEGER,
+      compression_ratio REAL,
+      access_count INTEGER DEFAULT 0,
+      last_accessed INTEGER DEFAULT (unixepoch()),
+      created_at INTEGER DEFAULT (unixepoch()),
+      migrated_at INTEGER,
+      score REAL,
+      migration_score REAL,
+      metadata TEXT,
+      FOREIGN KEY (trace_id) REFERENCES traces(id) ON DELETE CASCADE
+    )
+  `);
+
+  // Create indexes for storage_tiers
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_storage_tier ON storage_tiers(tier);
+    CREATE INDEX IF NOT EXISTS idx_storage_created ON storage_tiers(created_at);
+    CREATE INDEX IF NOT EXISTS idx_storage_accessed ON storage_tiers(last_accessed);
+  `);
+
+  const configManager = new ConfigManager();
+
+  // Initialize storage with Redis URL from environment
+  const storage = new RailwayOptimizedStorage(db, configManager, {
+    redis: {
+      url: process.env['REDIS_URL'],
+      ttlSeconds: 24 * 60 * 60, // 24 hours
+      maxMemory: '100mb',
+    },
+  });
+
+  // Test storing traces
+  const traces: Trace[] = [];
+  const results: { id: string; tier: string; score: number }[] = [];
+
+  console.log(chalk.yellow('\n✏️  Creating and storing test traces...'));
+
+  for (let i = 0; i < 10; i++) {
+    const trace = createMockTrace(i);
+    traces.push(trace);
+
+    const spinner = ora(`Storing trace #${i + 1}...`).start();
+
+    try {
+      // First insert the trace into the traces table
+      const insertTrace = db.prepare(`
+        INSERT INTO traces (
+          id, type, score, summary, start_time, end_time,
+          files_modified, errors_encountered, decisions_recorded, causal_chain,
+          created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `);
+
+      insertTrace.run(
+        trace.id,
+        trace.type,
+        trace.score,
+        trace.summary,
+        trace.metadata.startTime,
+        trace.metadata.endTime,
+        JSON.stringify(trace.metadata.filesModified || []),
+        JSON.stringify(trace.metadata.errorsEncountered || []),
+        JSON.stringify(trace.metadata.decisionsRecorded || []),
+        trace.metadata.causalChain ? 1 : 0,
+        Date.now()
+      );
+
+      // Insert tool calls
+      const insertToolCall = db.prepare(`
+        INSERT INTO tool_calls (
+          id, trace_id, tool, arguments, timestamp, result, files_affected, sequence_number
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      `);
+
+      trace.tools.forEach((tool, index) => {
+        insertToolCall.run(
+          tool.id,
+          trace.id,
+          tool.tool,
+          JSON.stringify(tool.arguments),
+          tool.timestamp,
+          tool.result || null,
+          JSON.stringify(tool.filesAffected || []),
+          index
+        );
+      });
+
+      // Now store in tiered storage
+      const tier = await storage.storeTrace(trace);
+      results.push({ id: trace.id, tier, score: trace.score });
+
+      const tierIcon = tier === 'hot' ? '🔥' : tier === 'warm' ? '☁️' : '❄️';
+      spinner.succeed(
+        `Trace #${i + 1} stored in ${tierIcon} ${tier} tier (score: ${trace.score.toFixed(2)})`
+      );
+    } catch (error: unknown) {
+      spinner.fail(`Failed to store trace #${i + 1}: ${error}`);
+    }
+
+    // Small delay
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+
+  // Test retrieval
+  console.log(chalk.yellow('\n🔍 Testing trace retrieval...'));
+
+  for (let i = 0; i < 3; i++) {
+    const result = results[i];
+    const spinner = ora(
+      `Retrieving trace ${result.id.substring(0, 8)}...`
+    ).start();
+
+    try {
+      const retrieved = await storage.retrieveTrace(result.id);
+
+      if (retrieved) {
+        spinner.succeed(
+          `Retrieved from ${result.tier} tier: ${retrieved.summary}`
+        );
+      } else {
+        spinner.fail('Trace not found');
+      }
+    } catch (error: unknown) {
+      spinner.fail(`Retrieval failed: ${error}`);
+    }
+  }
+
+  // Get storage statistics
+  console.log(chalk.yellow('\n📊 Storage Statistics:'));
+
+  const stats = storage.getStorageStats();
+
+  console.log(chalk.gray('━'.repeat(50)));
+  for (const tier of stats.byTier) {
+    const icon =
+      tier.tier === 'hot' ? '🔥' : tier.tier === 'warm' ? '☁️' : '❄️';
+    console.log(`${icon} ${chalk.bold(tier.tier.toUpperCase())} Tier:`);
+    console.log(`   Traces: ${tier.count}`);
+    console.log(`   Original Size: ${formatBytes(tier.total_original || 0)}`);
+    console.log(`   Compressed: ${formatBytes(tier.total_compressed || 0)}`);
+    if (tier.avg_compression) {
+      console.log(
+        `   Compression: ${(tier.avg_compression * 100).toFixed(1)}%`
+      );
+    }
+  }
+
+  // Test Redis-specific operations
+  console.log(chalk.yellow('\n🔥 Testing Redis Hot Tier...'));
+
+  const redisClient = createClient({ url: process.env['REDIS_URL'] });
+  await redisClient.connect();
+
+  // Check stored traces in Redis
+  const keys = await redisClient.keys('trace:*');
+  console.log(`   Traces in Redis: ${chalk.green(keys.length)}`);
+
+  // Check sorted sets
+  const byScore = await redisClient.zCard('traces:by_score');
+  const byTime = await redisClient.zCard('traces:by_time');
+  console.log(`   Score index: ${chalk.green(byScore)} entries`);
+  console.log(`   Time index: ${chalk.green(byTime)} entries`);
+
+  // Get top traces by score
+  const topTraces = await redisClient.zRangeWithScores(
+    'traces:by_score',
+    -3,
+    -1
+  );
+  if (topTraces.length > 0) {
+    console.log(chalk.yellow('\n🏆 Top Traces by Score:'));
+    for (const trace of topTraces.reverse()) {
+      console.log(
+        `   ${trace.value.substring(0, 8)}... - Score: ${trace.score.toFixed(3)}`
+      );
+    }
+  }
+
+  // Memory usage
+  const memInfo = await redisClient.memoryUsage('trace:' + results[0]?.id);
+  if (memInfo) {
+    console.log(chalk.yellow('\n💾 Memory Usage:'));
+    console.log(`   Sample trace memory: ${formatBytes(memInfo)}`);
+    console.log(`   Estimated total: ${formatBytes(memInfo * keys.length)}`);
+  }
+
+  await redisClient.quit();
+
+  // Test migration
+  console.log(chalk.yellow('\n🔄 Testing tier migration...'));
+
+  const migrationResults = await storage.migrateTiers();
+  console.log(
+    `   Hot → Warm: ${chalk.yellow(migrationResults.hotToWarm)} traces`
+  );
+  console.log(
+    `   Warm → Cold: ${chalk.cyan(migrationResults.warmToCold)} traces`
+  );
+  if (migrationResults.errors.length > 0) {
+    console.log(chalk.red(`   Errors: ${migrationResults.errors.length}`));
+  }
+
+  // Cleanup
+  db.close();
+
+  console.log(chalk.green('\n✅ Storage tests completed successfully!'));
+}
+
+function formatBytes(bytes: number): string {
+  if (bytes === 0) return '0 B';
+  const k = 1024;
+  const sizes = ['B', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${(bytes / Math.pow(k, i)).toFixed(2)} ${sizes[i]}`;
+}
+
+async function main() {
+  console.log(chalk.blue.bold('\n🧪 StackMemory Redis Storage Test\n'));
+
+  // Test Redis connection
+  const redisConnected = await testRedisConnection();
+
+  if (!redisConnected) {
+    console.log(chalk.red('\n❌ Cannot proceed without Redis connection'));
+    console.log(chalk.yellow('\nTo fix:'));
+    console.log('1. Ensure Redis is running');
+    console.log('2. Check REDIS_URL in .env file');
+    console.log('3. For Railway: Ensure Redis addon is provisioned');
+    process.exit(1);
+  }
+
+  // Test storage operations
+  await testStorageOperations();
+
+  // Interactive test
+  console.log(chalk.blue('\n🎮 Interactive Test'));
+  console.log(chalk.gray('━'.repeat(50)));
+  console.log(
+    chalk.cyan('You can now use the CLI to interact with the stored traces:')
+  );
+  console.log();
+  console.log(
+    '  ' +
+      chalk.white('stackmemory storage status') +
+      '     - View storage statistics'
+  );
+  console.log(
+    '  ' +
+      chalk.white('stackmemory storage migrate') +
+      '    - Migrate traces between tiers'
+  );
+  console.log(
+    '  ' +
+      chalk.white('stackmemory storage retrieve <id>') +
+      ' - Retrieve a specific trace'
+  );
+  console.log();
+  console.log(chalk.gray('Trace IDs from this test:'));
+
+  // Show first 3 trace IDs for testing
+  const dbPath = join(process.cwd(), '.stackmemory', 'test-context.db');
+  const db = new Database(dbPath);
+
+  // Make sure storage_tiers table exists before querying
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS storage_tiers (
+      trace_id TEXT PRIMARY KEY,
+      tier TEXT NOT NULL,
+      location TEXT NOT NULL,
+      original_size INTEGER,
+      compressed_size INTEGER,
+      compression_ratio REAL,
+      access_count INTEGER DEFAULT 0,
+      last_accessed INTEGER DEFAULT (unixepoch()),
+      created_at INTEGER DEFAULT (unixepoch()),
+      migrated_at INTEGER,
+      score REAL,
+      migration_score REAL,
+      metadata TEXT
+    )
+  `);
+
+  const recentTraces = db
+    .prepare(
+      `
+    SELECT trace_id, tier FROM storage_tiers 
+    ORDER BY created_at DESC LIMIT 3
+  `
+    )
+    .all() as Array<{ trace_id: string; tier: string }>;
+
+  for (const trace of recentTraces) {
+    const tierIcon =
+      trace.tier === 'hot' ? '🔥' : trace.tier === 'warm' ? '☁️' : '❄️';
+    console.log(`  ${tierIcon} ${trace.trace_id}`);
+  }
+
+  db.close();
+
+  console.log(chalk.green('\n✨ Test complete!'));
+}
+
+// Run the test
+main().catch((error) => {
+  console.error(chalk.red('Test failed:'), error);
+  process.exit(1);
+});

package/scripts/test-rlm-basic.sh

@@ -0,0 +1,122 @@
+#!/bin/bash
+
+# Basic RLM functionality test
+echo "================================"
+echo "Basic RLM End-to-End Test"
+echo "================================"
+echo ""
+
+# Colors
+GREEN='\033[0;32m'
+RED='\033[0;31m'
+YELLOW='\033[1;33m'
+NC='\033[0m'
+
+# Build first
+echo "Building project..."
+npm run build > /dev/null 2>&1
+
+echo ""
+echo "Test 1: Basic RLM Execution"
+echo "----------------------------"
+OUTPUT=$(stackmemory skills rlm "Create a hello world function" 2>&1)
+echo "$OUTPUT" | head -20
+
+# Check for key components
+echo ""
+echo "Checking key components:"
+
+if echo "$OUTPUT" | grep -q "RLM execution completed"; then
+    echo -e "${GREEN}✓ RLM execution completed${NC}"
+else
+    echo -e "${RED}✗ RLM execution did not complete${NC}"
+fi
+
+if echo "$OUTPUT" | grep -q "Created frame"; then
+    echo -e "${GREEN}✓ Frame created${NC}"
+else
+    echo -e "${RED}✗ Frame not created${NC}"
+fi
+
+if echo "$OUTPUT" | grep -q "Closed frame"; then
+    echo -e "${GREEN}✓ Frame closed${NC}"
+else
+    echo -e "${RED}✗ Frame not closed${NC}"
+fi
+
+if echo "$OUTPUT" | grep -q "planning subagent"; then
+    echo -e "${GREEN}✓ Planning subagent spawned${NC}"
+else
+    echo -e "${RED}✗ Planning subagent not spawned${NC}"
+fi
+
+if echo "$OUTPUT" | grep -q "Review stage.*complete"; then
+    echo -e "${GREEN}✓ Review stage completed${NC}"
+else
+    echo -e "${RED}✗ Review stage not completed${NC}"
+fi
+
+if echo "$OUTPUT" | grep -q "Quality threshold met"; then
+    echo -e "${GREEN}✓ Quality threshold met${NC}"
+else
+    echo -e "${RED}✗ Quality threshold not met${NC}"
+fi
+
+if echo "$OUTPUT" | grep -q "mockMode: true"; then
+    echo -e "${GREEN}✓ Mock mode active${NC}"
+else
+    echo -e "${RED}✗ Mock mode not active${NC}"
+fi
+
+echo ""
+echo "Test 2: Execution Summary"
+echo "-------------------------"
+echo "$OUTPUT" | grep -A 10 "Execution Summary"
+
+echo ""
+echo "Test 3: Frame Persistence"
+echo "-------------------------"
+FRAMES_BEFORE=$(stackmemory status 2>&1 | grep -oE "Frames: [0-9]+" | awk '{print $2}')
+stackmemory skills rlm "Test task for frame counting" > /dev/null 2>&1
+FRAMES_AFTER=$(stackmemory status 2>&1 | grep -oE "Frames: [0-9]+" | awk '{print $2}')
+
+echo "Frames before: ${FRAMES_BEFORE:-0}"
+echo "Frames after: ${FRAMES_AFTER:-0}"
+
+if [ "${FRAMES_AFTER:-0}" -gt "${FRAMES_BEFORE:-0}" ]; then
+    echo -e "${GREEN}✓ Frames persisted to database${NC}"
+else
+    echo -e "${YELLOW}⚠ Frame count unchanged (may be cleaned up)${NC}"
+fi
+
+echo ""
+echo "Test 4: Mock Subagent Responses"
+echo "-------------------------------"
+OUTPUT=$(stackmemory skills rlm "Create a REST API" 2>&1)
+
+if echo "$OUTPUT" | grep -q "Mock .* subagent completed"; then
+    echo -e "${GREEN}✓ Mock subagents responding${NC}"
+else
+    echo -e "${RED}✗ Mock subagents not responding${NC}"
+fi
+
+# Extract improvements if present
+echo ""
+echo "Improvements found:"
+echo "$OUTPUT" | grep -A 5 "Improvements:" | head -6
+
+echo ""
+echo "Test 5: Error Handling"
+echo "----------------------"
+# This should handle gracefully even with problematic input
+OUTPUT=$(stackmemory skills rlm "" 2>&1)
+if echo "$OUTPUT" | grep -q "RLM execution completed\|failed"; then
+    echo -e "${GREEN}✓ Empty input handled gracefully${NC}"
+else
+    echo -e "${RED}✗ Empty input caused crash${NC}"
+fi
+
+echo ""
+echo "================================"
+echo "Test Complete"
+echo "================================"