@stackmemoryai/stackmemory 0.3.16 → 0.3.18

package/scripts/query-chromadb.ts

@@ -0,0 +1,201 @@
+#!/usr/bin/env tsx
+
+/**
+ * Query ChromaDB for stored contexts
+ */
+
+import { ChromaClient } from 'chromadb';
+import dotenv from 'dotenv';
+import chalk from 'chalk';
+
+// Load environment variables
+dotenv.config();
+
+async function queryChromaDB() {
+  const apiKey = process.env.CHROMADB_API_KEY;
+  const tenant = process.env.CHROMADB_TENANT;
+  const database = process.env.CHROMADB_DATABASE || 'stackmemory';
+
+  console.log(chalk.cyan('🔍 Querying ChromaDB Contexts\n'));
+
+  // Connect to ChromaDB
+  const client = new ChromaClient({
+    ssl: true,
+    host: 'api.trychroma.com',
+    port: 443,
+    headers: {
+      'X-Chroma-Token': apiKey
+    },
+    tenant: tenant,
+    database: database
+  });
+
+  // List all collections first
+  const collections = await client.listCollections();
+  console.log(chalk.yellow('📚 Available Collections:'));
+  collections.forEach(col => {
+    console.log(`   - ${col.name}`);
+  });
+  console.log();
+
+  // Get collection - try claude_context first (from hooks), then stackmemory_contexts
+  let collection;
+  try {
+    collection = await client.getCollection({
+      name: 'claude_context'
+    });
+    console.log(chalk.green('✓ Using collection: claude_context\n'));
+  } catch {
+    collection = await client.getCollection({
+      name: 'stackmemory_contexts'
+    });
+    console.log(chalk.green('✓ Using collection: stackmemory_contexts\n'));
+  }
+
+  console.log(chalk.yellow('📊 Collection Stats:'));
+  const count = await collection.count();
+  console.log(`   Total documents: ${count}\n`);
+
+  // Query 1: Get all documents
+  console.log(chalk.cyan('📚 All Stored Contexts:\n'));
+  
+  const allDocs = await collection.get({
+    limit: 100
+  });
+
+  if (allDocs.ids.length > 0) {
+    for (let i = 0; i < allDocs.ids.length; i++) {
+      const metadata = allDocs.metadatas[i];
+      const document = allDocs.documents[i];
+      
+      console.log(chalk.green(`${i + 1}. ${allDocs.ids[i]}`));
+      console.log(`   Type: ${metadata.type}`);
+      console.log(`   Timestamp: ${metadata.timestamp}`);
+      console.log(`   User: ${metadata.user_id}`);
+      console.log(`   Project: ${metadata.project}`);
+      console.log(`   Content: ${document?.substring(0, 100)}...`);
+      console.log();
+    }
+  }
+
+  // Query 2: Search for specific content
+  console.log(chalk.cyan('\n🔎 Search Results for "TypeScript lint error":\n'));
+  
+  const searchResults = await collection.query({
+    queryTexts: ['TypeScript lint error fix'],
+    nResults: 5
+  });
+
+  if (searchResults.ids[0].length > 0) {
+    for (let i = 0; i < searchResults.ids[0].length; i++) {
+      const metadata = searchResults.metadatas[0][i];
+      const document = searchResults.documents[0][i];
+      const distance = searchResults.distances[0][i];
+      
+      console.log(chalk.yellow(`Match ${i + 1} (distance: ${distance.toFixed(3)}):`));
+      console.log(`   ID: ${searchResults.ids[0][i]}`);
+      console.log(`   Type: ${metadata.type}`);
+      console.log(`   Timestamp: ${metadata.timestamp}`);
+      console.log(`   Content: ${document?.substring(0, 150)}...`);
+      console.log();
+    }
+  } else {
+    console.log('No results found');
+  }
+
+  // Query 3: Filter by metadata
+  console.log(chalk.cyan('\n📋 Recent Task Completions:\n'));
+  
+  const taskCompletions = await collection.get({
+    where: {
+      type: 'task_complete'
+    },
+    limit: 10
+  });
+
+  if (taskCompletions.ids.length > 0) {
+    for (let i = 0; i < taskCompletions.ids.length; i++) {
+      const metadata = taskCompletions.metadatas[i];
+      const document = taskCompletions.documents[i];
+      
+      console.log(chalk.green(`Task ${i + 1}:`));
+      console.log(`   ID: ${taskCompletions.ids[i]}`);
+      console.log(`   Timestamp: ${metadata.timestamp}`);
+      console.log(`   Task ID: ${metadata.task_id}`);
+      console.log(`   Duration: ${metadata.duration}ms`);
+      console.log(`   Files Changed: ${metadata.files_changed}`);
+      console.log(`   Content: ${document?.substring(0, 100)}...`);
+      console.log();
+    }
+  } else {
+    console.log('No task completions found');
+  }
+
+  // Query 4: Get periodic saves
+  console.log(chalk.cyan('\n⏰ Periodic Checkpoints:\n'));
+  
+  const periodicSaves = await collection.get({
+    where: {
+      type: 'periodic_save'
+    },
+    limit: 10
+  });
+
+  if (periodicSaves.ids.length > 0) {
+    for (let i = 0; i < periodicSaves.ids.length; i++) {
+      const metadata = periodicSaves.metadatas[i];
+      const document = periodicSaves.documents[i];
+      
+      console.log(chalk.blue(`Checkpoint ${i + 1}:`));
+      console.log(`   Timestamp: ${metadata.timestamp}`);
+      console.log(`   Interval: ${metadata.interval}`);
+      console.log(`   Active Files: ${metadata.active_files}`);
+      console.log(`   Git Status: ${document?.substring(0, 150)}...`);
+      console.log();
+    }
+  } else {
+    console.log('No periodic saves found');
+  }
+
+  // Query 5: Get decisions
+  console.log(chalk.cyan('\n💡 Decisions Made:\n'));
+  
+  const decisions = await collection.get({
+    where: {
+      type: 'decision_made'
+    },
+    limit: 10
+  });
+
+  if (decisions.ids.length > 0) {
+    for (let i = 0; i < decisions.ids.length; i++) {
+      const metadata = decisions.metadatas[i];
+      const document = decisions.documents[i];
+      
+      console.log(chalk.magenta(`Decision ${i + 1}:`));
+      console.log(`   Category: ${metadata.category}`);
+      console.log(`   Alternatives: ${metadata.alternatives}`);
+      console.log(`   Reasoning: ${metadata.reasoning}`);
+      console.log(`   Decision: ${document?.substring(0, 200)}...`);
+      console.log();
+    }
+  } else {
+    console.log('No decisions found');
+  }
+
+  // Query 6: Group by type
+  console.log(chalk.cyan('\n📈 Context Types Summary:\n'));
+  
+  const types = new Map();
+  for (let i = 0; i < allDocs.ids.length; i++) {
+    const type = allDocs.metadatas[i].type || 'unknown';
+    types.set(type, (types.get(type) || 0) + 1);
+  }
+
+  for (const [type, count] of types.entries()) {
+    console.log(`   ${type}: ${count} documents`);
+  }
+}
+
+// Run query
+queryChromaDB().catch(console.error);

package/scripts/railway-env-setup.sh

@@ -0,0 +1,39 @@
+#!/bin/bash
+
+echo "🚂 Railway Environment Variables Setup"
+echo "======================================"
+echo ""
+echo "You need to add these environment variables in the Railway dashboard:"
+echo "https://railway.app/project/90d5083a-4adf-49b8-b2ff-95adfbb610f2/service/b2a145c3-065e-4225-8c84-aa0d8f49d243/settings"
+echo ""
+echo "Copy and paste these into Railway's environment variables section:"
+echo ""
+
+# Load .env file
+if [ -f .env ]; then
+    source .env
+    
+    echo "REDIS_URL=$REDIS_URL"
+    echo "LINEAR_API_KEY=$LINEAR_API_KEY"
+    echo "CHROMADB_API_KEY=$CHROMADB_API_KEY"
+    echo "CHROMADB_TENANT=$CHROMADB_TENANT"
+    echo "CHROMADB_DATABASE=$CHROMADB_DATABASE"
+    echo "LINEAR_TEAM_ID=$LINEAR_TEAM_ID"
+    echo "LINEAR_ORGANIZATION=$LINEAR_ORGANIZATION"
+    echo ""
+    echo "Optional (for cold storage tier):"
+    echo "GCS_BUCKET_NAME=stackmemory-cold-storage"
+    echo "GCS_PROJECT_ID=your-gcp-project-id"
+    echo "GCS_CLIENT_EMAIL=your-service-account@project.iam.gserviceaccount.com"
+    echo "GCS_PRIVATE_KEY=your-gcs-private-key"
+else
+    echo "❌ .env file not found. Please create one first."
+    exit 1
+fi
+
+echo ""
+echo "After adding these variables:"
+echo "1. Click 'Deploy' in Railway dashboard"
+echo "2. Or run: railway up"
+echo "3. Check deployment: railway logs"
+echo "4. Visit: https://stackmemory-production.up.railway.app/health"

package/scripts/reconcile-local-tasks.js

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+function reconcileLocalTasks() {
+  const tasksFile = path.join(__dirname, '..', '.stackmemory', 'tasks.jsonl');
+  
+  if (!fs.existsSync(tasksFile)) {
+    console.error('❌ Tasks file not found:', tasksFile);
+    return;
+  }
+  
+  // Read all tasks
+  const lines = fs.readFileSync(tasksFile, 'utf8').split('\n').filter(l => l.trim());
+  const tasks = new Map();
+  const tasksByLinearId = new Map();
+  const tasksByTitle = new Map();
+  
+  console.log('📊 Analyzing local tasks...\n');
+  
+  // Parse and organize tasks
+  for (const line of lines) {
+    try {
+      const task = JSON.parse(line);
+      
+      // Store latest version of each task
+      if (!tasks.has(task.id) || task.timestamp > tasks.get(task.id).timestamp) {
+        tasks.set(task.id, task);
+      }
+      
+      // Extract Linear ID if present
+      const linearMatch = task.title?.match(/\[(STA-\d+|ENG-\d+)\]/);
+      if (linearMatch) {
+        const linearId = linearMatch[1];
+        if (!tasksByLinearId.has(linearId)) {
+          tasksByLinearId.set(linearId, []);
+        }
+        tasksByLinearId.get(linearId).push(task);
+      }
+      
+      // Normalize title for duplicate detection
+      const normalizedTitle = task.title
+        ?.replace(/^\[[^\]]+\]\s*/, '') // Remove [STA-XXX] or [ENG-XXX]
+        ?.replace(/^\[.*?\]\s*/, '') // Remove priority markers
+        ?.trim();
+      
+      if (normalizedTitle) {
+        if (!tasksByTitle.has(normalizedTitle)) {
+          tasksByTitle.set(normalizedTitle, []);
+        }
+        tasksByTitle.get(normalizedTitle).push(task);
+      }
+    } catch (e) {
+      // Skip invalid lines
+    }
+  }
+  
+  console.log(`📋 Total unique tasks: ${tasks.size}`);
+  console.log(`🔗 Tasks with Linear IDs: ${tasksByLinearId.size}`);
+  
+  // Find duplicates by Linear ID
+  const duplicateLinearIds = [];
+  for (const [linearId, taskList] of tasksByLinearId.entries()) {
+    if (taskList.length > 1) {
+      duplicateLinearIds.push({ linearId, count: taskList.length, tasks: taskList });
+    }
+  }
+  
+  if (duplicateLinearIds.length > 0) {
+    console.log(`\n⚠️ Duplicate Linear IDs found (${duplicateLinearIds.length}):`);
+    for (const dup of duplicateLinearIds.slice(0, 5)) {
+      console.log(`  - ${dup.linearId}: ${dup.count} duplicates`);
+      for (const task of dup.tasks) {
+        console.log(`    • ${task.id}: ${task.status} (${new Date(task.timestamp).toISOString()})`);
+      }
+    }
+  }
+  
+  // Find duplicate titles
+  const duplicateTitles = [];
+  for (const [title, taskList] of tasksByTitle.entries()) {
+    if (taskList.length > 1) {
+      // Check if they have different Linear IDs
+      const linearIds = new Set();
+      for (const task of taskList) {
+        const match = task.title?.match(/\[(STA-\d+|ENG-\d+)\]/);
+        if (match) linearIds.add(match[1]);
+      }
+      
+      if (linearIds.size > 1 || linearIds.size === 0) {
+        duplicateTitles.push({ title, count: taskList.length, tasks: taskList });
+      }
+    }
+  }
+  
+  if (duplicateTitles.length > 0) {
+    console.log(`\n⚠️ Duplicate titles found (${duplicateTitles.length}):`);
+    for (const dup of duplicateTitles.slice(0, 5)) {
+      console.log(`  - "${dup.title}": ${dup.count} duplicates`);
+    }
+  }
+  
+  // Show task status breakdown
+  const statusCounts = {};
+  for (const task of tasks.values()) {
+    const status = task.status || 'unknown';
+    statusCounts[status] = (statusCounts[status] || 0) + 1;
+  }
+  
+  console.log('\n📊 Task Status Breakdown:');
+  for (const [status, count] of Object.entries(statusCounts)) {
+    const emoji = status === 'completed' ? '✅' :
+                  status === 'in_progress' ? '🔄' :
+                  status === 'cancelled' ? '❌' : '⏳';
+    console.log(`  ${emoji} ${status}: ${count}`);
+  }
+  
+  // Priority breakdown
+  const priorityCounts = {};
+  for (const task of tasks.values()) {
+    const priority = task.priority || 'none';
+    priorityCounts[priority] = (priorityCounts[priority] || 0) + 1;
+  }
+  
+  console.log('\n🎯 Priority Breakdown:');
+  for (const [priority, count] of Object.entries(priorityCounts)) {
+    console.log(`  - ${priority}: ${count}`);
+  }
+  
+  // Recent active tasks
+  const recentTasks = Array.from(tasks.values())
+    .filter(t => t.status === 'in_progress' || (t.timestamp > Date.now() - 7 * 24 * 60 * 60 * 1000))
+    .sort((a, b) => b.timestamp - a.timestamp)
+    .slice(0, 10);
+  
+  console.log('\n🕒 Recent Active Tasks:');
+  for (const task of recentTasks) {
+    const status = task.status === 'completed' ? '✅' :
+                   task.status === 'in_progress' ? '🔄' : '⏳';
+    const linearId = task.title?.match(/\[(STA-\d+|ENG-\d+)\]/)?.[1] || '';
+    console.log(`  ${status} ${linearId ? `[${linearId}]` : ''} ${task.title}`);
+  }
+  
+  // Recommendations
+  console.log('\n💡 Recommendations:');
+  if (duplicateLinearIds.length > 0) {
+    console.log(`  - ${duplicateLinearIds.length} tasks have duplicate Linear IDs - consider deduplication`);
+  }
+  if (duplicateTitles.length > 0) {
+    console.log(`  - ${duplicateTitles.length} task titles are duplicated - review for consolidation`);
+  }
+  
+  const pendingCount = statusCounts.pending || 0;
+  const inProgressCount = statusCounts.in_progress || 0;
+  
+  if (pendingCount > 20) {
+    console.log(`  - ${pendingCount} pending tasks - consider prioritizing or archiving old tasks`);
+  }
+  if (inProgressCount > 5) {
+    console.log(`  - ${inProgressCount} tasks in progress - consider focusing on completion`);
+  }
+  
+  console.log('\n✅ Task reconciliation complete!');
+}
+
+reconcileLocalTasks();

package/scripts/recreate-frames-db.js

@@ -0,0 +1,89 @@
+#!/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/claude-integration.js

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+/**
+ * Automatically configure Claude Desktop to use StackMemory MCP
+ */
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+function setupClaudeIntegration() {
+  console.log('🔧 Setting up Claude Desktop integration...\n');
+
+  // Find Claude Desktop config path
+  const configPaths = [
+    path.join(
+      os.homedir(),
+      'Library',
+      'Application Support',
+      'Claude',
+      'claude_desktop_config.json'
+    ), // macOS
+    path.join(os.homedir(), '.config', 'claude', 'claude_desktop_config.json'), // Linux
+    path.join(
+      os.homedir(),
+      'AppData',
+      'Roaming',
+      'Claude',
+      'claude_desktop_config.json'
+    ), // Windows
+  ];
+
+  let configPath = null;
+  for (const p of configPaths) {
+    if (fs.existsSync(p) || fs.existsSync(path.dirname(p))) {
+      configPath = p;
+      break;
+    }
+  }
+
+  if (!configPath) {
+    console.log('❌ Claude Desktop config directory not found');
+    console.log('📝 Manual setup required - add this to your Claude config:');
+    printManualConfig();
+    return;
+  }
+
+  // Current project path
+  const projectRoot = process.cwd();
+  const mcpServerPath = path.join(
+    projectRoot,
+    'dist',
+    'src',
+    'mcp',
+    'mcp-server.js'
+  );
+
+  // Read existing config or create new
+  let config = { mcpServers: {} };
+  if (fs.existsSync(configPath)) {
+    try {
+      const existing = fs.readFileSync(configPath, 'utf8');
+      config = JSON.parse(existing);
+      if (!config.mcpServers) config.mcpServers = {};
+    } catch (error) {
+      console.log('⚠️  Could not parse existing config, creating new one');
+    }
+  }
+
+  // Add/update StackMemory MCP server
+  config.mcpServers.stackmemory = {
+    command: 'node',
+    args: [mcpServerPath],
+    env: {
+      PROJECT_ROOT: projectRoot,
+      STACKMEMORY_AUTO_CHECK: 'true',
+    },
+  };
+
+  // Ensure directory exists
+  const configDir = path.dirname(configPath);
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
+  }
+
+  // Write config
+  try {
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    console.log('✅ Claude Desktop config updated successfully!');
+    console.log(`📁 Config location: ${configPath}\n`);
+
+    console.log(
+      '🔄 Please restart Claude Desktop to activate StackMemory integration\n'
+    );
+    console.log('🎯 StackMemory will now automatically:');
+    console.log('   • Save context every 15 minutes');
+    console.log('   • Load previous context on startup');
+    console.log('   • Track tasks and decisions');
+    console.log('   • Enable seamless context persistence\n');
+  } catch (error) {
+    console.log('❌ Failed to write config file:', error.message);
+    console.log('📝 Manual setup required:');
+    printManualConfig();
+  }
+}
+
+function printManualConfig() {
+  const projectRoot = process.cwd();
+  const mcpServerPath = path.join(
+    projectRoot,
+    'dist',
+    'src',
+    'mcp',
+    'mcp-server.js'
+  );
+
+  console.log(
+    '\n' +
+      JSON.stringify(
+        {
+          mcpServers: {
+            stackmemory: {
+              command: 'node',
+              args: [mcpServerPath],
+              env: {
+                PROJECT_ROOT: projectRoot,
+                STACKMEMORY_AUTO_CHECK: 'true',
+              },
+            },
+          },
+        },
+        null,
+        2
+      ) +
+      '\n'
+  );
+}
+
+setupClaudeIntegration();