@stackmemoryai/stackmemory 0.3.17 → 0.3.18

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

@@ -0,0 +1,230 @@
+#!/usr/bin/env node
+
+/**
+ * Analyze remaining tasks after first deletion round
+ */
+
+import 'dotenv/config';
+import fs from 'fs';
+
+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);
+}
+
+async function fetchAllIssues() {
+  const query = `
+    query GetAllIssues($after: String) {
+      issues(first: 100, after: $after, includeArchived: false) {
+        nodes {
+          id
+          identifier
+          title
+          description
+          state {
+            id
+            name
+            type
+          }
+          createdAt
+          updatedAt
+          priority
+          estimate
+          project {
+            id
+            name
+          }
+          team {
+            id
+            key
+            name
+          }
+        }
+        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(`  Fetched ${allIssues.length} issues...`);
+  }
+  
+  return allIssues;
+}
+
+async function analyzeRemainingDuplicates() {
+  try {
+    console.log('🔍 Analyzing remaining tasks for duplicates...\n');
+    console.log('📥 Fetching all tasks from Linear...');
+    
+    const allTasks = await fetchAllIssues();
+    console.log(`📊 Total tasks remaining: ${allTasks.length}\n`);
+    
+    // Group by normalized title to find duplicates
+    const titleGroups = new Map();
+    
+    allTasks.forEach(task => {
+      // Normalize title for comparison
+      const normalizedTitle = task.title
+        .toLowerCase()
+        .replace(/\[.*?\]/g, '') // Remove brackets
+        .replace(/sta-\d+/gi, '') // Remove STA references
+        .replace(/eng-\d+/gi, '') // Remove ENG references
+        .replace(/\s+/g, ' ') // Normalize whitespace
+        .trim();
+      
+      if (!titleGroups.has(normalizedTitle)) {
+        titleGroups.set(normalizedTitle, []);
+      }
+      titleGroups.get(normalizedTitle).push(task);
+    });
+    
+    // Find groups with duplicates
+    const duplicateGroups = Array.from(titleGroups.entries())
+      .filter(([_, tasks]) => tasks.length > 1)
+      .sort((a, b) => b[1].length - a[1].length);
+    
+    console.log('📋 REMAINING DUPLICATES ANALYSIS');
+    console.log('=' .repeat(60));
+    
+    console.log(`\nFound ${duplicateGroups.length} groups of duplicates:\n`);
+    
+    let totalDuplicates = 0;
+    const tasksToDelete = [];
+    
+    duplicateGroups.forEach(([title, tasks]) => {
+      console.log(`\n"${title.substring(0, 60)}..." - ${tasks.length} copies:`);
+      
+      // Sort by status and date to determine which to keep
+      const sorted = tasks.sort((a, b) => {
+        // Keep in-progress tasks
+        if (a.state.type === 'started') return -1;
+        if (b.state.type === 'started') return 1;
+        // Keep newer tasks
+        return new Date(b.updatedAt) - new Date(a.updatedAt);
+      });
+      
+      sorted.forEach((task, index) => {
+        const keep = index === 0 ? '✅ KEEP' : '❌ DELETE';
+        console.log(`  ${keep} ${task.identifier}: ${task.state.name}`);
+        
+        if (index > 0) {
+          tasksToDelete.push(task);
+          totalDuplicates++;
+        }
+      });
+    });
+    
+    // Look for specific patterns that might have been missed
+    console.log('\n\n🔍 CHECKING SPECIFIC PATTERNS:');
+    
+    const patterns = [
+      'Enable TypeScript Strict Mode',
+      'TypeScript Strict Mode',
+      'strict mode',
+      'Enhanced CLI Commands',
+      'CLI Commands',
+      'Performance Optimization',
+      'Error Handling',
+      'Security Audit',
+      'Testing Suite',
+      'Refactor Large Files'
+    ];
+    
+    patterns.forEach(pattern => {
+      const matches = allTasks.filter(task => 
+        task.title.toLowerCase().includes(pattern.toLowerCase())
+      );
+      
+      if (matches.length > 1) {
+        console.log(`\n"${pattern}": ${matches.length} tasks found`);
+        matches.forEach(task => {
+          console.log(`  • ${task.identifier}: ${task.title.substring(0, 60)}...`);
+        });
+      }
+    });
+    
+    console.log('\n\n🎯 DELETION SUMMARY');
+    console.log('=' .repeat(60));
+    console.log(`Current tasks: ${allTasks.length}`);
+    console.log(`Additional duplicates to delete: ${totalDuplicates}`);
+    console.log(`Tasks after cleanup: ${allTasks.length - totalDuplicates}`);
+    
+    // Save deletion list
+    const deleteList = {
+      timestamp: new Date().toISOString(),
+      summary: {
+        currentTotal: allTasks.length,
+        toDelete: totalDuplicates,
+        afterDeletion: allTasks.length - totalDuplicates
+      },
+      duplicateGroups: duplicateGroups.map(([title, tasks]) => ({
+        title,
+        count: tasks.length,
+        tasks: tasks.map(t => ({
+          id: t.id,
+          identifier: t.identifier,
+          title: t.title,
+          state: t.state.name
+        }))
+      })),
+      tasks: tasksToDelete.map(t => ({
+        id: t.id,
+        identifier: t.identifier,
+        title: t.title,
+        state: t.state.name
+      }))
+    };
+    
+    const filename = `remaining-duplicates-${new Date().toISOString().split('T')[0]}.json`;
+    fs.writeFileSync(filename, JSON.stringify(deleteList, null, 2));
+    
+    console.log(`\n💾 Deletion list saved to: ${filename}`);
+    console.log('\nTo delete these remaining duplicates, run:');
+    console.log('  node scripts/delete-remaining-duplicates.js\n');
+    
+    return deleteList;
+    
+  } catch (error) {
+    console.error('❌ Analysis failed:', error.message);
+    process.exit(1);
+  }
+}
+
+// Run if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  analyzeRemainingDuplicates().catch(console.error);
+}
+
+export { analyzeRemainingDuplicates };

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

@@ -0,0 +1,292 @@
+#!/usr/bin/env node
+
+/**
+ * Analyze Linear workspace specifically for STA duplicate tasks
+ */
+
+import 'dotenv/config';
+import { LinearRestClient } from '../dist/integrations/linear/rest-client.js';
+import fs from 'fs';
+
+// 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);
+}
+
+async function analyzeSTADuplicates() {
+  try {
+    console.log('🔍 Analyzing Linear workspace for STA duplicates and unneeded tasks...\n');
+    
+    const client = new LinearRestClient(API_KEY);
+    
+    // Fetch all tasks
+    console.log('📥 Fetching all tasks from Linear...');
+    const allTasks = await client.getAllTasks(true);
+    console.log(`📊 Total tasks in workspace: ${allTasks.length}\n`);
+    
+    // Filter STA tasks
+    const staTasks = allTasks.filter(task => 
+      task.identifier.startsWith('STA-') || 
+      task.title.includes('STA-') ||
+      task.title.includes('[STA-')
+    );
+    
+    console.log(`📌 Found ${staTasks.length} STA-related tasks\n`);
+    
+    // Analyze patterns
+    const staByNumber = new Map(); // STA number -> tasks
+    const completedSTA = [];
+    const canceledSTA = [];
+    const duplicateTitles = new Map();
+    const lowValuePatterns = [];
+    const backlogSTA = [];
+    const todoSTA = [];
+    
+    // Group tasks by patterns
+    staTasks.forEach(task => {
+      const state = task.state.type;
+      const status = task.state.name;
+      
+      // Extract STA number
+      const staMatch = task.identifier.match(/STA-(\d+)/);
+      if (staMatch) {
+        const staNum = parseInt(staMatch[1]);
+        if (!staByNumber.has(staNum)) {
+          staByNumber.set(staNum, []);
+        }
+        staByNumber.get(staNum).push(task);
+      }
+      
+      // Check for completed/canceled
+      if (state === 'completed') {
+        completedSTA.push(task);
+      } else if (state === 'canceled') {
+        canceledSTA.push(task);
+      } else if (state === 'backlog' || status === 'Backlog') {
+        backlogSTA.push(task);
+      } else if (state === 'triage' || status === 'Triage' || status === 'Todo') {
+        todoSTA.push(task);
+      }
+      
+      // Check for low-value patterns
+      if (task.title.includes('Documentation TODO') ||
+          task.title.includes('Meeting') ||
+          task.title.includes('Task Analytics Dashboard') ||
+          task.title.includes('Weekly Sync') ||
+          task.title.includes('Standup') ||
+          task.title.includes('[Duplicate]') ||
+          task.title.includes('Test Task') ||
+          task.description?.includes('auto-generated')) {
+        lowValuePatterns.push(task);
+      }
+      
+      // Find duplicate titles
+      const baseTitle = task.title.replace(/\[.*?\]/g, '').trim().toLowerCase();
+      if (!duplicateTitles.has(baseTitle)) {
+        duplicateTitles.set(baseTitle, []);
+      }
+      duplicateTitles.get(baseTitle).push(task);
+    });
+    
+    // Find true duplicates (same STA number)
+    const duplicateSTANumbers = Array.from(staByNumber.entries())
+      .filter(([_, tasks]) => tasks.length > 1)
+      .sort((a, b) => b[1].length - a[1].length);
+    
+    // Find duplicate titles
+    const trueDuplicateTitles = Array.from(duplicateTitles.entries())
+      .filter(([_, tasks]) => tasks.length > 1)
+      .sort((a, b) => b[1].length - a[1].length);
+    
+    // Generate report
+    console.log('📋 STA DUPLICATE ANALYSIS REPORT');
+    console.log('=' .repeat(60));
+    
+    console.log('\n📊 SUMMARY:');
+    console.log(`Total tasks: ${allTasks.length}`);
+    console.log(`STA tasks: ${staTasks.length}`);
+    console.log(`Completed STA: ${completedSTA.length}`);
+    console.log(`Canceled STA: ${canceledSTA.length}`);
+    console.log(`Backlog STA: ${backlogSTA.length}`);
+    console.log(`Todo/Triage STA: ${todoSTA.length}`);
+    console.log(`Low-value patterns: ${lowValuePatterns.length}`);
+    
+    console.log('\n🔄 DUPLICATE STA NUMBERS:');
+    if (duplicateSTANumbers.length > 0) {
+      console.log(`Found ${duplicateSTANumbers.length} STA numbers with duplicates:\n`);
+      duplicateSTANumbers.slice(0, 10).forEach(([staNum, tasks]) => {
+        console.log(`  STA-${staNum} - ${tasks.length} copies:`);
+        tasks.forEach(task => {
+          console.log(`    • ${task.identifier}: "${task.title.substring(0, 50)}..." (${task.state.name})`);
+        });
+      });
+    } else {
+      console.log('No duplicate STA numbers found');
+    }
+    
+    console.log('\n📝 DUPLICATE TITLES:');
+    if (trueDuplicateTitles.length > 0) {
+      console.log(`Found ${trueDuplicateTitles.length} duplicate title groups:\n`);
+      trueDuplicateTitles.slice(0, 10).forEach(([title, tasks]) => {
+        console.log(`  "${title.substring(0, 50)}..." - ${tasks.length} copies:`);
+        tasks.slice(0, 3).forEach(task => {
+          console.log(`    • ${task.identifier}: ${task.state.name}`);
+        });
+      });
+    }
+    
+    console.log('\n🗑️ LOW-VALUE PATTERNS:');
+    if (lowValuePatterns.length > 0) {
+      console.log(`Found ${lowValuePatterns.length} low-value tasks:\n`);
+      const patterns = {
+        'Documentation TODOs': lowValuePatterns.filter(t => t.title.includes('Documentation TODO')),
+        'Meeting tasks': lowValuePatterns.filter(t => t.title.includes('Meeting')),
+        'Analytics Dashboard': lowValuePatterns.filter(t => t.title.includes('Task Analytics Dashboard')),
+        'Test/Auto-generated': lowValuePatterns.filter(t => t.title.includes('Test Task') || t.description?.includes('auto-generated'))
+      };
+      
+      Object.entries(patterns).forEach(([category, tasks]) => {
+        if (tasks.length > 0) {
+          console.log(`  ${category}: ${tasks.length} tasks`);
+          tasks.slice(0, 3).forEach(task => {
+            console.log(`    • ${task.identifier}: ${task.title.substring(0, 50)}...`);
+          });
+        }
+      });
+    }
+    
+    // Build deletion list
+    const toDelete = [];
+    
+    // Add duplicates (keep the first one of each group)
+    duplicateSTANumbers.forEach(([_, tasks]) => {
+      // Keep the one that's in progress or most recently updated
+      const sorted = tasks.sort((a, b) => {
+        if (a.state.type === 'started') return -1;
+        if (b.state.type === 'started') return 1;
+        return new Date(b.updatedAt) - new Date(a.updatedAt);
+      });
+      toDelete.push(...sorted.slice(1)); // Delete all but the first
+    });
+    
+    // Add completed and canceled
+    toDelete.push(...completedSTA);
+    toDelete.push(...canceledSTA);
+    
+    // Add low-value patterns (but not if they're already in the list)
+    lowValuePatterns.forEach(task => {
+      if (!toDelete.find(t => t.id === task.id)) {
+        toDelete.push(task);
+      }
+    });
+    
+    // Remove duplicates from deletion list
+    const uniqueToDelete = Array.from(new Set(toDelete.map(t => t.id)))
+      .map(id => toDelete.find(t => t.id === id))
+      .sort((a, b) => {
+        const aNum = parseInt(a.identifier.replace('STA-', ''));
+        const bNum = parseInt(b.identifier.replace('STA-', ''));
+        return aNum - bNum;
+      });
+    
+    console.log('\n🎯 DELETION RECOMMENDATIONS');
+    console.log('=' .repeat(60));
+    console.log(`Total STA tasks: ${staTasks.length}`);
+    console.log(`Tasks to delete: ${uniqueToDelete.length}`);
+    console.log(`STA tasks remaining: ${staTasks.length - uniqueToDelete.length}`);
+    console.log(`Total workspace after deletion: ${allTasks.length - uniqueToDelete.length}\n`);
+    
+    // Group deletions by reason
+    const deleteCategories = {
+      'Duplicate STA Numbers': [],
+      'Completed Tasks': [],
+      'Canceled Tasks': [],
+      'Low-Value Patterns': []
+    };
+    
+    uniqueToDelete.forEach(task => {
+      if (completedSTA.find(t => t.id === task.id)) {
+        deleteCategories['Completed Tasks'].push(task.identifier);
+      } else if (canceledSTA.find(t => t.id === task.id)) {
+        deleteCategories['Canceled Tasks'].push(task.identifier);
+      } else if (lowValuePatterns.find(t => t.id === task.id)) {
+        deleteCategories['Low-Value Patterns'].push(task.identifier);
+      } else {
+        deleteCategories['Duplicate STA Numbers'].push(task.identifier);
+      }
+    });
+    
+    console.log('📝 Tasks to delete by category:\n');
+    Object.entries(deleteCategories).forEach(([category, tasks]) => {
+      if (tasks.length > 0) {
+        console.log(`${category} (${tasks.length} tasks):`);
+        const preview = tasks.slice(0, 20).join(', ');
+        console.log(`  ${preview}${tasks.length > 20 ? ` ... and ${tasks.length - 20} more` : ''}\n`);
+      }
+    });
+    
+    // Show what will remain
+    const remaining = staTasks.filter(t => !uniqueToDelete.find(d => d.id === t.id));
+    const inProgress = remaining.filter(t => t.state.type === 'started');
+    const todo = remaining.filter(t => t.state.type === 'unstarted' && t.state.name !== 'Backlog');
+    
+    console.log('✅ WHAT WILL REMAIN:');
+    console.log(`${remaining.length} STA tasks total:`);
+    console.log(`  • In Progress: ${inProgress.length} tasks`);
+    console.log(`  • Todo/Ready: ${todo.length} tasks`);
+    console.log(`  • Backlog: ${remaining.filter(t => t.state.name === 'Backlog').length} tasks\n`);
+    
+    // Save deletion list to file
+    const deleteList = {
+      timestamp: new Date().toISOString(),
+      summary: {
+        totalWorkspace: allTasks.length,
+        totalSTA: staTasks.length,
+        toDelete: uniqueToDelete.length,
+        remainingSTA: staTasks.length - uniqueToDelete.length,
+        remainingTotal: allTasks.length - uniqueToDelete.length
+      },
+      categories: deleteCategories,
+      tasks: uniqueToDelete.map(t => ({
+        id: t.id,
+        identifier: t.identifier,
+        title: t.title,
+        state: t.state.name,
+        reason: completedSTA.find(c => c.id === t.id) ? 'completed' :
+                canceledSTA.find(c => c.id === t.id) ? 'canceled' :
+                lowValuePatterns.find(l => l.id === t.id) ? 'low-value' : 'duplicate'
+      }))
+    };
+    
+    const filename = `sta-deletion-list-${new Date().toISOString().split('T')[0]}.json`;
+    fs.writeFileSync(filename, JSON.stringify(deleteList, null, 2));
+    console.log(`💾 Deletion list saved to: ${filename}\n`);
+    
+    console.log('🎯 NEXT STEPS:');
+    console.log('1. Review the deletion list above');
+    console.log('2. Run the delete script to remove these tasks');
+    console.log(`3. This will free up ${uniqueToDelete.length} tasks worth of capacity\n`);
+    
+    console.log('To delete these tasks, run:');
+    console.log('  node scripts/delete-sta-tasks.js\n');
+    
+    return deleteList;
+    
+  } catch (error) {
+    console.error('❌ Analysis failed:', error.message);
+    if (error.message.includes('401')) {
+      console.error('\n⚠️  Authentication failed. Check your LINEAR_API_KEY');
+    }
+    process.exit(1);
+  }
+}
+
+// Run if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  analyzeSTADuplicates().catch(console.error);
+}
+
+export { analyzeSTADuplicates };