@swarmdo/cli 1.30.0 → 1.45.0

package/dist/src/commands/hooks.js

@@ -8,6 +8,9 @@ import { callMCPTool, MCPClientError } from '../mcp-client.js';
 import { storeCommand } from './transfer-store.js';
 import { existsSync, readFileSync, statSync } from 'node:fs';
 import { join } from 'node:path';
+import { bridgeSearchEntries } from '../memory/memory-bridge.js';
+import { selectInjectionMemories, mapSearchResultsToCandidates, extractPromptFromPayload, } from '../memory-inject/select.js';
+import { classifyCommand, extractBashCommand, denyOutput } from '../hooks-recipe/command-guard.js';
 /**
  * #1686 — `?? 0` only defaults null/undefined; NaN slips through and
  * surfaces as `"NaN"` (or earlier crashed `.toFixed`) in the metrics
@@ -731,6 +734,174 @@ const routeCommand = {
         }
     }
 };
+/**
+ * Read a Claude Code hook payload from stdin (JSON on UserPromptSubmit), with a
+ * short timeout so it never hangs when stdin isn't closed (a known Windows
+ * failure mode). Returns '' for a TTY or on any error — the caller then simply
+ * injects nothing.
+ */
+async function readHookStdin(timeoutMs = 1500) {
+    if (process.stdin.isTTY)
+        return '';
+    return new Promise((resolve) => {
+        let data = '';
+        const finish = (v) => {
+            try {
+                process.stdin.pause();
+            }
+            catch { /* noop */ }
+            resolve(v);
+        };
+        const timer = setTimeout(() => finish(data), timeoutMs);
+        try {
+            process.stdin.setEncoding('utf8');
+            process.stdin.on('data', (c) => { data += c; });
+            process.stdin.on('end', () => { clearTimeout(timer); finish(data); });
+            process.stdin.on('error', () => { clearTimeout(timer); finish(data); });
+            process.stdin.resume();
+        }
+        catch {
+            clearTimeout(timer);
+            finish('');
+        }
+    });
+}
+const DEFAULT_INJECT_NAMESPACES = ['claude-memories', 'auto-memory', 'patterns'];
+/**
+ * memory-inject — the #43 prompt-time semantic memory injection hook. Embeds the
+ * submitted prompt, vector-searches AgentDB across the memory namespaces, and
+ * emits the most relevant stored memories as UserPromptSubmit `additionalContext`
+ * under a strict token budget. Wired for the hook path: it NEVER errors out
+ * (that would break the user's prompt) and stays silent when nothing is relevant.
+ */
+const memoryInjectCommand = {
+    name: 'memory-inject',
+    description: 'Inject relevant stored memories into the prompt (UserPromptSubmit hook)',
+    options: [
+        { name: 'prompt', short: 'p', description: 'Prompt text (else read the hook JSON from stdin)', type: 'string' },
+        { name: 'namespaces', description: 'Comma-separated namespaces to search', type: 'string', default: DEFAULT_INJECT_NAMESPACES.join(',') },
+        { name: 'budget', description: 'Max tokens of injected context', type: 'number', default: 800 },
+        { name: 'min-relevance', description: 'Minimum relevance score (0..1)', type: 'number', default: 0.35 },
+        { name: 'top-k', short: 'K', description: 'Max memories to inject', type: 'number', default: 5 },
+        { name: 'limit', description: 'Max search results to rank', type: 'number', default: 20 },
+        { name: 'preview', description: 'Print the block for humans instead of emitting hook JSON', type: 'boolean' },
+        { name: 'db', description: 'Path to the memory database', type: 'string' },
+    ],
+    examples: [
+        { command: 'swarmdo hooks memory-inject -p "refactor the auth module" --preview', description: 'Preview relevant memories for a prompt' },
+        { command: "echo '{\"prompt\":\"fix bug\"}' | swarmdo hooks memory-inject", description: 'Run as a UserPromptSubmit hook' },
+    ],
+    action: async (ctx) => {
+        const preview = Boolean(ctx.flags.preview);
+        // A hook must NEVER break the user's prompt: swallow every error and emit nothing.
+        try {
+            if (process.env.SWARMDO_MEMORY_INJECT_DISABLE === '1')
+                return { success: true };
+            let prompt = (ctx.flags.prompt || ctx.args.join(' ')).trim();
+            if (!prompt)
+                prompt = extractPromptFromPayload(await readHookStdin());
+            if (!prompt)
+                return { success: true }; // nothing to search on
+            const namespaces = String(ctx.flags.namespaces ?? DEFAULT_INJECT_NAMESPACES.join(','))
+                .split(',').map((s) => s.trim()).filter(Boolean);
+            const minRelevance = ctx.flags.minRelevance ?? 0.35;
+            const topK = ctx.flags.topK ?? 5;
+            const limit = Math.max(ctx.flags.limit ?? 20, topK);
+            const search = await bridgeSearchEntries({
+                query: prompt,
+                namespace: 'all',
+                limit,
+                threshold: minRelevance,
+                fullContent: true,
+                dbPath: ctx.flags.db,
+            });
+            const rows = (search && search.success ? search.results : []);
+            const candidates = mapSearchResultsToCandidates(rows, namespaces);
+            const result = selectInjectionMemories(candidates, {
+                budgetTokens: ctx.flags.budget ?? 800,
+                minRelevance,
+                topK,
+            });
+            if (preview) {
+                if (!result.block) {
+                    output.printInfo('No relevant memories to inject.');
+                }
+                else {
+                    output.writeln(result.block);
+                    output.writeln();
+                    output.printInfo(`Injected ${result.used.length} memor${result.used.length === 1 ? 'y' : 'ies'} ` +
+                        `(~${result.tokensUsed} tokens${result.skipped ? `, ${result.skipped} skipped` : ''}).`);
+                }
+                return { success: true, data: { used: result.used.length, skipped: result.skipped, tokensUsed: result.tokensUsed } };
+            }
+            // Hook mode: emit additionalContext JSON ONLY when there's something to add,
+            // so an irrelevant prompt leaves Claude's context untouched.
+            if (result.block) {
+                process.stdout.write(JSON.stringify({
+                    hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext: result.block },
+                }) + '\n');
+            }
+            return { success: true };
+        }
+        catch (err) {
+            if (preview)
+                output.printError(`Memory injection failed: ${String(err)}`);
+            return { success: true }; // never fail the hook
+        }
+    },
+};
+/**
+ * guard-bash — the #83 PreToolUse/Bash guardrail. Reads the hook payload from
+ * stdin (or --command), classifies the bash command against a conservative
+ * destructive-command denylist, and on a match emits Claude Code's
+ * `permissionDecision: "deny"` to hard-block it. This is the only safety net
+ * that still fires under headless `claude -p --dangerously-skip-permissions`.
+ * Hook-safe: it NEVER errors and stays silent (allow) for anything not on the
+ * denylist, so it can't break a legitimate command.
+ */
+const guardBashCommand = {
+    name: 'guard-bash',
+    description: 'Block dangerous bash commands (PreToolUse hook): emits permissionDecision:deny on a destructive-command denylist',
+    options: [
+        { name: 'command', short: 'c', description: 'Command to classify (else read the hook JSON from stdin)', type: 'string' },
+        { name: 'preview', description: 'Print the human-readable verdict instead of emitting hook JSON', type: 'boolean' },
+    ],
+    examples: [
+        { command: 'swarmdo hooks guard-bash -c "rm -rf /" --preview', description: 'Check whether a command would be blocked' },
+        { command: 'echo \'{"tool_input":{"command":"rm -rf /"}}\' | swarmdo hooks guard-bash', description: 'Run as a PreToolUse/Bash hook' },
+    ],
+    action: async (ctx) => {
+        const preview = Boolean(ctx.flags.preview);
+        // A hook must NEVER break a tool call by crashing: swallow everything, default to allow.
+        try {
+            if (process.env.SWARMDO_GUARD_BASH_DISABLE === '1')
+                return { success: true };
+            let command = (ctx.flags.command || ctx.args.join(' ')).trim();
+            if (!command)
+                command = extractBashCommand(await readHookStdin());
+            if (!command)
+                return { success: true }; // nothing to classify → allow
+            const verdict = classifyCommand(command);
+            if (preview) {
+                if (verdict.block)
+                    output.printError(`BLOCK: ${verdict.reason} [${verdict.rule}]`);
+                else
+                    output.printSuccess('allow — no destructive pattern matched');
+                return { success: true, data: verdict };
+            }
+            // Hook mode: emit the deny JSON only on a block; silence = allow.
+            if (verdict.block) {
+                process.stdout.write(JSON.stringify(denyOutput(verdict.reason)) + '\n');
+            }
+            return { success: true };
+        }
+        catch (err) {
+            if (preview)
+                output.printError(`guard-bash failed: ${String(err)}`);
+            return { success: true }; // never fail the hook (fail-open: a broken guard must not block work)
+        }
+    },
+};
 // Explain subcommand
 const explainCommand = {
     name: 'explain',
@@ -4447,7 +4618,7 @@ const notifyCommand = {
 const recipeCommand = {
     name: 'recipe',
     aliases: ['recipes'],
-    description: 'Install ready-made Claude Code hook recipes (desktop notify) into settings — dry-run unless --apply',
+    description: 'Install ready-made Claude Code hook recipes (desktop notify, memory injection) into settings — dry-run unless --apply',
     options: [
         { name: 'apply', type: 'boolean', description: 'write the change (default: preview only)', default: false },
         { name: 'shared', type: 'boolean', description: 'target .claude/settings.json (shared/committed) instead of settings.local.json', default: false },
@@ -4553,6 +4724,8 @@ export const hooksCommand = {
         sessionEndCommand,
         sessionRestoreCommand,
         routeCommand,
+        memoryInjectCommand,
+        guardBashCommand,
         explainCommand,
         pretrainCommand,
         buildAgentsCommand,
@@ -4610,6 +4783,8 @@ export const hooksCommand = {
             `${output.highlight('session-end')}     - End current session and persist state`,
             `${output.highlight('session-restore')} - Restore a previous session`,
             `${output.highlight('route')}           - Route tasks to optimal agents`,
+            `${output.highlight('memory-inject')}   - Inject relevant memories into the prompt (UserPromptSubmit)`,
+            `${output.highlight('guard-bash')}      - Block dangerous bash commands (PreToolUse deny)`,
             `${output.highlight('explain')}         - Explain routing decisions`,
             `${output.highlight('pretrain')}        - Bootstrap intelligence from repository`,
             `${output.highlight('build-agents')}    - Generate optimized agent configs`,