@stackmemoryai/stackmemory 0.5.3 → 0.5.5

package/templates/claude-hooks/post-edit-sweep.js

@@ -0,0 +1,437 @@
+#!/usr/bin/env node
+
+/**
+ * Post-Edit Sweep Hook for Claude Code
+ *
+ * Runs Sweep 1.5B predictions after file edits to suggest next changes.
+ * Tracks recent diffs and provides context-aware predictions.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const CONFIG = {
+  enabled: process.env.SWEEP_ENABLED !== 'false',
+  maxRecentDiffs: 5,
+  predictionTimeout: 30000,
+  minEditSize: 10,
+  debounceMs: 2000,
+  minDiffsForPrediction: 2,
+  cooldownMs: 10000,
+  codeExtensions: [
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx',
+    '.py',
+    '.go',
+    '.rs',
+    '.java',
+    '.c',
+    '.cpp',
+    '.h',
+    '.hpp',
+    '.cs',
+    '.rb',
+    '.php',
+    '.swift',
+    '.kt',
+    '.scala',
+    '.vue',
+    '.svelte',
+    '.astro',
+  ],
+  stateFile: path.join(
+    process.env.HOME || '/tmp',
+    '.stackmemory',
+    'sweep-state.json'
+  ),
+  logFile: path.join(
+    process.env.HOME || '/tmp',
+    '.stackmemory',
+    'sweep-predictions.log'
+  ),
+  pythonScript: path.join(
+    process.env.HOME || '/tmp',
+    '.stackmemory',
+    'sweep',
+    'sweep_predict.py'
+  ),
+};
+
+// Fallback locations for sweep_predict.py
+const SCRIPT_LOCATIONS = [
+  CONFIG.pythonScript,
+  path.join(
+    process.cwd(),
+    'packages',
+    'sweep-addon',
+    'python',
+    'sweep_predict.py'
+  ),
+  path.join(
+    process.cwd(),
+    'node_modules',
+    '@stackmemoryai',
+    'sweep-addon',
+    'python',
+    'sweep_predict.py'
+  ),
+];
+
+function findPythonScript() {
+  for (const loc of SCRIPT_LOCATIONS) {
+    if (fs.existsSync(loc)) {
+      return loc;
+    }
+  }
+  return null;
+}
+
+function loadState() {
+  try {
+    if (fs.existsSync(CONFIG.stateFile)) {
+      return JSON.parse(fs.readFileSync(CONFIG.stateFile, 'utf-8'));
+    }
+  } catch {
+    // Ignore errors
+  }
+  return {
+    recentDiffs: [],
+    lastPrediction: null,
+    pendingPrediction: null,
+    fileContents: {},
+  };
+}
+
+function saveState(state) {
+  try {
+    const dir = path.dirname(CONFIG.stateFile);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(CONFIG.stateFile, JSON.stringify(state, null, 2));
+  } catch {
+    // Ignore errors
+  }
+}
+
+function log(message, data = {}) {
+  try {
+    const dir = path.dirname(CONFIG.logFile);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    const entry = {
+      timestamp: new Date().toISOString(),
+      message,
+      ...data,
+    };
+    fs.appendFileSync(CONFIG.logFile, JSON.stringify(entry) + '\n');
+  } catch {
+    // Ignore
+  }
+}
+
+async function runPrediction(filePath, currentContent, recentDiffs) {
+  const scriptPath = findPythonScript();
+  if (!scriptPath) {
+    log('Sweep script not found');
+    return null;
+  }
+
+  const input = {
+    file_path: filePath,
+    current_content: currentContent,
+    recent_diffs: recentDiffs,
+  };
+
+  return new Promise((resolve) => {
+    const proc = spawn('python3', [scriptPath], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: CONFIG.predictionTimeout,
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    proc.stdout.on('data', (data) => (stdout += data));
+    proc.stderr.on('data', (data) => (stderr += data));
+
+    const timeout = setTimeout(() => {
+      proc.kill();
+      resolve(null);
+    }, CONFIG.predictionTimeout);
+
+    proc.on('close', (code) => {
+      clearTimeout(timeout);
+      try {
+        if (stdout.trim()) {
+          const result = JSON.parse(stdout.trim());
+          resolve(result);
+        } else {
+          resolve(null);
+        }
+      } catch {
+        resolve(null);
+      }
+    });
+
+    proc.on('error', () => {
+      clearTimeout(timeout);
+      resolve(null);
+    });
+
+    proc.stdin.write(JSON.stringify(input));
+    proc.stdin.end();
+  });
+}
+
+async function readInput() {
+  let input = '';
+  for await (const chunk of process.stdin) {
+    input += chunk;
+  }
+  return JSON.parse(input);
+}
+
+function isCodeFile(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  return CONFIG.codeExtensions.includes(ext);
+}
+
+function shouldRunPrediction(state, filePath) {
+  if (state.recentDiffs.length < CONFIG.minDiffsForPrediction) {
+    return false;
+  }
+
+  if (state.lastPrediction) {
+    const timeSince = Date.now() - state.lastPrediction.timestamp;
+    if (timeSince < CONFIG.cooldownMs) {
+      return false;
+    }
+  }
+
+  if (state.pendingPrediction) {
+    const timeSince = Date.now() - state.pendingPrediction;
+    if (timeSince < CONFIG.debounceMs) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+async function handleEdit(toolInput, toolResult) {
+  if (!CONFIG.enabled) return;
+
+  const { file_path, old_string, new_string } = toolInput;
+  if (!file_path || !old_string || !new_string) return;
+
+  if (!isCodeFile(file_path)) {
+    log('Skipping non-code file', { file_path });
+    return;
+  }
+
+  if (
+    new_string.length < CONFIG.minEditSize &&
+    old_string.length < CONFIG.minEditSize
+  ) {
+    return;
+  }
+
+  const state = loadState();
+
+  const diff = {
+    file_path,
+    original: old_string,
+    updated: new_string,
+    timestamp: Date.now(),
+  };
+
+  state.recentDiffs.unshift(diff);
+  state.recentDiffs = state.recentDiffs.slice(0, CONFIG.maxRecentDiffs);
+
+  try {
+    if (fs.existsSync(file_path)) {
+      state.fileContents[file_path] = fs.readFileSync(file_path, 'utf-8');
+    }
+  } catch {
+    // Ignore
+  }
+
+  saveState(state);
+  log('Edit recorded', { file_path, diffSize: new_string.length });
+
+  if (shouldRunPrediction(state, file_path)) {
+    state.pendingPrediction = Date.now();
+    saveState(state);
+
+    setTimeout(() => {
+      runPredictionAsync(file_path, loadState());
+    }, CONFIG.debounceMs);
+  }
+}
+
+async function runPredictionAsync(filePath, state) {
+  try {
+    const currentContent = state.fileContents[filePath] || '';
+    if (!currentContent) {
+      state.pendingPrediction = null;
+      saveState(state);
+      return;
+    }
+
+    const result = await runPrediction(
+      filePath,
+      currentContent,
+      state.recentDiffs
+    );
+
+    state.pendingPrediction = null;
+
+    if (result && result.success && result.predicted_content) {
+      state.lastPrediction = {
+        file_path: filePath,
+        prediction: result.predicted_content,
+        latency_ms: result.latency_ms,
+        timestamp: Date.now(),
+      };
+      saveState(state);
+
+      log('Prediction complete', {
+        file_path: filePath,
+        latency_ms: result.latency_ms,
+        tokens: result.tokens_generated,
+      });
+
+      const hint = formatPredictionHint(result);
+      if (hint) {
+        console.error(hint);
+      }
+    } else {
+      saveState(state);
+    }
+  } catch (error) {
+    state.pendingPrediction = null;
+    saveState(state);
+    log('Prediction error', { error: error.message });
+  }
+}
+
+function formatPredictionHint(result) {
+  if (!result.predicted_content || result.predicted_content.trim().length < 5) {
+    return null;
+  }
+
+  const preview = result.predicted_content
+    .trim()
+    .split('\n')
+    .slice(0, 3)
+    .join('\n');
+  const truncated = result.predicted_content.length > 200;
+
+  return `
+[Sweep Prediction] Next edit suggestion (${result.latency_ms}ms):
+${preview}${truncated ? '\n...' : ''}
+`;
+}
+
+async function handleWrite(toolInput, toolResult) {
+  if (!CONFIG.enabled) return;
+
+  const { file_path, content } = toolInput;
+  if (!file_path || !content) return;
+
+  if (!isCodeFile(file_path)) {
+    return;
+  }
+
+  const state = loadState();
+  state.fileContents[file_path] = content;
+  saveState(state);
+
+  log('Write recorded', { file_path, size: content.length });
+}
+
+async function main() {
+  try {
+    const input = await readInput();
+    const { tool_name, tool_input, tool_result, event_type } = input;
+
+    // Only handle post-tool-use events
+    if (event_type !== 'post_tool_use') {
+      process.exit(0);
+    }
+
+    // Handle different tools
+    switch (tool_name) {
+      case 'Edit':
+        await handleEdit(tool_input, tool_result);
+        break;
+      case 'Write':
+        await handleWrite(tool_input, tool_result);
+        break;
+    }
+
+    // Success
+    console.log(JSON.stringify({ status: 'ok' }));
+  } catch (error) {
+    log('Hook error', { error: error.message });
+    console.log(JSON.stringify({ status: 'error', message: error.message }));
+  }
+}
+
+// Handle info request
+if (process.argv.includes('--info')) {
+  console.log(
+    JSON.stringify({
+      hook: 'post-edit-sweep',
+      version: '1.0.0',
+      description: 'Runs Sweep 1.5B predictions after file edits',
+      config: {
+        enabled: CONFIG.enabled,
+        maxRecentDiffs: CONFIG.maxRecentDiffs,
+        predictionTimeout: CONFIG.predictionTimeout,
+      },
+    })
+  );
+  process.exit(0);
+}
+
+// Handle status request
+if (process.argv.includes('--status')) {
+  const state = loadState();
+  const scriptPath = findPythonScript();
+  console.log(
+    JSON.stringify(
+      {
+        enabled: CONFIG.enabled,
+        scriptFound: !!scriptPath,
+        scriptPath,
+        recentDiffs: state.recentDiffs.length,
+        lastPrediction: state.lastPrediction,
+      },
+      null,
+      2
+    )
+  );
+  process.exit(0);
+}
+
+// Handle clear request
+if (process.argv.includes('--clear')) {
+  saveState({ recentDiffs: [], lastPrediction: null, fileContents: {} });
+  console.log('Sweep state cleared');
+  process.exit(0);
+}
+
+main().catch((error) => {
+  console.error(JSON.stringify({ status: 'error', message: error.message }));
+  process.exit(1);
+});

package/templates/shell/sweep-complete.zsh

@@ -0,0 +1,116 @@
+#!/usr/bin/env zsh
+# StackMemory Sweep Completion for ZSH
+# Non-intrusive: shows context in RPROMPT, no input hijacking
+
+# Configuration
+SWEEP_COMPLETE_ENABLED=${SWEEP_COMPLETE_ENABLED:-true}
+SWEEP_STATE_FILE="${HOME}/.stackmemory/sweep-state.json"
+SWEEP_SUGGEST_SCRIPT="${HOME}/.stackmemory/shell/sweep-suggest.js"
+
+# State
+typeset -g _sweep_suggestion=""
+typeset -g _sweep_last_check=0
+
+# Get suggestion (called on-demand only)
+_sweep_get_suggestion() {
+    [[ "$SWEEP_COMPLETE_ENABLED" != "true" ]] && return 1
+    [[ ${#BUFFER} -lt 3 ]] && return 1
+
+    if [[ -f "$SWEEP_SUGGEST_SCRIPT" ]]; then
+        _sweep_suggestion=$(echo "$BUFFER" | timeout 0.5 node "$SWEEP_SUGGEST_SCRIPT" 2>/dev/null)
+        [[ -n "$_sweep_suggestion" ]] && return 0
+    fi
+    return 1
+}
+
+# Accept current suggestion
+_sweep_accept() {
+    if [[ -n "$_sweep_suggestion" ]]; then
+        BUFFER="${BUFFER}${_sweep_suggestion}"
+        CURSOR=${#BUFFER}
+        _sweep_suggestion=""
+        RPROMPT="$_sweep_saved_rprompt"
+        zle redisplay
+    else
+        # Fall through to normal tab completion
+        zle expand-or-complete
+    fi
+}
+
+# Request suggestion manually (Ctrl+])
+_sweep_request() {
+    if _sweep_get_suggestion; then
+        _sweep_saved_rprompt="$RPROMPT"
+        RPROMPT="%F{240}[${_sweep_suggestion}]%f"
+        zle redisplay
+    else
+        zle -M "No suggestion available"
+    fi
+}
+
+# Clear suggestion
+_sweep_clear() {
+    _sweep_suggestion=""
+    RPROMPT="$_sweep_saved_rprompt"
+}
+
+# Widget definitions
+zle -N sweep-accept _sweep_accept
+zle -N sweep-request _sweep_request
+zle -N sweep-clear _sweep_clear
+
+# Key bindings - ONLY these, no input hijacking
+bindkey '^[[Z' sweep-request    # Shift+Tab to request suggestion
+bindkey '^I' sweep-accept       # Tab to accept (falls through to normal completion if no suggestion)
+
+# Show recent file context in RPROMPT (passive, after each command)
+_sweep_show_context() {
+    [[ "$SWEEP_COMPLETE_ENABLED" != "true" ]] && return
+
+    if [[ -f "$SWEEP_STATE_FILE" ]]; then
+        local recent_file=$(grep -o '"file_path":"[^"]*"' "$SWEEP_STATE_FILE" 2>/dev/null | head -1 | cut -d'"' -f4)
+        if [[ -n "$recent_file" ]]; then
+            local filename=$(basename "$recent_file")
+            _sweep_saved_rprompt="%F{240}[${filename}]%f"
+            RPROMPT="$_sweep_saved_rprompt"
+        fi
+    fi
+}
+
+# Hook into prompt refresh (runs after each command, not during typing)
+autoload -Uz add-zsh-hook
+add-zsh-hook precmd _sweep_show_context
+
+# Status
+sweep_status() {
+    echo "Sweep Shell Integration"
+    echo "  Enabled: $SWEEP_COMPLETE_ENABLED"
+    echo "  Current suggestion: ${_sweep_suggestion:-none}"
+    echo ""
+    if [[ -f "$SWEEP_STATE_FILE" ]]; then
+        local count=$(grep -c '"file_path"' "$SWEEP_STATE_FILE" 2>/dev/null || echo 0)
+        echo "  Recent edits tracked: $count"
+    fi
+    echo ""
+    echo "Usage:"
+    echo "  Shift+Tab  Request suggestion based on input"
+    echo "  Tab        Accept suggestion (or normal completion)"
+    echo ""
+    echo "The right prompt shows your most recently edited file."
+}
+
+# Toggle
+sweep_toggle() {
+    if [[ "$SWEEP_COMPLETE_ENABLED" == "true" ]]; then
+        SWEEP_COMPLETE_ENABLED=false
+        RPROMPT=""
+        echo "Sweep disabled"
+    else
+        SWEEP_COMPLETE_ENABLED=true
+        _sweep_show_context
+        echo "Sweep enabled"
+    fi
+}
+
+alias sweep-on='SWEEP_COMPLETE_ENABLED=true; _sweep_show_context; echo "Sweep enabled"'
+alias sweep-off='SWEEP_COMPLETE_ENABLED=false; RPROMPT=""; echo "Sweep disabled"'

package/templates/shell/sweep-suggest.js

@@ -0,0 +1,161 @@
+#!/usr/bin/env node
+/**
+ * Sweep Suggestion Script for Shell Integration
+ * Reads input from stdin and returns a suggestion
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const STATE_FILE = path.join(
+  process.env.HOME || '/tmp',
+  '.stackmemory',
+  'sweep-state.json'
+);
+
+function loadState() {
+  try {
+    if (fs.existsSync(STATE_FILE)) {
+      return JSON.parse(fs.readFileSync(STATE_FILE, 'utf-8'));
+    }
+  } catch {
+    // Ignore
+  }
+  return { recentDiffs: [], fileContents: {} };
+}
+
+function getRecentFile(state) {
+  if (!state.recentDiffs || state.recentDiffs.length === 0) {
+    return null;
+  }
+  return state.recentDiffs[0]?.file_path;
+}
+
+function getFilename(filepath) {
+  if (!filepath) return null;
+  return path.basename(filepath);
+}
+
+function getSuggestion(userInput) {
+  const state = loadState();
+  const recentFile = getRecentFile(state);
+  const filename = getFilename(recentFile);
+
+  if (!filename) return null;
+
+  const input = userInput.toLowerCase().trim();
+
+  // Git commands - suggest based on recent file
+  if (input.startsWith('git commit')) {
+    if (input === 'git commit') {
+      return ` -m "Update ${filename}"`;
+    }
+    if (input === 'git commit -m') {
+      return ` "Update ${filename}"`;
+    }
+    if (input === 'git commit -m "') {
+      return `Update ${filename}"`;
+    }
+  }
+
+  if (input === 'git add') {
+    return ` ${recentFile}`;
+  }
+
+  if (input === 'git diff') {
+    return ` ${recentFile}`;
+  }
+
+  if (input === 'git log') {
+    return ` --oneline -10`;
+  }
+
+  // Action keywords at end
+  const actionPatterns = {
+    fix: ` the bug in ${filename}`,
+    add: ` feature to ${filename}`,
+    update: ` ${filename}`,
+    refactor: ` ${filename}`,
+    test: ` ${filename}`,
+    implement: ` in ${filename}`,
+    create: ` new function in ${filename}`,
+    delete: ` from ${filename}`,
+    remove: ` from ${filename}`,
+    edit: ` ${filename}`,
+    open: ` ${recentFile}`,
+    check: ` ${filename}`,
+    review: ` ${filename}`,
+    debug: ` ${filename}`,
+  };
+
+  for (const [keyword, suffix] of Object.entries(actionPatterns)) {
+    if (input.endsWith(keyword)) {
+      return suffix;
+    }
+    if (input.endsWith(keyword + ' ')) {
+      return suffix.trim();
+    }
+  }
+
+  // Preposition patterns
+  if (
+    input.endsWith(' in ') ||
+    input.endsWith(' to ') ||
+    input.endsWith(' for ')
+  ) {
+    return filename;
+  }
+
+  if (input.endsWith(' file ') || input.endsWith(' the ')) {
+    return filename;
+  }
+
+  // npm/node commands
+  if (input === 'npm run') {
+    return ' build';
+  }
+
+  if (input === 'npm test') {
+    return ` -- ${filename.replace(/\.[^/.]+$/, '')}`;
+  }
+
+  if (input === 'node') {
+    return ` ${recentFile}`;
+  }
+
+  // Cat/less/vim
+  if (
+    input === 'cat' ||
+    input === 'less' ||
+    input === 'vim' ||
+    input === 'code'
+  ) {
+    return ` ${recentFile}`;
+  }
+
+  return null;
+}
+
+async function main() {
+  let data = '';
+
+  process.stdin.setEncoding('utf8');
+
+  for await (const chunk of process.stdin) {
+    data += chunk;
+  }
+
+  const userInput = data.trim();
+
+  if (!userInput || userInput.length < 2) {
+    process.exit(0);
+  }
+
+  const suggestion = getSuggestion(userInput);
+
+  if (suggestion) {
+    console.log(suggestion);
+  }
+}
+
+main().catch(() => process.exit(0));