@stackmemoryai/stackmemory 0.8.1 → 1.0.0

package/scripts/initialize.ts

@@ -1,220 +0,0 @@
-#!/usr/bin/env tsx
-/**
- * Initialize StackMemory in the current project
- */
-
-import {
-  existsSync,
-  mkdirSync,
-  writeFileSync,
-  readFileSync,
-  appendFileSync,
-} from 'fs';
-import { join } from 'path';
-import { execSync } from 'child_process';
-import chalk from 'chalk';
-
-// Parse CLI args for --with-diffmem flag
-const enableDiffMem = process.argv.includes('--with-diffmem');
-// Type-safe environment variable access
-function getEnv(key: string, defaultValue?: string): string {
-  const value = process.env[key];
-  if (value === undefined) {
-    if (defaultValue !== undefined) return defaultValue;
-    throw new Error(`Environment variable ${key} is required`);
-  }
-  return value;
-}
-
-function getOptionalEnv(key: string): string | undefined {
-  return process.env[key];
-}
-
-const projectRoot = process.cwd();
-
-console.log(chalk.blue.bold('\n🚀 Initializing StackMemory...\n'));
-
-// 1. Create .stackmemory directory
-const stackDir = join(projectRoot, '.stackmemory');
-if (!existsSync(stackDir)) {
-  mkdirSync(stackDir, { recursive: true });
-  console.log(chalk.green('✓') + ' Created .stackmemory directory');
-} else {
-  console.log(chalk.yellow('⚠') + ' .stackmemory directory already exists');
-}
-
-// 2. Add to .gitignore
-const gitignorePath = join(projectRoot, '.gitignore');
-const gitignoreEntry =
-  '\n# StackMemory\n.stackmemory/*.db\n.stackmemory/*.db-*\n';
-
-if (existsSync(gitignorePath)) {
-  const gitignore = readFileSync(gitignorePath, 'utf-8');
-  if (!gitignore.includes('.stackmemory')) {
-    appendFileSync(gitignorePath, gitignoreEntry);
-    console.log(chalk.green('✓') + ' Added .stackmemory to .gitignore');
-  }
-} else {
-  writeFileSync(gitignorePath, gitignoreEntry);
-  console.log(chalk.green('✓') + ' Created .gitignore with .stackmemory');
-}
-
-// 3. Create config file
-const configPath = join(stackDir, 'config.json');
-if (!existsSync(configPath)) {
-  const config = {
-    projectId: projectRoot.split('/').pop(),
-    userId: process.env['USER'] || 'default',
-    teamId: 'local',
-    initialized: new Date().toISOString(),
-  };
-  writeFileSync(configPath, JSON.stringify(config, null, 2));
-  console.log(chalk.green('✓') + ' Created config file');
-}
-
-// 4. Create initial JSONL file
-const jsonlPath = join(stackDir, 'frames.jsonl');
-if (!existsSync(jsonlPath)) {
-  const initialFrame = {
-    id: 'init_' + Date.now(),
-    type: 'system',
-    content: 'StackMemory initialized',
-    timestamp: Date.now(),
-  };
-  writeFileSync(jsonlPath, JSON.stringify(initialFrame) + '\n');
-  console.log(chalk.green('✓') + ' Created frames.jsonl');
-}
-
-// 5. Create MCP config for Claude Code
-const isMacOS = process.platform === 'darwin';
-const mcpConfigPath = isMacOS
-  ? join(
-      process.env['HOME'] || '~',
-      'Library',
-      'Application Support',
-      'Claude',
-      'claude_desktop_config.json'
-    )
-  : join(
-      process.env['HOME'] || '~',
-      '.config',
-      'claude',
-      'claude_desktop_config.json'
-    );
-console.log(chalk.blue('\n📝 MCP Configuration for Claude Code:\n'));
-
-const mcpConfig = {
-  mcpServers: {
-    stackmemory: {
-      command: 'node',
-      args: [join(projectRoot, 'dist', 'integrations', 'mcp', 'server.js')],
-      env: {
-        PROJECT_ROOT: projectRoot,
-      },
-    },
-  },
-};
-
-console.log(chalk.gray('Add this to your Claude Code MCP configuration:'));
-console.log(chalk.gray('(' + mcpConfigPath + ')\n'));
-console.log(chalk.cyan(JSON.stringify(mcpConfig, null, 2)));
-
-// 6. Build the project
-console.log(chalk.blue('\n📦 Building TypeScript files...\n'));
-try {
-  execSync('npm run build', { stdio: 'inherit', cwd: projectRoot });
-  console.log(chalk.green('✓') + ' Build completed');
-} catch {
-  console.log(chalk.yellow('⚠') + ' Build failed - run npm run build manually');
-}
-
-// 7. Optional: Initialize DiffMem for long-term user memory
-if (enableDiffMem) {
-  console.log(chalk.blue('\n🧠 Setting up DiffMem integration...\n'));
-
-  const diffmemDir = join(stackDir, 'diffmem');
-  const diffmemStorageDir = join(diffmemDir, 'storage');
-  const diffmemWorktreesDir = join(diffmemDir, 'worktrees');
-
-  // Create DiffMem directories
-  mkdirSync(diffmemStorageDir, { recursive: true });
-  mkdirSync(diffmemWorktreesDir, { recursive: true });
-
-  // Initialize git repo for storage
-  if (!existsSync(join(diffmemStorageDir, '.git'))) {
-    try {
-      execSync('git init', { cwd: diffmemStorageDir, stdio: 'pipe' });
-      execSync('git commit --allow-empty -m "Initialize DiffMem storage"', {
-        cwd: diffmemStorageDir,
-        stdio: 'pipe',
-      });
-      console.log(chalk.green('✓') + ' Initialized DiffMem storage repository');
-    } catch {
-      console.log(
-        chalk.yellow('⚠') + ' Failed to initialize git repo for DiffMem'
-      );
-    }
-  }
-
-  // Create DiffMem config
-  const diffmemConfigPath = join(diffmemDir, 'config.json');
-  const diffmemConfig = {
-    enabled: true,
-    endpoint: 'http://localhost:8000',
-    userId: process.env['USER'] || 'default',
-    storagePath: diffmemStorageDir,
-    worktreePath: diffmemWorktreesDir,
-  };
-  writeFileSync(diffmemConfigPath, JSON.stringify(diffmemConfig, null, 2));
-  console.log(chalk.green('✓') + ' Created DiffMem configuration');
-
-  // Add DiffMem env vars to .env file
-  const envPath = join(projectRoot, '.env');
-  const diffmemEnvVars = `
-# DiffMem Configuration (Long-term User Memory)
-DIFFMEM_ENABLED=true
-DIFFMEM_ENDPOINT=http://localhost:8000
-DIFFMEM_USER_ID=${process.env['USER'] || 'default'}
-DIFFMEM_STORAGE_PATH=${diffmemStorageDir}
-DIFFMEM_WORKTREE_PATH=${diffmemWorktreesDir}
-`;
-
-  if (existsSync(envPath)) {
-    const envContent = readFileSync(envPath, 'utf-8');
-    if (!envContent.includes('DIFFMEM_')) {
-      appendFileSync(envPath, diffmemEnvVars);
-      console.log(chalk.green('✓') + ' Added DiffMem configuration to .env');
-    }
-  } else {
-    writeFileSync(envPath, diffmemEnvVars.trim() + '\n');
-    console.log(chalk.green('✓') + ' Created .env with DiffMem configuration');
-  }
-
-  console.log(chalk.green('✓') + ' DiffMem integration configured');
-  console.log(
-    chalk.gray(
-      '  Note: DiffMem server must be running for user memory features'
-    )
-  );
-}
-
-console.log(chalk.green.bold('\n✅ StackMemory initialized successfully!\n'));
-console.log(chalk.gray('Next steps:'));
-console.log(chalk.gray('1. Add the MCP configuration above to Claude Code'));
-console.log(chalk.gray('2. Restart Claude Code'));
-console.log(chalk.gray('3. Start using context tracking!'));
-if (enableDiffMem) {
-  console.log(chalk.gray('4. Start DiffMem server: npm run diffmem:start'));
-}
-console.log(chalk.gray('\nUseful commands:'));
-console.log(
-  chalk.cyan('  npm run mcp:dev') + ' - Start MCP server in dev mode'
-);
-console.log(chalk.cyan('  npm run status') + ' - Check StackMemory status');
-console.log(chalk.cyan('  npm run analyze') + ' - Analyze context usage');
-if (enableDiffMem) {
-  console.log(
-    chalk.cyan('  npm run diffmem:start') + ' - Start DiffMem server'
-  );
-}
-console.log();

package/scripts/linear-auto-sync.js

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

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