@stackmemoryai/stackmemory 0.3.16 → 0.3.18

package/scripts/linear-auto-sync.js

@@ -0,0 +1,262 @@
+#!/usr/bin/env node
+
+/**
+ * Linear Auto-Sync Script
+ * Automatically syncs tasks from Linear to local store
+ * Can be run via cron job or scheduled task
+ */
+
+import { PebblesTaskStore } from '../dist/features/tasks/pebbles-task-store.js';
+import { LinearSyncEngine } from '../dist/integrations/linear/sync.js';
+import { LinearAuthManager } from '../dist/integrations/linear/auth.js';
+import { logger } from '../dist/core/monitoring/logger.js';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import Database from 'better-sqlite3';
+
+const SYNC_STATE_FILE = '.stackmemory/linear-sync-state.json';
+const DEFAULT_SYNC_CONFIG = {
+  enabled: true,
+  direction: 'from_linear', // Only pull from Linear, don't push local changes
+  autoSync: false,
+  conflictResolution: 'linear_wins', // Linear is source of truth
+  maxBatchSize: 50,
+  rateLimitDelay: 500,
+};
+
+class LinearAutoSync {
+  constructor() {
+    this.projectRoot = process.cwd();
+    this.lastSyncTime = this.loadLastSyncTime();
+  }
+
+  /**
+   * Load last sync time from state file
+   */
+  loadLastSyncTime() {
+    const stateFile = join(this.projectRoot, SYNC_STATE_FILE);
+    if (existsSync(stateFile)) {
+      try {
+        const state = JSON.parse(readFileSync(stateFile, 'utf8'));
+        return state.lastSyncTime || null;
+      } catch (error) {
+        console.error('Failed to load sync state:', error.message);
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Save last sync time to state file
+   */
+  saveLastSyncTime(timestamp) {
+    const stateFile = join(this.projectRoot, SYNC_STATE_FILE);
+    const state = {
+      lastSyncTime: timestamp,
+      lastSyncDate: new Date(timestamp).toISOString(),
+    };
+
+    try {
+      writeFileSync(stateFile, JSON.stringify(state, null, 2));
+    } catch (error) {
+      console.error('Failed to save sync state:', error.message);
+    }
+  }
+
+  /**
+   * Run the sync process
+   */
+  async sync() {
+    console.log('🔄 Starting Linear auto-sync...');
+    console.log(
+      `Last sync: ${this.lastSyncTime ? new Date(this.lastSyncTime).toLocaleString() : 'Never'}`
+    );
+
+    // Check for API key
+    if (!process.env.LINEAR_API_KEY) {
+      console.error('❌ LINEAR_API_KEY environment variable not set');
+      console.log('Set it with: export LINEAR_API_KEY="your-api-key"');
+      process.exit(1);
+    }
+
+    try {
+      // Check if StackMemory is initialized
+      const dbPath = join(this.projectRoot, '.stackmemory', 'context.db');
+      if (!existsSync(dbPath)) {
+        console.error(
+          '❌ StackMemory not initialized. Run "stackmemory init" first.'
+        );
+        process.exit(1);
+      }
+
+      // Initialize components
+      const db = new Database(dbPath);
+      const taskStore = new PebblesTaskStore(this.projectRoot, db);
+      const authManager = new LinearAuthManager(this.projectRoot);
+      const syncEngine = new LinearSyncEngine(
+        taskStore,
+        authManager,
+        DEFAULT_SYNC_CONFIG,
+        this.projectRoot
+      );
+
+      // Run sync
+      const startTime = Date.now();
+      const result = await syncEngine.sync();
+      const duration = ((Date.now() - startTime) / 1000).toFixed(2);
+
+      // Display results
+      if (result.success) {
+        console.log(`✅ Sync completed in ${duration}s`);
+        console.log(`   From Linear: ${result.synced.fromLinear} created`);
+        console.log(`   Updated: ${result.synced.updated} tasks`);
+
+        if (result.conflicts.length > 0) {
+          console.log(`\n⚠️  Conflicts (${result.conflicts.length}):`);
+          result.conflicts.forEach((c) => {
+            console.log(`   - Task ${c.taskId}: ${c.reason}`);
+          });
+        }
+
+        // Save sync time
+        this.saveLastSyncTime(Date.now());
+      } else {
+        console.error('❌ Sync failed');
+        result.errors.forEach((error) => {
+          console.error(`   - ${error}`);
+        });
+        process.exit(1);
+      }
+
+      // Show task summary
+      await this.showTaskSummary(taskStore);
+    } catch (error) {
+      console.error('❌ Sync error:', error.message);
+      if (error.stack && process.env.DEBUG) {
+        console.error(error.stack);
+      }
+      process.exit(1);
+    }
+  }
+
+  /**
+   * Show summary of local tasks
+   */
+  async showTaskSummary(taskStore) {
+    const tasks = taskStore.getActiveTasks();
+
+    // Count by status
+    const byStatus = {};
+    const byPriority = {};
+    const linearTasks = [];
+
+    tasks.forEach((task) => {
+      byStatus[task.status] = (byStatus[task.status] || 0) + 1;
+      byPriority[task.priority] = (byPriority[task.priority] || 0) + 1;
+
+      if (task.title.match(/\[ENG-\d+\]/) || task.title.match(/\[STA-\d+\]/)) {
+        linearTasks.push(task);
+      }
+    });
+
+    console.log('\n📊 Local Task Summary:');
+    console.log(`   Total tasks: ${tasks.length}`);
+    console.log(`   Linear tasks: ${linearTasks.length}`);
+    console.log(`   Local-only tasks: ${tasks.length - linearTasks.length}`);
+
+    console.log('\n   By Status:');
+    Object.entries(byStatus).forEach(([status, count]) => {
+      console.log(`   - ${status}: ${count}`);
+    });
+
+    console.log('\n   By Priority:');
+    Object.entries(byPriority).forEach(([priority, count]) => {
+      console.log(`   - ${priority}: ${count}`);
+    });
+
+    // Show recent Linear tasks
+    if (linearTasks.length > 0) {
+      console.log('\n   Recent Linear tasks:');
+      linearTasks.slice(-5).forEach((task) => {
+        const identifier = task.title.match(/\[(\w+-\d+)\]/)?.[1] || '';
+        const title = task.title.replace(/\[\w+-\d+\]\s*/, '').substring(0, 50);
+        console.log(`   - ${identifier}: ${title}...`);
+      });
+    }
+  }
+
+  /**
+   * Run in watch mode - sync every N minutes
+   */
+  async watch(intervalMinutes = 5) {
+    console.log(
+      `👀 Running in watch mode (syncing every ${intervalMinutes} minutes)`
+    );
+
+    // Initial sync
+    await this.sync();
+
+    // Schedule periodic syncs
+    setInterval(
+      async () => {
+        console.log(
+          `\n⏰ Running scheduled sync at ${new Date().toLocaleString()}`
+        );
+        await this.sync();
+      },
+      intervalMinutes * 60 * 1000
+    );
+
+    console.log('\nPress Ctrl+C to stop watching');
+  }
+}
+
+// CLI execution
+async function main() {
+  const autoSync = new LinearAutoSync();
+  const args = process.argv.slice(2);
+
+  if (args.includes('--watch') || args.includes('-w')) {
+    // Watch mode
+    const intervalIndex = args.findIndex(
+      (a) => a === '--interval' || a === '-i'
+    );
+    const interval = intervalIndex >= 0 ? parseInt(args[intervalIndex + 1]) : 5;
+    await autoSync.watch(interval);
+  } else if (args.includes('--help') || args.includes('-h')) {
+    // Help
+    console.log(`
+Linear Auto-Sync Script
+-----------------------
+
+Usage:
+  npm run linear:sync                    Run one-time sync
+  npm run linear:sync -- --watch         Watch mode (sync every 5 minutes)
+  npm run linear:sync -- --watch -i 10   Watch mode with custom interval
+
+Options:
+  --watch, -w           Run in watch mode
+  --interval, -i <min>  Sync interval in minutes (default: 5)
+  --help, -h           Show this help
+
+Environment:
+  LINEAR_API_KEY       Required - your Linear API key
+
+Example cron job (every 15 minutes):
+  */15 * * * * cd /path/to/project && LINEAR_API_KEY=xxx npm run linear:sync
+    `);
+  } else {
+    // One-time sync
+    await autoSync.sync();
+  }
+}
+
+// Run if executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main().catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+  });
+}
+
+export { LinearAutoSync };

package/scripts/linear-auto-sync.sh

@@ -0,0 +1,161 @@
+#!/bin/bash
+
+# Linear Auto-Sync Daemon for StackMemory
+# Automatically syncs tasks with Linear at regular intervals
+
+# Configuration
+INTERVAL=${1:-5}  # Default 5 minutes
+PID_FILE="/tmp/stackmemory-linear-sync.pid"
+LOG_FILE="${HOME}/.stackmemory/logs/linear-sync.log"
+
+# Ensure log directory exists
+mkdir -p "$(dirname "$LOG_FILE")"
+
+# Colors for output
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+RED='\033[0;31m'
+NC='\033[0m' # No Color
+
+log() {
+    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a "$LOG_FILE"
+}
+
+cleanup() {
+    log "🛑 Stopping Linear auto-sync daemon..."
+    
+    # Final sync before exit
+    if [ -n "$LINEAR_API_KEY" ] && [ -d ".stackmemory" ]; then
+        log "📤 Performing final sync..."
+        stackmemory linear sync 2>&1 | tee -a "$LOG_FILE"
+    fi
+    
+    rm -f "$PID_FILE"
+    log "✅ Linear auto-sync stopped"
+    exit 0
+}
+
+# Check prerequisites
+check_requirements() {
+    if [ -z "$LINEAR_API_KEY" ]; then
+        echo -e "${RED}❌ LINEAR_API_KEY not set${NC}"
+        echo "Please set: export LINEAR_API_KEY='your_api_key'"
+        exit 1
+    fi
+    
+    if ! command -v stackmemory &> /dev/null; then
+        echo -e "${RED}❌ StackMemory not installed${NC}"
+        echo "Install with: npm install -g @stackmemoryai/stackmemory"
+        exit 1
+    fi
+    
+    if [ ! -d ".stackmemory" ]; then
+        echo -e "${YELLOW}⚠️  No .stackmemory directory found${NC}"
+        echo "Initialize with: stackmemory init"
+        exit 1
+    fi
+}
+
+start_daemon() {
+    # Check if already running
+    if [ -f "$PID_FILE" ]; then
+        OLD_PID=$(cat "$PID_FILE")
+        if kill -0 "$OLD_PID" 2>/dev/null; then
+            echo -e "${YELLOW}⚠️  Linear auto-sync already running (PID: $OLD_PID)${NC}"
+            exit 1
+        else
+            rm -f "$PID_FILE"
+        fi
+    fi
+    
+    # Save PID
+    echo $$ > "$PID_FILE"
+    
+    log "🚀 Linear auto-sync daemon started (PID: $$)"
+    log "   Interval: ${INTERVAL} minutes"
+    log "   API Key: ${LINEAR_API_KEY:0:10}..."
+    log "   Log file: $LOG_FILE"
+    echo -e "${GREEN}✅ Auto-sync running. Use 'tail -f $LOG_FILE' to monitor${NC}"
+    
+    # Initial sync
+    log "📤 Performing initial sync..."
+    stackmemory linear sync 2>&1 | tee -a "$LOG_FILE"
+    
+    # Main loop
+    while true; do
+        sleep $((INTERVAL * 60))
+        
+        log "🔄 Auto-syncing with Linear..."
+        
+        # Run sync and capture output
+        SYNC_OUTPUT=$(stackmemory linear sync 2>&1)
+        SYNC_EXIT=$?
+        
+        if [ $SYNC_EXIT -eq 0 ]; then
+            # Check if there were changes
+            if echo "$SYNC_OUTPUT" | grep -q "created\|updated"; then
+                log "✅ Sync completed with changes"
+                echo "$SYNC_OUTPUT" >> "$LOG_FILE"
+            else
+                log "✅ Sync completed (no changes)"
+            fi
+        else
+            log "⚠️  Sync failed: $SYNC_OUTPUT"
+        fi
+    done
+}
+
+# Parse commands
+case "${1:-start}" in
+    start)
+        check_requirements
+        trap cleanup EXIT INT TERM
+        start_daemon
+        ;;
+    stop)
+        if [ -f "$PID_FILE" ]; then
+            PID=$(cat "$PID_FILE")
+            if kill -0 "$PID" 2>/dev/null; then
+                kill "$PID"
+                echo -e "${GREEN}✅ Stopped Linear auto-sync (PID: $PID)${NC}"
+            else
+                echo -e "${YELLOW}⚠️  Process not running${NC}"
+                rm -f "$PID_FILE"
+            fi
+        else
+            echo -e "${YELLOW}⚠️  No daemon running${NC}"
+        fi
+        ;;
+    status)
+        if [ -f "$PID_FILE" ]; then
+            PID=$(cat "$PID_FILE")
+            if kill -0 "$PID" 2>/dev/null; then
+                echo -e "${GREEN}✅ Linear auto-sync running (PID: $PID)${NC}"
+                echo "   Log: tail -f $LOG_FILE"
+            else
+                echo -e "${RED}❌ Linear auto-sync not running (stale PID file)${NC}"
+                rm -f "$PID_FILE"
+            fi
+        else
+            echo -e "${YELLOW}⚠️  Linear auto-sync not running${NC}"
+        fi
+        ;;
+    logs)
+        if [ -f "$LOG_FILE" ]; then
+            tail -f "$LOG_FILE"
+        else
+            echo -e "${YELLOW}⚠️  No log file found${NC}"
+        fi
+        ;;
+    *)
+        echo "Usage: $0 {start|stop|status|logs} [interval_minutes]"
+        echo ""
+        echo "Examples:"
+        echo "  $0 start       # Start with 5-minute interval (default)"
+        echo "  $0 start 10    # Start with 10-minute interval"
+        echo "  $0 stop        # Stop the daemon"
+        echo "  $0 status      # Check if running"
+        echo "  $0 logs        # Tail the log file"
+        exit 1
+        ;;
+esac

package/scripts/linear-sync-daemon.js

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+
+/**
+ * Linear Sync Daemon - Runs hourly sync between Linear and local tasks
+ * Checks .env first for API keys, then falls back to environment variables
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import dotenv from 'dotenv';
+import { spawn } from 'child_process';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// Load environment variables from .env file first (as per user preference)
+dotenv.config({ 
+  path: path.join(__dirname, '..', '.env'),
+  override: false // Don't override existing env vars
+});
+
+const SYNC_INTERVAL = 60 * 60 * 1000; // 1 hour in milliseconds
+const LOG_FILE = path.join(__dirname, '..', '.stackmemory', 'linear-sync.log');
+
+class LinearSyncDaemon {
+  constructor() {
+    this.isRunning = false;
+    this.syncCount = 0;
+    this.lastSyncTime = null;
+    this.intervalId = null;
+  }
+
+  log(message) {
+    const timestamp = new Date().toISOString();
+    const logMessage = `[${timestamp}] ${message}\n`;
+    
+    console.log(logMessage.trim());
+    
+    // Append to log file
+    try {
+      fs.appendFileSync(LOG_FILE, logMessage);
+    } catch (error) {
+      console.error('Failed to write to log file:', error.message);
+    }
+  }
+
+  async runSync() {
+    if (this.isRunning) {
+      this.log('⏭️  Sync already in progress, skipping...');
+      return;
+    }
+
+    this.isRunning = true;
+    this.syncCount++;
+    
+    this.log(`🔄 Starting Linear sync #${this.syncCount}...`);
+    
+    return new Promise((resolve) => {
+      const syncScript = path.join(__dirname, 'sync-linear-graphql.js');
+      
+      // Run the sync script as a child process
+      const syncProcess = spawn('node', [syncScript], {
+        env: process.env,
+        stdio: ['ignore', 'pipe', 'pipe']
+      });
+      
+      let output = '';
+      let errorOutput = '';
+      
+      syncProcess.stdout.on('data', (data) => {
+        output += data.toString();
+      });
+      
+      syncProcess.stderr.on('data', (data) => {
+        errorOutput += data.toString();
+      });
+      
+      syncProcess.on('close', (code) => {
+        this.isRunning = false;
+        this.lastSyncTime = new Date();
+        
+        if (code === 0) {
+          // Parse output for summary
+          const lines = output.split('\n');
+          const summaryLine = lines.find(l => l.includes('Added to local:'));
+          const addedCount = summaryLine ? summaryLine.match(/\d+/)?.[0] : '0';
+          
+          this.log(`✅ Sync #${this.syncCount} completed successfully. Added ${addedCount} tasks.`);
+        } else {
+          this.log(`❌ Sync #${this.syncCount} failed with code ${code}`);
+          if (errorOutput) {
+            this.log(`Error output: ${errorOutput.substring(0, 500)}`);
+          }
+        }
+        
+        resolve();
+      });
+      
+      syncProcess.on('error', (error) => {
+        this.isRunning = false;
+        this.log(`❌ Failed to start sync process: ${error.message}`);
+        resolve();
+      });
+    });
+  }
+
+  async start() {
+    // Check for API key
+    if (!process.env.LINEAR_API_KEY) {
+      this.log('❌ LINEAR_API_KEY not found in .env or environment variables');
+      this.log('Please add LINEAR_API_KEY to your .env file or export it');
+      process.exit(1);
+    }
+    
+    this.log('🚀 Linear Sync Daemon starting...');
+    this.log(`📅 Sync interval: Every hour`);
+    this.log(`🔑 API Key: Found (${process.env.LINEAR_API_KEY.substring(0, 10)}...)`);
+    
+    // Run initial sync
+    await this.runSync();
+    
+    // Schedule hourly syncs
+    this.intervalId = setInterval(() => {
+      this.runSync();
+    }, SYNC_INTERVAL);
+    
+    this.log('⏰ Hourly sync scheduled. Daemon running in background...');
+    
+    // Handle graceful shutdown
+    process.on('SIGINT', () => this.stop());
+    process.on('SIGTERM', () => this.stop());
+  }
+
+  stop() {
+    this.log('🛑 Stopping Linear Sync Daemon...');
+    
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+    
+    this.log(`📊 Final stats: ${this.syncCount} syncs completed`);
+    this.log('👋 Daemon stopped');
+    process.exit(0);
+  }
+}
+
+// Start the daemon
+const daemon = new LinearSyncDaemon();
+daemon.start();