@stackmemoryai/stackmemory 0.8.1 → 1.0.0

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

@@ -1,399 +0,0 @@
-#!/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

@@ -1,246 +0,0 @@
-#!/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);
-});