@unerr-ai/unerr 0.2.0 → 0.2.2

package/dist/hooks/adapters/cline.js

@@ -1,100 +0,0 @@
-/**
- * Cline hook adapter.
- *
- * Protocol (Cline extension hooks):
- *   stdin:  { tool: "read_file", params: { path: "..." }, event: "pre_tool" | "post_tool" }
- *   stdout (PreToolUse):
- *     - passthrough: { allow: true }
- *     - nudge:       { allow: true, context: "..." }
- *     - deny:        { allow: false, reason: "..." }  (not used by unerr — never block)
- *   stdout (PostToolUse):
- *     - passthrough: {}
- *     - enrich:      { context: "..." }
- *   stdout (UserPromptSubmit):
- *     - passthrough: {}
- *     - enrich:      { context: "..." }
- *
- * Detection: Cline sends `tool` (lowercase, snake_case tool name) + `params` at root.
- */
-/** Map Cline tool names to normalized tool names. */
-const CLINE_TOOL_MAP = {
-    read_file: "Read",
-    write_to_file: "Write",
-    replace_in_file: "Edit",
-    search_files: "Grep",
-    list_files: "Glob",
-    execute_command: "Bash",
-};
-export const clineAdapter = {
-    name: "cline",
-    detect(payload) {
-        // Cline sends `tool` (string) + `params` (object) at root
-        // Distinguish from Claude Code (has hook_event_name) and Cursor (has toolName)
-        return (typeof payload.tool === "string" &&
-            typeof payload.params === "object" &&
-            payload.params !== null &&
-            typeof payload.hook_event_name !== "string" &&
-            typeof payload.toolName !== "string");
-    },
-    normalize(payload) {
-        const params = (payload.params ?? {});
-        const clineTool = payload.tool;
-        const toolName = CLINE_TOOL_MAP[clineTool] ?? clineTool;
-        // Normalize Cline's param names to match our expectations
-        const toolInput = { ...params };
-        // Cline uses `path` instead of `file_path`
-        if (toolInput.path && !toolInput.file_path) {
-            toolInput.file_path = toolInput.path;
-        }
-        // Cline uses `regex` instead of `pattern`
-        if (toolInput.regex && !toolInput.pattern) {
-            toolInput.pattern = toolInput.regex;
-        }
-        // Cline uses `command` for execute_command
-        // (already matches our expected format)
-        // Map Cline event names
-        let event;
-        const clineEvent = payload.event;
-        if (clineEvent === "pre_tool")
-            event = "PreToolUse";
-        else if (clineEvent === "post_tool")
-            event = "PostToolUse";
-        return { raw: payload, toolInput, toolName, event };
-    },
-    formatPreToolUse(result) {
-        if (result.type === "passthrough") {
-            return JSON.stringify({ allow: true });
-        }
-        if (result.type === "nudge" && result.message) {
-            return JSON.stringify({
-                allow: true,
-                context: result.message,
-            });
-        }
-        if (result.type === "rewrite" && result.updatedInput) {
-            // Cline doesn't support input rewriting directly — allow with context
-            return JSON.stringify({
-                allow: true,
-                context: "Suggested rewrite: use unerr exec for this command.",
-            });
-        }
-        return JSON.stringify({ allow: true });
-    },
-    formatPostToolUse(result) {
-        if (result.type === "passthrough")
-            return "{}";
-        if ((result.type === "enrich" || result.type === "nudge") &&
-            result.message) {
-            return JSON.stringify({ context: result.message });
-        }
-        return "{}";
-    },
-    formatPromptSubmit(result) {
-        if (result.type === "passthrough")
-            return "{}";
-        if (result.message) {
-            return JSON.stringify({ context: result.message });
-        }
-        return "{}";
-    },
-};

package/dist/hooks/adapters/cursor.js

@@ -1,98 +0,0 @@
-/**
- * Cursor hook adapter.
- *
- * Protocol (from official Cursor hooks documentation):
- *   stdin (preToolUse):  { tool_name: "Read", tool_input: { file_path: "..." }, tool_use_id: "abc", cwd: "/project", model: "..." }
- *   stdin (postToolUse): { tool_name: "Read", tool_input: {...}, tool_output: "...", tool_use_id: "abc", cwd: "/project", duration: 1234 }
- *   stdin (beforeSubmitPrompt): { prompt: "...", attachments: [...] }
- *
- *   stdout (preToolUse):
- *     - passthrough: { permission: "allow" }
- *     - nudge:       { permission: "allow", agent_message: "..." }
- *     - rewrite:     { permission: "allow", updated_input: { ... } }
- *   stdout (postToolUse):
- *     - passthrough: {}
- *     - enrich:      { additional_context: "..." }
- *   stdout (beforeSubmitPrompt):
- *     - always:      { continue: true }
- *
- * Detection: Cursor sends `tool_name` (snake_case) + `cwd` at root level,
- * without `hook_event_name` (which is Claude Code's marker).
- */
-export const cursorAdapter = {
-    name: "cursor",
-    detect(payload) {
-        // Cursor sends tool_name (snake_case) + cwd, without hook_event_name
-        return (typeof payload.tool_name === "string" &&
-            typeof payload.hook_event_name !== "string" &&
-            typeof payload.cwd === "string");
-    },
-    normalize(payload) {
-        const toolInput = (payload.tool_input ?? {});
-        const toolName = payload.tool_name;
-        // Cursor doesn't send explicit event type in a single field — infer from context:
-        // postToolUse payloads include tool_output; preToolUse does not
-        // beforeSubmitPrompt payloads include prompt
-        let event;
-        if (typeof payload.prompt === "string") {
-            event = "UserPromptSubmit";
-        }
-        else if (typeof payload.tool_output === "string" ||
-            payload.tool_output !== undefined) {
-            event = "PostToolUse";
-        }
-        else {
-            event = "PreToolUse";
-        }
-        return { raw: payload, toolInput, toolName, event };
-    },
-    formatPreToolUse(result) {
-        if (result.type === "passthrough") {
-            return JSON.stringify({ permission: "allow" });
-        }
-        if (result.type === "nudge" && result.message) {
-            return JSON.stringify({
-                permission: "allow",
-                agent_message: result.message,
-            });
-        }
-        if (result.type === "rewrite" && result.updatedInput) {
-            return JSON.stringify({
-                permission: "allow",
-                updated_input: result.updatedInput,
-            });
-        }
-        return JSON.stringify({ permission: "allow" });
-    },
-    formatPostToolUse(result) {
-        if (result.type === "passthrough") {
-            return "{}";
-        }
-        if ((result.type === "enrich" || result.type === "nudge") &&
-            result.message) {
-            return JSON.stringify({
-                additional_context: result.message,
-            });
-        }
-        return "{}";
-    },
-    formatPromptSubmit(result) {
-        // Cursor's beforeSubmitPrompt only supports:
-        //   { continue: true|false, user_message: "..." }
-        // user_message is shown to the USER in the client, not injected into agent context.
-        // There is no agent_message or additionalContext field for this hook.
-        // So we always continue — the prompt-submit nudge only works in Claude Code.
-        if (result.type === "passthrough") {
-            return JSON.stringify({ continue: true });
-        }
-        // Even with a message, we can't inject it into agent context via this hook.
-        // The best we can do is show it to the user via user_message.
-        if (result.message) {
-            return JSON.stringify({
-                continue: true,
-                user_message: result.message,
-            });
-        }
-        return JSON.stringify({ continue: true });
-    },
-};

package/dist/hooks/hook-dedup.js

@@ -1,79 +0,0 @@
-/**
- * File-based dedup for PostToolUse hooks.
- *
- * Hooks are invoked as subprocess spawns by the agent — each call is a fresh
- * Node process with no in-memory state to share. To dedup a recently-emitted
- * reminder for the same (tool, file) pair we persist a tiny timestamp map to
- * `.unerr/state/hook-recent.json` and consult it on each invocation.
- *
- * Failure modes (no .unerr dir, corrupt JSON, write error) all degrade safely:
- * we return true (emit) so the reminder still surfaces. We never throw.
- */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-const STATE_FILE = join(".unerr", "state", "hook-recent.json");
-const DEFAULT_TTL_MS = 30_000;
-const PRUNE_FACTOR = 10;
-function readMap(file) {
-    try {
-        if (!existsSync(file))
-            return {};
-        const raw = readFileSync(file, "utf8");
-        const obj = JSON.parse(raw);
-        if (obj && typeof obj === "object")
-            return obj;
-    }
-    catch {
-        // fall through
-    }
-    return {};
-}
-function writeMap(file, map) {
-    try {
-        const dir = dirname(file);
-        if (!existsSync(dir))
-            mkdirSync(dir, { recursive: true });
-        writeFileSync(file, JSON.stringify(map));
-    }
-    catch {
-        // best-effort; if we can't persist, next call won't dedup but won't crash
-    }
-}
-function prune(map, now, ttlMs) {
-    const cutoff = now - ttlMs * PRUNE_FACTOR;
-    const out = {};
-    for (const [k, v] of Object.entries(map)) {
-        if (typeof v === "number" && v >= cutoff)
-            out[k] = v;
-    }
-    return out;
-}
-/**
- * Returns true if the caller should emit the reminder for `key` now, false if
- * it was already emitted within `ttlMs`. On first emission the timestamp is
- * persisted; subsequent calls within TTL return false.
- *
- * @param key  stable identifier — `${tool}:${absPath}` is typical
- * @param ttlMs  dedup window; default 30s
- */
-export function shouldEmitOnce(key, ttlMs = DEFAULT_TTL_MS) {
-    const now = Date.now();
-    const map = readMap(STATE_FILE);
-    const last = map[key];
-    if (typeof last === "number" && now - last < ttlMs) {
-        return false;
-    }
-    map[key] = now;
-    writeMap(STATE_FILE, prune(map, now, ttlMs));
-    return true;
-}
-/** Test helper — clears the on-disk dedup file. */
-export function resetHookDedup() {
-    try {
-        if (existsSync(STATE_FILE))
-            writeFileSync(STATE_FILE, "{}");
-    }
-    catch {
-        // ignore
-    }
-}

package/dist/hooks/hook-runner.js

@@ -1,113 +0,0 @@
-/**
- * Universal Hook Runner — agent-agnostic hook orchestrator.
- *
- * Detects the calling agent from stdin JSON shape, routes through the
- * appropriate adapter, and returns the response in the agent's expected format.
- *
- * Adapter protocol:
- *   1. Parse stdin JSON
- *   2. Try each adapter's `detect()` until one matches
- *   3. Extract normalized tool input via adapter
- *   4. Run the hook handler (returns agent-agnostic HookResult)
- *   5. Format the response via adapter
- *
- * Supported agents: Claude Code, Cursor, Cline.
- * Fallback: Claude Code (most common MCP hook consumer).
- */
-import { claudeCodeAdapter } from "./adapters/claude-code.js";
-import { clineAdapter } from "./adapters/cline.js";
-import { cursorAdapter } from "./adapters/cursor.js";
-// ── Adapter Registry ─────────────────────────────────────────────────
-/**
- * Ordered list of adapters. More specific detectors first.
- * Claude Code is last (default fallback).
- */
-const ADAPTERS = [
-    cursorAdapter,
-    clineAdapter,
-    claudeCodeAdapter, // default fallback
-];
-// ── Runner ───────────────────────────────────────────────────────────
-/**
- * Detect the appropriate adapter for a parsed stdin payload.
- * Returns Claude Code adapter as fallback (most common).
- */
-export function detectAdapter(payload) {
-    for (const adapter of ADAPTERS) {
-        if (adapter.detect(payload))
-            return adapter;
-    }
-    return claudeCodeAdapter;
-}
-/** Parse stdin JSON, returning null on failure. */
-function parseStdin(stdinJson) {
-    const trimmed = stdinJson.trim();
-    if (!trimmed)
-        return null;
-    try {
-        return JSON.parse(trimmed);
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Run a PreToolUse hook through the universal runner.
- *
- * @param stdinJson — raw stdin from the hook process
- * @param handler — agent-agnostic handler that produces a HookResult
- * @returns JSON string for stdout
- */
-export function runPreToolUseHook(stdinJson, handler) {
-    const payload = parseStdin(stdinJson);
-    if (!payload)
-        return "{}";
-    const adapter = detectAdapter(payload);
-    const normalized = adapter.normalize(payload);
-    normalized.agentName = adapter.name;
-    const result = handler(normalized);
-    return adapter.formatPreToolUse(result);
-}
-/**
- * Run a PostToolUse hook through the universal runner.
- */
-export function runPostToolUseHook(stdinJson, handler) {
-    const payload = parseStdin(stdinJson);
-    if (!payload)
-        return "{}";
-    const adapter = detectAdapter(payload);
-    const normalized = adapter.normalize(payload);
-    normalized.agentName = adapter.name;
-    const result = handler(normalized);
-    return adapter.formatPostToolUse(result);
-}
-/**
- * Run a UserPromptSubmit hook through the universal runner.
- */
-export function runPromptSubmitHook(stdinJson, handler) {
-    const payload = parseStdin(stdinJson);
-    if (!payload)
-        return "{}";
-    const adapter = detectAdapter(payload);
-    const normalized = adapter.normalize(payload);
-    normalized.agentName = adapter.name;
-    const result = handler(normalized);
-    return adapter.formatPromptSubmit(result);
-}
-// ── Convenience Constructors ─────────────────────────────────────────
-/** Create a passthrough result. */
-export function passthrough() {
-    return { type: "passthrough" };
-}
-/** Create a nudge (advisory systemMessage) result. */
-export function nudge(message) {
-    return { type: "nudge", message };
-}
-/** Create a rewrite (updatedInput) result. */
-export function rewrite(updatedInput) {
-    return { type: "rewrite", updatedInput };
-}
-/** Create an enrich (additionalContext) result. */
-export function enrich(message) {
-    return { type: "enrich", message };
-}

package/dist/hooks/navigation-hooks.js

@@ -1,175 +0,0 @@
-/**
- * PreToolUse + PostToolUse hooks for Read/Grep/Glob/Write/Edit.
- *
- * Uses the universal hook runner for multi-agent protocol support.
- * Handlers return agent-agnostic HookResults; adapters format for each agent.
- *
- * Design: NEVER block — always allow, only advise or enrich.
- */
-import { shouldEmitOnce } from "./hook-dedup.js";
-import { enrich, nudge, passthrough, runPostToolUseHook, runPreToolUseHook, } from "./hook-runner.js";
-// ── Helper ───────────────────────────────────────────────────────────
-/** Extract file path from normalized tool input. */
-function extractFilePath(input) {
-    const fp = (input.file_path ?? input.path ?? input.filePath);
-    return typeof fp === "string" && fp.length > 0 ? fp : undefined;
-}
-/** Check if file is a code file (not config/docs/binary). */
-function isCodeFile(filePath) {
-    return !/\.(md|json|ya?ml|toml|txt|lock|css|html|svg|png|jpg|pdf)$/i.test(filePath);
-}
-// ── PreToolUse Handlers (agent-agnostic) ─────────────────────────────
-const preReadHandler = (normalized) => {
-    const input = normalized.toolInput;
-    const filePath = extractFilePath(input);
-    if (!filePath)
-        return passthrough();
-    const isClaudeCode = normalized.agentName === "claude-code";
-    const hasOffset = input.offset !== undefined;
-    const hasLimit = input.limit !== undefined;
-    const isTargeted = hasOffset || hasLimit;
-    // Claude Code: targeted Read (offset/limit) before Edit is the correct workflow — allow silently.
-    // Non-Claude Code agents: built-in Read is never needed, always nudge toward file_read.
-    if (isClaudeCode && isTargeted) {
-        return passthrough();
-    }
-    if (isClaudeCode) {
-        // Full-file Read in Claude Code — nudge to use offset/limit for the Edit workflow
-        return nudge(`READ ROUTING: Built-in Read is ONLY for the Edit workflow (Read → Edit). Use offset/limit to read only the lines you plan to edit — do NOT read the entire file.\nFor all other reading, use unerr tools instead:\n- Reading to understand: \`file_read({ file_path: "${filePath}" })\`\n- File structure: \`file_outline("${filePath}")\`\n- Specific function: \`get_entity\` or \`file_read\` with \`entity\` param`);
-    }
-    // Non-Claude Code agents: always nudge toward file_read
-    return nudge(`Use unerr tools instead of built-in Read:\n- \`file_read({ file_path: "${filePath}" })\` — auto-injects conventions, facts, drift status\n- \`file_outline("${filePath}")\` — file structure overview\n- \`get_entity\` or \`file_read\` with \`entity\` param — specific function/class`);
-};
-const preGrepHandler = (normalized) => {
-    const input = normalized.toolInput;
-    const pattern = (input.pattern ?? input.regex ?? input.query);
-    if (typeof pattern !== "string" || pattern.length === 0)
-        return passthrough();
-    const looksLikeFunctionSearch = /^[a-zA-Z_]\w*$/.test(pattern);
-    const looksLikeImportSearch = /import|require|from\s/.test(pattern);
-    if (looksLikeFunctionSearch) {
-        return nudge(`STOP: You MUST use unerr graph tools instead of Grep for "${pattern}".\n- \`search_code("${pattern}")\` — finds ALL matching functions/classes/types in <5ms (zero false positives)\n- \`get_references("${pattern}")\` — finds all callers including indirect references\nText grep matches comments, strings, and unrelated code. Graph tools are precise and faster.`);
-    }
-    if (looksLikeImportSearch) {
-        return nudge("STOP: Use `get_imports` instead of Grep for import/dependency tracing. It returns structured import maps in <5ms — more reliable than grepping for import statements.");
-    }
-    return nudge("REQUIRED: This project has unerr graph tools indexed. Use `search_code` for code entity searches (faster, more accurate than Grep). Use `get_references` for finding callers.");
-};
-const preGlobHandler = (normalized) => {
-    const input = normalized.toolInput;
-    const pattern = (input.pattern ?? input.glob ?? input.path);
-    if (typeof pattern !== "string" || pattern.length === 0)
-        return passthrough();
-    return nudge(`STOP: You MUST use unerr graph tools instead of Glob.\n- \`search_code("${pattern}")\` — finds ALL matching functions/classes/types across the entire codebase in <5ms\n- \`file_outline\` — get file structure without reading entire files\n- \`get_file\` — get all entities in a file with structured metadata\nGlob+Grep is a multi-step pattern that wastes tokens. search_code does it in one call.`);
-};
-const preWriteHandler = (normalized) => {
-    const filePath = extractFilePath(normalized.toolInput);
-    if (!filePath || !isCodeFile(filePath))
-        return passthrough();
-    return nudge(`Before writing "${filePath}", check for unintended side effects:\n- \`get_references\` on any functions you're modifying — ensure callers still work after your changes\n- \`file_connections("${filePath}")\` — see all files that depend on this one\n- \`get_test_coverage\` on modified entities — know which tests to run`);
-};
-const preEditHandler = (normalized) => {
-    const input = normalized.toolInput;
-    const filePath = extractFilePath(input);
-    if (!filePath || !isCodeFile(filePath))
-        return passthrough();
-    const isClaudeCode = normalized.agentName === "claude-code";
-    // Read prerequisite warning — Claude Code only (other agents don't require built-in Read before Edit)
-    const readPrereq = isClaudeCode
-        ? `CRITICAL: Edit REQUIRES built-in Read to have been called on "${filePath}" first. file_read (MCP) does NOT satisfy this — the Edit tool will fail with "File has not been read yet". If you haven't called built-in Read (with offset/limit on the target lines) on this file, do so now before attempting Edit.\n\n`
-        : "";
-    const oldStr = input.old_string;
-    const hasSignatureChange = oldStr &&
-        /^(export\s+)?(async\s+)?function\s+\w+|^(export\s+)?class\s+\w+/.test(oldStr.trim());
-    if (hasSignatureChange) {
-        return nudge(`${readPrereq}You're editing a function/class signature in "${filePath}". This may break callers.\n- \`get_references\` on the entity you're modifying — all callers must be updated to match\n- \`get_test_coverage\` on the entity — verify which tests cover it`);
-    }
-    return nudge(`${readPrereq}Before editing "${filePath}":\n- \`get_references\` on any entity you're changing — ensure callers won't break`);
-};
-// ── PostToolUse Handlers (agent-agnostic) ────────────────────────────
-const postReadHandler = (normalized) => {
-    const input = normalized.toolInput;
-    const filePath = extractFilePath(input);
-    if (!filePath || !isCodeFile(filePath))
-        return passthrough();
-    if (!shouldEmitOnce(`Read:${filePath}`))
-        return passthrough();
-    const isClaudeCode = normalized.agentName === "claude-code";
-    if (isClaudeCode) {
-        return enrich("ur|hnt Edit needs built-in Read first; for understanding use `file_read` (auto-injects facts/drift).");
-    }
-    return enrich("ur|hnt Prefer `file_read` over built-in Read — it auto-injects conventions, facts, drift.");
-};
-const postGrepHandler = (normalized) => {
-    const input = normalized.toolInput;
-    const pattern = (input.pattern ?? input.regex ?? input.query);
-    if (typeof pattern !== "string" || pattern.length === 0)
-        return passthrough();
-    const looksLikeFunctionSearch = /^[a-zA-Z_]\w*$/.test(pattern);
-    if (looksLikeFunctionSearch) {
-        return enrich(`You just grepped for "${pattern}". For structured results, try:\n` +
-            `- \`get_references "${pattern}"\` — finds ALL callers including indirect references (no false positives from comments/strings)\n` +
-            `- \`get_entity "${pattern}"\` — returns the entity with its full signature, body, and metadata\n` +
-            `- \`search_code "${pattern}"\` — ranked results across the entire codebase in <5ms`);
-    }
-    return enrich("You just grepped for a pattern. For structured code navigation, unerr graph tools are faster and more accurate:\n" +
-        "- `search_code` for entity-level search (functions, classes, types)\n" +
-        "- `get_references` for reference tracing (no false positives)");
-};
-const postGlobHandler = () => {
-    return enrich("You just found files via Glob. For efficient exploration of matched files:\n" +
-        "- `file_outline` on each file — see all entities without reading full contents (<5ms)\n" +
-        "- `search_code` — search for specific entities across all matched files in one call\n" +
-        `- \`get_file\` — get a structured summary of any file's entities, imports, and exports`);
-};
-const postWriteHandler = (normalized) => {
-    const filePath = extractFilePath(normalized.toolInput);
-    if (!filePath || !isCodeFile(filePath))
-        return passthrough();
-    if (!shouldEmitOnce(`Write:${filePath}`))
-        return passthrough();
-    // Table row #27 TRIM — slash-command fragments replaced with "why".
-    return enrich(`ur|hnt Wrote ${filePath} — get_references on exports to check blast radius`);
-};
-const postEditHandler = (normalized) => {
-    const filePath = extractFilePath(normalized.toolInput);
-    if (!filePath || !isCodeFile(filePath))
-        return passthrough();
-    if (!shouldEmitOnce(`Edit:${filePath}`))
-        return passthrough();
-    // Table row #28 TRIM — drop slash-command fragments, keep concrete next call.
-    return enrich(`ur|hnt Edited ${filePath} — get_references to check callers of changed entities`);
-};
-// ── Public API ───────────────────────────────────────────────────────
-// These maintain the same function signatures for backward compatibility
-// with hook.ts CLI commands.
-export function runPreReadHook(stdinJson) {
-    return runPreToolUseHook(stdinJson, preReadHandler);
-}
-export function runPreGrepHook(stdinJson) {
-    return runPreToolUseHook(stdinJson, preGrepHandler);
-}
-export function runPreGlobHook(stdinJson) {
-    return runPreToolUseHook(stdinJson, preGlobHandler);
-}
-export function runPreWriteHook(stdinJson) {
-    return runPreToolUseHook(stdinJson, preWriteHandler);
-}
-export function runPreEditHook(stdinJson) {
-    return runPreToolUseHook(stdinJson, preEditHandler);
-}
-export function runPostReadHook(stdinJson) {
-    return runPostToolUseHook(stdinJson, postReadHandler);
-}
-export function runPostGrepHook(stdinJson) {
-    return runPostToolUseHook(stdinJson, postGrepHandler);
-}
-export function runPostGlobHook(stdinJson) {
-    return runPostToolUseHook(stdinJson, postGlobHandler);
-}
-export function runPostWriteHook(stdinJson) {
-    return runPostToolUseHook(stdinJson, postWriteHandler);
-}
-export function runPostEditHook(stdinJson) {
-    return runPostToolUseHook(stdinJson, postEditHandler);
-}

package/dist/hooks/prompt-hooks.js

@@ -1,63 +0,0 @@
-/**
- * UserPromptSubmit hook — appends a concise unerr tool reminder to user prompt context.
- *
- * Uses the universal hook runner for multi-agent protocol support.
- * Fires on every user message. Appends ~50 tokens of context reminding the agent
- * that unerr graph tools are available.
- */
-import { readNudgeState, updateNudgeState } from "../proxy/nudge-state.js";
-import { enrich, passthrough, runPromptSubmitHook, } from "./hook-runner.js";
-/**
- * Agent-agnostic prompt submit handler.
- * Injects a brief tool-preference reminder into user prompt context.
- *
- * Nudge v2 (N1): when UNERR_NUDGE_V2=1, only fire on the first non-trivial
- * prompt of a session, then go silent until the next session. v1 default
- * behavior (fire on every prompt ≥10 chars) is preserved.
- */
-const promptSubmitHandler = (normalized) => {
-    // Extract the user's message to detect if it's code-related
-    const raw = normalized.raw;
-    const message = (raw.user_message ?? raw.prompt ?? "");
-    // Skip for very short messages (likely confirmations like "yes", "ok", "continue")
-    if (message.length < 10)
-        return passthrough();
-    // N1 — Tier 0 one-shot session onboarding (opt-in)
-    if (process.env.UNERR_NUDGE_V2 === "1") {
-        try {
-            const cwd = process.cwd();
-            const state = readNudgeState(cwd);
-            if (state.tier0_emitted)
-                return passthrough();
-            updateNudgeState(cwd, (s) => {
-                s.tier0_emitted = true;
-            });
-        }
-        catch {
-            // State unavailable — fall through to v1 behaviour
-        }
-    }
-    // Detect code-related intent for stronger nudge
-    const isCodeTask = /\b(fix|bug|add|implement|refactor|debug|update|change|modify|create|delete|remove|test|find|search|where|who calls|callers|dependencies|import)\b/i.test(message);
-    // Table rows #24/#25 TRIM — why (faster/graph-backed/project-aware) leads,
-    // then what (tool roster + when-tags for markers). Half the bytes, same signal.
-    if (isCodeTask) {
-        return enrich("[unerr] Prefer unerr MCP tools for code work (faster, graph-backed, project-aware): " +
-            "`search_code` (NOT grep/glob) · `get_references` (NOT grep for fn names) · " +
-            "`file_read` (NOT built-in Read for understanding; built-in Read is only for pre-Edit) · " +
-            "`file_outline` · `get_entity`. " +
-            "Mark progress: `mark_intent` (task start) · `mark_decision` · `mark_blocker` · " +
-            "`mark_resolution` — these power the cross-session timeline.");
-    }
-    return enrich("[unerr] Prefer unerr MCP tools (graph-backed, <5ms): " +
-        "`search_code` · `get_references` · `file_read` · `file_outline` · `get_entity`. " +
-        "Drop `mark_intent` / `mark_decision` / `mark_blocker` / `mark_resolution` as you work — " +
-        "they keep the timeline coherent across sessions.");
-};
-/**
- * UserPromptSubmit hook handler.
- * Returns JSON string for stdout.
- */
-export function runUserPromptSubmitHook(stdinJson) {
-    return runPromptSubmitHook(stdinJson, promptSubmitHandler);
-}

package/dist/hooks/shell-hooks.js

@@ -1,47 +0,0 @@
-/**
- * Layer 6 Sprint FE-D — PreToolUse stdin/stdout bridge for Bash -> `unerr exec`.
- *
- * Uses the universal hook runner for multi-agent protocol support.
- * Claude Code, Cursor, and Cline all route through the same handler;
- * the adapter layer handles protocol differences.
- *
- * Commands are base64-encoded (`--b64`) to avoid shell re-parsing issues
- * with multi-line commands, nested quotes, and special characters.
- */
-import { normalizeShellCommand } from "../proxy/shell-classifier.js";
-import { passthrough, rewrite, runPreToolUseHook, } from "./hook-runner.js";
-/**
- * Agent-agnostic Bash rewrite handler.
- * Rewrites shell commands to route through `unerr exec --b64 <base64>`.
- * Base64-encoding preserves quoting, newlines, and special characters
- * that would otherwise break when embedded in a shell command line.
- */
-const preBashHandler = (normalized) => {
-    const input = normalized.toolInput;
-    const cmd = typeof input.command === "string"
-        ? input.command
-        : typeof input.shell_command === "string"
-            ? input.shell_command
-            : "";
-    if (!normalizeShellCommand(cmd))
-        return passthrough();
-    const n = normalizeShellCommand(cmd);
-    if (n.startsWith("unerr exec") || n.startsWith("npx unerr exec")) {
-        return passthrough();
-    }
-    // Base64-encode commands that contain characters unsafe for shell embedding:
-    // newlines, quotes, parentheses, backticks, $, {, }, etc.
-    // Simple commands (ls, git status) pass through as plain argv for readability.
-    if (/[\n"'`(){}$\\;<>|&!~*?]/.test(cmd)) {
-        const b64 = Buffer.from(cmd, "utf-8").toString("base64");
-        return rewrite({ command: `unerr exec --b64 ${b64}` });
-    }
-    return rewrite({ command: `unerr exec -- ${cmd}` });
-};
-/**
- * Read hook JSON from stdin, rewrite Bash command to run through `unerr exec`.
- * Returns JSON string for stdout, or passthrough response.
- */
-export function runPreBashHook(stdinJson) {
-    return runPreToolUseHook(stdinJson, preBashHandler);
-}