@vinaes/succ 1.3.19

package/hooks/succ-stop-reflection.cjs

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+/**
+ * Stop Hook - Signal that Claude finished responding
+ *
+ * Notifies the daemon that Claude has finished responding.
+ * The daemon handles idle detection and reflection trigger.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('readable', () => {
+  let chunk;
+  while ((chunk = process.stdin.read()) !== null) {
+    input += chunk;
+  }
+});
+
+process.stdin.on('end', async () => {
+  try {
+    const hookInput = JSON.parse(input);
+    let projectDir = hookInput.cwd || process.cwd();
+
+    // Convert /c/... to C:/... on Windows if needed
+    if (process.platform === 'win32' && /^\/[a-z]\//.test(projectDir)) {
+      projectDir = projectDir[1].toUpperCase() + ':' + projectDir.slice(2);
+    }
+
+    // Skip if succ is not initialized in this project
+    if (!fs.existsSync(path.join(projectDir, '.succ'))) {
+      process.exit(0);
+    }
+
+    const tmpDir = path.join(projectDir, '.succ', '.tmp');
+    if (!fs.existsSync(tmpDir)) {
+      fs.mkdirSync(tmpDir, { recursive: true });
+    }
+
+    // Get session_id from transcript_path (unique per session)
+    const transcriptPath = hookInput.transcript_path || '';
+    const sessionId = transcriptPath ? path.basename(transcriptPath, '.jsonl') : null;
+
+    // Read daemon port
+    let daemonPort = null;
+    try {
+      const portFile = path.join(tmpDir, 'daemon.port');
+      if (fs.existsSync(portFile)) {
+        daemonPort = parseInt(fs.readFileSync(portFile, 'utf8').trim(), 10);
+      }
+    } catch {}
+
+    // Check if this is a service session (e.g., reflection subagent)
+    const isServiceSession = process.env.SUCC_SERVICE_SESSION === '1';
+
+    // Notify daemon of stop activity (awaited)
+    const notifyDaemon = async () => {
+      if (!daemonPort || !sessionId) return;
+
+      try {
+        await fetch(`http://127.0.0.1:${daemonPort}/api/session/activity`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            session_id: sessionId,
+            type: 'stop',
+            transcript_path: transcriptPath,
+            is_service: isServiceSession,
+          }),
+          signal: AbortSignal.timeout(2000),
+        });
+      } catch {}
+    };
+
+    // Wait for daemon notification before exit
+    await notifyDaemon();
+    process.exit(0);
+  } catch (err) {
+    process.exit(0);
+  }
+});
+
+// Safety timeout
+setTimeout(() => {
+  process.exit(0);
+}, 3000);

package/hooks/succ-user-prompt.cjs

@@ -0,0 +1,220 @@
+#!/usr/bin/env node
+/**
+ * UserPromptSubmit Hook - Notify daemon of user activity
+ *
+ * Used for:
+ * 1. Idle detection - tracks when user sends prompts
+ * 2. Compact fallback - re-injects context if SessionStart output was lost
+ *
+ * NOTE: Auto-recall logic is disabled. Claude can use succ_recall MCP tool
+ * when it needs memory context - it's smarter than regex pattern matching.
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+// Logging helper - writes to .succ/.tmp/hooks.log
+function log(succDir, message) {
+  try {
+    const tmpDir = path.join(succDir, '.tmp');
+    if (!fs.existsSync(tmpDir)) {
+      fs.mkdirSync(tmpDir, { recursive: true });
+    }
+    const logFile = path.join(tmpDir, 'hooks.log');
+    const timestamp = new Date().toISOString();
+    fs.appendFileSync(logFile, `[${timestamp}] [user-prompt] ${message}\n`);
+  } catch {
+    // Logging failed, not critical
+  }
+}
+
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('readable', () => {
+  let chunk;
+  while ((chunk = process.stdin.read()) !== null) {
+    input += chunk;
+  }
+});
+
+process.stdin.on('end', async () => {
+  try {
+    const hookInput = JSON.parse(input);
+    let projectDir = hookInput.cwd || process.cwd();
+
+    // Windows path fix
+    if (process.platform === 'win32' && /^\/[a-z]\//.test(projectDir)) {
+      projectDir = projectDir[1].toUpperCase() + ':' + projectDir.slice(2);
+    }
+
+    // Skip if succ is not initialized in this project
+    if (!fs.existsSync(path.join(projectDir, '.succ'))) {
+      process.exit(0);
+    }
+
+    const tmpDir = path.join(projectDir, '.succ', '.tmp');
+
+    // Get session_id from transcript_path (unique per session)
+    const transcriptPath = hookInput.transcript_path || '';
+    const sessionId = transcriptPath ? path.basename(transcriptPath, '.jsonl') : null;
+
+    // Read daemon port
+    let daemonPort = null;
+    try {
+      const portFile = path.join(tmpDir, 'daemon.port');
+      if (fs.existsSync(portFile)) {
+        daemonPort = parseInt(fs.readFileSync(portFile, 'utf8').trim(), 10);
+      }
+    } catch {}
+
+    // Check if this is a service session (e.g., reflection subagent)
+    const isServiceSession = process.env.SUCC_SERVICE_SESSION === '1';
+
+    const succDir = path.join(projectDir, '.succ');
+
+    // Check for compact-pending fallback
+    // This handles the case where SessionStart hook output was lost after /compact
+    // See: https://github.com/anthropics/claude-code/issues/15174
+    const compactPendingFile = path.join(tmpDir, 'compact-pending');
+    if (fs.existsSync(compactPendingFile) && !isServiceSession) {
+      try {
+        const pendingContext = fs.readFileSync(compactPendingFile, 'utf8');
+        // Delete the file before outputting to avoid duplicate injection
+        fs.unlinkSync(compactPendingFile);
+
+        if (pendingContext.trim()) {
+          log(succDir, `Injecting compact-pending fallback context (${pendingContext.length} chars)`);
+
+          // Output as additionalContext - this will be injected into Claude's context
+          const output = {
+            hookSpecificOutput: {
+              hookEventName: 'UserPromptSubmit',
+              additionalContext: `<compact-fallback reason="SessionStart output may have been lost">\n${pendingContext}\n</compact-fallback>`
+            }
+          };
+          console.log(JSON.stringify(output));
+        }
+      } catch (err) {
+        log(succDir, `Error processing compact-pending: ${err.message || err}`);
+      }
+    }
+
+    // Notify daemon of user activity
+    if (daemonPort && sessionId) {
+      try {
+        await fetch(`http://127.0.0.1:${daemonPort}/api/session/activity`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            session_id: sessionId,
+            type: 'user_prompt',
+            transcript_path: transcriptPath,
+            is_service: isServiceSession,
+          }),
+          signal: AbortSignal.timeout(2000),
+        });
+      } catch {}
+    }
+
+    // --- Skill Suggestions ---
+    // LLM-powered skill suggestions based on user prompt.
+    // Uses extractKeywords → BM25 search → LLM ranking.
+    // Respects cooldown to avoid suggesting on every prompt.
+    if (daemonPort && !isServiceSession) {
+      const prompt = hookInput.prompt || hookInput.message || '';
+
+      // Load config to check if auto_suggest is enabled
+      let skillsConfig = null;
+      const configPaths = [
+        path.join(succDir, 'config.json'),
+        path.join(require('os').homedir(), '.succ', 'config.json'),
+      ];
+      for (const configPath of configPaths) {
+        if (fs.existsSync(configPath)) {
+          try {
+            const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+            if (config.skills) {
+              skillsConfig = config.skills;
+              break;
+            }
+          } catch {
+            // Ignore parse errors
+          }
+        }
+      }
+
+      // Defaults
+      const autoSuggest = skillsConfig?.auto_suggest || {};
+      const enabled = autoSuggest.enabled !== false; // default: true
+      const onUserPrompt = autoSuggest.on_user_prompt !== false; // default: true
+      const minPromptLength = autoSuggest.min_prompt_length || 20;
+      const cooldownPrompts = autoSuggest.cooldown_prompts || 3;
+
+      if (enabled && onUserPrompt && prompt.length >= minPromptLength) {
+        // Check cooldown (track prompts since last suggestion per session)
+        const cooldownFile = path.join(tmpDir, `skill-cooldown-${sessionId}`);
+        let promptsSinceLastSuggestion = 0;
+
+        try {
+          if (fs.existsSync(cooldownFile)) {
+            promptsSinceLastSuggestion = parseInt(fs.readFileSync(cooldownFile, 'utf8').trim(), 10) || 0;
+          }
+        } catch {}
+
+        // Only suggest if cooldown has passed
+        if (promptsSinceLastSuggestion >= cooldownPrompts || promptsSinceLastSuggestion === 0) {
+          try {
+            const response = await fetch(`http://127.0.0.1:${daemonPort}/api/skills/suggest`, {
+              method: 'POST',
+              headers: { 'Content-Type': 'application/json' },
+              body: JSON.stringify({ prompt }),
+              signal: AbortSignal.timeout(15000), // 15s timeout for 2 LLM calls (extraction + ranking)
+            });
+
+            if (response.ok) {
+              const data = await response.json();
+              const suggestions = data.suggestions || [];
+
+              if (suggestions.length > 0) {
+                // Reset cooldown counter
+                fs.writeFileSync(cooldownFile, '0', 'utf8');
+
+                // Format suggestions
+                const lines = suggestions.map((s) => {
+                  return `- **${s.name}**: ${s.reason} (confidence: ${(s.confidence * 100).toFixed(0)}%)`;
+                });
+
+                const suggestionContext = `<skill-suggestions hint="Use /${suggestions[0].name} to invoke">\n${lines.join('\n')}\n</skill-suggestions>`;
+
+                log(succDir, `Suggesting ${suggestions.length} skill(s): ${suggestions.map(s => s.name).join(', ')}`);
+
+                // Output as additionalContext
+                const output = {
+                  hookSpecificOutput: {
+                    hookEventName: 'UserPromptSubmit',
+                    additionalContext: suggestionContext
+                  }
+                };
+                console.log(JSON.stringify(output));
+              } else {
+                // No suggestions, increment cooldown
+                fs.writeFileSync(cooldownFile, String(promptsSinceLastSuggestion + 1), 'utf8');
+              }
+            }
+          } catch (err) {
+            log(succDir, `Skill suggestion error: ${err.message || err}`);
+          }
+        } else {
+          // Cooldown not passed, increment counter
+          try {
+            fs.writeFileSync(cooldownFile, String(promptsSinceLastSuggestion + 1), 'utf8');
+          } catch {}
+        }
+      }
+    }
+
+    process.exit(0);
+  } catch (err) {
+    process.exit(0);
+  }
+});

package/package.json

@@ -0,0 +1,128 @@
+{
+  "name": "@vinaes/succ",
+  "version": "1.3.19",
+  "description": "Semantic Understanding for Code Contexts — persistent memory for AI coding assistants (Claude Code, Cursor, Windsurf, Continue.dev)",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/cli.js",
+  "types": "./dist/cli.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/cli.d.ts",
+      "default": "./dist/cli.js"
+    },
+    "./api": {
+      "types": "./dist/lib/public-api.d.ts",
+      "default": "./dist/lib/public-api.js"
+    },
+    "./mcp": {
+      "types": "./dist/mcp-server.d.ts",
+      "default": "./dist/mcp-server.js"
+    }
+  },
+  "bin": {
+    "succ": "./dist/cli.js",
+    "succ-mcp": "./dist/mcp-server.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/cli.ts",
+    "test": "vitest",
+    "test:storage": "vitest --run src/lib/storage/",
+    "test:storage:integration": "vitest --run src/lib/storage/**/*.integration.test.ts",
+    "test:integration": "node tests/integration-llm.mjs",
+    "test:integration:backends": "node tests/integration-llm-backends.mjs",
+    "test:integration:skills": "node tests/integration-skills.mjs",
+    "test:integration:sleep-agent": "node tests/integration-sleep-agent.mjs",
+    "test:integration:all": "npm run test:integration && npm run test:integration:backends && npm run test:integration:skills && npm run test:integration:sleep-agent",
+    "benchmark:storage": "tsx src/lib/storage/benchmark.ts",
+    "lint": "eslint src/",
+    "lint:fix": "eslint src/ --fix",
+    "format": "prettier --write src/",
+    "format:check": "prettier --check src/",
+    "prepare": "npm run build",
+    "prepublishOnly": "npm run build && npm run lint"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "memory",
+    "rag",
+    "embeddings",
+    "ai",
+    "mcp",
+    "semantic-search",
+    "knowledge-graph",
+    "cursor",
+    "windsurf"
+  ],
+  "author": "vinaes",
+  "license": "FSL-1.1-Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vinaes/succ.git"
+  },
+  "homepage": "https://github.com/vinaes/succ#readme",
+  "bugs": {
+    "url": "https://github.com/vinaes/succ/issues"
+  },
+  "dependencies": {
+    "@huggingface/transformers": "^3.0.0",
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "@parcel/watcher": "^2.5.6",
+    "@redactpii/node": "^1.0.16",
+    "better-sqlite3": "^12.6.2",
+    "commander": "^14.0.3",
+    "cross-spawn": "^7.0.6",
+    "glob": "^13.0.3",
+    "gray-matter": "^4.0.3",
+    "inquirer": "^13.2.2",
+    "is-installed-globally": "^1.0.0",
+    "onnxruntime-node": "1.24.1",
+    "ora": "^9.3.0",
+    "sqlite-vec": "0.1.7-alpha.2",
+    "web-tree-sitter": "^0.26.5",
+    "ws": "^8.19.0",
+    "zod": "^3.25.76"
+  },
+  "optionalDependencies": {
+    "@qdrant/js-client-rest": "^1.12.0",
+    "pg": "^8.13.0"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.0",
+    "@types/inquirer": "^9.0.9",
+    "@types/node": "^25.2.3",
+    "@types/pg": "^8.11.0",
+    "@types/ws": "^8.18.1",
+    "@typescript-eslint/eslint-plugin": "^8.54.0",
+    "@typescript-eslint/parser": "^8.54.0",
+    "eslint": "^9.39.2",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.5",
+    "prettier": "^3.8.1",
+    "tsx": "^4.0.0",
+    "typescript": "^5.0.0",
+    "typescript-eslint": "^8.55.0",
+    "vitest": "^4.0.18"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "dist/**/*.js.map",
+    "dist/**/*.d.ts.map",
+    "!dist/**/*.test.*",
+    "!dist/**/*.integration.*",
+    "!dist/**/test-backends.*",
+    "hooks",
+    "agents"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "overrides": {
+    "onnxruntime-node": "1.24.1"
+  }
+}