@stackmemoryai/stackmemory 0.8.1 → 1.0.1

package/scripts/sync-and-clean-tasks.js

@@ -1,258 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Sync Linear tasks with local storage and clean up duplicates
- */
-
-import 'dotenv/config';
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const API_KEY = process.env.LINEAR_OAUTH_TOKEN || process.env.STACKMEMORY_LINEAR_API_KEY || process.env.LINEAR_API_KEY;
-if (!API_KEY) {
-  console.error('❌ LINEAR_OAUTH_TOKEN or LINEAR_API_KEY environment variable not set');
-  console.log('Please set LINEAR_OAUTH_TOKEN or LINEAR_API_KEY in your .env file or export it in your shell');
-  process.exit(1);
-}
-
-async function fetchAllLinearTasks() {
-  console.log('📥 Fetching all tasks from Linear...');
-  
-  const query = `
-    query GetAllIssues($after: String) {
-      issues(first: 100, after: $after, includeArchived: false) {
-        nodes {
-          id
-          identifier
-          title
-          description
-          state {
-            id
-            name
-            type
-          }
-          priority
-          estimate
-          createdAt
-          updatedAt
-        }
-        pageInfo {
-          hasNextPage
-          endCursor
-        }
-      }
-    }
-  `;
-  
-  let allIssues = [];
-  let hasNextPage = true;
-  let cursor = null;
-  
-  while (hasNextPage) {
-    const response = await fetch('https://api.linear.app/graphql', {
-      method: 'POST',
-      headers: {
-        'Authorization': `Bearer ${API_KEY}`,
-        'Content-Type': 'application/json'
-      },
-      body: JSON.stringify({
-        query,
-        variables: { after: cursor }
-      })
-    });
-    
-    const result = await response.json();
-    
-    if (result.errors) {
-      throw new Error(result.errors[0].message);
-    }
-    
-    allIssues = allIssues.concat(result.data.issues.nodes);
-    hasNextPage = result.data.issues.pageInfo.hasNextPage;
-    cursor = result.data.issues.pageInfo.endCursor;
-  }
-  
-  console.log(`  Found ${allIssues.length} Linear tasks\n`);
-  return allIssues;
-}
-
-function readLocalTasks() {
-  const tasksFile = path.join(process.cwd(), '.stackmemory', 'tasks.jsonl');
-  
-  if (!fs.existsSync(tasksFile)) {
-    return [];
-  }
-  
-  const lines = fs.readFileSync(tasksFile, 'utf8').split('\n').filter(Boolean);
-  return lines.map(line => {
-    try {
-      return JSON.parse(line);
-    } catch {
-      return null;
-    }
-  }).filter(Boolean);
-}
-
-function writeLocalTasks(tasks) {
-  const tasksFile = path.join(process.cwd(), '.stackmemory', 'tasks.jsonl');
-  const backupFile = `${tasksFile}.backup-${Date.now()}`;
-  
-  // Backup current file
-  if (fs.existsSync(tasksFile)) {
-    fs.copyFileSync(tasksFile, backupFile);
-    console.log(`  Backed up to: ${path.basename(backupFile)}`);
-  }
-  
-  // Write new tasks
-  const content = tasks.map(t => JSON.stringify(t)).join('\n');
-  fs.writeFileSync(tasksFile, content + '\n');
-}
-
-async function syncAndCleanTasks() {
-  console.log('🔄 Syncing and cleaning local tasks with Linear...\n');
-  
-  try {
-    // Fetch Linear tasks
-    const linearTasks = await fetchAllLinearTasks();
-    const linearMap = new Map(linearTasks.map(t => [t.identifier, t]));
-    
-    // Read local tasks
-    console.log('📂 Reading local tasks...');
-    const localTasks = readLocalTasks();
-    console.log(`  Found ${localTasks.length} local tasks\n`);
-    
-    // Build new clean task list from Linear
-    const cleanTasks = [];
-    const taskIdMap = new Map(); // To track duplicates
-    
-    for (const linearTask of linearTasks) {
-      // Skip if we already have this task ID
-      if (taskIdMap.has(linearTask.identifier)) {
-        console.log(`  Skipping duplicate: ${linearTask.identifier}`);
-        continue;
-      }
-      
-      // Find matching local task for metadata
-      const localTask = localTasks.find(t => 
-        t.linearId === linearTask.identifier ||
-        t.taskId === linearTask.identifier ||
-        t.id === linearTask.identifier
-      );
-      
-      // Create clean task entry
-      const cleanTask = {
-        id: linearTask.identifier,
-        taskId: linearTask.identifier,
-        linearId: linearTask.identifier,
-        title: linearTask.title,
-        description: linearTask.description || '',
-        status: mapLinearStatus(linearTask.state),
-        priority: linearTask.priority || 4,
-        createdAt: linearTask.createdAt,
-        updatedAt: linearTask.updatedAt,
-        linearState: linearTask.state.name,
-        linearStateType: linearTask.state.type,
-        // Preserve local metadata if it exists
-        ...(localTask ? {
-          localContext: localTask.localContext,
-          gitBranch: localTask.gitBranch,
-          files: localTask.files,
-          completedAt: localTask.completedAt
-        } : {})
-      };
-      
-      cleanTasks.push(cleanTask);
-      taskIdMap.set(linearTask.identifier, true);
-    }
-    
-    console.log('📊 Sync Results:');
-    console.log(`  Linear tasks: ${linearTasks.length}`);
-    console.log(`  Local tasks (before): ${localTasks.length}`);
-    console.log(`  Clean tasks (after): ${cleanTasks.length}`);
-    console.log(`  Removed duplicates: ${localTasks.length - cleanTasks.length}\n`);
-    
-    // Show what's being removed
-    const removedTasks = localTasks.filter(t => 
-      !linearMap.has(t.linearId) && 
-      !linearMap.has(t.taskId) &&
-      !linearMap.has(t.id)
-    );
-    
-    if (removedTasks.length > 0) {
-      console.log('🗑️  Removing local-only tasks (not in Linear):');
-      removedTasks.slice(0, 10).forEach(t => {
-        console.log(`  - ${t.taskId || t.id}: ${(t.title || '').substring(0, 50)}...`);
-      });
-      if (removedTasks.length > 10) {
-        console.log(`  ... and ${removedTasks.length - 10} more\n`);
-      }
-    }
-    
-    // Write clean tasks
-    console.log('💾 Writing clean task list...');
-    writeLocalTasks(cleanTasks);
-    
-    // Update Linear mappings
-    const mappingsFile = path.join(process.cwd(), '.stackmemory', 'linear-mappings.json');
-    const mappings = {};
-    
-    for (const task of cleanTasks) {
-      mappings[task.linearId] = {
-        linearId: task.linearId,
-        localId: task.id,
-        title: task.title,
-        state: task.linearState,
-        lastSync: new Date().toISOString()
-      };
-    }
-    
-    fs.writeFileSync(mappingsFile, JSON.stringify(mappings, null, 2));
-    console.log('  Updated linear-mappings.json\n');
-    
-    // Clean up old backup files
-    console.log('🧹 Cleaning up old backup files...');
-    const backupFiles = fs.readdirSync(path.join(process.cwd(), '.stackmemory'))
-      .filter(f => f.startsWith('tasks.jsonl.backup-'))
-      .sort()
-      .reverse();
-    
-    // Keep only the 3 most recent backups
-    const toDelete = backupFiles.slice(3);
-    toDelete.forEach(file => {
-      fs.unlinkSync(path.join(process.cwd(), '.stackmemory', file));
-      console.log(`  Deleted: ${file}`);
-    });
-    
-    if (toDelete.length === 0) {
-      console.log('  No old backups to delete');
-    }
-    
-    console.log('\n✅ Sync and cleanup complete!');
-    console.log(`  Active tasks: ${cleanTasks.filter(t => t.linearStateType !== 'completed' && t.linearStateType !== 'canceled').length}`);
-    console.log(`  Completed tasks: ${cleanTasks.filter(t => t.linearStateType === 'completed').length}`);
-    console.log(`  Total synced tasks: ${cleanTasks.length}`);
-    
-  } catch (error) {
-    console.error('❌ Sync failed:', error.message);
-    process.exit(1);
-  }
-}
-
-function mapLinearStatus(state) {
-  switch (state.type) {
-    case 'completed': return 'completed';
-    case 'started': return 'in_progress';
-    case 'canceled': return 'cancelled';
-    case 'backlog': return 'backlog';
-    default: return 'todo';
-  }
-}
-
-// Run if called directly
-if (import.meta.url === `file://${process.argv[1]}`) {
-  syncAndCleanTasks().catch(console.error);
-}
-
-export { syncAndCleanTasks };

package/scripts/sync-linear-graphql.js

@@ -1,303 +0,0 @@
-#!/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.STACKMEMORY_LINEAR_API_KEY || process.env.LINEAR_API_KEY) ? 'Yes' : 'No'} (length: ${(process.env.STACKMEMORY_LINEAR_API_KEY || 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.STACKMEMORY_LINEAR_API_KEY || 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.STACKMEMORY_LINEAR_API_KEY || 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();