@stackmemoryai/stackmemory 0.3.17 → 0.3.19

package/scripts/hooks/cleanup-shell.sh

@@ -0,0 +1,130 @@
+#!/bin/bash
+
+# Script to clean up and consolidate StackMemory shell configurations
+
+echo "🧹 Cleaning up shell configurations..."
+
+# Backup files first
+for file in ~/.zshrc ~/.bash_profile ~/.bashrc; do
+    if [ -f "$file" ]; then
+        cp "$file" "$file.backup.$(date +%Y%m%d_%H%M%S)"
+        echo "✓ Backed up $file"
+    fi
+done
+
+# Create a consolidated StackMemory configuration
+cat > ~/.stackmemory/shell-integration-consolidated.sh << 'EOF'
+#!/bin/bash
+# Consolidated StackMemory Shell Integration
+
+# Auto-start StackMemory services if available
+if command -v stackmemory &> /dev/null; then
+    # Review recent context on shell start (silent)
+    ~/.stackmemory/bin/sm-review recent 1 2>/dev/null || true
+    
+    # Start daemon if not running
+    if ! pgrep -f "stackmemory-daemon" > /dev/null; then
+        ~/.stackmemory/bin/stackmemory-daemon start --port 9877 2>/dev/null &
+    fi
+    
+    # Configure monitor interval
+    ~/.stackmemory/bin/stackmemory-monitor config interval 15 2>/dev/null || true
+fi
+
+# Auto-detection on directory/git changes
+if command -v stackmemory &> /dev/null; then
+    function __stackmemory_auto() {
+        stackmemory auto --check 2>/dev/null &
+    }
+    
+    # Override cd to trigger auto-detection
+    function cd() {
+        builtin cd "$@" && __stackmemory_auto
+    }
+    
+    # Override git for branch operations
+    function git() {
+        command git "$@"
+        [[ "$1" =~ ^(clone|checkout|switch|merge|pull)$ ]] && __stackmemory_auto
+    }
+fi
+
+# Claude Code + StackMemory integration function
+claude_code_with_sm() {
+    local original_dir=$(pwd)
+    claude-code "$@"
+    local exit_code=$?
+    
+    # If still in a StackMemory project, save context
+    if [ -d ".stackmemory" ]; then
+        echo "📝 Saving StackMemory context..."
+        stackmemory status 2>/dev/null
+        [ -n "$LINEAR_API_KEY" ] && stackmemory linear sync 2>/dev/null
+    fi
+    
+    return $exit_code
+}
+
+# Task completion hook
+task_complete() {
+    ~/Dev/stackmemory/scripts/task-complete-hook.sh complete "$@"
+}
+
+# Linear task check
+check_tasks() {
+    ~/Dev/stackmemory/scripts/task-complete-hook.sh check
+}
+EOF
+
+chmod +x ~/.stackmemory/shell-integration-consolidated.sh
+
+echo "✅ Created consolidated shell integration file"
+echo ""
+echo "To complete cleanup:"
+echo "1. Remove duplicate StackMemory entries from ~/.zshrc and ~/.bash_profile"
+echo "2. Keep only: source ~/.stackmemory/shell-integration-consolidated.sh"
+echo "3. Keep the claude-sm alias"
+echo ""
+echo "Would you like me to do this automatically? (y/n)"
+read -p "> " response
+
+if [[ "$response" == "y" || "$response" == "Y" ]]; then
+    # Clean up ~/.zshrc
+    if [ -f ~/.zshrc ]; then
+        # Remove duplicate StackMemory blocks, keeping only essential ones
+        sed -i '' '/# StackMemory Auto-Start for Claude Code/,/^fi$/d' ~/.zshrc
+        sed -i '' '/# StackMemory Auto-Detection/,/^fi$/d' ~/.zshrc
+        sed -i '' '/# Auto-start StackMemory when Claude Code is detected/d' ~/.zshrc
+        sed -i '' '/source ~\/.stackmemory\/auto-start.sh/d' ~/.zshrc
+        
+        # Ensure we have the consolidated integration
+        if ! grep -q "shell-integration-consolidated.sh" ~/.zshrc; then
+            sed -i '' 's|source ~/.stackmemory/shell-integration.sh|source ~/.stackmemory/shell-integration-consolidated.sh|' ~/.zshrc
+        fi
+        
+        echo "✓ Cleaned up ~/.zshrc"
+    fi
+    
+    # Clean up ~/.bash_profile
+    if [ -f ~/.bash_profile ]; then
+        # Remove duplicate StackMemory blocks
+        sed -i '' '/# StackMemory Auto-Start/,/^fi$/d' ~/.bash_profile
+        sed -i '' '/# StackMemory Auto-Detection/,/^fi$/d' ~/.bash_profile
+        
+        # Add consolidated integration if not present
+        if ! grep -q "stackmemory/shell-integration" ~/.bash_profile; then
+            echo "" >> ~/.bash_profile
+            echo "# StackMemory integration" >> ~/.bash_profile
+            echo "source ~/.stackmemory/shell-integration-consolidated.sh" >> ~/.bash_profile
+        fi
+        
+        echo "✓ Cleaned up ~/.bash_profile"
+    fi
+    
+    echo ""
+    echo "🎉 Cleanup complete! Please restart your terminal or run:"
+    echo "   source ~/.zshrc  (for zsh)"
+    echo "   source ~/.bash_profile  (for bash)"
+else
+    echo "Manual cleanup required. Please edit your shell configs."
+fi

package/scripts/hooks/task-complete.sh

@@ -0,0 +1,114 @@
+#!/bin/bash
+
+# Task Completion Hook for StackMemory
+# Integrates with Linear to prompt for next task when current task is completed
+
+# Colors for output
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Function to check Linear tasks
+check_linear_tasks() {
+    if [ -n "$LINEAR_API_KEY" ]; then
+        echo -e "${BLUE}📋 Checking Linear tasks...${NC}"
+        
+        # Run Linear sync to get latest tasks
+        stackmemory linear sync 2>/dev/null || true
+        
+        # Get current task status
+        local status=$(stackmemory linear status 2>/dev/null)
+        
+        if [ -n "$status" ]; then
+            echo -e "${GREEN}Current Linear Status:${NC}"
+            echo "$status"
+            echo ""
+        fi
+        
+        # Get available tasks
+        echo -e "${YELLOW}Available Linear tasks:${NC}"
+        stackmemory linear list --state "todo,in_progress" 2>/dev/null || echo "No tasks found"
+        
+        echo ""
+        echo -e "${BLUE}What would you like to work on next?${NC}"
+        echo "Options:"
+        echo "  1) Pick a Linear task (enter task ID)"
+        echo "  2) Continue with local tasks"
+        echo "  3) Review recent context"
+        echo "  4) Exit"
+        
+        read -p "Choice (1-4 or task ID): " choice
+        
+        case $choice in
+            1)
+                read -p "Enter Linear task ID: " task_id
+                echo "Starting work on Linear task: $task_id"
+                stackmemory linear start "$task_id" 2>/dev/null || true
+                ;;
+            2)
+                echo "Continuing with local tasks..."
+                ;;
+            3)
+                echo -e "${BLUE}Recent context:${NC}"
+                stackmemory review recent 5
+                ;;
+            4)
+                echo "Exiting..."
+                exit 0
+                ;;
+            *)
+                # Assume it's a task ID
+                if [[ $choice =~ ^[A-Z]+-[0-9]+$ ]]; then
+                    echo "Starting work on Linear task: $choice"
+                    stackmemory linear start "$choice" 2>/dev/null || true
+                fi
+                ;;
+        esac
+    else
+        echo -e "${YELLOW}Linear API key not configured. Skipping Linear integration.${NC}"
+    fi
+}
+
+# Function to save completion context
+save_completion_context() {
+    local task_name="$1"
+    local completion_notes="$2"
+    
+    echo -e "${GREEN}✅ Task completed: $task_name${NC}"
+    
+    # Save to StackMemory
+    if command -v stackmemory &> /dev/null; then
+        stackmemory save-context "Task completed: $task_name. $completion_notes" --type "completion"
+        stackmemory review snapshot
+    fi
+}
+
+# Main execution
+main() {
+    # Check if we're in a StackMemory-enabled project
+    if [ ! -d ".stackmemory" ]; then
+        echo "Not in a StackMemory project. Initialize with: stackmemory init"
+        exit 1
+    fi
+    
+    # Parse arguments
+    case "$1" in
+        complete)
+            shift
+            save_completion_context "$@"
+            check_linear_tasks
+            ;;
+        check)
+            check_linear_tasks
+            ;;
+        *)
+            echo "Usage: $0 {complete <task_name> [notes]|check}"
+            echo "  complete - Mark a task as complete and check for next tasks"
+            echo "  check    - Check Linear for available tasks"
+            exit 1
+            ;;
+    esac
+}
+
+main "$@"

package/scripts/initialize.ts

@@ -0,0 +1,129 @@
+#!/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';
+// 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 mcpConfigPath = join(
+  process.env['HOME'] || '~',
+  '.config',
+  'claude',
+  'mcp.json'
+);
+console.log(chalk.blue('\n📝 MCP Configuration for Claude Code:\n'));
+
+const mcpConfig = {
+  mcpServers: {
+    stackmemory: {
+      command: 'node',
+      args: [join(projectRoot, 'dist', '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');
+}
+
+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!'));
+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\n');

package/scripts/install-claude-hooks-auto.js

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+
+/**
+ * Auto-install Claude hooks during npm install
+ * This runs as a postinstall script to set up tracing hooks
+ */
+
+import { existsSync, mkdirSync, copyFileSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const claudeHooksDir = join(homedir(), '.claude', 'hooks');
+const claudeConfigFile = join(homedir(), '.claude', 'hooks.json');
+const templatesDir = join(__dirname, '..', 'templates', 'claude-hooks');
+
+async function installClaudeHooks() {
+  try {
+    // Create Claude hooks directory if it doesn't exist
+    if (!existsSync(claudeHooksDir)) {
+      mkdirSync(claudeHooksDir, { recursive: true });
+      console.log('📁 Created Claude hooks directory');
+    }
+
+    // Copy hook files
+    const hookFiles = ['tool-use-trace.js', 'on-startup.js', 'on-clear.js'];
+    let installed = 0;
+
+    for (const hookFile of hookFiles) {
+      const srcPath = join(templatesDir, hookFile);
+      const destPath = join(claudeHooksDir, hookFile);
+      
+      if (existsSync(srcPath)) {
+        // Backup existing hook if it exists
+        if (existsSync(destPath)) {
+          const backupPath = `${destPath}.backup-${Date.now()}`;
+          copyFileSync(destPath, backupPath);
+          console.log(`📋 Backed up existing hook: ${hookFile}`);
+        }
+        
+        copyFileSync(srcPath, destPath);
+        
+        // Make executable
+        try {
+          const { execSync } = await import('child_process');
+          execSync(`chmod +x "${destPath}"`, { stdio: 'ignore' });
+        } catch {
+          // Silent fail on chmod
+        }
+        
+        installed++;
+        console.log(`✅ Installed hook: ${hookFile}`);
+      }
+    }
+
+    // Update hooks.json configuration
+    let hooksConfig = {};
+    if (existsSync(claudeConfigFile)) {
+      try {
+        hooksConfig = JSON.parse(readFileSync(claudeConfigFile, 'utf8'));
+        console.log('📋 Loaded existing hooks.json');
+      } catch (err) {
+        console.log('⚠️  Could not parse existing hooks.json, creating new');
+      }
+    }
+
+    // Add our hooks (don't overwrite existing hooks unless they're ours)
+    const newHooksConfig = {
+      ...hooksConfig,
+      'tool-use-approval': join(claudeHooksDir, 'tool-use-trace.js'),
+      'on-startup': join(claudeHooksDir, 'on-startup.js'),
+      'on-clear': join(claudeHooksDir, 'on-clear.js')
+    };
+
+    writeFileSync(claudeConfigFile, JSON.stringify(newHooksConfig, null, 2));
+    console.log('🔧 Updated hooks.json configuration');
+
+    if (installed > 0) {
+      console.log(`\n🎉 Successfully installed ${installed} Claude hooks for StackMemory tracing!`);
+      console.log('🔍 Tool usage and session data will now be automatically logged');
+      console.log(`📁 Traces saved to: ${join(homedir(), '.stackmemory', 'traces')}`);
+      console.log('\nTo disable tracing, set DEBUG_TRACE=false in your .env file');
+    }
+
+    return true;
+  } catch (error) {
+    console.error('❌ Failed to install Claude hooks:', error.message);
+    console.error('   This is not critical - StackMemory will still work without hooks');
+    return false;
+  }
+}
+
+// Only run if called directly (not imported)
+if (import.meta.url === `file://${process.argv[1]}`) {
+  console.log('🔧 Installing StackMemory Claude Code integration hooks...\n');
+  await installClaudeHooks();
+}
+
+export { installClaudeHooks };

package/scripts/install-claude-hooks.sh

@@ -0,0 +1,133 @@
+#!/bin/bash
+# Install Claude-SM pre-commit hooks
+
+set -e
+
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+REPO_ROOT="$(git rev-parse --show-toplevel 2>/dev/null || pwd)"
+HOOKS_DIR="$REPO_ROOT/.git/hooks"
+
+# Colors
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+RED='\033[0;31m'
+NC='\033[0m'
+
+echo -e "${BLUE}🔧 Installing Claude-SM Pre-commit Hooks${NC}"
+
+# Check if in a git repository
+if [ ! -d "$REPO_ROOT/.git" ]; then
+    echo -e "${RED}❌ Not in a git repository${NC}"
+    exit 1
+fi
+
+# Create hooks directory if it doesn't exist
+mkdir -p "$HOOKS_DIR"
+
+# Make the claude-pre-commit.sh executable
+chmod +x "$SCRIPT_DIR/claude-pre-commit.sh"
+
+# Check if pre-commit hook exists
+if [ -f "$HOOKS_DIR/pre-commit" ]; then
+    echo -e "${YELLOW}⚠ Pre-commit hook already exists${NC}"
+    echo "Do you want to:"
+    echo "  1) Replace it with Claude-SM hook"
+    echo "  2) Add Claude-SM to existing hook"
+    echo "  3) Cancel installation"
+    read -p "Choice [1-3]: " choice
+    
+    case $choice in
+        1)
+            mv "$HOOKS_DIR/pre-commit" "$HOOKS_DIR/pre-commit.backup.$(date +%s)"
+            echo -e "${GREEN}✓ Backed up existing hook${NC}"
+            ;;
+        2)
+            mv "$HOOKS_DIR/pre-commit" "$HOOKS_DIR/pre-commit.original"
+            ;;
+        3)
+            echo -e "${YELLOW}Installation cancelled${NC}"
+            exit 0
+            ;;
+        *)
+            echo -e "${RED}Invalid choice${NC}"
+            exit 1
+            ;;
+    esac
+fi
+
+# Create the pre-commit hook
+cat > "$HOOKS_DIR/pre-commit" << 'EOF'
+#!/bin/bash
+# Git pre-commit hook with Claude-SM integration
+
+# Run original hook if it exists (for option 2)
+if [ -f .git/hooks/pre-commit.original ]; then
+    .git/hooks/pre-commit.original
+    if [ $? -ne 0 ]; then
+        exit 1
+    fi
+fi
+
+# Get the directory of this script
+HOOKS_DIR="$(dirname "$0")"
+REPO_ROOT="$(git rev-parse --show-toplevel)"
+
+# Run Claude-SM pre-commit
+if [ -f "$REPO_ROOT/scripts/claude-pre-commit.sh" ]; then
+    "$REPO_ROOT/scripts/claude-pre-commit.sh"
+else
+    echo "⚠ Claude-SM pre-commit script not found"
+fi
+EOF
+
+chmod +x "$HOOKS_DIR/pre-commit"
+
+# Create configuration file
+cat > "$REPO_ROOT/.claude-precommit" << 'EOF'
+# Claude-SM Pre-commit Configuration
+# Edit these settings to customize behavior
+
+# Enable/disable features
+CLAUDE_REVIEW_ENABLED=true      # Code review for security/bugs
+CLAUDE_REFACTOR_ENABLED=true    # Refactoring suggestions
+CLAUDE_TEST_ENABLED=true        # Edge case test generation
+CLAUDE_AUTO_FIX=false           # Auto-apply fixes (dangerous!)
+
+# Size limits
+MAX_FILE_SIZE=100000            # Max size per file (100KB)
+MAX_TOTAL_SIZE=500000           # Max total size (500KB)
+
+# Claude CLI settings
+CLAUDE_MODEL=claude-3-opus      # Model to use
+CLAUDE_MAX_TOKENS=4000          # Max tokens per request
+
+# File patterns to check (regex)
+INCLUDE_PATTERNS='\\.(js|ts|jsx|tsx|py|go|rs|java)$'
+EXCLUDE_PATTERNS='(node_modules|dist|build|vendor)/'
+
+# Severity thresholds
+BLOCK_ON_CRITICAL=true          # Block commit on critical issues
+WARN_ON_MEDIUM=true             # Show warnings for medium issues
+SUGGEST_IMPROVEMENTS=true        # Show improvement suggestions
+
+# StackMemory integration
+USE_STACKMEMORY=true            # Use SM for context
+SAVE_REVIEW_HISTORY=true        # Save reviews to SM
+EOF
+
+echo -e "${GREEN}✅ Claude-SM pre-commit hooks installed successfully!${NC}"
+echo ""
+echo "Configuration file created at: .claude-precommit"
+echo ""
+echo "To test the hook, try committing some code:"
+echo "  git add <file>"
+echo "  git commit -m 'test'"
+echo ""
+echo "To skip the hook for a commit:"
+echo "  git commit --no-verify -m 'emergency fix'"
+echo ""
+echo "Environment variables you can set:"
+echo "  CLAUDE_AUTO_FIX=true         # Auto-apply suggested fixes"
+echo "  CLAUDE_REVIEW_ENABLED=false  # Skip code review"
+echo "  CLAUDE_TEST_ENABLED=false    # Skip test generation"