@stackmemoryai/stackmemory 0.3.17 → 0.3.18

package/scripts/claude-linear-skill.js

@@ -0,0 +1,455 @@
+#!/usr/bin/env node
+
+/**
+ * Claude Linear Update Skill
+ * Automatically updates Linear tasks based on Claude's work
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import dotenv from 'dotenv';
+import chalk from 'chalk';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// Load environment variables
+dotenv.config({ 
+  path: path.join(__dirname, '..', '.env'),
+  override: true,
+  silent: true
+});
+
+class LinearUpdateSkill {
+  constructor() {
+    this.apiKey = process.env.LINEAR_API_KEY;
+    this.graphqlUrl = 'https://api.linear.app/graphql';
+    this.logFile = path.join(process.env.HOME, '.stackmemory', 'logs', 'linear-skill.log');
+    
+    // State mappings
+    this.stateMap = {
+      'todo': 'backlog',
+      'backlog': 'backlog',
+      'in_progress': 'started',
+      'in progress': 'started',
+      'started': 'started',
+      'completed': 'completed',
+      'done': 'completed',
+      'finished': 'completed',
+      'implemented': 'completed',
+      'blocked': 'blocked',
+      'cancelled': 'cancelled',
+      'canceled': 'cancelled',
+    };
+  }
+
+  /**
+   * Parse task identifier from text
+   */
+  parseTaskId(text) {
+    // Match STA-XXX pattern
+    const staMatch = text.match(/STA-(\d+)/i);
+    if (staMatch) {
+      return { identifier: staMatch[0].toUpperCase(), type: 'identifier' };
+    }
+
+    // Match Linear URL
+    const urlMatch = text.match(/linear\.app\/[^\/]+\/issue\/([^\/\s]+)/);
+    if (urlMatch) {
+      return { identifier: urlMatch[1], type: 'identifier' };
+    }
+
+    // Match UUID pattern
+    const uuidMatch = text.match(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/);
+    if (uuidMatch) {
+      return { identifier: uuidMatch[0], type: 'id' };
+    }
+
+    return null;
+  }
+
+  /**
+   * Detect status from text
+   */
+  detectStatus(text) {
+    const lowerText = text.toLowerCase();
+    
+    // Check for explicit status keywords
+    for (const [keyword, status] of Object.entries(this.stateMap)) {
+      if (lowerText.includes(keyword)) {
+        return status;
+      }
+    }
+
+    // Check for action keywords
+    if (lowerText.includes('implement') || lowerText.includes('complet') || 
+        lowerText.includes('done') || lowerText.includes('finish')) {
+      return 'completed';
+    }
+    
+    if (lowerText.includes('start') || lowerText.includes('working on') || 
+        lowerText.includes('in progress')) {
+      return 'started';
+    }
+    
+    if (lowerText.includes('block')) {
+      return 'blocked';
+    }
+
+    return null;
+  }
+
+  /**
+   * Extract implementation details from text
+   */
+  extractImplementationDetails(text) {
+    const details = [];
+    
+    // Extract features
+    const featuresMatch = text.match(/(?:features?|implemented?|added?)[::\s]*([\s\S]*?)(?=\n\n|\n[A-Z]|$)/i);
+    if (featuresMatch) {
+      details.push('## Implementation Details\n' + featuresMatch[1].trim());
+    }
+
+    // Extract technical details
+    const techMatch = text.match(/(?:technical|implementation)[::\s]*([\s\S]*?)(?=\n\n|\n[A-Z]|$)/i);
+    if (techMatch) {
+      details.push('## Technical Implementation\n' + techMatch[1].trim());
+    }
+
+    // Extract file changes
+    const filesMatch = text.match(/(?:files?|created?|modified?)[::\s]*([\s\S]*?)(?=\n\n|\n[A-Z]|$)/i);
+    if (filesMatch) {
+      details.push('## Files Changed\n' + filesMatch[1].trim());
+    }
+
+    // Add timestamp
+    details.push(`\n---\n_Updated by Claude: ${new Date().toISOString()}_`);
+
+    return details.join('\n\n');
+  }
+
+  /**
+   * Get Linear issue by identifier
+   */
+  async getIssue(identifier) {
+    const query = `
+      query GetIssue($identifier: String!) {
+        issue(id: $identifier) {
+          id
+          identifier
+          title
+          description
+          state {
+            id
+            name
+            type
+          }
+        }
+      }
+    `;
+
+    try {
+      const response = await fetch(this.graphqlUrl, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': this.apiKey,
+        },
+        body: JSON.stringify({
+          query,
+          variables: { identifier },
+        }),
+      });
+
+      const data = await response.json();
+      
+      if (data.errors) {
+        this.log(`Error fetching issue: ${data.errors[0].message}`, 'ERROR');
+        return null;
+      }
+
+      return data.data.issue;
+    } catch (error) {
+      this.log(`Failed to fetch issue: ${error.message}`, 'ERROR');
+      return null;
+    }
+  }
+
+  /**
+   * Get Linear state ID by name
+   */
+  async getStateId(stateName) {
+    const query = `
+      query GetStates {
+        workflowStates {
+          nodes {
+            id
+            name
+            type
+          }
+        }
+      }
+    `;
+
+    try {
+      const response = await fetch(this.graphqlUrl, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': this.apiKey,
+        },
+        body: JSON.stringify({ query }),
+      });
+
+      const data = await response.json();
+      
+      if (data.errors) {
+        this.log(`Error fetching states: ${data.errors[0].message}`, 'ERROR');
+        return null;
+      }
+
+      const states = data.data.workflowStates.nodes;
+      const state = states.find(s => s.type === stateName || s.name.toLowerCase() === stateName);
+      
+      return state ? state.id : null;
+    } catch (error) {
+      this.log(`Failed to fetch states: ${error.message}`, 'ERROR');
+      return null;
+    }
+  }
+
+  /**
+   * Update Linear issue
+   */
+  async updateIssue(issueId, updates) {
+    const mutation = `
+      mutation UpdateIssue($id: String!, $input: IssueUpdateInput!) {
+        issueUpdate(id: $id, input: $input) {
+          success
+          issue {
+            id
+            identifier
+            title
+            state {
+              name
+            }
+          }
+        }
+      }
+    `;
+
+    try {
+      const response = await fetch(this.graphqlUrl, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': this.apiKey,
+        },
+        body: JSON.stringify({
+          query: mutation,
+          variables: {
+            id: issueId,
+            input: updates,
+          },
+        }),
+      });
+
+      const data = await response.json();
+      
+      if (data.errors) {
+        this.log(`Error updating issue: ${data.errors[0].message}`, 'ERROR');
+        return false;
+      }
+
+      if (data.data.issueUpdate.success) {
+        const issue = data.data.issueUpdate.issue;
+        this.log(`Updated ${issue.identifier}: ${issue.state.name}`);
+        return true;
+      }
+
+      return false;
+    } catch (error) {
+      this.log(`Failed to update issue: ${error.message}`, 'ERROR');
+      return false;
+    }
+  }
+
+  /**
+   * Process update request
+   */
+  async processUpdate(text, options = {}) {
+    // Parse task ID
+    const taskInfo = this.parseTaskId(text);
+    if (!taskInfo) {
+      this.log('No task identifier found in text');
+      return { success: false, reason: 'No task identifier found' };
+    }
+
+    this.log(`Processing update for ${taskInfo.identifier}`);
+
+    // Get issue details
+    const issue = await this.getIssue(taskInfo.identifier);
+    if (!issue) {
+      return { success: false, reason: 'Issue not found' };
+    }
+
+    // Prepare updates
+    const updates = {};
+
+    // Detect and set new status
+    const newStatus = options.status || this.detectStatus(text);
+    if (newStatus) {
+      const stateId = await this.getStateId(newStatus);
+      if (stateId) {
+        updates.stateId = stateId;
+        this.log(`Setting status to ${newStatus}`);
+      }
+    }
+
+    // Add implementation details if completing
+    if (newStatus === 'completed' && options.addDetails !== false) {
+      const details = this.extractImplementationDetails(text);
+      if (details) {
+        updates.description = issue.description + '\n\n' + details;
+        this.log('Adding implementation details');
+      }
+    }
+
+    // Add comment if provided
+    if (options.comment) {
+      updates.comment = {
+        body: options.comment,
+      };
+    }
+
+    // Update the issue
+    if (Object.keys(updates).length > 0) {
+      const success = await this.updateIssue(issue.id, updates);
+      return {
+        success,
+        issue: issue.identifier,
+        updates: Object.keys(updates),
+      };
+    }
+
+    return { success: false, reason: 'No updates to apply' };
+  }
+
+  /**
+   * Log message
+   */
+  log(message, level = 'INFO') {
+    const timestamp = new Date().toISOString();
+    const logMessage = `[${timestamp}] [${level}] ${message}\n`;
+    
+    console.log(level === 'ERROR' ? chalk.red(message) : chalk.green(message));
+    
+    try {
+      fs.appendFileSync(this.logFile, logMessage);
+    } catch {
+      // Silent fail
+    }
+  }
+
+  /**
+   * Batch update multiple tasks
+   */
+  async batchUpdate(updates) {
+    const results = [];
+    
+    for (const update of updates) {
+      const result = await this.processUpdate(update.text, update.options);
+      results.push({
+        ...result,
+        original: update,
+      });
+      
+      // Rate limiting
+      await new Promise(resolve => setTimeout(resolve, 500));
+    }
+    
+    return results;
+  }
+}
+
+// CLI interface
+async function main() {
+  const skill = new LinearUpdateSkill();
+  
+  if (!skill.apiKey) {
+    console.error(chalk.red('LINEAR_API_KEY not found in environment'));
+    process.exit(1);
+  }
+
+  const command = process.argv[2];
+  const args = process.argv.slice(3).join(' ');
+
+  if (!command) {
+    console.log(chalk.yellow('Linear Update Skill'));
+    console.log('Usage:');
+    console.log('  claude-linear-skill update <text>  - Update task from text');
+    console.log('  claude-linear-skill detect <text>  - Detect task and status');
+    console.log('  claude-linear-skill test           - Test connection');
+    console.log();
+    console.log('Examples:');
+    console.log('  claude-linear-skill update "STA-287 is completed with infinite storage"');
+    console.log('  claude-linear-skill update "Starting work on STA-288"');
+    process.exit(0);
+  }
+
+  switch (command) {
+    case 'update':
+      if (!args) {
+        console.error(chalk.red('Please provide update text'));
+        process.exit(1);
+      }
+      
+      const result = await skill.processUpdate(args);
+      if (result.success) {
+        console.log(chalk.green(`✅ Updated ${result.issue}`));
+        console.log('Updates:', result.updates.join(', '));
+      } else {
+        console.log(chalk.red(`❌ Update failed: ${result.reason}`));
+      }
+      break;
+
+    case 'detect':
+      if (!args) {
+        console.error(chalk.red('Please provide text to analyze'));
+        process.exit(1);
+      }
+      
+      const taskId = skill.parseTaskId(args);
+      const status = skill.detectStatus(args);
+      
+      console.log('Detected:');
+      console.log(`  Task: ${taskId ? taskId.identifier : 'Not found'}`);
+      console.log(`  Status: ${status || 'Not detected'}`);
+      break;
+
+    case 'test':
+      const testResult = await skill.getStateId('backlog');
+      if (testResult) {
+        console.log(chalk.green('✅ Linear API connection successful'));
+      } else {
+        console.log(chalk.red('❌ Linear API connection failed'));
+      }
+      break;
+
+    default:
+      console.error(chalk.red(`Unknown command: ${command}`));
+      process.exit(1);
+  }
+}
+
+// Export for use in other scripts
+export { LinearUpdateSkill };
+
+// Run if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main().catch(error => {
+    console.error(chalk.red('Error:'), error);
+    process.exit(1);
+  });
+}