@stackmemoryai/stackmemory 0.3.17 → 0.3.18

package/scripts/archive/delete-sta-oauth.js

@@ -0,0 +1,201 @@
+#!/usr/bin/env node
+
+/**
+ * Delete duplicate STA tasks from Linear using OAuth token
+ */
+
+import 'dotenv/config';
+import fs from 'fs';
+import readline from 'readline';
+
+// Load OAuth token from environment
+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);
+}
+const BATCH_SIZE = 10;
+const DELAY_BETWEEN_BATCHES = 3000;
+
+const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+
+async function deleteSTATasks() {
+  try {
+    // Load deletion list
+    const deleteFile = `sta-deletion-list-${new Date().toISOString().split('T')[0]}.json`;
+    if (!fs.existsSync(deleteFile)) {
+      console.error(`❌ Deletion list not found: ${deleteFile}`);
+      console.log('Run analyze-sta-graphql.js first to generate the list.');
+      process.exit(1);
+    }
+    
+    const deleteList = JSON.parse(fs.readFileSync(deleteFile, 'utf8'));
+    
+    console.log('📋 STA TASK DELETION SUMMARY (Using OAuth Token)');
+    console.log('=' .repeat(60));
+    console.log(`\n  Total workspace tasks: ${deleteList.summary.totalWorkspace}`);
+    console.log(`  Current STA tasks: ${deleteList.summary.totalSTA}`);
+    console.log(`  Tasks to delete: ${deleteList.summary.toDelete}`);
+    console.log(`  Workspace after deletion: ${deleteList.summary.remainingTotal}`);
+    console.log(`\n  🎯 Capacity to be freed: ${deleteList.summary.capacityFreed} task slots\n`);
+    
+    // Show breakdown
+    console.log('📝 Tasks to delete by category:');
+    Object.entries(deleteList.categories).forEach(([category, tasks]) => {
+      if (tasks.length > 0) {
+        console.log(`  • ${category}: ${tasks.length} tasks`);
+      }
+    });
+    
+    // Safety confirmation
+    console.log('\n⚠️  WARNING: This will permanently delete ' + deleteList.summary.toDelete + ' tasks from Linear!');
+    console.log('This action cannot be undone. Make sure you have reviewed the list.\n');
+    console.log('Type "DELETE STA TASKS" 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 STA TASKS') {
+      console.log('❌ Deletion cancelled');
+      process.exit(0);
+    }
+    
+    console.log('\n🗑️  Starting deletion process with OAuth token...');
+    console.log(`Will delete in batches of ${BATCH_SIZE} with ${DELAY_BETWEEN_BATCHES/1000}s delay\n`);
+    
+    let deleted = 0;
+    let failed = 0;
+    let alreadyDeleted = 0;
+    const results = [];
+    const errors = [];
+    
+    // Process in batches
+    for (let i = 0; i < deleteList.tasks.length; i += BATCH_SIZE) {
+      const batch = deleteList.tasks.slice(i, i + BATCH_SIZE);
+      console.log(`\n📦 Batch ${Math.floor(i/BATCH_SIZE) + 1}/${Math.ceil(deleteList.tasks.length/BATCH_SIZE)}`);
+      
+      for (const task of batch) {
+        try {
+          process.stdout.write(`  Deleting ${task.identifier}: ${task.title.substring(0, 40)}... `);
+          
+          const deleteQuery = `
+            mutation DeleteIssue($id: String!) {
+              issueDelete(id: $id) {
+                success
+              }
+            }
+          `;
+          
+          const response = await fetch('https://api.linear.app/graphql', {
+            method: 'POST',
+            headers: {
+              'Authorization': `Bearer ${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++;
+            results.push({ ...task, status: 'deleted' });
+          } else if (result.errors?.[0]?.message?.includes('not found')) {
+            console.log('⚠️  (already gone)');
+            alreadyDeleted++;
+            results.push({ ...task, status: 'already_deleted' });
+          } else {
+            const error = result.errors?.[0]?.message || 'Unknown error';
+            console.log(`❌ (${error})`);
+            failed++;
+            errors.push({ ...task, error });
+            results.push({ ...task, status: 'failed', error });
+          }
+          
+        } catch (error) {
+          console.log(`❌ (${error.message})`);
+          failed++;
+          errors.push({ ...task, error: error.message });
+          results.push({ ...task, status: 'error', error: error.message });
+          
+          // If rate limited, wait longer
+          if (error.message?.includes('rate') || error.message?.includes('429')) {
+            console.log('⏳ Rate limited. Waiting 30 seconds...');
+            await delay(30000);
+          }
+        }
+      }
+      
+      // Progress update
+      const total = deleted + alreadyDeleted + failed;
+      const percent = Math.round((total / deleteList.tasks.length) * 100);
+      console.log(`\n📊 Progress: ${total}/${deleteList.tasks.length} (${percent}%)`);
+      console.log(`   ✅ Deleted: ${deleted} | ⚠️  Already gone: ${alreadyDeleted} | ❌ Failed: ${failed}`);
+      
+      // Delay before next batch
+      if (i + BATCH_SIZE < deleteList.tasks.length) {
+        console.log(`⏳ Waiting ${DELAY_BETWEEN_BATCHES/1000}s before next batch...`);
+        await delay(DELAY_BETWEEN_BATCHES);
+      }
+    }
+    
+    // Save results
+    const resultsFile = `sta-deletion-results-oauth-${new Date().toISOString().split('T')[0]}.json`;
+    fs.writeFileSync(resultsFile, JSON.stringify({
+      summary: { 
+        attempted: deleteList.tasks.length,
+        deleted, 
+        alreadyDeleted,
+        failed, 
+        success_rate: Math.round(((deleted + alreadyDeleted) / deleteList.tasks.length) * 100) 
+      },
+      results,
+      errors: errors.length > 0 ? errors : undefined,
+      timestamp: new Date().toISOString()
+    }, null, 2));
+    
+    // Final report
+    console.log('\n' + '='.repeat(60));
+    console.log('📊 DELETION COMPLETE');
+    console.log('='.repeat(60));
+    console.log(`\n✅ Successfully deleted: ${deleted} tasks`);
+    console.log(`⚠️  Already deleted: ${alreadyDeleted} tasks`);
+    console.log(`❌ Failed: ${failed} tasks`);
+    console.log(`📈 Success rate: ${Math.round(((deleted + alreadyDeleted) / deleteList.tasks.length) * 100)}%`);
+    console.log(`\n💾 Results saved to: ${resultsFile}`);
+    
+    const totalFreed = deleted + alreadyDeleted;
+    if (totalFreed > 0) {
+      console.log(`\n🎉 Freed up ${totalFreed} task slots in your Linear workspace!`);
+      console.log('\nYour workspace now has capacity for new tasks.');
+      console.log('The backlog has been cleaned of duplicates and similar tasks.');
+    }
+    
+    if (failed > 0) {
+      console.log(`\n⚠️  ${failed} tasks could not be deleted. Check ${resultsFile} for details.`);
+    }
+    
+  } catch (error) {
+    console.error('\n💥 Script failed:', error.message);
+    process.exit(1);
+  }
+}
+
+// Run if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  deleteSTATasks().catch(console.error);
+}
+
+export { deleteSTATasks };

package/scripts/archive/export-sta-tasks.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+
+/**
+ * Export STA- tasks to JSON for manual import
+ */
+
+import { LinearRestClient } from '../dist/integrations/linear/rest-client.js';
+import fs from 'fs';
+
+async function exportSTATasks() {
+  try {
+    console.log('🔄 Exporting STA- tasks...');
+    
+    const client = new LinearRestClient(process.env.LINEAR_API_KEY);
+    const allTasks = await client.getAllTasks(true);
+    
+    // Filter STA- tasks
+    const staTasks = allTasks.filter(task => task.identifier.startsWith('STA-'));
+    
+    // Export data
+    const exportData = {
+      exported: new Date().toISOString(),
+      source: 'LiftCL-Stackmemoryai',
+      taskCount: staTasks.length,
+      tasks: staTasks.map(task => ({
+        identifier: task.identifier,
+        title: task.title,
+        description: task.description || '',
+        state: task.state.name,
+        priority: task.priority || 0,
+        assignee: task.assignee?.name || null,
+        estimate: task.estimate || null,
+        createdAt: task.createdAt,
+        updatedAt: task.updatedAt,
+        url: task.url
+      }))
+    };
+    
+    // Write to file
+    const filename = `sta-tasks-export-${new Date().toISOString().split('T')[0]}.json`;
+    fs.writeFileSync(filename, JSON.stringify(exportData, null, 2));
+    
+    console.log(`✅ Exported ${staTasks.length} STA- tasks to ${filename}`);
+    console.log('📋 Summary by state:');
+    
+    const stateCounts = {};
+    staTasks.forEach(task => {
+      const state = task.state.type;
+      stateCounts[state] = (stateCounts[state] || 0) + 1;
+    });
+    
+    Object.entries(stateCounts).forEach(([state, count]) => {
+      console.log(`  ${state}: ${count}`);
+    });
+    
+  } catch (error) {
+    console.error('❌ Export failed:', error.message);
+    process.exit(1);
+  }
+}
+
+exportSTATasks();

package/scripts/archive/install-auto-sync.js

@@ -0,0 +1,266 @@
+#!/usr/bin/env node
+/**
+ * Install StackMemory Linear Auto-Sync as a system service
+ */
+
+import { execSync } from 'child_process';
+import { writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import os from 'os';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const projectRoot = join(__dirname, '..');
+
+function detectPlatform() {
+  const platform = os.platform();
+  if (platform === 'darwin') return 'macos';
+  if (platform === 'linux') return 'linux';
+  if (platform === 'win32') return 'windows';
+  throw new Error(`Unsupported platform: ${platform}`);
+}
+
+function installMacOS() {
+  const homeDir = os.homedir();
+  const launchAgentDir = join(homeDir, 'Library', 'LaunchAgents');
+
+  if (!existsSync(launchAgentDir)) {
+    mkdirSync(launchAgentDir, { recursive: true });
+  }
+
+  const plistPath = join(launchAgentDir, 'ai.stackmemory.linear-sync.plist');
+  const stackmemoryBin = join(projectRoot, 'dist', 'src', 'cli', 'cli.js');
+
+  const plistContent = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>ai.stackmemory.linear-sync</string>
+  
+  <key>ProgramArguments</key>
+  <array>
+    <string>node</string>
+    <string>${stackmemoryBin}</string>
+    <string>linear</string>
+    <string>auto-sync</string>
+    <string>--start</string>
+    <string>--interval</string>
+    <string>5</string>
+  </array>
+  
+  <key>WorkingDirectory</key>
+  <string>${homeDir}</string>
+  
+  <key>StandardOutPath</key>
+  <string>${homeDir}/.stackmemory/logs/linear-sync.log</string>
+  
+  <key>StandardErrorPath</key>
+  <string>${homeDir}/.stackmemory/logs/linear-sync-error.log</string>
+  
+  <key>RunAtLoad</key>
+  <true/>
+  
+  <key>KeepAlive</key>
+  <dict>
+    <key>SuccessfulExit</key>
+    <false/>
+  </dict>
+  
+  <key>StartInterval</key>
+  <integer>300</integer>
+  
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin</string>
+    <key>NODE_ENV</key>
+    <string>production</string>
+  </dict>
+</dict>
+</plist>`;
+
+  writeFileSync(plistPath, plistContent);
+
+  // Create log directory
+  const logDir = join(homeDir, '.stackmemory', 'logs');
+  if (!existsSync(logDir)) {
+    mkdirSync(logDir, { recursive: true });
+  }
+
+  try {
+    execSync(`launchctl load ${plistPath}`);
+    console.log('✅ macOS LaunchAgent installed and started');
+    console.log(`📄 Configuration: ${plistPath}`);
+    console.log(`📝 Logs: ${logDir}/linear-sync.log`);
+    console.log('\n💡 Management commands:');
+    console.log(`   Start:  launchctl load ${plistPath}`);
+    console.log(`   Stop:   launchctl unload ${plistPath}`);
+    console.log(`   Status: launchctl list | grep stackmemory`);
+  } catch (error) {
+    console.error('❌ Failed to load LaunchAgent:', error.message);
+    console.log(`📄 Configuration saved to: ${plistPath}`);
+    console.log('💡 To start manually: launchctl load ${plistPath}');
+  }
+}
+
+function installLinux() {
+  const serviceContent = `[Unit]
+Description=StackMemory Linear Auto-Sync
+After=network.target
+
+[Service]
+Type=simple
+User=${os.userInfo().username}
+WorkingDirectory=${os.homedir()}
+ExecStart=node ${join(projectRoot, 'dist', 'src', 'cli', 'cli.js')} linear auto-sync --start --interval 5
+Restart=always
+RestartSec=10
+StandardOutput=append:${os.homedir()}/.stackmemory/logs/linear-sync.log
+StandardError=append:${os.homedir()}/.stackmemory/logs/linear-sync-error.log
+Environment=NODE_ENV=production
+Environment=PATH=/usr/local/bin:/usr/bin:/bin
+
+[Install]
+WantedBy=default.target`;
+
+  const serviceDir = join(os.homedir(), '.config', 'systemd', 'user');
+  if (!existsSync(serviceDir)) {
+    mkdirSync(serviceDir, { recursive: true });
+  }
+
+  const servicePath = join(serviceDir, 'stackmemory-linear-sync.service');
+  writeFileSync(servicePath, serviceContent);
+
+  // Create log directory
+  const logDir = join(os.homedir(), '.stackmemory', 'logs');
+  if (!existsSync(logDir)) {
+    mkdirSync(logDir, { recursive: true });
+  }
+
+  try {
+    execSync('systemctl --user daemon-reload');
+    execSync('systemctl --user enable stackmemory-linear-sync.service');
+    execSync('systemctl --user start stackmemory-linear-sync.service');
+
+    console.log('✅ Linux systemd service installed and started');
+    console.log(`📄 Configuration: ${servicePath}`);
+    console.log(`📝 Logs: ${logDir}/linear-sync.log`);
+    console.log('\n💡 Management commands:');
+    console.log('   Start:  systemctl --user start stackmemory-linear-sync');
+    console.log('   Stop:   systemctl --user stop stackmemory-linear-sync');
+    console.log('   Status: systemctl --user status stackmemory-linear-sync');
+    console.log('   Logs:   journalctl --user -u stackmemory-linear-sync -f');
+  } catch (error) {
+    console.error('❌ Failed to start systemd service:', error.message);
+    console.log(`📄 Configuration saved to: ${servicePath}`);
+    console.log('💡 To start manually:');
+    console.log('   systemctl --user daemon-reload');
+    console.log('   systemctl --user enable stackmemory-linear-sync');
+    console.log('   systemctl --user start stackmemory-linear-sync');
+  }
+}
+
+function installWindows() {
+  const taskXml = `<?xml version="1.0" encoding="UTF-16"?>
+<Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
+  <RegistrationInfo>
+    <Date>2024-01-01T00:00:00</Date>
+    <Author>StackMemory</Author>
+    <Description>StackMemory Linear Auto-Sync Service</Description>
+  </RegistrationInfo>
+  <Triggers>
+    <CalendarTrigger>
+      <StartBoundary>1999-01-01T00:00:00</StartBoundary>
+      <Enabled>true</Enabled>
+      <ScheduleByDay>
+        <DaysInterval>1</DaysInterval>
+      </ScheduleByDay>
+      <Repetition>
+        <Interval>PT5M</Interval>
+        <StopAtDurationEnd>false</StopAtDurationEnd>
+      </Repetition>
+    </CalendarTrigger>
+  </Triggers>
+  <Settings>
+    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
+    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
+    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>
+    <AllowHardTerminate>true</AllowHardTerminate>
+    <StartWhenAvailable>false</StartWhenAvailable>
+    <RunOnlyIfNetworkAvailable>true</RunOnlyIfNetworkAvailable>
+    <AllowStartOnDemand>true</AllowStartOnDemand>
+    <Enabled>true</Enabled>
+    <Hidden>false</Hidden>
+    <RunOnlyIfIdle>false</RunOnlyIfIdle>
+    <WakeToRun>false</WakeToRun>
+    <ExecutionTimeLimit>PT0S</ExecutionTimeLimit>
+    <Priority>7</Priority>
+  </Settings>
+  <Actions>
+    <Exec>
+      <Command>node</Command>
+      <Arguments>"${join(projectRoot, 'dist', 'src', 'cli', 'cli.js').replace(/\\/g, '\\\\')}" linear auto-sync --start --interval 5</Arguments>
+      <WorkingDirectory>${os.homedir().replace(/\\/g, '\\\\')}</WorkingDirectory>
+    </Exec>
+  </Actions>
+</Task>`;
+
+  const taskFile = join(os.tmpdir(), 'stackmemory-linear-sync.xml');
+  writeFileSync(taskFile, taskXml);
+
+  try {
+    execSync(
+      `schtasks /create /tn "StackMemory Linear Sync" /xml "${taskFile}"`
+    );
+    console.log('✅ Windows Task Scheduler task created');
+    console.log('\n💡 Management commands:');
+    console.log('   Start:  schtasks /run /tn "StackMemory Linear Sync"');
+    console.log('   Stop:   schtasks /end /tn "StackMemory Linear Sync"');
+    console.log('   Status: schtasks /query /tn "StackMemory Linear Sync"');
+    console.log('   Delete: schtasks /delete /tn "StackMemory Linear Sync"');
+  } catch (error) {
+    console.error('❌ Failed to create scheduled task:', error.message);
+    console.log(`📄 Task XML saved to: ${taskFile}`);
+    console.log('💡 Import manually through Task Scheduler');
+  }
+}
+
+function main() {
+  console.log('🔧 Installing StackMemory Linear Auto-Sync Service\n');
+
+  const platform = detectPlatform();
+  console.log(`🖥️  Detected platform: ${platform}`);
+
+  // Check if StackMemory is built
+  const builtCli = join(projectRoot, 'dist', 'src', 'cli', 'cli.js');
+  if (!existsSync(builtCli)) {
+    console.error('❌ StackMemory not built. Run "npm run build" first.');
+    process.exit(1);
+  }
+
+  switch (platform) {
+    case 'macos':
+      installMacOS();
+      break;
+    case 'linux':
+      installLinux();
+      break;
+    case 'windows':
+      installWindows();
+      break;
+    default:
+      throw new Error(`Unsupported platform: ${platform}`);
+  }
+
+  console.log('\n🎉 Installation complete!');
+  console.log('\n📋 Next steps:');
+  console.log('1. Configure Linear integration: stackmemory linear setup');
+  console.log('2. Authorize with Linear: stackmemory linear authorize <code>');
+  console.log('3. Check service status with platform commands above');
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main();
+}

package/scripts/archive/install-chromadb-hooks.sh

@@ -0,0 +1,133 @@
+#!/bin/bash
+
+# Install ChromaDB hooks for Claude
+# This script sets up automatic context saving and loading
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(dirname "$SCRIPT_DIR")"
+CLAUDE_DIR="$PROJECT_ROOT/.claude"
+HOOKS_DIR="$CLAUDE_DIR/hooks"
+LOG_DIR="$HOME/.stackmemory/logs"
+
+echo "🔧 Installing ChromaDB hooks for Claude..."
+
+# Create directories
+mkdir -p "$HOOKS_DIR"
+mkdir -p "$LOG_DIR"
+
+# Make hooks executable
+chmod +x "$HOOKS_DIR"/*.js 2>/dev/null || true
+
+# Check for ChromaDB API key
+if [ -z "$CHROMADB_API_KEY" ]; then
+    echo "⚠️  CHROMADB_API_KEY not found in environment"
+    echo "   Add to .env: CHROMADB_API_KEY=your_key_here"
+else
+    echo "✅ ChromaDB API key found"
+fi
+
+# Test ChromaDB connection
+echo "🔄 Testing ChromaDB connection..."
+if node -e "
+const { ChromaDBAdapter } = require('$PROJECT_ROOT/dist/core/storage/chromadb-adapter.js');
+const adapter = new ChromaDBAdapter({
+  apiKey: process.env.CHROMADB_API_KEY,
+  apiUrl: process.env.CHROMADB_API_URL || 'http://localhost:8000',
+  collectionName: 'claude_context',
+  userId: process.env.USER || 'default'
+});
+adapter.initialize().then(() => {
+  console.log('✅ ChromaDB connection successful');
+  process.exit(0);
+}).catch(err => {
+  console.error('❌ ChromaDB connection failed:', err.message);
+  process.exit(1);
+});
+" 2>/dev/null; then
+    echo "✅ ChromaDB is accessible"
+else
+    echo "⚠️  ChromaDB connection failed - hooks will be installed but may not work"
+fi
+
+# Create a launcher script
+cat > "$PROJECT_ROOT/claude-with-chromadb.sh" << 'EOF'
+#!/bin/bash
+
+# Launch Claude with ChromaDB hooks enabled
+PROJECT_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+# Load environment
+if [ -f "$PROJECT_ROOT/.env" ]; then
+    export $(grep -v '^#' "$PROJECT_ROOT/.env" | xargs)
+fi
+
+# Run startup hook to load context
+echo "Loading context from ChromaDB..."
+node "$PROJECT_ROOT/.claude/hooks/on-startup.js"
+
+# Start periodic save in background
+(
+    while true; do
+        sleep 900  # 15 minutes
+        node "$PROJECT_ROOT/.claude/hooks/periodic-save.js" 2>/dev/null
+    done
+) &
+PERIODIC_PID=$!
+
+# Cleanup function
+cleanup() {
+    echo "Saving final context..."
+    node "$PROJECT_ROOT/.claude/hooks/chromadb-save-hook.js" << JSON
+{
+  "event": "session_end",
+  "data": {
+    "summary": "Claude session ended",
+    "duration": "$SECONDS seconds"
+  }
+}
+JSON
+    kill $PERIODIC_PID 2>/dev/null
+    exit
+}
+
+trap cleanup EXIT INT TERM
+
+echo "✨ Claude with ChromaDB hooks is ready!"
+echo "   - Context loaded from last 24 hours"
+echo "   - Periodic saves every 15 minutes"
+echo "   - Linear task updates enabled"
+echo ""
+echo "Press Ctrl+C to exit and save context"
+
+# Keep running
+wait
+EOF
+
+chmod +x "$PROJECT_ROOT/claude-with-chromadb.sh"
+
+# Summary
+echo ""
+echo "✅ ChromaDB hooks installed successfully!"
+echo ""
+echo "📋 Installed hooks:"
+echo "   - on-startup.js: Loads context on Claude startup"
+echo "   - on-code-change.js: Saves when code is modified"
+echo "   - on-task-complete.js: Saves and updates Linear on task completion"
+echo "   - periodic-save.js: Auto-saves every 15 minutes"
+echo "   - chromadb-save-hook.js: Core context saving logic"
+echo "   - linear-update-hook.js: Auto-updates Linear tasks"
+echo ""
+echo "🚀 To use:"
+echo "   1. Ensure CHROMADB_API_KEY is in .env"
+echo "   2. Run: ./claude-with-chromadb.sh"
+echo "   3. Or hooks will activate automatically in Claude"
+echo ""
+echo "📊 ChromaDB will save context on:"
+echo "   - Session start (loads last 24h)"
+echo "   - Every 15 minutes"
+echo "   - Task completions"
+echo "   - Code changes"
+echo "   - Git commits"
+echo "   - Session end"