@stackmemoryai/stackmemory 0.3.17 → 0.3.18

package/scripts/archive/delete-linear-duplicates.js

@@ -0,0 +1,182 @@
+#!/usr/bin/env node
+
+/**
+ * Delete duplicate Linear issues identified by clean-linear-backlog.js
+ * This script will delete issues from Linear using their IDs
+ */
+
+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'),
+  override: true
+});
+
+async function mutateLinear(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 deleteLinearDuplicates() {
+  const apiKey = process.env.LINEAR_API_KEY;
+  
+  if (!apiKey) {
+    console.error('❌ LINEAR_API_KEY not found in environment');
+    process.exit(1);
+  }
+
+  // Load the deletion list
+  const deletionFile = path.join(__dirname, '..', 'linear-cleanup-2026-01-07.json');
+  
+  if (!fs.existsSync(deletionFile)) {
+    console.error('❌ Deletion list not found. Run clean-linear-backlog.js first');
+    process.exit(1);
+  }
+
+  const deletionList = JSON.parse(fs.readFileSync(deletionFile, 'utf8'));
+  
+  console.log(`🗑️  Found ${deletionList.length} issues to delete\n`);
+
+  // Group by reason
+  const byReason = {
+    duplicate: deletionList.filter(i => i.reason === 'duplicate'),
+    test: deletionList.filter(i => i.reason === 'test'),
+    cancelled: deletionList.filter(i => i.reason === 'cancelled')
+  };
+
+  console.log('📊 Breakdown:');
+  console.log(`  Duplicates: ${byReason.duplicate.length}`);
+  console.log(`  Test tasks: ${byReason.test.length}`);
+  console.log(`  Cancelled: ${byReason.cancelled.length}`);
+
+  // Ask for confirmation
+  console.log('\n⚠️  WARNING: This will permanently delete these issues from Linear!');
+  console.log('Press Ctrl+C to cancel, or wait 5 seconds to continue...\n');
+  
+  await new Promise(resolve => setTimeout(resolve, 5000));
+
+  console.log('🚀 Starting deletion process...\n');
+
+  let deleted = 0;
+  let failed = 0;
+  const errors = [];
+
+  // Process in batches to avoid rate limiting
+  const batchSize = 10;
+  for (let i = 0; i < deletionList.length; i += batchSize) {
+    const batch = deletionList.slice(i, i + batchSize);
+    
+    console.log(`📦 Processing batch ${Math.floor(i/batchSize) + 1}/${Math.ceil(deletionList.length/batchSize)}...`);
+    
+    for (const issue of batch) {
+      try {
+        // Archive instead of delete (safer)
+        const result = await mutateLinear(`
+          mutation ArchiveIssue($id: String!) {
+            issueArchive(id: $id) {
+              success
+              issue {
+                id
+                identifier
+                title
+              }
+            }
+          }
+        `, { id: issue.id });
+
+        if (result.issueArchive.success) {
+          deleted++;
+          process.stdout.write('✓');
+        } else {
+          failed++;
+          errors.push({ issue: issue.identifier, error: 'Archive failed' });
+          process.stdout.write('✗');
+        }
+      } catch (error) {
+        failed++;
+        errors.push({ issue: issue.identifier, error: error.message });
+        process.stdout.write('✗');
+      }
+    }
+    
+    console.log(''); // New line after batch
+    
+    // Rate limiting - wait between batches
+    if (i + batchSize < deletionList.length) {
+      await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+  }
+
+  // Summary
+  console.log('\n📊 Final Results:');
+  console.log(`  ✅ Successfully archived: ${deleted}`);
+  console.log(`  ❌ Failed: ${failed}`);
+
+  if (errors.length > 0) {
+    console.log('\n❌ Errors:');
+    for (const error of errors.slice(0, 10)) {
+      console.log(`  - ${error.issue}: ${error.error}`);
+    }
+    if (errors.length > 10) {
+      console.log(`  ... and ${errors.length - 10} more errors`);
+    }
+
+    // Save error log
+    const errorFile = `linear-deletion-errors-${new Date().toISOString().split('T')[0]}.json`;
+    fs.writeFileSync(
+      path.join(__dirname, '..', errorFile),
+      JSON.stringify(errors, null, 2)
+    );
+    console.log(`\n💾 Error log saved to: ${errorFile}`);
+  }
+
+  console.log('\n✅ Cleanup complete!');
+  console.log('💡 Tip: Run sync-linear-graphql.js to update local tasks');
+}
+
+// Add dry run option
+const isDryRun = process.argv.includes('--dry-run');
+
+if (isDryRun) {
+  console.log('🔍 DRY RUN MODE - No changes will be made\n');
+  
+  const deletionFile = path.join(__dirname, '..', 'linear-cleanup-2026-01-07.json');
+  const deletionList = JSON.parse(fs.readFileSync(deletionFile, 'utf8'));
+  
+  console.log('Would delete:');
+  const byTitle = {};
+  for (const issue of deletionList) {
+    const title = issue.title.substring(0, 50);
+    if (!byTitle[title]) {
+      byTitle[title] = 0;
+    }
+    byTitle[title]++;
+  }
+  
+  const sorted = Object.entries(byTitle).sort((a, b) => b[1] - a[1]);
+  for (const [title, count] of sorted.slice(0, 15)) {
+    console.log(`  ${count}x ${title}...`);
+  }
+  
+  process.exit(0);
+}
+
+deleteLinearDuplicates();

package/scripts/archive/delete-remaining-duplicates.js

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+
+/**
+ * Delete remaining duplicate tasks
+ */
+
+import 'dotenv/config';
+import fs from 'fs';
+import readline from 'readline';
+
+const API_KEY = process.env.LINEAR_OAUTH_TOKEN || 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);
+}
+
+const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+
+async function deleteRemainingDuplicates() {
+  try {
+    // Load deletion list
+    const deleteFile = `remaining-duplicates-${new Date().toISOString().split('T')[0]}.json`;
+    if (!fs.existsSync(deleteFile)) {
+      console.error(`❌ Deletion list not found: ${deleteFile}`);
+      console.log('Run analyze-remaining-duplicates.js first.');
+      process.exit(1);
+    }
+    
+    const deleteList = JSON.parse(fs.readFileSync(deleteFile, 'utf8'));
+    
+    console.log('📋 REMAINING DUPLICATES DELETION');
+    console.log('=' .repeat(60));
+    console.log(`\n  Current tasks: ${deleteList.summary.currentTotal}`);
+    console.log(`  Tasks to delete: ${deleteList.summary.toDelete}`);
+    console.log(`  After deletion: ${deleteList.summary.afterDeletion}\n`);
+    
+    // Show what will be deleted
+    console.log('📝 Tasks to be deleted:');
+    deleteList.tasks.forEach(task => {
+      console.log(`  • ${task.identifier}: ${task.title.substring(0, 60)}...`);
+    });
+    
+    // Confirmation
+    console.log(`\n⚠️  This will permanently delete ${deleteList.summary.toDelete} duplicate tasks.`);
+    console.log('Type "DELETE" to confirm, or press Ctrl+C to cancel:\n');
+    
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    
+    const confirmation = await new Promise(resolve => {
+      rl.question('Confirmation: ', resolve);
+    });
+    rl.close();
+    
+    if (confirmation !== 'DELETE') {
+      console.log('❌ Deletion cancelled');
+      process.exit(0);
+    }
+    
+    console.log('\n🗑️  Deleting remaining duplicates...\n');
+    
+    let deleted = 0;
+    let failed = 0;
+    const results = [];
+    
+    for (const task of deleteList.tasks) {
+      try {
+        process.stdout.write(`Deleting ${task.identifier}: ${task.title.substring(0, 40)}... `);
+        
+        const deleteQuery = `
+          mutation DeleteIssue($id: String!) {
+            issueDelete(id: $id) {
+              success
+            }
+          }
+        `;
+        
+        const response = await fetch('https://api.linear.app/graphql', {
+          method: 'POST',
+          headers: {
+            'Authorization': `Bearer ${API_KEY}`,
+            'Content-Type': 'application/json'
+          },
+          body: JSON.stringify({
+            query: deleteQuery,
+            variables: { id: task.id }
+          })
+        });
+        
+        const result = await response.json();
+        
+        if (result.data?.issueDelete?.success) {
+          console.log('✅');
+          deleted++;
+          results.push({ ...task, status: 'deleted' });
+        } else if (result.errors?.[0]?.message?.includes('not found')) {
+          console.log('⚠️  (already gone)');
+          deleted++;
+          results.push({ ...task, status: 'already_deleted' });
+        } else {
+          const error = result.errors?.[0]?.message || 'Unknown error';
+          console.log(`❌ (${error})`);
+          failed++;
+          results.push({ ...task, status: 'failed', error });
+        }
+        
+        // Small delay between deletions
+        await delay(500);
+        
+      } catch (error) {
+        console.log(`❌ (${error.message})`);
+        failed++;
+        results.push({ ...task, status: 'error', error: error.message });
+      }
+    }
+    
+    // Save results
+    const resultsFile = `remaining-deletion-results-${new Date().toISOString().split('T')[0]}.json`;
+    fs.writeFileSync(resultsFile, JSON.stringify({
+      summary: { 
+        attempted: deleteList.tasks.length,
+        deleted, 
+        failed,
+        success_rate: Math.round((deleted / deleteList.tasks.length) * 100) 
+      },
+      results,
+      timestamp: new Date().toISOString()
+    }, null, 2));
+    
+    // Final report
+    console.log('\n' + '='.repeat(60));
+    console.log('📊 DELETION COMPLETE');
+    console.log('='.repeat(60));
+    console.log(`\n✅ Successfully deleted: ${deleted} tasks`);
+    console.log(`❌ Failed: ${failed} tasks`);
+    console.log(`📈 Success rate: ${Math.round((deleted / deleteList.tasks.length) * 100)}%`);
+    console.log(`\n💾 Results saved to: ${resultsFile}`);
+    
+    if (deleted > 0) {
+      console.log(`\n🎉 Workspace cleaned! Now at ${deleteList.summary.afterDeletion} tasks.`);
+      console.log('All TypeScript Strict Mode duplicates have been removed.');
+    }
+    
+  } catch (error) {
+    console.error('\n💥 Script failed:', error.message);
+    process.exit(1);
+  }
+}
+
+// Run if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  deleteRemainingDuplicates().catch(console.error);
+}
+
+export { deleteRemainingDuplicates };

package/scripts/archive/delete-sta-duplicates.js

@@ -0,0 +1,201 @@
+#!/usr/bin/env node
+
+/**
+ * Delete duplicate STA tasks from Linear to free up capacity
+ */
+
+import 'dotenv/config';
+import fs from 'fs';
+import readline from 'readline';
+
+// Load API key from environment
+const API_KEY = process.env.LINEAR_API_KEY;
+if (!API_KEY) {
+  console.error('❌ LINEAR_API_KEY environment variable not set');
+  console.log('Please set LINEAR_API_KEY in your .env file or export it in your shell');
+  process.exit(1);
+}
+const BATCH_SIZE = 10; // Delete in batches to avoid rate limits
+const DELAY_BETWEEN_BATCHES = 3000; // 3 seconds between batches
+
+const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+
+async function deleteSTATasks() {
+  try {
+    // Load deletion list
+    const deleteFile = `sta-deletion-list-${new Date().toISOString().split('T')[0]}.json`;
+    if (!fs.existsSync(deleteFile)) {
+      console.error(`❌ Deletion list not found: ${deleteFile}`);
+      console.log('Run analyze-sta-graphql.js first to generate the list.');
+      process.exit(1);
+    }
+    
+    const deleteList = JSON.parse(fs.readFileSync(deleteFile, 'utf8'));
+    
+    console.log('📋 STA TASK DELETION SUMMARY');
+    console.log('=' .repeat(60));
+    console.log(`\n  Total workspace tasks: ${deleteList.summary.totalWorkspace}`);
+    console.log(`  Current STA tasks: ${deleteList.summary.totalSTA}`);
+    console.log(`  Tasks to delete: ${deleteList.summary.toDelete}`);
+    console.log(`  Workspace after deletion: ${deleteList.summary.remainingTotal}`);
+    console.log(`\n  🎯 Capacity to be freed: ${deleteList.summary.capacityFreed} task slots\n`);
+    
+    // Show breakdown
+    console.log('📝 Tasks to delete by category:');
+    Object.entries(deleteList.categories).forEach(([category, tasks]) => {
+      if (tasks.length > 0) {
+        console.log(`  • ${category}: ${tasks.length} tasks`);
+      }
+    });
+    
+    // Safety confirmation
+    console.log('\n⚠️  WARNING: This will permanently delete ${deleteList.summary.toDelete} tasks from Linear!');
+    console.log('This action cannot be undone. Make sure you have reviewed the list.\n');
+    console.log('Type "DELETE STA TASKS" to confirm, or press Ctrl+C to cancel:\n');
+    
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    
+    const confirmation = await new Promise(resolve => {
+      rl.question('Confirmation: ', resolve);
+    });
+    rl.close();
+    
+    if (confirmation !== 'DELETE STA TASKS') {
+      console.log('❌ Deletion cancelled');
+      process.exit(0);
+    }
+    
+    console.log('\n🗑️  Starting deletion process...');
+    console.log(`Will delete in batches of ${BATCH_SIZE} with ${DELAY_BETWEEN_BATCHES/1000}s delay\n`);
+    
+    let deleted = 0;
+    let failed = 0;
+    let alreadyDeleted = 0;
+    const results = [];
+    const errors = [];
+    
+    // Process in batches
+    for (let i = 0; i < deleteList.tasks.length; i += BATCH_SIZE) {
+      const batch = deleteList.tasks.slice(i, i + BATCH_SIZE);
+      console.log(`\n📦 Batch ${Math.floor(i/BATCH_SIZE) + 1}/${Math.ceil(deleteList.tasks.length/BATCH_SIZE)}`);
+      
+      for (const task of batch) {
+        try {
+          process.stdout.write(`  Deleting ${task.identifier}: ${task.title.substring(0, 40)}... `);
+          
+          const deleteQuery = `
+            mutation DeleteIssue($id: String!) {
+              issueDelete(id: $id) {
+                success
+              }
+            }
+          `;
+          
+          const response = await fetch('https://api.linear.app/graphql', {
+            method: 'POST',
+            headers: {
+              'Authorization': API_KEY,
+              'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+              query: deleteQuery,
+              variables: { id: task.id }
+            })
+          });
+          
+          const result = await response.json();
+          
+          if (result.data?.issueDelete?.success) {
+            console.log('✅');
+            deleted++;
+            results.push({ ...task, status: 'deleted' });
+          } else if (result.errors?.[0]?.message?.includes('not found')) {
+            console.log('⚠️  (already gone)');
+            alreadyDeleted++;
+            results.push({ ...task, status: 'already_deleted' });
+          } else {
+            const error = result.errors?.[0]?.message || 'Unknown error';
+            console.log(`❌ (${error})`);
+            failed++;
+            errors.push({ ...task, error });
+            results.push({ ...task, status: 'failed', error });
+          }
+          
+        } catch (error) {
+          console.log(`❌ (${error.message})`);
+          failed++;
+          errors.push({ ...task, error: error.message });
+          results.push({ ...task, status: 'error', error: error.message });
+          
+          // If rate limited, wait longer
+          if (error.message?.includes('rate') || error.message?.includes('429')) {
+            console.log('⏳ Rate limited. Waiting 30 seconds...');
+            await delay(30000);
+          }
+        }
+      }
+      
+      // Progress update
+      const total = deleted + alreadyDeleted + failed;
+      const percent = Math.round((total / deleteList.tasks.length) * 100);
+      console.log(`\n📊 Progress: ${total}/${deleteList.tasks.length} (${percent}%)`);
+      console.log(`   ✅ Deleted: ${deleted} | ⚠️  Already gone: ${alreadyDeleted} | ❌ Failed: ${failed}`);
+      
+      // Delay before next batch
+      if (i + BATCH_SIZE < deleteList.tasks.length) {
+        console.log(`⏳ Waiting ${DELAY_BETWEEN_BATCHES/1000}s before next batch...`);
+        await delay(DELAY_BETWEEN_BATCHES);
+      }
+    }
+    
+    // Save results
+    const resultsFile = `sta-deletion-results-${new Date().toISOString().split('T')[0]}.json`;
+    fs.writeFileSync(resultsFile, JSON.stringify({
+      summary: { 
+        attempted: deleteList.tasks.length,
+        deleted, 
+        alreadyDeleted,
+        failed, 
+        success_rate: Math.round(((deleted + alreadyDeleted) / deleteList.tasks.length) * 100) 
+      },
+      results,
+      errors: errors.length > 0 ? errors : undefined,
+      timestamp: new Date().toISOString()
+    }, null, 2));
+    
+    // Final report
+    console.log('\n' + '='.repeat(60));
+    console.log('📊 DELETION COMPLETE');
+    console.log('='.repeat(60));
+    console.log(`\n✅ Successfully deleted: ${deleted} tasks`);
+    console.log(`⚠️  Already deleted: ${alreadyDeleted} tasks`);
+    console.log(`❌ Failed: ${failed} tasks`);
+    console.log(`📈 Success rate: ${Math.round(((deleted + alreadyDeleted) / deleteList.tasks.length) * 100)}%`);
+    console.log(`\n💾 Results saved to: ${resultsFile}`);
+    
+    const totalFreed = deleted + alreadyDeleted;
+    if (totalFreed > 0) {
+      console.log(`\n🎉 Freed up ${totalFreed} task slots in your Linear workspace!`);
+      console.log('\nYour workspace now has capacity for new tasks.');
+      console.log('The backlog has been cleaned of duplicates and similar tasks.');
+    }
+    
+    if (failed > 0) {
+      console.log(`\n⚠️  ${failed} tasks could not be deleted. Check ${resultsFile} for details.`);
+    }
+    
+  } catch (error) {
+    console.error('\n💥 Script failed:', error.message);
+    process.exit(1);
+  }
+}
+
+// Run if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  deleteSTATasks().catch(console.error);
+}
+
+export { deleteSTATasks };