@stackmemoryai/stackmemory 0.3.16 → 0.3.18

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

@@ -0,0 +1,399 @@
+#!/usr/bin/env node
+
+/**
+ * Analyze Linear workspace for STA duplicates using GraphQL API directly
+ */
+
+import 'dotenv/config';
+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 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': 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 analyzeSTADuplicates() {
+  try {
+    console.log('🔍 Analyzing Linear workspace for STA duplicates and unneeded tasks...\n');
+    console.log('📥 Fetching all tasks from Linear (using GraphQL)...');
+    
+    const allTasks = await fetchAllIssues();
+    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();
+    const completedSTA = [];
+    const canceledSTA = [];
+    const duplicateTitles = new Map();
+    const lowValuePatterns = [];
+    const backlogSTA = [];
+    const todoSTA = [];
+    const inProgressSTA = [];
+    
+    // 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 state
+      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 === 'started' || status === 'In Progress') {
+        inProgressSTA.push(task);
+      } else if (state === 'unstarted' || state === 'triage' || status === 'Todo') {
+        todoSTA.push(task);
+      }
+      
+      // Check for low-value patterns
+      const lowValueKeywords = [
+        'Documentation TODO',
+        'Meeting',
+        'Task Analytics Dashboard',
+        'Weekly Sync',
+        'Standup',
+        '[Duplicate]',
+        'Test Task',
+        'Demo Task',
+        'Example Task'
+      ];
+      
+      if (lowValueKeywords.some(keyword => task.title.includes(keyword)) ||
+          task.description?.includes('auto-generated') ||
+          task.description?.includes('automatically created')) {
+        lowValuePatterns.push(task);
+      }
+      
+      // Find duplicate titles
+      const baseTitle = task.title
+        .replace(/\[.*?\]/g, '')
+        .replace(/STA-\d+/g, '')
+        .trim()
+        .toLowerCase();
+      
+      if (baseTitle.length > 10) { // Only consider meaningful titles
+        if (!duplicateTitles.has(baseTitle)) {
+          duplicateTitles.set(baseTitle, []);
+        }
+        duplicateTitles.get(baseTitle).push(task);
+      }
+    });
+    
+    // Find true duplicates
+    const duplicateSTANumbers = Array.from(staByNumber.entries())
+      .filter(([_, tasks]) => tasks.length > 1)
+      .sort((a, b) => b[1].length - a[1].length);
+    
+    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 TASK ANALYSIS REPORT');
+    console.log('=' .repeat(60));
+    
+    console.log('\n📊 OVERVIEW:');
+    console.log(`Total workspace tasks: ${allTasks.length}`);
+    console.log(`STA-prefixed tasks: ${staTasks.length} (${Math.round(staTasks.length / allTasks.length * 100)}% of workspace)`);
+    console.log(`\nStatus breakdown:`);
+    console.log(`  • In Progress: ${inProgressSTA.length}`);
+    console.log(`  • Todo/Ready: ${todoSTA.length}`);
+    console.log(`  • Backlog: ${backlogSTA.length}`);
+    console.log(`  • Completed: ${completedSTA.length}`);
+    console.log(`  • Canceled: ${canceledSTA.length}`);
+    
+    if (duplicateSTANumbers.length > 0) {
+      console.log('\n🔄 DUPLICATE STA NUMBERS:');
+      console.log(`Found ${duplicateSTANumbers.length} STA numbers with multiple tasks:\n`);
+      duplicateSTANumbers.forEach(([staNum, tasks]) => {
+        console.log(`  STA-${staNum} has ${tasks.length} instances:`);
+        tasks.forEach(task => {
+          console.log(`    • ${task.identifier}: "${task.title.substring(0, 60)}..." (${task.state.name})`);
+        });
+      });
+    }
+    
+    if (trueDuplicateTitles.length > 0) {
+      console.log('\n📝 SIMILAR TITLES (potential duplicates):');
+      console.log(`Found ${trueDuplicateTitles.length} groups of similar titles:\n`);
+      trueDuplicateTitles.slice(0, 15).forEach(([title, tasks]) => {
+        console.log(`  "${title.substring(0, 50)}..." appears ${tasks.length} times:`);
+        tasks.slice(0, 5).forEach(task => {
+          console.log(`    • ${task.identifier}: ${task.state.name}`);
+        });
+      });
+    }
+    
+    if (lowValuePatterns.length > 0) {
+      console.log('\n🗑️ LOW-VALUE/AUTO-GENERATED TASKS:');
+      console.log(`Found ${lowValuePatterns.length} potentially low-value tasks:\n`);
+      const categories = {
+        'Meeting/Sync tasks': lowValuePatterns.filter(t => 
+          t.title.includes('Meeting') || t.title.includes('Sync') || t.title.includes('Standup')),
+        'Documentation TODOs': lowValuePatterns.filter(t => 
+          t.title.includes('Documentation TODO')),
+        'Test/Demo tasks': lowValuePatterns.filter(t => 
+          t.title.includes('Test Task') || t.title.includes('Demo') || t.title.includes('Example')),
+        'Auto-generated': lowValuePatterns.filter(t => 
+          t.description?.includes('auto-generated') || t.description?.includes('automatically'))
+      };
+      
+      Object.entries(categories).forEach(([category, tasks]) => {
+        if (tasks.length > 0) {
+          console.log(`  ${category}: ${tasks.length} tasks`);
+          tasks.slice(0, 5).forEach(task => {
+            console.log(`    • ${task.identifier}: ${task.title.substring(0, 50)}...`);
+          });
+        }
+      });
+    }
+    
+    // Build deletion recommendations
+    const toDelete = new Set();
+    
+    // Add duplicates (keep most recent or in-progress)
+    duplicateSTANumbers.forEach(([_, tasks]) => {
+      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);
+      });
+      sorted.slice(1).forEach(t => toDelete.add(t));
+    });
+    
+    // Add similar titles (be more conservative)
+    trueDuplicateTitles.forEach(([_, tasks]) => {
+      if (tasks.every(t => t.state.type !== 'started')) {
+        // If none are in progress, keep newest
+        const sorted = tasks.sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt));
+        sorted.slice(1).forEach(t => toDelete.add(t));
+      }
+    });
+    
+    // Add completed and canceled
+    completedSTA.forEach(t => toDelete.add(t));
+    canceledSTA.forEach(t => toDelete.add(t));
+    
+    // Add clear low-value patterns
+    lowValuePatterns.forEach(task => {
+      if (task.state.type !== 'started' && 
+          (task.title.includes('[Duplicate]') || 
+           task.title.includes('Test Task') ||
+           task.description?.includes('auto-generated'))) {
+        toDelete.add(task);
+      }
+    });
+    
+    const uniqueToDelete = Array.from(toDelete)
+      .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(`\nCapacity Analysis:`);
+    console.log(`  Current workspace total: ${allTasks.length} tasks`);
+    console.log(`  Current STA tasks: ${staTasks.length}`);
+    console.log(`  Recommended to delete: ${uniqueToDelete.length} tasks`);
+    console.log(`  Workspace after deletion: ${allTasks.length - uniqueToDelete.length} tasks`);
+    console.log(`  STA tasks after deletion: ${staTasks.length - uniqueToDelete.length}`);
+    console.log(`  **Capacity freed: ${uniqueToDelete.length} task slots**`);
+    
+    // Categorize deletions
+    const deleteReasons = {
+      'Duplicate STA numbers': [],
+      'Similar/duplicate titles': [],
+      'Completed tasks': [],
+      'Canceled tasks': [],
+      'Low-value/auto-generated': []
+    };
+    
+    uniqueToDelete.forEach(task => {
+      let categorized = false;
+      
+      // Check if it's a duplicate STA number
+      const staMatch = task.identifier.match(/STA-(\d+)/);
+      if (staMatch) {
+        const staNum = parseInt(staMatch[1]);
+        const dupes = staByNumber.get(staNum);
+        if (dupes && dupes.length > 1 && dupes[0].id !== task.id) {
+          deleteReasons['Duplicate STA numbers'].push(task);
+          categorized = true;
+        }
+      }
+      
+      if (!categorized && completedSTA.find(t => t.id === task.id)) {
+        deleteReasons['Completed tasks'].push(task);
+        categorized = true;
+      }
+      
+      if (!categorized && canceledSTA.find(t => t.id === task.id)) {
+        deleteReasons['Canceled tasks'].push(task);
+        categorized = true;
+      }
+      
+      if (!categorized && lowValuePatterns.find(t => t.id === task.id)) {
+        deleteReasons['Low-value/auto-generated'].push(task);
+        categorized = true;
+      }
+      
+      if (!categorized) {
+        deleteReasons['Similar/duplicate titles'].push(task);
+      }
+    });
+    
+    console.log('\n📝 Deletion breakdown by reason:');
+    Object.entries(deleteReasons).forEach(([reason, tasks]) => {
+      if (tasks.length > 0) {
+        console.log(`\n${reason}: ${tasks.length} tasks`);
+        const preview = tasks.slice(0, 10)
+          .map(t => `${t.identifier}`)
+          .join(', ');
+        console.log(`  ${preview}${tasks.length > 10 ? ` ... +${tasks.length - 10} more` : ''}`);
+      }
+    });
+    
+    // Save deletion list
+    const deleteList = {
+      timestamp: new Date().toISOString(),
+      summary: {
+        totalWorkspace: allTasks.length,
+        totalSTA: staTasks.length,
+        toDelete: uniqueToDelete.length,
+        capacityFreed: uniqueToDelete.length,
+        remainingSTA: staTasks.length - uniqueToDelete.length,
+        remainingTotal: allTasks.length - uniqueToDelete.length
+      },
+      categories: Object.entries(deleteReasons).reduce((acc, [reason, tasks]) => {
+        acc[reason] = tasks.map(t => t.identifier);
+        return acc;
+      }, {}),
+      tasks: uniqueToDelete.map(t => ({
+        id: t.id,
+        identifier: t.identifier,
+        title: t.title,
+        state: t.state.name,
+        team: t.team?.name || 'No team'
+      }))
+    };
+    
+    const filename = `sta-deletion-list-${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('\n✅ Ready to free up capacity!');
+    console.log('\nNext: Create a deletion script or manually review the JSON file');
+    
+    return deleteList;
+    
+  } catch (error) {
+    console.error('❌ Analysis failed:', error.message);
+    if (error.message.includes('401') || error.message.includes('Unauthorized')) {
+      console.error('\n⚠️  Authentication failed. Please 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 };

package/scripts/archive/cancel-duplicate-tasks.ts

@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+
+/**
+ * Script to cancel duplicate Linear tasks
+ * Uses the actual Linear API to find and cancel duplicates
+ */
+
+import { readFileSync } from 'fs';
+import { join } from 'path';
+
+interface TaskGroup {
+  pattern: string;
+  keepFirst: boolean;
+}
+
+interface LinearIssue {
+  id: string;
+  identifier: string;
+  title: string;
+  createdAt: string;
+  team?: {
+    states?: {
+      nodes?: Array<{ id: string; type: string }>;
+    };
+  };
+}
+
+interface WorkflowState {
+  id: string;
+  type: string;
+}
+
+// Define patterns to identify duplicate tasks
+const duplicatePatterns: TaskGroup[] = [
+  { pattern: 'Linear API Integration', keepFirst: true },
+  { pattern: 'Performance Optimization', keepFirst: true },
+  { pattern: 'Security Audit', keepFirst: true },
+  { pattern: '[HIGH] Implement Proper Error Handling', keepFirst: true },
+  { pattern: '[HIGH] Implement Comprehensive Testing Suite', keepFirst: true },
+];
+
+async function cancelDuplicateTasks(dryRun = true) {
+  const mode = dryRun ? '🔍 DRY RUN MODE' : '⚡ LIVE MODE';
+  console.log(`\n${mode} - Cancel duplicate Linear tasks\n`);
+  console.log('='.repeat(60));
+
+  // Load Linear tokens
+  const tokensPath = join(process.cwd(), '.stackmemory', 'linear-tokens.json');
+  let accessToken: string;
+
+  try {
+    const tokensData = readFileSync(tokensPath, 'utf8');
+    const tokens = JSON.parse(tokensData);
+    accessToken = tokens.accessToken;
+    console.log('✅ Loaded Linear authentication tokens\n');
+  } catch {
+    console.error(
+      '❌ Failed to load Linear tokens. Please run: stackmemory linear setup'
+    );
+    process.exit(1);
+  }
+
+  // GraphQL helper
+  const linearApiUrl = 'https://api.linear.app/graphql';
+
+  async function graphqlRequest(
+    query: string,
+    variables: Record<string, unknown> = {}
+  ) {
+    const response = await fetch(linearApiUrl, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ query, variables }),
+    });
+
+    if (!response.ok) {
+      throw new Error(
+        `Linear API error: ${response.status} ${response.statusText}`
+      );
+    }
+
+    const result = (await response.json()) as {
+      errors?: unknown[];
+      data: unknown;
+    };
+    if (result.errors) {
+      throw new Error(`GraphQL errors: ${JSON.stringify(result.errors)}`);
+    }
+
+    return result.data;
+  }
+
+  // First, get all issues
+  console.log('Fetching all issues...\n');
+  const issuesQuery = `
+    query {
+      issues(first: 250, filter: { state: { type: { nin: ["completed", "canceled"] } } }) {
+        nodes {
+          id
+          identifier
+          title
+          description
+          createdAt
+          state {
+            id
+            name
+            type
+          }
+          team {
+            id
+            key
+            states {
+              nodes {
+                id
+                name
+                type
+              }
+            }
+          }
+        }
+      }
+    }
+  `;
+
+  const issuesData = (await graphqlRequest(issuesQuery)) as {
+    issues: { nodes: LinearIssue[] };
+  };
+  const allIssues = issuesData.issues.nodes;
+
+  console.log(`Found ${allIssues.length} active issues\n`);
+
+  // Get canceled state from the first issue's team
+  const canceledState = allIssues[0]?.team?.states?.nodes?.find(
+    (s: WorkflowState) => s.type === 'canceled'
+  );
+  if (!canceledState) {
+    console.error('❌ No canceled state found in workflow');
+    process.exit(1);
+  }
+
+  // Group issues by pattern
+  const groupedIssues = new Map<string, LinearIssue[]>();
+
+  for (const pattern of duplicatePatterns) {
+    const matches = allIssues.filter((issue: LinearIssue) =>
+      issue.title.includes(pattern.pattern)
+    );
+
+    if (matches.length > 1) {
+      // Sort by creation date to keep the oldest
+      matches.sort(
+        (a: LinearIssue, b: LinearIssue) =>
+          new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime()
+      );
+      groupedIssues.set(pattern.pattern, matches);
+    }
+  }
+
+  // Process each group
+  let totalCanceled = 0;
+  let totalKept = 0;
+
+  for (const [pattern, issues] of groupedIssues.entries()) {
+    console.log(`\n📋 Pattern: "${pattern}"`);
+    console.log(`   Found ${issues.length} matching issues:`);
+
+    const [primary, ...duplicates] = issues;
+
+    console.log(`   ✅ Keep: ${primary.identifier} - ${primary.title}`);
+    totalKept++;
+
+    for (const duplicate of duplicates) {
+      console.log(
+        `   ${dryRun ? '🔍' : '❌'} Cancel: ${duplicate.identifier} - ${duplicate.title}`
+      );
+
+      if (!dryRun) {
+        try {
+          const cancelMutation = `
+            mutation CancelIssue($id: String!, $stateId: String!) {
+              issueUpdate(
+                id: $id,
+                input: {
+                  stateId: $stateId,
+                  description: "Duplicate task - kept ${primary.identifier}"
+                }
+              ) {
+                success
+                issue {
+                  identifier
+                  state {
+                    name
+                  }
+                }
+              }
+            }
+          `;
+
+          await graphqlRequest(cancelMutation, {
+            id: duplicate.id,
+            stateId: canceledState.id,
+          });
+
+          console.log(`      ✅ Successfully canceled ${duplicate.identifier}`);
+          totalCanceled++;
+        } catch (error: unknown) {
+          const errorMessage =
+            error instanceof Error ? error.message : String(error);
+          console.log(
+            `      ❌ Failed to cancel ${duplicate.identifier}: ${errorMessage}`
+          );
+        }
+      } else {
+        totalCanceled++;
+      }
+    }
+  }
+
+  // Summary
+  console.log('\n' + '='.repeat(60));
+  console.log(`\n✨ ${dryRun ? 'DRY RUN' : 'CLEANUP'} COMPLETE!\n`);
+  console.log('📊 Summary:');
+  console.log(`   Duplicate groups found: ${groupedIssues.size}`);
+  console.log(`   Tasks to keep: ${totalKept}`);
+  console.log(
+    `   Tasks ${dryRun ? 'to cancel' : 'canceled'}: ${totalCanceled}`
+  );
+  console.log(`   Total active tasks: ${allIssues.length}`);
+  console.log(`   Tasks after cleanup: ${allIssues.length - totalCanceled}`);
+
+  if (dryRun) {
+    console.log('\n💡 To execute these changes, run with --execute flag');
+  }
+}
+
+// Parse command line arguments
+const isDryRun = !process.argv.includes('--execute');
+
+// Run the cleanup
+cancelDuplicateTasks(isDryRun).catch((error) => {
+  console.error('❌ Fatal error:', error);
+  process.exit(1);
+});