@stackmemoryai/stackmemory 0.5.67 → 0.6.1

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

@@ -35,16 +35,16 @@ const distDir = join(__dirname, '..', 'dist');
  * Returns true if user consents, false otherwise
  */
 async function askForConsent() {
-  // Skip prompt if:
-  // 1. Not a TTY (CI/CD, piped input)
-  // 2. STACKMEMORY_AUTO_HOOKS=true is set
-  // 3. Running in CI environment
-  if (
-    !process.stdin.isTTY ||
-    process.env.STACKMEMORY_AUTO_HOOKS === 'true' ||
-    process.env.CI === 'true'
-  ) {
-    // In non-interactive mode, skip hook installation silently
+  // Auto-install if STACKMEMORY_AUTO_HOOKS=true (no prompt needed)
+  if (process.env.STACKMEMORY_AUTO_HOOKS === 'true') {
+    console.log(
+      'STACKMEMORY_AUTO_HOOKS=true — installing hooks automatically.'
+    );
+    return true;
+  }
+
+  // Skip prompt if not interactive (CI/CD, piped input)
+  if (!process.stdin.isTTY || process.env.CI === 'true') {
     console.log(
       'StackMemory installed. Run "stackmemory setup-mcp" to configure Claude Code integration.'
     );
@@ -58,6 +58,8 @@ async function askForConsent() {
   console.log('  - Track tool usage for better context');
   console.log('  - Enable session persistence across restarts');
   console.log('  - Sync context with Linear (optional)');
+  console.log('  - Auto-update PROMPT_PLAN on task completion');
+  console.log('  - Recommend relevant skills based on your prompts');
   console.log('\nThis will modify files in ~/.claude/\n');
 
   return new Promise((resolve) => {
@@ -89,11 +91,19 @@ async function installClaudeHooks() {
       console.log('Created ~/.claude/hooks directory');
     }
 
-    // Copy hook files
-    const hookFiles = ['tool-use-trace.js', 'on-startup.js', 'on-clear.js'];
+    // Copy hook files (scripts + data files)
+    const hookFiles = [
+      'tool-use-trace.js',
+      'on-startup.js',
+      'on-clear.js',
+      'on-task-complete.js',
+      'skill-eval.sh',
+      'skill-eval.cjs',
+    ];
+    const dataFiles = ['skill-rules.json'];
     let installed = 0;
 
-    for (const hookFile of hookFiles) {
+    for (const hookFile of [...hookFiles, ...dataFiles]) {
       const srcPath = join(templatesDir, hookFile);
       const destPath = join(claudeHooksDir, hookFile);
 
@@ -107,12 +117,14 @@ async function installClaudeHooks() {
 
         copyFileSync(srcPath, destPath);
 
-        // Make executable
-        try {
-          const { execSync } = await import('child_process');
-          execSync(`chmod +x "${destPath}"`, { stdio: 'ignore' });
-        } catch {
-          // Silent fail on chmod
+        // Make executable (scripts only, not data files)
+        if (!dataFiles.includes(hookFile)) {
+          try {
+            const { execSync } = await import('child_process');
+            execSync(`chmod +x "${destPath}"`, { stdio: 'ignore' });
+          } catch {
+            // Silent fail on chmod
+          }
         }
 
         installed++;
@@ -136,6 +148,8 @@ async function installClaudeHooks() {
       'tool-use-approval': join(claudeHooksDir, 'tool-use-trace.js'),
       'on-startup': join(claudeHooksDir, 'on-startup.js'),
       'on-clear': join(claudeHooksDir, 'on-clear.js'),
+      'on-task-complete': join(claudeHooksDir, 'on-task-complete.js'),
+      'user-prompt-submit': join(claudeHooksDir, 'skill-eval.sh'),
     };
 
     writeFileSync(claudeConfigFile, JSON.stringify(newHooksConfig, null, 2));

package/templates/claude-hooks/hooks.json

@@ -1,5 +1,7 @@
 {
   "tool-use-approval": "~/.claude/hooks/tool-use-trace.js",
   "on-startup": "~/.claude/hooks/on-startup.js",
-  "on-clear": "~/.claude/hooks/on-clear.js"
-}
+  "on-clear": "~/.claude/hooks/on-clear.js",
+  "on-task-complete": "~/.claude/hooks/on-task-complete.js",
+  "user-prompt-submit": "~/.claude/hooks/skill-eval.sh"
+}

package/templates/claude-hooks/on-task-complete.js

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+
+/**
+ * On-task-complete hook for StackMemory
+ * Triggers when a task is marked as done in Claude Code.
+ *
+ * Actions:
+ * 1. Auto-updates PROMPT_PLAN.md checkboxes (fuzzy match on task keywords)
+ * 2. Syncs Linear tasks (if STA-* identifier present)
+ * 3. Logs to ~/.stackmemory/logs/hook-errors.log on failure (non-blocking)
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+async function onTaskComplete() {
+  try {
+    const input = JSON.parse(fs.readFileSync(0, 'utf-8'));
+
+    // Sync Linear if STA task
+    if (input.task && input.task.includes('STA-')) {
+      try {
+        const syncScript = path.join(
+          process.cwd(),
+          'scripts',
+          'sync-linear-graphql.js'
+        );
+        if (fs.existsSync(syncScript)) {
+          const { execSync } = require('child_process');
+          execSync(`node "${syncScript}"`, {
+            stdio: 'ignore',
+            timeout: 10000,
+          });
+        }
+      } catch (_e) {
+        // Non-blocking
+      }
+    }
+
+    // Auto-update PROMPT_PLAN checkboxes if spec exists
+    const promptPlanPath = path.join(
+      process.cwd(),
+      'docs',
+      'specs',
+      'PROMPT_PLAN.md'
+    );
+    if (fs.existsSync(promptPlanPath) && input.task) {
+      try {
+        const content = fs.readFileSync(promptPlanPath, 'utf-8');
+        const taskWords = input.task.split(/\s+/).filter((w) => w.length > 3);
+        const lines = content.split('\n');
+        let updated = false;
+        for (let i = 0; i < lines.length; i++) {
+          if (
+            lines[i].includes('- [ ]') &&
+            taskWords.some((w) =>
+              lines[i].toLowerCase().includes(w.toLowerCase())
+            )
+          ) {
+            lines[i] = lines[i].replace('- [ ]', '- [x]');
+            updated = true;
+            break;
+          }
+        }
+        if (updated) {
+          fs.writeFileSync(promptPlanPath, lines.join('\n'));
+        }
+      } catch (_e) {
+        // Silently fail
+      }
+    }
+  } catch (error) {
+    const logDir = path.join(
+      process.env.HOME || '/tmp',
+      '.stackmemory',
+      'logs'
+    );
+    try {
+      fs.mkdirSync(logDir, { recursive: true });
+      fs.appendFileSync(
+        path.join(logDir, 'hook-errors.log'),
+        `[${new Date().toISOString()}] on-task-complete: ${error.message}\n`
+      );
+    } catch (_e) {
+      // Last resort: silent
+    }
+  }
+}
+
+onTaskComplete();

package/templates/claude-hooks/skill-eval.cjs

@@ -0,0 +1,411 @@
+#!/usr/bin/env node
+/**
+ * Skill Evaluation Engine v2.0
+ *
+ * Intelligent skill activation based on:
+ * - Keywords and patterns in prompts
+ * - File paths mentioned or being edited
+ * - Directory mappings
+ * - Intent detection
+ * - Content pattern matching
+ *
+ * Outputs a structured reminder with matched skills and reasons.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Configuration
+const RULES_PATH = path.join(__dirname, 'skill-rules.json');
+
+/**
+ * @typedef {Object} SkillMatch
+ * @property {string} name - Skill name
+ * @property {number} score - Confidence score
+ * @property {string[]} reasons - Why this skill was matched
+ * @property {number} priority - Skill priority
+ */
+
+/**
+ * Load skill rules from JSON file
+ * @returns {Object} Parsed skill rules
+ */
+function loadRules() {
+  try {
+    const content = fs.readFileSync(RULES_PATH, 'utf-8');
+    return JSON.parse(content);
+  } catch (error) {
+    console.error(`Failed to load skill rules: ${error.message}`);
+    process.exit(0); // Exit gracefully to not block the prompt
+  }
+}
+
+/**
+ * Extract file paths mentioned in the prompt
+ * @param {string} prompt - User's prompt text
+ * @returns {string[]} Array of detected file paths
+ */
+function extractFilePaths(prompt) {
+  const paths = new Set();
+
+  // Match explicit paths with extensions (.tsx, .ts, .jsx, .js, .json, .gql, .yaml, .yml, .md, .sh)
+  const extensionPattern =
+    /(?:^|\s|["'`])([\w\-./]+\.(?:[tj]sx?|json|gql|ya?ml|md|sh))\b/gi;
+  let match;
+  while ((match = extensionPattern.exec(prompt)) !== null) {
+    paths.add(match[1]);
+  }
+
+  // Match paths starting with common directories
+  const dirPattern =
+    /(?:^|\s|["'`])((?:src|app|components|screens|hooks|utils|services|navigation|graphql|localization|\.claude|\.github|\.maestro)\/[\w\-./]+)/gi;
+  while ((match = dirPattern.exec(prompt)) !== null) {
+    paths.add(match[1]);
+  }
+
+  // Match quoted paths
+  const quotedPattern = /["'`]([\w\-./]+\/[\w\-./]+)["'`]/g;
+  while ((match = quotedPattern.exec(prompt)) !== null) {
+    paths.add(match[1]);
+  }
+
+  return Array.from(paths);
+}
+
+/**
+ * Check if a pattern matches the text
+ * @param {string} text - Text to search in
+ * @param {string} pattern - Regex pattern
+ * @param {string} flags - Regex flags
+ * @returns {boolean}
+ */
+function matchesPattern(text, pattern, flags = 'i') {
+  try {
+    const regex = new RegExp(pattern, flags);
+    return regex.test(text);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if a glob pattern matches a file path
+ * @param {string} filePath - File path to check
+ * @param {string} globPattern - Glob pattern (simplified)
+ * @returns {boolean}
+ */
+function matchesGlob(filePath, globPattern) {
+  // Convert glob to regex (simplified)
+  const regexPattern = globPattern
+    .replace(/\./g, '\\.')
+    .replace(/\*\*\//g, '<<<DOUBLESTARSLASH>>>')
+    .replace(/\*\*/g, '<<<DOUBLESTAR>>>')
+    .replace(/\*/g, '[^/]*')
+    .replace(/<<<DOUBLESTARSLASH>>>/g, '(.*\\/)?')
+    .replace(/<<<DOUBLESTAR>>>/g, '.*')
+    .replace(/\?/g, '.');
+
+  try {
+    const regex = new RegExp(`^${regexPattern}$`, 'i');
+    return regex.test(filePath);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if file path matches any directory mapping
+ * @param {string} filePath - File path to check
+ * @param {Object} mappings - Directory to skill mappings
+ * @returns {string|null} Matched skill name or null
+ */
+function matchDirectoryMapping(filePath, mappings) {
+  for (const [dir, skillName] of Object.entries(mappings)) {
+    if (filePath === dir || filePath.startsWith(dir + '/')) {
+      return skillName;
+    }
+  }
+  return null;
+}
+
+/**
+ * Evaluate a single skill against the prompt and context
+ * @param {string} skillName - Name of the skill
+ * @param {Object} skill - Skill configuration
+ * @param {string} prompt - User's prompt
+ * @param {string} promptLower - Lowercase prompt
+ * @param {string[]} filePaths - Extracted file paths
+ * @param {Object} rules - Full rules object
+ * @returns {SkillMatch|null}
+ */
+function evaluateSkill(
+  skillName,
+  skill,
+  prompt,
+  promptLower,
+  filePaths,
+  rules
+) {
+  const { triggers = {}, excludePatterns = [], priority = 5 } = skill;
+  const scoring = rules.scoring;
+
+  let score = 0;
+  const reasons = [];
+
+  // Check exclude patterns first
+  for (const excludePattern of excludePatterns) {
+    if (matchesPattern(promptLower, excludePattern)) {
+      return null;
+    }
+  }
+
+  // 1. Check keywords
+  if (triggers.keywords) {
+    for (const keyword of triggers.keywords) {
+      if (promptLower.includes(keyword.toLowerCase())) {
+        score += scoring.keyword;
+        reasons.push(`keyword "${keyword}"`);
+      }
+    }
+  }
+
+  // 2. Check keyword patterns (regex)
+  if (triggers.keywordPatterns) {
+    for (const pattern of triggers.keywordPatterns) {
+      if (matchesPattern(promptLower, pattern)) {
+        score += scoring.keywordPattern;
+        reasons.push(`pattern /${pattern}/`);
+      }
+    }
+  }
+
+  // 3. Check intent patterns
+  if (triggers.intentPatterns) {
+    for (const pattern of triggers.intentPatterns) {
+      if (matchesPattern(promptLower, pattern)) {
+        score += scoring.intentPattern;
+        reasons.push(`intent detected`);
+        break;
+      }
+    }
+  }
+
+  // 4. Check context patterns
+  if (triggers.contextPatterns) {
+    for (const pattern of triggers.contextPatterns) {
+      if (promptLower.includes(pattern.toLowerCase())) {
+        score += scoring.contextPattern;
+        reasons.push(`context "${pattern}"`);
+      }
+    }
+  }
+
+  // 5. Check file paths against path patterns
+  if (triggers.pathPatterns && filePaths.length > 0) {
+    for (const filePath of filePaths) {
+      for (const pattern of triggers.pathPatterns) {
+        if (matchesGlob(filePath, pattern)) {
+          score += scoring.pathPattern;
+          reasons.push(`path "${filePath}"`);
+          break;
+        }
+      }
+    }
+  }
+
+  // 6. Check directory mappings
+  if (rules.directoryMappings && filePaths.length > 0) {
+    for (const filePath of filePaths) {
+      const mappedSkill = matchDirectoryMapping(
+        filePath,
+        rules.directoryMappings
+      );
+      if (mappedSkill === skillName) {
+        score += scoring.directoryMatch;
+        reasons.push(`directory mapping`);
+        break;
+      }
+    }
+  }
+
+  // 7. Check content patterns in prompt (for code snippets)
+  if (triggers.contentPatterns) {
+    for (const pattern of triggers.contentPatterns) {
+      if (matchesPattern(prompt, pattern)) {
+        score += scoring.contentPattern;
+        reasons.push(`code pattern detected`);
+        break;
+      }
+    }
+  }
+
+  if (score > 0) {
+    return {
+      name: skillName,
+      score,
+      reasons: [...new Set(reasons)],
+      priority,
+    };
+  }
+
+  return null;
+}
+
+/**
+ * Get related skills that should also be suggested
+ * @param {SkillMatch[]} matches - Current matches
+ * @param {Object} skills - All skill definitions
+ * @returns {string[]} Additional skill names to suggest
+ */
+function getRelatedSkills(matches, skills) {
+  const matchedNames = new Set(matches.map((m) => m.name));
+  const related = new Set();
+
+  for (const match of matches) {
+    const skill = skills[match.name];
+    if (skill?.relatedSkills) {
+      for (const relatedName of skill.relatedSkills) {
+        if (!matchedNames.has(relatedName)) {
+          related.add(relatedName);
+        }
+      }
+    }
+  }
+
+  return Array.from(related);
+}
+
+/**
+ * Format confidence level based on score
+ * @param {number} score - Confidence score
+ * @param {number} minScore - Minimum threshold
+ * @returns {string} Confidence label
+ */
+function formatConfidence(score, minScore) {
+  if (score >= minScore * 3) return 'HIGH';
+  if (score >= minScore * 2) return 'MEDIUM';
+  return 'LOW';
+}
+
+/**
+ * Main evaluation function
+ * @param {string} prompt - User's prompt
+ * @returns {string} Formatted output
+ */
+function evaluate(prompt) {
+  const rules = loadRules();
+  const { config, skills } = rules;
+
+  const promptLower = prompt.toLowerCase();
+  const filePaths = extractFilePaths(prompt);
+
+  // Evaluate all skills
+  const matches = [];
+  for (const [name, skill] of Object.entries(skills)) {
+    const match = evaluateSkill(
+      name,
+      skill,
+      prompt,
+      promptLower,
+      filePaths,
+      rules
+    );
+    if (match && match.score >= config.minConfidenceScore) {
+      matches.push(match);
+    }
+  }
+
+  if (matches.length === 0) {
+    return '';
+  }
+
+  // Sort by score (descending), then by priority (descending)
+  matches.sort((a, b) => {
+    if (b.score !== a.score) return b.score - a.score;
+    return b.priority - a.priority;
+  });
+
+  // Limit to max skills
+  const topMatches = matches.slice(0, config.maxSkillsToShow);
+
+  // Check for related skills
+  const relatedSkills = getRelatedSkills(topMatches, skills);
+
+  // Format output
+  let output = '<user-prompt-submit-hook>\n';
+  output += 'SKILL ACTIVATION REQUIRED\n\n';
+
+  if (filePaths.length > 0) {
+    output += `Detected file paths: ${filePaths.join(', ')}\n\n`;
+  }
+
+  output += 'Matched skills (ranked by relevance):\n';
+
+  for (let i = 0; i < topMatches.length; i++) {
+    const match = topMatches[i];
+    const confidence = formatConfidence(match.score, config.minConfidenceScore);
+
+    output += `${i + 1}. ${match.name} (${confidence} confidence)\n`;
+
+    if (config.showMatchReasons && match.reasons.length > 0) {
+      output += `   Matched: ${match.reasons.slice(0, 3).join(', ')}\n`;
+    }
+  }
+
+  if (relatedSkills.length > 0) {
+    output += `\nRelated skills to consider: ${relatedSkills.join(', ')}\n`;
+  }
+
+  output += '\nBefore implementing, you MUST:\n';
+  output += '1. EVALUATE: State YES/NO for each skill with brief reasoning\n';
+  output += '2. ACTIVATE: Invoke the Skill tool for each YES skill\n';
+  output += '3. IMPLEMENT: Only proceed after skill activation\n';
+  output += '\nExample evaluation:\n';
+  output += `- ${topMatches[0].name}: YES - [your reasoning]\n`;
+  if (topMatches.length > 1) {
+    output += `- ${topMatches[1].name}: NO - [your reasoning]\n`;
+  }
+  output += '\nDO NOT skip this step. Invoke relevant skills NOW.\n';
+  output += '</user-prompt-submit-hook>';
+
+  return output;
+}
+
+// Main execution
+function main() {
+  let input = '';
+
+  process.stdin.setEncoding('utf8');
+
+  process.stdin.on('data', (chunk) => {
+    input += chunk;
+  });
+
+  process.stdin.on('end', () => {
+    let prompt = '';
+
+    try {
+      const data = JSON.parse(input);
+      prompt = data.prompt || '';
+    } catch {
+      prompt = input;
+    }
+
+    if (!prompt.trim()) {
+      process.exit(0);
+    }
+
+    try {
+      const output = evaluate(prompt);
+      if (output) {
+        console.log(output);
+      }
+    } catch (error) {
+      console.error(`Skill evaluation failed: ${error.message}`);
+    }
+
+    process.exit(0);
+  });
+}
+
+main();

package/templates/claude-hooks/skill-eval.sh

@@ -0,0 +1,31 @@
+#!/bin/bash
+# Skill Evaluation Hook v2.0
+# Wrapper script that delegates to the Node.js evaluation engine
+#
+# This hook runs on UserPromptSubmit and analyzes the prompt for:
+# - Keywords and patterns indicating skill relevance
+# - File paths mentioned in the prompt
+# - Intent patterns (what the user wants to do)
+# - Directory mappings (what directories map to which skills)
+#
+# Configuration is in skill-rules.json
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+NODE_SCRIPT="$SCRIPT_DIR/skill-eval.cjs"
+
+# Check if Node.js is available
+if ! command -v node &>/dev/null; then
+  # Fallback: exit silently if Node.js not found
+  exit 0
+fi
+
+# Check if the Node script exists
+if [[ ! -f "$NODE_SCRIPT" ]]; then
+  exit 0
+fi
+
+# Pipe stdin to the Node.js script (suppress stderr noise from nvm/shell init)
+cat | node "$NODE_SCRIPT" 2>/dev/null
+
+# Always exit 0 to allow the prompt through
+exit 0