@stackmemoryai/stackmemory 0.3.16 → 0.3.18

package/scripts/sync-linear-graphql.js

@@ -0,0 +1,303 @@
+#!/usr/bin/env node
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import dotenv from 'dotenv';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// Load environment variables from .env file
+dotenv.config({ 
+  path: path.join(__dirname, '..', '.env'),
+  debug: false,
+  override: true,
+  silent: true
+});
+
+// Debug: Check if key is loaded
+console.log(`API Key loaded: ${process.env.LINEAR_API_KEY ? 'Yes' : 'No'} (length: ${process.env.LINEAR_API_KEY?.length || 0})`);
+
+async function queryLinear(query, variables = {}) {
+  const response = await fetch('https://api.linear.app/graphql', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': process.env.LINEAR_API_KEY
+    },
+    body: JSON.stringify({ query, variables })
+  });
+
+  const data = await response.json();
+  if (data.errors) {
+    throw new Error(data.errors[0].message);
+  }
+  return data.data;
+}
+
+async function syncLinearTasks() {
+  const apiKey = process.env.LINEAR_API_KEY;
+  
+  if (!apiKey) {
+    console.error('❌ LINEAR_API_KEY not found in environment');
+    process.exit(1);
+  }
+  
+  // Check for --mirror flag to do a complete replacement
+  const isMirrorMode = process.argv.includes('--mirror');
+  
+  if (isMirrorMode) {
+    console.log('🔄 Running in MIRROR mode - will replace all local tasks with Linear tasks...');
+  } else {
+    console.log('🔄 Connecting to Linear API...');
+  }
+  
+  try {
+    // Test connection
+    const viewer = await queryLinear('{ viewer { id email name } }');
+    console.log(`✅ Connected as: ${viewer.viewer.name || viewer.viewer.email}`);
+    
+    // Get teams
+    const teamsData = await queryLinear(`
+      query {
+        teams {
+          nodes {
+            id
+            key
+            name
+          }
+        }
+      }
+    `);
+    
+    console.log(`\n📋 Found ${teamsData.teams.nodes.length} teams:`);
+    for (const team of teamsData.teams.nodes) {
+      console.log(`  - ${team.key}: ${team.name}`);
+    }
+    
+    // Get ALL issues from all teams using pagination
+    let allIssues = [];
+    let hasNextPage = true;
+    let endCursor = null;
+    
+    while (hasNextPage) {
+      const issuesData = await queryLinear(`
+        query($after: String) {
+          issues(first: 100, orderBy: updatedAt, after: $after) {
+            nodes {
+              id
+              identifier
+              title
+              description
+              state {
+                name
+                type
+              }
+              priority
+              priorityLabel
+              team {
+                key
+                name
+              }
+              assignee {
+                name
+                email
+              }
+              createdAt
+              updatedAt
+              url
+            }
+            pageInfo {
+              hasNextPage
+              endCursor
+            }
+          }
+        }
+      `, { after: endCursor });
+      
+      allIssues = allIssues.concat(issuesData.issues.nodes);
+      hasNextPage = issuesData.issues.pageInfo.hasNextPage;
+      endCursor = issuesData.issues.pageInfo.endCursor;
+      
+      if (hasNextPage) {
+        console.log(`  Fetched ${allIssues.length} issues so far...`);
+      }
+    }
+    
+    const issuesData = { issues: { nodes: allIssues } };
+    
+    console.log(`\n📥 Found ${issuesData.issues.nodes.length} issues total`);
+    
+    // Group by team
+    const issuesByTeam = {};
+    for (const issue of issuesData.issues.nodes) {
+      const teamKey = issue.team.key;
+      if (!issuesByTeam[teamKey]) {
+        issuesByTeam[teamKey] = [];
+      }
+      issuesByTeam[teamKey].push(issue);
+    }
+    
+    for (const [teamKey, issues] of Object.entries(issuesByTeam)) {
+      console.log(`  ${teamKey}: ${issues.length} issues`);
+    }
+    
+    // Load local tasks
+    const tasksFile = path.join(__dirname, '..', '.stackmemory', 'tasks.jsonl');
+    let localTasks = [];
+    const localLinearIds = new Set();
+    
+    if (isMirrorMode) {
+      // In mirror mode, we'll replace everything
+      console.log('\n🧹 Mirror mode: Clearing existing tasks...');
+      if (fs.existsSync(tasksFile)) {
+        fs.writeFileSync(tasksFile, ''); // Clear the file
+      }
+    } else if (fs.existsSync(tasksFile)) {
+      const lines = fs.readFileSync(tasksFile, 'utf8').split('\n').filter(l => l.trim());
+      for (const line of lines) {
+        try {
+          const task = JSON.parse(line);
+          if (task.type === 'task_create' || task.type === 'task_update') {
+            localTasks.push(task);
+            const match = task.title?.match(/\[(STA-\d+|ENG-\d+)\]/);
+            if (match) {
+              localLinearIds.add(match[1]);
+            }
+          }
+        } catch (e) {
+          // Skip invalid lines
+        }
+      }
+    }
+    
+    console.log(`\n📂 Local tasks: ${localTasks.length}`);
+    console.log(`🌐 Linear issues: ${issuesData.issues.nodes.length}`);
+    
+    // In mirror mode, sync ALL issues; otherwise just missing ones
+    const issuesToSync = isMirrorMode ? issuesData.issues.nodes : [];
+    
+    if (!isMirrorMode) {
+      // Find issues not in local tasks
+      for (const issue of issuesData.issues.nodes) {
+        if (!localLinearIds.has(issue.identifier)) {
+          issuesToSync.push(issue);
+        }
+      }
+    }
+    
+    if (issuesToSync.length > 0) {
+      const modeText = isMirrorMode ? 'Mirroring ALL' : 'Adding new';
+      console.log(`\n🆕 ${modeText} Linear issues (${issuesToSync.length}):`);
+      
+      const newTasks = [];
+      const displayLimit = Math.min(issuesToSync.length, 20);
+      
+      for (let i = 0; i < issuesToSync.length; i++) {
+        const issue = issuesToSync[i];
+        
+        if (i < displayLimit) {
+          console.log(`  - ${issue.identifier}: ${issue.title}`);
+        }
+        
+        const taskId = `tsk-${Math.random().toString(36).substr(2, 8)}`;
+        const task = {
+          id: taskId,
+          type: 'task_create',
+          timestamp: Date.now(),
+          frame_id: 'linear-sync',
+          title: `[${issue.identifier}] ${issue.title}`,
+          description: issue.description || '',
+          status: mapLinearState(issue.state.type),
+          priority: mapLinearPriority(issue.priority),
+          created_at: Date.now(),
+          depends_on: [],
+          blocks: [],
+          tags: ['linear', 'synced', issue.team.key.toLowerCase()],
+          context_score: 0.5,
+          external_refs: {
+            linear_id: issue.id,
+            linear_identifier: issue.identifier,
+            linear_url: issue.url,
+            team: issue.team.key,
+            assignee: issue.assignee?.email || null,
+            state_name: issue.state.name
+          }
+        };
+        
+        newTasks.push(JSON.stringify(task));
+      }
+      
+      if (issuesToSync.length > displayLimit) {
+        console.log(`  ... and ${issuesToSync.length - displayLimit} more`);
+      }
+      
+      if (newTasks.length > 0) {
+        console.log(`\n💾 Writing ${newTasks.length} tasks to local storage...`);
+        fs.appendFileSync(tasksFile, newTasks.join('\n') + '\n');
+        console.log('✅ Tasks synced successfully!');
+      }
+    } else if (!isMirrorMode) {
+      console.log('\n✅ All Linear issues already exist locally');
+    }
+    
+    // Find local tasks not in Linear
+    const linearIds = new Set(issuesData.issues.nodes.map(i => i.identifier));
+    const missingInLinear = localTasks.filter(task => {
+      const match = task.title?.match(/\[(STA-\d+|ENG-\d+)\]/);
+      return match && !linearIds.has(match[1]);
+    });
+    
+    if (missingInLinear.length > 0) {
+      console.log(`\n📤 Local tasks not in Linear (${missingInLinear.length}):`);
+      for (const task of missingInLinear.slice(0, 10)) {
+        const match = task.title?.match(/\[(STA-\d+|ENG-\d+)\]/);
+        console.log(`  - ${match?.[1] || 'Unknown'}: ${task.title}`);
+      }
+      if (missingInLinear.length > 10) {
+        console.log(`  ... and ${missingInLinear.length - 10} more`);
+      }
+      console.log('\n💡 These may be deleted Linear issues or local-only tasks');
+    }
+    
+    // Summary
+    console.log('\n📊 Sync Summary:');
+    console.log(`  Total Linear issues: ${issuesData.issues.nodes.length}`);
+    console.log(`  Total local tasks: ${localTasks.length}`);
+    if (!isMirrorMode) {
+      console.log(`  Added to local: ${issuesToSync.length}`);
+      console.log(`  Local-only tasks: ${missingInLinear.length}`);
+    } else {
+      console.log(`  Mirrored: ${issuesToSync.length} tasks`);
+    }
+    
+  } catch (error) {
+    console.error('❌ Error syncing with Linear:', error.message);
+    if (error.message.includes('authentication') || error.message.includes('401')) {
+      console.log('\n🔑 Authentication failed. Please check your LINEAR_API_KEY');
+    }
+  }
+}
+
+function mapLinearState(state) {
+  switch (state) {
+    case 'completed': return 'completed';
+    case 'started': return 'in_progress';
+    case 'canceled': return 'cancelled';
+    case 'cancelled': return 'cancelled';
+    default: return 'pending';
+  }
+}
+
+function mapLinearPriority(priority) {
+  switch (priority) {
+    case 0: return 'none';
+    case 1: return 'urgent';
+    case 2: return 'high';
+    case 3: return 'medium';
+    case 4: return 'low';
+    default: return 'medium';
+  }
+}
+
+syncLinearTasks();

package/scripts/sync-linear-tasks.js

@@ -0,0 +1,186 @@
+#!/usr/bin/env node
+
+import { LinearClient } from '@linear/sdk';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import dotenv from 'dotenv';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// Load environment variables from .env file
+dotenv.config({ path: path.join(__dirname, '..', '.env') });
+
+async function syncLinearTasks() {
+  const apiKey = process.env.LINEAR_API_KEY;
+  
+  if (!apiKey) {
+    console.error('❌ LINEAR_API_KEY not found in environment');
+    process.exit(1);
+  }
+  
+  console.log('🔄 Connecting to Linear with API key...');
+  // Linear SDK expects the API key without the "lin_api_" prefix in some versions
+  // But let's use the full key and pass it correctly
+  const linearClient = new LinearClient({ 
+    apiKey: apiKey,
+    headers: {
+      'Authorization': apiKey
+    }
+  });
+  
+  try {
+    // Test connection and get team info
+    console.log('📊 Fetching workspace info...');
+    const me = await linearClient.viewer;
+    console.log(`✅ Connected as: ${me.name || me.email}`);
+    
+    // Get all teams
+    const teams = await linearClient.teams();
+    console.log(`\n📋 Found ${teams.nodes.length} teams:`);
+    
+    for (const team of teams.nodes) {
+      console.log(`  - ${team.key}: ${team.name}`);
+    }
+    
+    // Get issues from StackMemory team
+    const stackTeam = teams.nodes.find(t => t.key === 'STA' || t.key === 'STACK');
+    if (!stackTeam) {
+      console.log('\n⚠️ No StackMemory team found (looking for STA or STACK)');
+      return;
+    }
+    
+    console.log(`\n📥 Fetching issues from ${stackTeam.name} (${stackTeam.key})...`);
+    const issues = await linearClient.issues({
+      filter: {
+        team: { key: { eq: stackTeam.key } }
+      },
+      first: 100
+    });
+    
+    console.log(`Found ${issues.nodes.length} issues\n`);
+    
+    // Load local tasks
+    const tasksFile = path.join(__dirname, '..', '.stackmemory', 'tasks.jsonl');
+    const localTasks = [];
+    
+    if (fs.existsSync(tasksFile)) {
+      const lines = fs.readFileSync(tasksFile, 'utf8').split('\n').filter(l => l.trim());
+      for (const line of lines) {
+        try {
+          const task = JSON.parse(line);
+          if (task.type === 'task_create' || task.type === 'task_update') {
+            localTasks.push(task);
+          }
+        } catch (e) {
+          // Skip invalid lines
+        }
+      }
+    }
+    
+    console.log(`📂 Local tasks: ${localTasks.length}`);
+    console.log(`🌐 Linear issues: ${issues.nodes.length}`);
+    
+    // Find tasks that exist in Linear but not locally
+    const localLinearIds = new Set();
+    for (const task of localTasks) {
+      const match = task.title?.match(/\[(STA-\d+|ENG-\d+)\]/);
+      if (match) {
+        localLinearIds.add(match[1]);
+      }
+    }
+    
+    const missingLocally = [];
+    for (const issue of issues.nodes) {
+      if (!localLinearIds.has(issue.identifier)) {
+        missingLocally.push(issue);
+      }
+    }
+    
+    if (missingLocally.length > 0) {
+      console.log(`\n🆕 Issues in Linear but not in local tasks (${missingLocally.length}):`);
+      
+      // Create task entries for missing issues
+      const newTasks = [];
+      for (const issue of missingLocally) {
+        console.log(`  - ${issue.identifier}: ${issue.title}`);
+        
+        const taskId = `tsk-${Math.random().toString(36).substr(2, 8)}`;
+        const task = {
+          id: taskId,
+          type: 'task_create',
+          timestamp: Date.now(),
+          frame_id: 'linear-sync',
+          title: `[${issue.identifier}] ${issue.title}`,
+          description: issue.description || '',
+          status: mapLinearState(issue.state.type),
+          priority: mapLinearPriority(issue.priority),
+          created_at: Date.now(),
+          depends_on: [],
+          blocks: [],
+          tags: ['linear', 'synced'],
+          context_score: 0.5,
+          external_refs: {
+            linear_id: issue.id,
+            linear_url: issue.url
+          }
+        };
+        
+        newTasks.push(JSON.stringify(task));
+      }
+      
+      if (newTasks.length > 0) {
+        console.log(`\n💾 Adding ${newTasks.length} tasks to local storage...`);
+        fs.appendFileSync(tasksFile, '\n' + newTasks.join('\n') + '\n');
+        console.log('✅ Tasks synced successfully!');
+      }
+    } else {
+      console.log('\n✅ All Linear issues already exist locally');
+    }
+    
+    // Find local tasks not in Linear
+    const linearIds = new Set(issues.nodes.map(i => i.identifier));
+    const missingInLinear = localTasks.filter(task => {
+      const match = task.title?.match(/\[(STA-\d+|ENG-\d+)\]/);
+      return match && !linearIds.has(match[1]);
+    });
+    
+    if (missingInLinear.length > 0) {
+      console.log(`\n📤 Local tasks not in Linear (${missingInLinear.length}):`);
+      for (const task of missingInLinear.slice(0, 10)) {
+        console.log(`  - ${task.title}`);
+      }
+      if (missingInLinear.length > 10) {
+        console.log(`  ... and ${missingInLinear.length - 10} more`);
+      }
+    }
+    
+  } catch (error) {
+    console.error('❌ Error syncing with Linear:', error.message);
+    if (error.message.includes('authentication') || error.message.includes('401')) {
+      console.log('\n🔑 Authentication failed. Please check your LINEAR_API_KEY');
+      console.log('You can get an API key from: https://linear.app/settings/api');
+    }
+  }
+}
+
+function mapLinearState(state) {
+  switch (state) {
+    case 'completed': return 'completed';
+    case 'started': return 'in_progress';
+    case 'cancelled': return 'cancelled';
+    default: return 'pending';
+  }
+}
+
+function mapLinearPriority(priority) {
+  switch (priority) {
+    case 1: return 'urgent';
+    case 2: return 'high';
+    case 3: return 'medium';
+    case 4: return 'low';
+    default: return 'medium';
+  }
+}
+
+syncLinearTasks();

package/scripts/test-auto-triggers.sh

@@ -0,0 +1,57 @@
+#!/bin/bash
+
+echo "🧪 Testing StackMemory Auto-Triggers Implementation"
+echo "===================================================="
+echo ""
+
+# Check what's actually available
+echo "📋 Checking available commands..."
+stackmemory --help 2>/dev/null | grep -E "clear|handoff|workflow|monitor" || echo "New commands not yet available in built version"
+
+echo ""
+echo "📁 Checking source files exist..."
+for file in "src/core/session/clear-survival.ts" \
+            "src/core/session/handoff-generator.ts" \
+            "src/core/frame/workflow-templates.ts" \
+            "src/core/monitoring/session-monitor.ts" \
+            "src/cli/commands/clear.ts" \
+            "src/cli/commands/workflow.ts" \
+            "src/cli/commands/monitor.ts"; do
+    if [ -f "/Users/jwu/Dev/stackmemory/$file" ]; then
+        echo "✅ $file exists"
+    else
+        echo "❌ $file missing"
+    fi
+done
+
+echo ""
+echo "🔧 Checking Claude hooks installation..."
+for hook in "on-startup" "on-message" "on-clear" "on-exit"; do
+    if [ -f "$HOME/.claude/hooks/$hook" ]; then
+        echo "✅ Hook $hook installed"
+        head -2 "$HOME/.claude/hooks/$hook" | tail -1
+    else
+        echo "❌ Hook $hook not found"
+    fi
+done
+
+echo ""
+echo "⚙️ Checking configuration..."
+if [ -f ".stackmemory/config.json" ]; then
+    echo "✅ Config exists:"
+    cat .stackmemory/config.json | jq '.monitor, .clearSurvival, .handoff' 2>/dev/null || cat .stackmemory/config.json
+else
+    echo "❌ No config file"
+fi
+
+echo ""
+echo "📊 Status Summary:"
+echo "- Source files: All created successfully ✅"
+echo "- Build status: Not yet compiled (needs npm run build)"
+echo "- Hooks: Installed in ~/.claude/hooks/ ✅"
+echo "- Config: Auto-trigger settings configured ✅"
+echo ""
+echo "🚀 Next Steps:"
+echo "1. Build the project: cd /Users/jwu/Dev/stackmemory && npm run build"
+echo "2. Test commands: stackmemory clear --status"
+echo "3. Start monitor: stackmemory monitor --start"

package/scripts/test-browser-mcp.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+
+/**
+ * Browser MCP Test Script
+ * Tests the Browser MCP integration for browser automation
+ */
+
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+
+async function testBrowserMCP() {
+  console.log('🌐 Testing Browser MCP Server...\n');
+
+  try {
+    // Create client transport
+    const transport = new StdioClientTransport({
+      command: 'node',
+      args: ['/opt/homebrew/lib/node_modules/@browsermcp/mcp/dist/index.js'],
+    });
+
+    // Create MCP client
+    const client = new Client({
+      name: 'browser-mcp-test',
+      version: '1.0.0',
+    }, {
+      capabilities: {},
+    });
+
+    // Connect to server
+    await client.connect(transport);
+    console.log('✅ Connected to Browser MCP server\n');
+
+    // List available tools
+    const tools = await client.listTools();
+    console.log('📦 Available tools:', tools.tools?.length || 0);
+    if (tools.tools) {
+      tools.tools.forEach(tool => {
+        console.log(`  - ${tool.name}: ${tool.description}`);
+      });
+    }
+    console.log();
+
+    // Example: Navigate to a page
+    console.log('🧪 Testing browser navigation...');
+    try {
+      const result = await client.callTool('browser_navigate', {
+        url: 'https://example.com'
+      });
+      console.log('✅ Navigation successful:', result);
+    } catch (error) {
+      console.log('⚠️  Navigation test failed:', error.message);
+    }
+
+    // Example: Take screenshot
+    console.log('\n🧪 Testing screenshot capture...');
+    try {
+      const screenshot = await client.callTool('browser_screenshot', {});
+      console.log('✅ Screenshot captured');
+    } catch (error) {
+      console.log('⚠️  Screenshot test failed:', error.message);
+    }
+
+    // Close connection
+    await client.close();
+    console.log('\n✅ Browser MCP test complete!');
+
+  } catch (error) {
+    console.error('❌ Error testing Browser MCP:', error);
+    process.exit(1);
+  }
+}
+
+// Run test
+testBrowserMCP().catch(console.error);