@stackmemoryai/stackmemory 0.3.17 → 0.3.19

package/scripts/codex-wrapper.sh

@@ -0,0 +1,88 @@
+#!/bin/bash
+
+# Codex CLI wrapper with StackMemory integration
+# Usage: Add alias to your shell: alias codex-sm='~/Dev/stackmemory/scripts/codex-wrapper.sh'
+
+# Check for auto-sync flag
+AUTO_SYNC=false
+SYNC_INTERVAL=5
+for arg in "$@"; do
+    case $arg in
+        --auto-sync)
+            AUTO_SYNC=true
+            shift
+            ;;
+        --sync-interval=*)
+            SYNC_INTERVAL="${arg#*=}"
+            shift
+            ;;
+    esac
+done
+
+# Auto-initialize StackMemory if in git repo without it
+if [ -d ".git" ] && [ ! -d ".stackmemory" ]; then
+    echo "📦 Initializing StackMemory for this project..."
+    stackmemory init --silent 2>/dev/null || true
+fi
+
+# Load existing context if available
+if [ -d ".stackmemory" ]; then
+    echo "🧠 Loading StackMemory context..."
+    stackmemory status --brief 2>/dev/null || true
+fi
+
+# Start Linear auto-sync in background if requested
+SYNC_PID=""
+if [ "$AUTO_SYNC" = true ] && [ -n "$LINEAR_API_KEY" ]; then
+    echo "🔄 Starting Linear auto-sync (${SYNC_INTERVAL}min intervals)..."
+    (
+        while true; do
+            sleep $((SYNC_INTERVAL * 60))
+            if [ -d ".stackmemory" ]; then
+                stackmemory linear sync --quiet 2>/dev/null || true
+            fi
+        done
+    ) &
+    SYNC_PID=$!
+fi
+
+cleanup() {
+    echo ""
+    echo "📝 Saving StackMemory context..."
+
+    # Kill auto-sync if running
+    if [ -n "$SYNC_PID" ] && kill -0 $SYNC_PID 2>/dev/null; then
+        echo "🛑 Stopping auto-sync..."
+        kill $SYNC_PID 2>/dev/null || true
+    fi
+
+    # Check if in a git repo with stackmemory
+    if [ -d ".stackmemory" ]; then
+        # Save current context
+        stackmemory status 2>/dev/null
+
+        # If Linear API key is set, final sync
+        if [ -n "$LINEAR_API_KEY" ]; then
+            echo "🔄 Final Linear sync..."
+            stackmemory linear sync 2>/dev/null
+        fi
+
+        echo "✅ StackMemory context saved"
+    fi
+}
+
+# Set trap for exit signals
+# shellcheck disable=SC2064
+trap cleanup EXIT INT TERM
+
+# Run Codex CLI
+if command -v codex &> /dev/null; then
+    codex "$@"
+elif command -v codex-cli &> /dev/null; then
+    codex-cli "$@"
+else
+    echo "❌ Codex CLI not found. Please install it first."
+    echo "   See: https://github.com/openai/codex-cli"
+    exit 1
+fi
+

package/scripts/create-sandbox.sh

@@ -0,0 +1,269 @@
+#!/bin/bash
+
+# StackMemory Sandbox Environment Creator
+# Creates an isolated test environment for local development
+
+set -e
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+echo "🏗️  StackMemory Sandbox Environment Creator"
+echo "==========================================="
+
+# Configuration
+SANDBOX_BASE="/tmp/stackmemory-sandbox"
+TIMESTAMP=$(date +%Y%m%d_%H%M%S)
+SANDBOX_DIR="${SANDBOX_BASE}/${TIMESTAMP}"
+SOURCE_DIR="$(pwd)"
+
+# Parse arguments
+PROJECT_PATH="${1:-/tmp/test-project}"
+CLEAN_INSTALL="${2:-true}"
+
+echo -e "\n${GREEN}Configuration:${NC}"
+echo "  Source: $SOURCE_DIR"
+echo "  Sandbox: $SANDBOX_DIR"
+echo "  Test Project: $PROJECT_PATH"
+echo ""
+
+# Create sandbox directory
+echo -e "${YELLOW}📁 Creating sandbox directory...${NC}"
+mkdir -p "$SANDBOX_DIR"
+mkdir -p "$PROJECT_PATH"
+
+# Copy source files (excluding node_modules, dist, .git)
+echo -e "${YELLOW}📋 Copying source files...${NC}"
+rsync -av \
+  --exclude='node_modules' \
+  --exclude='dist' \
+  --exclude='.git' \
+  --exclude='*.tgz' \
+  --exclude='.stackmemory' \
+  --exclude='package-lock.json' \
+  "$SOURCE_DIR/" "$SANDBOX_DIR/"
+
+# Navigate to sandbox
+cd "$SANDBOX_DIR"
+
+# Create sandbox-specific configuration
+echo -e "${YELLOW}⚙️  Creating sandbox configuration...${NC}"
+cat > sandbox.config.json << EOF
+{
+  "environment": "sandbox",
+  "timestamp": "$TIMESTAMP",
+  "sourceDir": "$SOURCE_DIR",
+  "projectPath": "$PROJECT_PATH",
+  "port": 3333,
+  "features": {
+    "autoUpdate": false,
+    "telemetry": false,
+    "production": false
+  }
+}
+EOF
+
+# Update package.json for sandbox
+echo -e "${YELLOW}📦 Updating package.json for sandbox...${NC}"
+node -e "
+const fs = require('fs');
+const pkg = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+pkg.name = '@stackmemory-sandbox/stackmemory';
+pkg.version = pkg.version + '-sandbox.$TIMESTAMP';
+fs.writeFileSync('package.json', JSON.stringify(pkg, null, 2));
+console.log('Updated package name to:', pkg.name);
+console.log('Updated version to:', pkg.version);
+"
+
+# Install dependencies
+if [ "$CLEAN_INSTALL" = "true" ]; then
+  echo -e "${YELLOW}📥 Installing dependencies...${NC}"
+  npm install --silent
+else
+  echo -e "${YELLOW}📥 Copying node_modules from source...${NC}"
+  cp -r "$SOURCE_DIR/node_modules" .
+fi
+
+# Build the sandbox version
+echo -e "${YELLOW}🔨 Building sandbox version...${NC}"
+npm run build
+
+# Create test environment script
+echo -e "${YELLOW}🧪 Creating test environment...${NC}"
+cat > run-sandbox.sh << 'EOF'
+#!/bin/bash
+
+# Sandbox Test Runner
+echo "🧪 StackMemory Sandbox Test Environment"
+echo "======================================="
+
+# Set sandbox environment variables
+export STACKMEMORY_ENV=sandbox
+export STACKMEMORY_DEBUG=true
+export PROJECT_ROOT="$1"
+
+# Available commands
+show_help() {
+  echo ""
+  echo "Available commands:"
+  echo "  ./run-sandbox.sh init [project_path]     - Initialize StackMemory in project"
+  echo "  ./run-sandbox.sh status                  - Show status"
+  echo "  ./run-sandbox.sh mcp-server              - Start MCP server"
+  echo "  ./run-sandbox.sh linear-sync             - Test Linear sync"
+  echo "  ./run-sandbox.sh test                    - Run all tests"
+  echo "  ./run-sandbox.sh cli [command]           - Run any CLI command"
+  echo "  ./run-sandbox.sh clean                   - Clean sandbox"
+  echo ""
+}
+
+case "$1" in
+  init)
+    PROJECT="${2:-/tmp/test-project}"
+    echo "Initializing StackMemory in: $PROJECT"
+    mkdir -p "$PROJECT"
+    cd "$PROJECT"
+    node "$SANDBOX_DIR/dist/src/cli/cli.js" init
+    ;;
+  
+  status)
+    node "$SANDBOX_DIR/dist/src/cli/cli.js" status
+    ;;
+  
+  mcp-server)
+    echo "Starting MCP server on sandbox..."
+    node "$SANDBOX_DIR/dist/src/cli/cli.js" mcp-server --project "${2:-/tmp/test-project}"
+    ;;
+  
+  linear-sync)
+    echo "Testing Linear sync..."
+    export LINEAR_API_KEY="${LINEAR_API_KEY:-test_key}"
+    node "$SANDBOX_DIR/dist/src/cli/cli.js" linear sync
+    ;;
+  
+  test)
+    echo "Running tests..."
+    cd "$SANDBOX_DIR"
+    npm test
+    ;;
+  
+  cli)
+    shift
+    node "$SANDBOX_DIR/dist/src/cli/cli.js" "$@"
+    ;;
+  
+  clean)
+    echo "Cleaning sandbox..."
+    rm -rf "$SANDBOX_DIR"
+    echo "Sandbox cleaned!"
+    ;;
+  
+  *)
+    show_help
+    ;;
+esac
+EOF
+
+chmod +x run-sandbox.sh
+
+# Create test project structure
+echo -e "${YELLOW}🏗️  Setting up test project...${NC}"
+mkdir -p "$PROJECT_PATH/.stackmemory"
+cd "$PROJECT_PATH"
+
+# Initialize git repo for testing
+git init --quiet
+echo "# Test Project" > README.md
+echo "node_modules/" > .gitignore
+git add .
+git commit -m "Initial commit" --quiet
+
+# Initialize StackMemory in test project
+echo -e "${YELLOW}🚀 Initializing StackMemory in test project...${NC}"
+node "$SANDBOX_DIR/dist/src/cli/cli.js" init
+
+# Create sandbox info file
+echo -e "${YELLOW}📄 Creating sandbox info...${NC}"
+cat > "$SANDBOX_DIR/SANDBOX_INFO.md" << EOF
+# StackMemory Sandbox Environment
+
+Created: $TIMESTAMP
+Location: $SANDBOX_DIR
+Test Project: $PROJECT_PATH
+
+## Quick Start
+
+\`\`\`bash
+cd $SANDBOX_DIR
+
+# Run commands
+./run-sandbox.sh status
+./run-sandbox.sh mcp-server
+./run-sandbox.sh test
+
+# Clean up
+./run-sandbox.sh clean
+\`\`\`
+
+## Files
+
+- Source: $SOURCE_DIR
+- Build: $SANDBOX_DIR/dist
+- Config: $SANDBOX_DIR/sandbox.config.json
+- Test Project: $PROJECT_PATH
+
+## Environment Variables
+
+- STACKMEMORY_ENV=sandbox
+- STACKMEMORY_DEBUG=true
+- PROJECT_ROOT=$PROJECT_PATH
+
+EOF
+
+# Create VS Code workspace for sandbox
+cat > "$SANDBOX_DIR/sandbox.code-workspace" << EOF
+{
+  "folders": [
+    {
+      "path": ".",
+      "name": "StackMemory Sandbox"
+    },
+    {
+      "path": "$PROJECT_PATH",
+      "name": "Test Project"
+    }
+  ],
+  "settings": {
+    "terminal.integrated.env.osx": {
+      "STACKMEMORY_ENV": "sandbox",
+      "PROJECT_ROOT": "$PROJECT_PATH"
+    }
+  }
+}
+EOF
+
+# Summary
+echo ""
+echo -e "${GREEN}✅ Sandbox environment created successfully!${NC}"
+echo ""
+echo "📍 Locations:"
+echo "  Sandbox: $SANDBOX_DIR"
+echo "  Test Project: $PROJECT_PATH"
+echo ""
+echo "🚀 Quick Start:"
+echo "  cd $SANDBOX_DIR"
+echo "  ./run-sandbox.sh status"
+echo "  ./run-sandbox.sh mcp-server"
+echo ""
+echo "🧹 Clean up:"
+echo "  $SANDBOX_DIR/run-sandbox.sh clean"
+echo ""
+echo "📖 Full documentation: $SANDBOX_DIR/SANDBOX_INFO.md"
+echo ""
+
+# Save sandbox path for easy access
+echo "$SANDBOX_DIR" > /tmp/stackmemory-sandbox-latest
+
+echo -e "${GREEN}Sandbox ready! Path saved to: /tmp/stackmemory-sandbox-latest${NC}"

package/scripts/debug-linear-update.js

@@ -0,0 +1,174 @@
+#!/usr/bin/env node
+
+/**
+ * Debug why Linear updates are failing
+ */
+
+import 'dotenv/config';
+
+const API_KEY = process.env.LINEAR_OAUTH_TOKEN || process.env.LINEAR_API_KEY;
+if (!API_KEY) {
+  console.error('❌ LINEAR_OAUTH_TOKEN or LINEAR_API_KEY environment variable not set');
+  console.log('Please set LINEAR_OAUTH_TOKEN or LINEAR_API_KEY in your .env file or export it in your shell');
+  process.exit(1);
+}
+
+async function debugLinearUpdate() {
+  console.log('🔍 Debugging Linear update issues...\n');
+  
+  // First, test basic API access
+  console.log('1. Testing API authentication:');
+  const testQuery = `
+    query TestAuth {
+      viewer {
+        id
+        email
+      }
+    }
+  `;
+  
+  let response = await fetch('https://api.linear.app/graphql', {
+    method: 'POST',
+    headers: {
+      'Authorization': `Bearer ${API_KEY}`,
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify({ query: testQuery })
+  });
+  
+  let result = await response.json();
+  console.log('Auth result:', JSON.stringify(result, null, 2));
+  
+  // Get workflow states
+  console.log('\n2. Fetching workflow states:');
+  const statesQuery = `
+    query GetStates {
+      workflowStates {
+        nodes {
+          id
+          name
+          type
+          team {
+            id
+            key
+          }
+        }
+      }
+    }
+  `;
+  
+  response = await fetch('https://api.linear.app/graphql', {
+    method: 'POST',
+    headers: {
+      'Authorization': `Bearer ${API_KEY}`,
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify({ query: statesQuery })
+  });
+  
+  result = await response.json();
+  console.log('States:', JSON.stringify(result.data?.workflowStates?.nodes || [], null, 2));
+  
+  // Try to get a specific task
+  console.log('\n3. Fetching specific task STA-279:');
+  const taskQuery = `
+    query GetIssue {
+      issue(id: "STA-279") {
+        id
+        identifier
+        title
+        state {
+          id
+          name
+          type
+        }
+      }
+    }
+  `;
+  
+  response = await fetch('https://api.linear.app/graphql', {
+    method: 'POST',
+    headers: {
+      'Authorization': `Bearer ${API_KEY}`,
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify({ query: taskQuery })
+  });
+  
+  result = await response.json();
+  console.log('Task result:', JSON.stringify(result, null, 2));
+  
+  // If task exists, try to update it
+  if (result.data?.issue) {
+    const task = result.data.issue;
+    console.log('\n4. Attempting to update task:', task.identifier);
+    
+    // Find Done state for the same team
+    const statesResponse = await fetch('https://api.linear.app/graphql', {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${API_KEY}`,
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify({ query: statesQuery })
+    });
+    
+    const statesResult = await statesResponse.json();
+    const doneState = statesResult.data?.workflowStates?.nodes?.find(s => 
+      s.type === 'completed' && s.team?.key === 'STA'
+    );
+    
+    if (!doneState) {
+      console.log('❌ Could not find Done state for STA team');
+      return;
+    }
+    
+    console.log('Found Done state:', doneState.id, doneState.name);
+    
+    const updateMutation = `
+      mutation UpdateIssue($issueId: String!, $stateId: String!) {
+        issueUpdate(
+          id: $issueId,
+          input: { 
+            stateId: $stateId
+          }
+        ) {
+          success
+          issue {
+            identifier
+            state {
+              name
+            }
+          }
+        }
+      }
+    `;
+    
+    const updateResponse = await fetch('https://api.linear.app/graphql', {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${API_KEY}`,
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify({ 
+        query: updateMutation,
+        variables: {
+          issueId: task.id,
+          stateId: doneState.id
+        }
+      })
+    });
+    
+    const updateResult = await updateResponse.json();
+    console.log('\nUpdate result:', JSON.stringify(updateResult, null, 2));
+    
+    if (updateResult.errors) {
+      console.log('\n❌ Update failed with errors:', updateResult.errors);
+    } else if (updateResult.data?.issueUpdate?.success) {
+      console.log('\n✅ Update successful!');
+    }
+  }
+}
+
+// Run
+debugLinearUpdate().catch(console.error);

package/scripts/delete-linear-tasks.js

@@ -0,0 +1,167 @@
+#!/usr/bin/env node
+
+/**
+ * Delete duplicate and low-value tasks from Linear to free up capacity
+ */
+
+import 'dotenv/config';
+import fs from 'fs';
+import readline from 'readline';
+
+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);
+}
+const DELAY_BETWEEN_DELETES = 2000; // 2 seconds to avoid rate limits
+
+const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+
+async function deleteLinearTasks() {
+  try {
+    // Load deletion list
+    const deleteFile = `linear-deletion-list-${new Date().toISOString().split('T')[0]}.json`;
+    if (!fs.existsSync(deleteFile)) {
+      console.error(`❌ Deletion list not found: ${deleteFile}`);
+      console.log('Run analyze-linear-duplicates.js first to generate the list.');
+      process.exit(1);
+    }
+    
+    const deleteList = JSON.parse(fs.readFileSync(deleteFile, 'utf8'));
+    console.log('📋 Deletion Summary:');
+    console.log(`  Total tasks in workspace: ${deleteList.summary.total}`);
+    console.log(`  Tasks to delete: ${deleteList.summary.toDelete}`);
+    console.log(`  Tasks remaining after: ${deleteList.summary.remaining}\n`);
+    
+    // Show categories
+    console.log('📝 Tasks to delete by category:');
+    Object.entries(deleteList.categories).forEach(([category, tasks]) => {
+      if (tasks.length > 0) {
+        console.log(`  • ${category}: ${tasks.length} tasks`);
+      }
+    });
+    
+    // Confirm deletion
+    console.log('\n⚠️  WARNING: This will permanently delete these tasks from Linear!');
+    console.log('Type "DELETE" to confirm, or press Ctrl+C to cancel:\n');
+    
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    
+    const confirmation = await new Promise(resolve => {
+      rl.question('Confirmation: ', resolve);
+    });
+    rl.close();
+    
+    if (confirmation !== 'DELETE') {
+      console.log('❌ Deletion cancelled');
+      process.exit(0);
+    }
+    
+    console.log('\n🗑️  Starting deletion process...\n');
+    
+    let deleted = 0;
+    let failed = 0;
+    const results = [];
+    
+    // Process tasks in batches
+    for (const task of deleteList.tasks) {
+      try {
+        console.log(`Deleting ${task.identifier}: ${task.title.substring(0, 50)}...`);
+        
+        const deleteQuery = `
+          mutation DeleteIssue($id: String!) {
+            issueDelete(id: $id) {
+              success
+            }
+          }
+        `;
+        
+        const response = await fetch('https://api.linear.app/graphql', {
+          method: 'POST',
+          headers: {
+            'Authorization': API_KEY,
+            'Content-Type': 'application/json'
+          },
+          body: JSON.stringify({
+            query: deleteQuery,
+            variables: { id: task.id }
+          })
+        });
+        
+        const result = await response.json();
+        
+        if (result.data?.issueDelete?.success) {
+          console.log(`  ✅ Deleted ${task.identifier}`);
+          deleted++;
+          results.push({ ...task, deleted: true });
+        } else if (result.errors?.[0]?.message?.includes('not found')) {
+          console.log(`  ⚠️  ${task.identifier} already deleted or not found`);
+          deleted++; // Count as successful since it's gone
+          results.push({ ...task, deleted: true, note: 'Already deleted' });
+        } else {
+          throw new Error(result.errors?.[0]?.message || 'Unknown error');
+        }
+        
+        // Delay to avoid rate limits
+        if (deleted < deleteList.tasks.length) {
+          await delay(DELAY_BETWEEN_DELETES);
+        }
+        
+        // Show progress every 10 tasks
+        if (deleted % 10 === 0) {
+          console.log(`\n📊 Progress: ${deleted}/${deleteList.tasks.length} deleted\n`);
+        }
+        
+      } catch (error) {
+        console.log(`  ❌ Failed to delete ${task.identifier}: ${error.message}`);
+        failed++;
+        results.push({ ...task, deleted: false, error: error.message });
+        
+        // If rate limited, wait longer
+        if (error.message?.includes('rate limit') || error.message?.includes('usage limit')) {
+          console.log('⏳ Hit rate limit. Waiting 30 seconds...');
+          await delay(30000);
+        }
+      }
+    }
+    
+    // Save results
+    const resultsFile = `linear-deletion-results-${new Date().toISOString().split('T')[0]}.json`;
+    fs.writeFileSync(resultsFile, JSON.stringify({
+      summary: { deleted, failed, total: deleteList.tasks.length },
+      results,
+      timestamp: new Date().toISOString()
+    }, null, 2));
+    
+    // Final summary
+    console.log('\n' + '='.repeat(60));
+    console.log('📊 DELETION COMPLETE');
+    console.log('='.repeat(60));
+    console.log(`✅ Successfully deleted: ${deleted} tasks`);
+    console.log(`❌ Failed: ${failed} tasks`);
+    console.log(`📈 Success rate: ${Math.round((deleted / deleteList.tasks.length) * 100)}%`);
+    console.log(`💾 Results saved to: ${resultsFile}\n`);
+    
+    if (deleted > 0) {
+      console.log('🎉 Workspace capacity freed! You can now add the new phase tasks.');
+      console.log('\nNext steps:');
+      console.log('1. Run: node scripts/add-phase-tasks-to-linear.js');
+      console.log('2. Start implementing Phase 2 high-priority tasks');
+    }
+    
+  } catch (error) {
+    console.error('💥 Script failed:', error.message);
+    process.exit(1);
+  }
+}
+
+// Run if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  deleteLinearTasks().catch(console.error);
+}
+
+export { deleteLinearTasks };