@stackmemoryai/stackmemory 0.3.16 → 0.3.18

package/scripts/detect-and-rehydrate.js

@@ -0,0 +1,162 @@
+#!/usr/bin/env node
+
+/**
+ * Smart Compaction Detection and Auto-Rehydration
+ * Monitors Claude Code context and triggers rehydration when needed
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { exec } = require('child_process');
+const { promisify } = require('util');
+
+const execAsync = promisify(exec);
+
+// Compaction detection patterns
+const COMPACTION_INDICATORS = [
+  'earlier in this conversation',
+  'previously discussed',
+  'as mentioned before', 
+  'summarized for brevity',
+  '[conversation compressed]',
+  '[context truncated]',
+  '⏺ Compact summary',
+  'Previous Conversation Compacted',
+  'Referenced file',
+  /⎿.*Referenced file/,
+  /⎿.*Read.*\(\d+ lines\)/
+];
+
+class CompactionDetector {
+  constructor() {
+    this.logFile = path.join(process.cwd(), '.stackmemory', 'compaction.log');
+    this.lastCheck = 0;
+    this.ensureLogDirectory();
+  }
+
+  ensureLogDirectory() {
+    const dir = path.dirname(this.logFile);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+  }
+
+  log(message) {
+    const timestamp = new Date().toISOString();
+    const logEntry = `${timestamp}: ${message}\n`;
+    
+    console.log(`🔍 ${message}`);
+    
+    try {
+      fs.appendFileSync(this.logFile, logEntry);
+    } catch (error) {
+      console.error('Failed to write to log:', error.message);
+    }
+  }
+
+  async detectCompaction(inputText) {
+    if (!inputText) return false;
+
+    const lowerText = inputText.toLowerCase();
+    
+    // Check for exact string matches
+    const hasStringIndicator = COMPACTION_INDICATORS.some(indicator => {
+      if (typeof indicator === 'string') {
+        return lowerText.includes(indicator.toLowerCase());
+      } else if (indicator instanceof RegExp) {
+        return indicator.test(inputText);
+      }
+      return false;
+    });
+
+    // Check for compact summary patterns
+    const hasCompactPattern = /⏺.*compact summary|compact.*summary/i.test(inputText);
+    
+    // Check for conversation compression indicators  
+    const hasCompressionPattern = /previous conversation.*compacted|context.*truncated/i.test(inputText);
+
+    // Check for file reference patterns (common after compaction)
+    const hasFileReferencePattern = /⎿.*referenced file|⎿.*read.*\(\d+ lines\)/i.test(inputText);
+
+    return hasStringIndicator || hasCompactPattern || hasCompressionPattern || hasFileReferencePattern;
+  }
+
+  async triggerRehydration() {
+    this.log('Compaction detected, triggering context rehydration...');
+
+    try {
+      // Check if StackMemory is available
+      await execAsync('stackmemory status');
+      
+      // Check for existing checkpoints
+      const { stdout: listOutput } = await execAsync('stackmemory context rehydrate --list');
+      
+      if (listOutput.includes('No rehydration checkpoints')) {
+        this.log('No checkpoints found, creating initial checkpoint...');
+        await execAsync('stackmemory context rehydrate --create');
+        this.log('Initial checkpoint created');
+      }
+
+      // Perform rehydration
+      this.log('Performing context rehydration...');
+      const { stdout: rehydrateOutput } = await execAsync('stackmemory context rehydrate --verbose');
+      
+      this.log('Context rehydration completed successfully');
+      console.log('\n✅ Rich context restored! Your session now includes:');
+      console.log('   📁 File snapshots with content previews');
+      console.log('   🗺️  Project structure and relationships');
+      console.log('   🧠 Previous decisions and reasoning');
+      console.log('   🎯 Active workflows and focus areas\n');
+
+      return true;
+
+    } catch (error) {
+      this.log(`Context rehydration failed: ${error.message}`);
+      console.error('❌ Failed to rehydrate context:', error.message);
+      return false;
+    }
+  }
+
+  async checkInput(text) {
+    if (await this.detectCompaction(text)) {
+      // Debounce multiple detections
+      const now = Date.now();
+      if (now - this.lastCheck < 30000) { // 30 second cooldown
+        this.log('Compaction detected but within cooldown period, skipping...');
+        return;
+      }
+      
+      this.lastCheck = now;
+      await this.triggerRehydration();
+    }
+  }
+}
+
+// CLI usage
+async function main() {
+  const detector = new CompactionDetector();
+
+  if (process.argv.length > 2) {
+    // Check specific text
+    const text = process.argv.slice(2).join(' ');
+    const detected = await detector.detectCompaction(text);
+    console.log(`Compaction detected: ${detected}`);
+    
+    if (detected) {
+      await detector.triggerRehydration();
+    }
+  } else {
+    // Monitor mode (could be enhanced to monitor clipboard, files, etc.)
+    console.log('📡 StackMemory Compaction Detector Ready');
+    console.log('💡 Usage: node detect-and-rehydrate.js "text to check"');
+    console.log('🔧 Integrate with Claude Code hooks for automatic detection');
+  }
+}
+
+// Export for use as module
+module.exports = { CompactionDetector };
+
+// Run if called directly
+if (require.main === module) {
+  main().catch(console.error);
+}

package/scripts/detect-and-rehydrate.mjs

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+
+/**
+ * Smart Compaction Detection and Auto-Rehydration
+ * Monitors Claude Code context and triggers rehydration when needed
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const execAsync = promisify(exec);
+
+// Compaction detection patterns
+const COMPACTION_INDICATORS = [
+  'earlier in this conversation',
+  'previously discussed',
+  'as mentioned before', 
+  'summarized for brevity',
+  '[conversation compressed]',
+  '[context truncated]',
+  '⏺ Compact summary',
+  'Previous Conversation Compacted',
+  'Referenced file',
+  /⎿.*Referenced file/,
+  /⎿.*Read.*\(\d+ lines\)/
+];
+
+class CompactionDetector {
+  constructor() {
+    this.logFile = path.join(process.cwd(), '.stackmemory', 'compaction.log');
+    this.lastCheck = 0;
+    this.ensureLogDirectory();
+  }
+
+  ensureLogDirectory() {
+    const dir = path.dirname(this.logFile);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+  }
+
+  log(message) {
+    const timestamp = new Date().toISOString();
+    const logEntry = `${timestamp}: ${message}\n`;
+    
+    console.log(`🔍 ${message}`);
+    
+    try {
+      fs.appendFileSync(this.logFile, logEntry);
+    } catch (error) {
+      console.error('Failed to write to log:', error.message);
+    }
+  }
+
+  async detectCompaction(inputText) {
+    if (!inputText) return false;
+
+    const lowerText = inputText.toLowerCase();
+    
+    // Check for exact string matches
+    const hasStringIndicator = COMPACTION_INDICATORS.some(indicator => {
+      if (typeof indicator === 'string') {
+        return lowerText.includes(indicator.toLowerCase());
+      } else if (indicator instanceof RegExp) {
+        return indicator.test(inputText);
+      }
+      return false;
+    });
+
+    // Check for compact summary patterns
+    const hasCompactPattern = /⏺.*compact summary|compact.*summary/i.test(inputText);
+    
+    // Check for conversation compression indicators  
+    const hasCompressionPattern = /previous conversation.*compacted|context.*truncated/i.test(inputText);
+
+    // Check for file reference patterns (common after compaction)
+    const hasFileReferencePattern = /⎿.*referenced file|⎿.*read.*\(\d+ lines\)/i.test(inputText);
+
+    return hasStringIndicator || hasCompactPattern || hasCompressionPattern || hasFileReferencePattern;
+  }
+
+  async triggerRehydration() {
+    this.log('Compaction detected, triggering context rehydration...');
+
+    try {
+      // Check if StackMemory is available
+      await execAsync('~/.stackmemory/bin/stackmemory status');
+      
+      // Check for existing checkpoints
+      const { stdout: listOutput } = await execAsync('~/.stackmemory/bin/stackmemory context rehydrate --list');
+      
+      if (listOutput.includes('No rehydration checkpoints')) {
+        this.log('No checkpoints found, creating initial checkpoint...');
+        await execAsync('~/.stackmemory/bin/stackmemory context rehydrate --create');
+        this.log('Initial checkpoint created');
+      }
+
+      // Perform rehydration
+      this.log('Performing context rehydration...');
+      const { stdout: rehydrateOutput } = await execAsync('~/.stackmemory/bin/stackmemory context rehydrate --verbose');
+      
+      this.log('Context rehydration completed successfully');
+      console.log('\n✅ Rich context restored! Your session now includes:');
+      console.log('   📁 File snapshots with content previews');
+      console.log('   🗺️  Project structure and relationships');
+      console.log('   🧠 Previous decisions and reasoning');
+      console.log('   🎯 Active workflows and focus areas\n');
+
+      return true;
+
+    } catch (error) {
+      this.log(`Context rehydration failed: ${error.message}`);
+      console.error('❌ Failed to rehydrate context:', error.message);
+      return false;
+    }
+  }
+
+  async checkInput(text) {
+    if (await this.detectCompaction(text)) {
+      // Debounce multiple detections
+      const now = Date.now();
+      if (now - this.lastCheck < 30000) { // 30 second cooldown
+        this.log('Compaction detected but within cooldown period, skipping...');
+        return;
+      }
+      
+      this.lastCheck = now;
+      await this.triggerRehydration();
+    }
+  }
+}
+
+// CLI usage
+async function main() {
+  const detector = new CompactionDetector();
+
+  if (process.argv.length > 2) {
+    // Check specific text
+    const text = process.argv.slice(2).join(' ');
+    const detected = await detector.detectCompaction(text);
+    console.log(`Compaction detected: ${detected}`);
+    
+    if (detected) {
+      await detector.triggerRehydration();
+    }
+  } else {
+    // Monitor mode
+    console.log('📡 StackMemory Compaction Detector Ready');
+    console.log('💡 Usage: node detect-and-rehydrate.mjs "text to check"');
+    console.log('🔧 Integrate with Claude Code hooks for automatic detection');
+  }
+}
+
+// Run if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main().catch(console.error);
+}
+
+export { CompactionDetector };

package/scripts/development/create-demo-tasks.js

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+/**
+ * Create demo tasks to review current system and plan Linear integration
+ */
+
+import Database from 'better-sqlite3';
+import { join } from 'path';
+import { PebblesTaskStore } from './dist/src/pebbles/pebbles-task-store.js';
+import { FrameManager } from './dist/src/core/frame-manager.js';
+
+const projectRoot = process.cwd();
+const dbPath = join(projectRoot, '.stackmemory', 'context.db');
+const db = new Database(dbPath);
+
+// Initialize managers
+const frameManager = new FrameManager(db, 'stackmemory-demo');
+const taskStore = new PebblesTaskStore(projectRoot, db);
+
+console.log('🚀 Creating demo development tasks...\n');
+
+// Create a main development frame
+const mainFrameId = frameManager.createFrame({
+  type: 'task',
+  name: 'StackMemory v0.3.0 Development',
+  inputs: {
+    constraints: [
+      'Must maintain git-native architecture',
+      'Zero infrastructure requirements',
+    ],
+    goals: [
+      'Linear integration',
+      'Enhanced task management',
+      'Team collaboration',
+    ],
+  },
+});
+
+console.log(`📋 Created main frame: ${mainFrameId}\n`);
+
+// Create development tasks
+const tasks = [
+  {
+    title: 'Linear API Integration',
+    description:
+      'Implement bi-directional sync with Linear for team collaboration. Include webhook handlers, status mapping, and conflict resolution.',
+    priority: 'high',
+    estimatedEffort: 240, // 4 hours
+    tags: ['integration', 'linear', 'api', 'team'],
+    dependsOn: [],
+  },
+  {
+    title: 'Enhanced CLI Commands',
+    description:
+      'Add comprehensive task management commands to StackMemory CLI. Include list, update, create, and dependency management.',
+    priority: 'medium',
+    estimatedEffort: 120, // 2 hours
+    tags: ['cli', 'ux', 'commands'],
+    dependsOn: [],
+  },
+  {
+    title: 'Git Hooks Integration',
+    description:
+      'Automate task state sync with git workflow. Pre-commit validation, post-commit updates, and branch-based task isolation.',
+    priority: 'medium',
+    estimatedEffort: 90, // 1.5 hours
+    tags: ['git', 'automation', 'hooks'],
+    dependsOn: [],
+  },
+  {
+    title: 'Task Analytics Dashboard',
+    description:
+      'Web UI for task metrics and project insights. Show completion rates, effort accuracy, blocking issues, and team performance.',
+    priority: 'low',
+    estimatedEffort: 480, // 8 hours
+    tags: ['ui', 'analytics', 'web', 'dashboard'],
+    dependsOn: [],
+  },
+  {
+    title: 'Performance Optimization',
+    description:
+      'Optimize context assembly and JSONL parsing performance. Implement lazy loading, caching, and parallel processing.',
+    priority: 'high',
+    estimatedEffort: 180, // 3 hours
+    tags: ['performance', 'optimization', 'caching'],
+    dependsOn: [],
+  },
+];
+
+const createdTasks = [];
+
+for (const task of tasks) {
+  const taskId = taskStore.createTask({
+    title: task.title,
+    description: task.description,
+    priority: task.priority,
+    frameId: mainFrameId,
+    tags: task.tags,
+    estimatedEffort: task.estimatedEffort,
+  });
+
+  createdTasks.push({ id: taskId, ...task });
+  console.log(`✅ Created: ${task.title} (${taskId})`);
+}
+
+console.log(`\n📊 Created ${createdTasks.length} development tasks`);
+
+// Set up some task dependencies
+console.log('\n🔗 Setting up task dependencies...');
+
+// Find Linear integration task
+const linearTask = createdTasks.find((t) => t.title.includes('Linear'));
+const cliTask = createdTasks.find((t) => t.title.includes('CLI'));
+
+if (linearTask && cliTask) {
+  // CLI commands should depend on Linear integration being available
+  taskStore.addDependency(cliTask.id, linearTask.id);
+  console.log(`🔗 ${cliTask.title} depends on ${linearTask.title}`);
+}
+
+// Start the Linear integration task as in_progress
+if (linearTask) {
+  taskStore.updateTaskStatus(linearTask.id, 'in_progress');
+  console.log(`🚀 Started: ${linearTask.title}`);
+}
+
+console.log('\n📈 Current metrics:');
+const metrics = taskStore.getMetrics();
+console.log(`- Total tasks: ${metrics.total_tasks}`);
+console.log(`- In progress: ${metrics.by_status.in_progress || 0}`);
+console.log(`- Pending: ${metrics.by_status.pending || 0}`);
+console.log(`- High priority: ${metrics.by_priority.high || 0}`);
+
+console.log('\n🎯 Active tasks:');
+const activeTasks = taskStore.getActiveTasks();
+activeTasks.forEach((task) => {
+  const status = task.status.replace('_', ' ').toUpperCase();
+  const effort = task.estimated_effort ? ` (${task.estimated_effort}m)` : '';
+  console.log(`- [${status}] ${task.title}${effort}`);
+});
+
+console.log('\n✅ Demo tasks created! Use MCP tools to interact with them.');
+
+db.close();

package/scripts/development/debug-frame-test.js

@@ -0,0 +1,16 @@
+// Test the actual issue with a simpler approach
+import { v4 as uuidv4 } from 'uuid';
+
+console.log('Testing simple UUID generation...');
+const testId = uuidv4();
+console.log('UUID result:', testId);
+console.log('Type:', typeof testId);
+
+// Let me check if this is a vitest issue
+const simpleFunction = function () {
+  return 'string-result';
+};
+
+const result = simpleFunction();
+console.log('Simple function result:', result);
+console.log('Simple function type:', typeof result);

package/scripts/development/demo-auto-sync.js

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+/**
+ * Demo: Linear Auto-Sync Functionality
+ * Demonstrates how the auto-sync works locally
+ */
+
+import {
+  initializeAutoSync,
+  getAutoSyncService,
+} from './dist/src/integrations/linear-auto-sync.js';
+
+console.log('🚀 Linear Auto-Sync Demo\n');
+
+// Simulate a project directory
+const projectRoot = process.cwd();
+
+console.log('📋 Demo Scenario:');
+console.log('- Configure auto-sync with 30-second intervals');
+console.log('- Show service status and configuration');
+console.log(
+  '- Simulate what happens during sync (without actual Linear connection)'
+);
+console.log('- Demonstrate configuration management\n');
+
+// Step 1: Initialize auto-sync service
+console.log('1️⃣ Initializing auto-sync service...');
+const autoSyncService = initializeAutoSync(projectRoot, {
+  interval: 0.5, // 30 seconds for demo
+  direction: 'bidirectional',
+  conflictResolution: 'newest_wins',
+  enabled: true,
+  retryAttempts: 2,
+  retryDelay: 5000, // 5 seconds
+});
+
+console.log('✅ Auto-sync service initialized\n');
+
+// Step 2: Show service status
+console.log('2️⃣ Current service status:');
+const status = autoSyncService.getStatus();
+console.log(`   Running: ${status.running ? '✅' : '❌'}`);
+console.log(`   Interval: ${status.config.interval} minutes`);
+console.log(`   Direction: ${status.config.direction}`);
+console.log(`   Conflict Resolution: ${status.config.conflictResolution}`);
+console.log(`   Retry Attempts: ${status.config.retryAttempts}`);
+
+if (status.config.quietHours) {
+  console.log(
+    `   Quiet Hours: ${status.config.quietHours.start}:00 - ${status.config.quietHours.end}:00`
+  );
+}
+
+console.log('\n');
+
+// Step 3: Simulate configuration updates
+console.log('3️⃣ Demonstrating configuration updates...');
+autoSyncService.updateConfig({
+  interval: 1, // Change to 1 minute
+  conflictResolution: 'linear_wins',
+});
+console.log('✅ Updated: interval=1min, conflict_resolution=linear_wins\n');
+
+// Step 4: Show updated status
+console.log('4️⃣ Updated service status:');
+const updatedStatus = autoSyncService.getStatus();
+console.log(`   Interval: ${updatedStatus.config.interval} minutes`);
+console.log(
+  `   Conflict Resolution: ${updatedStatus.config.conflictResolution}\n`
+);
+
+// Step 5: Demonstrate the auto-sync would work with Linear
+console.log('5️⃣ How auto-sync works with Linear:');
+console.log('');
+console.log('🔄 **Automatic Synchronization Process:**');
+console.log('   1. Every N minutes (configurable), check for changes');
+console.log('   2. Sync StackMemory tasks → Linear issues');
+console.log('   3. Sync Linear issues → StackMemory task updates');
+console.log(
+  '   4. Handle conflicts based on strategy (newest_wins, linear_wins, etc.)'
+);
+console.log('   5. Log results and schedule next sync');
+console.log('');
+console.log('📊 **Status Mapping:**');
+console.log('   StackMemory pending     → Linear Backlog');
+console.log('   StackMemory in_progress → Linear In Progress');
+console.log('   StackMemory completed   → Linear Done');
+console.log('   StackMemory blocked     → Linear Blocked');
+console.log('');
+console.log('⚡ **Smart Features:**');
+console.log('   • Quiet hours (no sync 10pm-7am by default)');
+console.log('   • Automatic retry with exponential backoff');
+console.log('   • Conflict detection and resolution');
+console.log('   • Persistent configuration');
+console.log('   • Background service support');
+console.log('');
+
+// Step 6: Show NPM integration
+console.log('6️⃣ NPM Package Integration:');
+console.log('');
+console.log('📦 **Available Commands:**');
+console.log('   npm run linear:setup     # Setup Linear OAuth');
+console.log('   npm run linear:status    # Check integration status');
+console.log('   npm run linear:config    # View/edit configuration');
+console.log('   npm run linear:auto-sync # Start auto-sync service');
+console.log('');
+console.log('🔧 **Manual Commands:**');
+console.log('   stackmemory linear config --set-interval 10');
+console.log('   stackmemory linear auto-sync --start');
+console.log('   stackmemory linear force-sync');
+console.log('');
+
+// Step 7: Cleanup
+console.log('7️⃣ Stopping demo service...');
+autoSyncService.stop();
+console.log('✅ Demo completed!\n');
+
+console.log('🎯 **To Use in Production:**');
+console.log('1. Set up Linear OAuth: stackmemory linear setup');
+console.log('2. Authorize integration: stackmemory linear authorize <code>');
+console.log(
+  '3. Configure auto-sync: stackmemory linear config --set-interval 5'
+);
+console.log('4. Start auto-sync: stackmemory linear auto-sync --start');
+console.log('');
+console.log('📖 **Documentation:**');
+console.log('   All settings persist in .stackmemory/linear-auto-sync.json');
+console.log('   Auto-sync runs as a background process within the npm package');
+console.log('   No external services required - everything runs locally');