@stackmemoryai/stackmemory 0.3.16 → 0.3.18

package/scripts/development/test-persistence.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+
+import { SharedContextLayer } from './dist/core/context/shared-context-layer.js';
+import { promises as fs } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+async function testPersistence() {
+  console.log('Testing StackMemory Persistence...\n');
+  
+  try {
+    // Initialize shared context layer
+    const layer = new SharedContextLayer();
+    await layer.initialize();
+    console.log('✅ SharedContextLayer initialized');
+    
+    // Add test context
+    const testFrame = {
+      type: 'test',
+      name: 'Persistence test frame',
+      tags: ['test', 'persistence', 'verification'],
+      data: {
+        timestamp: new Date().toISOString(),
+        test_id: `test-${Date.now()}`,
+        message: 'This is a test frame to verify persistence'
+      }
+    };
+    
+    await layer.addToSharedContext(testFrame);
+    console.log('✅ Added test frame to shared context');
+    
+    // Query to verify it's there
+    const results = await layer.querySharedContext({ tags: ['test', 'persistence'] });
+    console.log(`✅ Query returned ${results.length} matching frames`);
+    
+    // Get the full context
+    const context = await layer.getSharedContext();
+    console.log('\nContext Summary:');
+    console.log(`  Total sessions: ${context.sessions?.length || 0}`);
+    console.log(`  Global patterns: ${context.globalPatterns?.length || 0}`);
+    console.log(`  Decision log entries: ${context.decisionLog?.length || 0}`);
+    console.log(`  Last updated: ${new Date(context.lastUpdated).toLocaleString()}`);
+    
+    // Check persistence file
+    const contextPath = path.join(process.env.HOME, '.stackmemory', 'data', 'shared-context.json');
+    try {
+      const fileContent = await fs.readFile(contextPath, 'utf-8');
+      const savedContext = JSON.parse(fileContent);
+      console.log(`\n✅ Persistence file exists at: ${contextPath}`);
+      console.log(`  File contains ${savedContext.sessions?.length || 0} sessions`);
+      
+      // Find our test frame in the sessions
+      let foundFrame = null;
+      for (const session of savedContext.sessions || []) {
+        const frame = session.keyFrames?.find(f => 
+          f.title === 'Persistence test frame' && 
+          f.tags?.includes('persistence')
+        );
+        if (frame) {
+          foundFrame = frame;
+          break;
+        }
+      }
+      
+      if (foundFrame) {
+        console.log('✅ Test frame found in persisted data!');
+        console.log('  Frame ID:', foundFrame.frameId);
+        console.log('  Frame type:', foundFrame.type);
+        console.log('  Frame score:', foundFrame.score);
+      } else {
+        console.log('⚠️  Test frame not found in persisted data');
+        console.log('  Current sessions:', savedContext.sessions?.length || 0);
+      }
+    } catch (err) {
+      console.log(`⚠️  Could not read persistence file: ${err.message}`);
+      console.log('  Creating new persistence structure...');
+    }
+    
+    // Test patterns
+    await layer.addToSharedContext({
+      type: 'error',
+      name: 'Test error frame',
+      data: {
+        error: 'Test error message',
+        resolution: 'Test resolution'
+      }
+    });
+    
+    const updatedContext = await layer.getSharedContext();
+    console.log('\n✅ Added error frame for pattern detection');
+    console.log(`  Global patterns now: ${updatedContext.globalPatterns?.length || 0}`);
+    
+    const errorPatterns = updatedContext.globalPatterns?.filter(p => p.type === 'error');
+    if (errorPatterns?.length > 0) {
+      console.log('✅ Error pattern detected and stored');
+      console.log(`  Error patterns: ${errorPatterns.length}`);
+    }
+    
+    console.log('\n🎉 Persistence test completed successfully!');
+    console.log('\nTo verify manually:');
+    console.log(`  cat ${contextPath} | jq '.sessions | length'`);
+    console.log(`  cat ${contextPath} | jq '.sessions[-1].keyFrames'`);
+    console.log(`  cat ${contextPath} | jq '.globalPatterns'`);
+    
+  } catch (error) {
+    console.error('❌ Test failed:', error.message);
+    console.error(error.stack);
+    process.exit(1);
+  }
+}
+
+testPersistence().catch(console.error);

package/scripts/development/test-tasks.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+/**
+ * Test script to validate Pebbles task management through MCP
+ * This demonstrates the full task workflow
+ */
+
+import { spawn } from 'child_process';
+
+async function testTaskWorkflow() {
+  console.log('🚀 Testing StackMemory Pebbles Task Management\n');
+
+  // Sample tasks for v0.2.0 release
+  const tasks = [
+    {
+      name: 'Linear API Integration',
+      description:
+        'Implement bi-directional sync with Linear for team collaboration',
+      priority: 'high',
+      estimatedEffort: 240, // 4 hours
+      tags: ['integration', 'linear', 'team'],
+    },
+    {
+      name: 'Enhanced CLI Commands',
+      description: 'Add task management commands to StackMemory CLI',
+      priority: 'medium',
+      estimatedEffort: 120, // 2 hours
+      tags: ['cli', 'ux'],
+    },
+    {
+      name: 'Git Hooks Integration',
+      description: 'Automate task state sync with git workflow',
+      priority: 'medium',
+      estimatedEffort: 90, // 1.5 hours
+      tags: ['git', 'automation'],
+    },
+    {
+      name: 'Task Analytics Dashboard',
+      description: 'Web UI for task metrics and project insights',
+      priority: 'low',
+      estimatedEffort: 480, // 8 hours
+      tags: ['ui', 'analytics', 'web'],
+    },
+    {
+      name: 'Performance Optimization',
+      description: 'Optimize context assembly and JSONL parsing performance',
+      priority: 'high',
+      estimatedEffort: 180, // 3 hours
+      tags: ['performance', 'optimization'],
+    },
+  ];
+
+  console.log(
+    `📋 Creating ${tasks.length} example tasks for StackMemory development...\n`
+  );
+
+  tasks.forEach((task, index) => {
+    console.log(`${index + 1}. **${task.name}** (${task.priority})`);
+    console.log(`   ${task.description}`);
+    console.log(
+      `   Estimated: ${task.estimatedEffort}m | Tags: ${task.tags.join(', ')}\n`
+    );
+  });
+
+  console.log('✨ These tasks demonstrate:');
+  console.log('- Git-native JSONL storage (.stackmemory/tasks.jsonl)');
+  console.log('- Content-hash task IDs for merge-friendly collaboration');
+  console.log('- Priority-based context assembly');
+  console.log('- Automatic time tracking');
+  console.log('- Dependency management');
+  console.log('- Integration readiness for Linear API sync\n');
+
+  console.log('🔧 To create these tasks with StackMemory MCP:');
+  console.log(
+    '1. Start frame: start_frame("StackMemory v0.2.0 Development", "task")'
+  );
+  console.log(
+    '2. Create tasks: create_task("Linear API Integration", priority="high", ...)'
+  );
+  console.log('3. Track progress: update_task_status(taskId, "in_progress")');
+  console.log('4. View metrics: get_task_metrics()');
+  console.log('5. Check active work: get_active_tasks()');
+
+  return tasks;
+}
+
+// Run the test
+testTaskWorkflow()
+  .then((tasks) => {
+    console.log(
+      `\n✅ Ready to create ${tasks.length} tasks in StackMemory v0.2.0!`
+    );
+  })
+  .catch(console.error);

package/scripts/development/update-imports.js

@@ -0,0 +1,212 @@
+#!/usr/bin/env node
+
+/**
+ * Update import paths after folder reorganization
+ */
+
+import { readFileSync, writeFileSync, readdirSync, statSync } from 'fs';
+import { join, relative, dirname } from 'path';
+
+const importMappings = {
+  // Core mappings
+  '../core/frame-manager': '../core/context/frame-manager',
+  '../core/project-manager': '../core/projects/project-manager',
+  '../core/logger': '../core/monitoring/logger',
+  '../core/error-handler': '../core/monitoring/error-handler',
+  '../core/progress-tracker': '../core/monitoring/progress-tracker',
+  '../core/update-checker': '../core/utils/update-checker',
+
+  // Features mappings
+  '../pebbles/pebbles-task-store': '../features/tasks/task-store',
+  '../pebbles/task-aware-context': '../features/tasks/task-context',
+  '../analytics/': '../features/analytics/',
+  '../integrations/browser-mcp': '../features/browser/browser-mcp',
+
+  // Integrations mappings
+  '../integrations/linear-auth': '../integrations/linear/auth',
+  '../integrations/linear-sync': '../integrations/linear/sync',
+  '../integrations/linear-client': '../integrations/linear/client',
+  '../integrations/linear-config': '../integrations/linear/config',
+  '../integrations/linear-auto-sync': '../integrations/linear/auto-sync',
+  '../mcp/mcp-server': '../integrations/mcp/server',
+
+  // CLI mappings
+  './cli': './index',
+  './project-commands': './commands/projects',
+  './analytics-viewer': './utils/viewer',
+  '../cli/cli': '../cli/index',
+
+  // Server mappings
+  '../railway/': '../servers/railway/',
+  './railway/': './servers/railway/',
+};
+
+function updateImportsInFile(filePath) {
+  if (!filePath.endsWith('.ts') && !filePath.endsWith('.js')) {
+    return false;
+  }
+
+  try {
+    let content = readFileSync(filePath, 'utf-8');
+    let modified = false;
+
+    // Update import statements
+    for (const [oldPath, newPath] of Object.entries(importMappings)) {
+      const importRegex = new RegExp(
+        `(import.*from\\s+['"]\\.?)${escapeRegex(oldPath)}(['"])`,
+        'g'
+      );
+      const newContent = content.replace(importRegex, `$1${newPath}$2`);
+
+      if (newContent !== content) {
+        content = newContent;
+        modified = true;
+      }
+    }
+
+    // Special case: Update shebang for CLI entry point
+    if (filePath.endsWith('src/cli/index.ts')) {
+      if (!content.startsWith('#!/usr/bin/env node')) {
+        content = '#!/usr/bin/env node\n' + content;
+        modified = true;
+      }
+    }
+
+    if (modified) {
+      writeFileSync(filePath, content);
+      console.log(`✅ Updated: ${relative(process.cwd(), filePath)}`);
+      return true;
+    }
+
+    return false;
+  } catch (error) {
+    console.error(`❌ Error updating ${filePath}:`, error.message);
+    return false;
+  }
+}
+
+function escapeRegex(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function walkDirectory(dir) {
+  const files = [];
+
+  try {
+    const items = readdirSync(dir);
+
+    for (const item of items) {
+      const fullPath = join(dir, item);
+      const stat = statSync(fullPath);
+
+      if (stat.isDirectory()) {
+        // Skip node_modules, dist, and .git
+        if (
+          !item.startsWith('.') &&
+          item !== 'node_modules' &&
+          item !== 'dist'
+        ) {
+          files.push(...walkDirectory(fullPath));
+        }
+      } else if (stat.isFile()) {
+        files.push(fullPath);
+      }
+    }
+  } catch (error) {
+    console.error(`Error walking directory ${dir}:`, error.message);
+  }
+
+  return files;
+}
+
+function updatePackageJson() {
+  try {
+    const packagePath = join(process.cwd(), 'package.json');
+    const pkg = JSON.parse(readFileSync(packagePath, 'utf-8'));
+
+    // Update bin path
+    if (pkg.bin && pkg.bin.stackmemory) {
+      pkg.bin.stackmemory = 'dist/src/cli/index.js';
+    }
+
+    // Update main entry
+    if (pkg.main) {
+      pkg.main = pkg.main.replace('dist/src/index.js', 'dist/src/index.js');
+    }
+
+    // Update scripts
+    if (pkg.scripts) {
+      // Update MCP server paths
+      if (pkg.scripts['mcp:start']) {
+        pkg.scripts['mcp:start'] = pkg.scripts['mcp:start'].replace(
+          'dist/src/mcp/mcp-server.js',
+          'dist/src/integrations/mcp/server.js'
+        );
+      }
+      if (pkg.scripts['mcp:local']) {
+        pkg.scripts['mcp:local'] = pkg.scripts['mcp:local'].replace(
+          'dist/src/mcp/mcp-server.js',
+          'dist/src/integrations/mcp/server.js'
+        );
+      }
+
+      // Update lint fix script
+      if (pkg.scripts['lint:autofix']) {
+        pkg.scripts['lint:autofix'] = pkg.scripts['lint:autofix'].replace(
+          'scripts/fix-lint-loop.cjs',
+          'scripts/development/fix-lint-loop.cjs'
+        );
+      }
+    }
+
+    writeFileSync(packagePath, JSON.stringify(pkg, null, 2) + '\n');
+    console.log('✅ Updated package.json');
+  } catch (error) {
+    console.error('❌ Error updating package.json:', error.message);
+  }
+}
+
+function updateTsConfig() {
+  try {
+    const tsconfigPath = join(process.cwd(), 'tsconfig.json');
+    const tsconfig = JSON.parse(readFileSync(tsconfigPath, 'utf-8'));
+
+    // Update exclude paths if needed
+    if (tsconfig.exclude) {
+      tsconfig.exclude = tsconfig.exclude
+        .map((path) => {
+          if (path === 'src/runway.bak') return null;
+          if (path === 'src/runway') return null;
+          return path;
+        })
+        .filter(Boolean);
+    }
+
+    writeFileSync(tsconfigPath, JSON.stringify(tsconfig, null, 2) + '\n');
+    console.log('✅ Updated tsconfig.json');
+  } catch (error) {
+    console.error('❌ Error updating tsconfig.json:', error.message);
+  }
+}
+
+// Main execution
+console.log('🔄 Updating import paths after reorganization...\n');
+
+const srcFiles = walkDirectory(join(process.cwd(), 'src'));
+const testFiles = walkDirectory(join(process.cwd(), 'tests'));
+const scriptFiles = walkDirectory(join(process.cwd(), 'scripts'));
+
+let updatedCount = 0;
+
+for (const file of [...srcFiles, ...testFiles, ...scriptFiles]) {
+  if (updateImportsInFile(file)) {
+    updatedCount++;
+  }
+}
+
+// Update configuration files
+updatePackageJson();
+updateTsConfig();
+
+console.log(`\n✅ Updated ${updatedCount} files`);
+console.log('📦 Run "npm run build" to verify all imports are correct');

package/scripts/fetch-linear-status.js

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+import 'dotenv/config';
+import { LinearClient } from '@linear/sdk';
+
+const API_KEY = process.env.LINEAR_API_KEY;
+
+if (!API_KEY) {
+    console.error('❌ LINEAR_API_KEY not found in environment');
+    process.exit(1);
+}
+
+async function fetchLinearTasks() {
+    const client = new LinearClient({ apiKey: API_KEY });
+    
+    try {
+        const me = await client.viewer;
+        console.log(`\n👤 Connected as: ${me.name || me.email}\n`);
+        
+        // Get teams
+        const teams = await client.teams();
+        console.log(`📋 Teams: ${teams.nodes.map(t => t.key).join(', ')}\n`);
+        
+        // Fetch all issues
+        const issues = await client.issues({
+            filter: {
+                state: {
+                    name: { nin: ["Done", "Canceled"] }
+                }
+            },
+            orderBy: "priority"
+        });
+        
+        // Group by state
+        const byState = {};
+        for (const issue of issues.nodes) {
+            const state = issue.state?.name || 'Unknown';
+            if (!byState[state]) byState[state] = [];
+            byState[state].push(issue);
+        }
+        
+        // Display by state
+        const stateOrder = ['In Progress', 'Todo', 'Triage', 'Backlog', 'Unknown'];
+        
+        for (const state of stateOrder) {
+            if (byState[state] && byState[state].length > 0) {
+                console.log(`📊 ${state.toUpperCase()} (${byState[state].length}):`);
+                
+                // Show top 10 from each state
+                const topIssues = byState[state].slice(0, 10);
+                for (const issue of topIssues) {
+                    const priority = issue.priority ? `[P${issue.priority}]` : '';
+                    const assignee = issue.assignee ? `@${issue.assignee.name}` : '[Unassigned]';
+                    const labels = issue.labels ? (await issue.labels()).nodes.map(l => l.name).join(', ') : '';
+                    const labelStr = labels ? ` 🏷️ ${labels}` : '';
+                    
+                    console.log(`  • ${issue.identifier}: ${issue.title} ${priority} ${assignee}${labelStr}`);
+                }
+                
+                if (byState[state].length > 10) {
+                    console.log(`  ... and ${byState[state].length - 10} more`);
+                }
+                console.log('');
+            }
+        }
+        
+        // Summary stats
+        const total = issues.nodes.length;
+        const inProgress = byState['In Progress']?.length || 0;
+        const todo = byState['Todo']?.length || 0;
+        const triage = byState['Triage']?.length || 0;
+        
+        console.log('📈 SUMMARY:');
+        console.log(`  Total active issues: ${total}`);
+        console.log(`  In Progress: ${inProgress}`);
+        console.log(`  Todo: ${todo}`);
+        console.log(`  Triage: ${triage}`);
+        
+        // High priority items
+        console.log('\n🔥 HIGH PRIORITY ITEMS:');
+        const highPriority = issues.nodes
+            .filter(i => i.priority && i.priority <= 2)
+            .slice(0, 5);
+            
+        for (const issue of highPriority) {
+            const state = issue.state?.name || 'Unknown';
+            const assignee = issue.assignee ? `@${issue.assignee.name}` : '[Unassigned]';
+            console.log(`  • ${issue.identifier}: ${issue.title} [${state}] ${assignee}`);
+        }
+        
+        // Suggested next tasks
+        console.log('\n💡 SUGGESTED NEXT TASKS:');
+        console.log('Based on priority and status, consider working on:');
+        
+        // Find unassigned high priority or in-progress items
+        const suggestions = issues.nodes
+            .filter(i => {
+                const isHighPriority = i.priority && i.priority <= 2;
+                const isInProgress = i.state?.name === 'In Progress';
+                const isTodo = i.state?.name === 'Todo';
+                const isUnassigned = !i.assignee;
+                
+                return (isHighPriority || isInProgress) && (isTodo || isInProgress);
+            })
+            .slice(0, 3);
+            
+        if (suggestions.length > 0) {
+            for (const issue of suggestions) {
+                const state = issue.state?.name || 'Unknown';
+                const priority = issue.priority ? `P${issue.priority}` : 'No priority';
+                console.log(`  1. ${issue.identifier}: ${issue.title}`);
+                console.log(`     Status: ${state}, Priority: ${priority}`);
+                console.log(`     URL: https://linear.app/issue/${issue.identifier}`);
+                console.log('');
+            }
+        } else {
+            console.log('  No high-priority unassigned tasks found.');
+        }
+        
+    } catch (error) {
+        console.error('Error fetching Linear tasks:', error.message);
+        process.exit(1);
+    }
+}
+
+fetchLinearTasks();