@unerr-ai/unerr 0.0.1 → 0.1.1

package/dist/config/claude-settings-hooks.js

@@ -0,0 +1,304 @@
+/**
+ * Merge unerr hooks into `.claude/settings.json`.
+ *
+ * PreToolUse hooks: Bash (rewrite), Read (nudge), Grep (nudge), Glob (nudge).
+ * PostToolUse hooks: Read (enrich), Grep (enrich), Glob (enrich).
+ * All hooks are installed on `unerr install claude-code` and removed on `unerr uninstall`.
+ */
+import { execSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+/**
+ * Resolve the absolute path to the `unerr` binary.
+ *
+ * Tries (in order):
+ * 1. `process.argv[1]` — the script currently running (works for global installs, pnpm link, npm link)
+ * 2. `which unerr` — fallback to PATH lookup at install time
+ * 3. `"unerr"` — bare name as last resort (relies on subprocess PATH)
+ *
+ * The resolved absolute path is written into settings.json so hooks work even when
+ * the subprocess PATH doesn't include the package manager's global bin directory.
+ */
+function resolveUnerrBinary() {
+    // process.argv[1] is the entry script — for global installs this is the real
+    // binary path (e.g. /Users/jaswanth/Library/pnpm/unerr or /usr/local/bin/unerr).
+    // Require the basename to actually look like the unerr binary so we don't
+    // bake in a path to vitest, tsx, or some other wrapper that happened to spawn
+    // the current process (which would write unrecognisable hook commands that
+    // `isAnyUnerrHook` can't match for removal).
+    const entryScript = process.argv[1];
+    if (entryScript && existsSync(entryScript)) {
+        const base = entryScript.split("/").pop() ?? "";
+        if (base === "unerr" || base.startsWith("unerr.")) {
+            return entryScript;
+        }
+    }
+    // Fallback: `which unerr` at install time (captures current PATH)
+    try {
+        const resolved = execSync("which unerr", { encoding: "utf-8" }).trim();
+        if (resolved && existsSync(resolved)) {
+            return resolved;
+        }
+    }
+    catch {
+        // which not found or unerr not on PATH — fall through
+    }
+    // Last resort: bare name (original behavior — `isAnyUnerrHook` still matches
+    // `^unerr\s+hook\s+`).
+    return "unerr";
+}
+/** Cached resolved binary path (computed once per process). */
+let _resolvedBinary;
+function getUnerrBinary() {
+    if (_resolvedBinary === undefined) {
+        _resolvedBinary = resolveUnerrBinary();
+    }
+    return _resolvedBinary;
+}
+/** Build hook command templates using the resolved binary path. */
+function buildMatcherHooks() {
+    const bin = getUnerrBinary();
+    return [
+        // PreToolUse — advisory nudges + Bash rewrite
+        { event: "PreToolUse", matcher: "Bash", command: `${bin} hook pre-bash` },
+        { event: "PreToolUse", matcher: "Read", command: `${bin} hook pre-read` },
+        { event: "PreToolUse", matcher: "Grep", command: `${bin} hook pre-grep` },
+        { event: "PreToolUse", matcher: "Glob", command: `${bin} hook pre-glob` },
+        // PreToolUse — blast radius + convention validation for writes
+        { event: "PreToolUse", matcher: "Write", command: `${bin} hook pre-write` },
+        { event: "PreToolUse", matcher: "Edit", command: `${bin} hook pre-edit` },
+        // PostToolUse — enrich tool output with graph navigation suggestions
+        { event: "PostToolUse", matcher: "Read", command: `${bin} hook post-read` },
+        { event: "PostToolUse", matcher: "Grep", command: `${bin} hook post-grep` },
+        { event: "PostToolUse", matcher: "Glob", command: `${bin} hook post-glob` },
+        {
+            event: "PostToolUse",
+            matcher: "Write",
+            command: `${bin} hook post-write`,
+        },
+        { event: "PostToolUse", matcher: "Edit", command: `${bin} hook post-edit` },
+    ];
+}
+/** Build global hook templates using the resolved binary path. */
+function buildGlobalHooks() {
+    const bin = getUnerrBinary();
+    return [{ event: "UserPromptSubmit", command: `${bin} hook prompt-submit` }];
+}
+/** Check if an entry is ANY unerr hook (for removal and dedup). */
+function isAnyUnerrHook(entry) {
+    if (!entry || typeof entry !== "object")
+        return false;
+    const e = entry;
+    const hs = e.hooks;
+    if (!Array.isArray(hs))
+        return false;
+    // Match any hook command that contains "unerr hook" (covers both bare and absolute paths)
+    return hs.some((h) => {
+        if (!h || typeof h !== "object")
+            return false;
+        const cmd = h.command;
+        return typeof cmd === "string" && /(?:^|\/)unerr\s+hook\s+/.test(cmd);
+    });
+}
+/**
+ * Merge all unerr hooks into `.claude/settings.json`.
+ * Handles PreToolUse/PostToolUse (matcher-based) and UserPromptSubmit (global).
+ * Idempotent — skips hooks that are already present.
+ */
+export function mergePreToolUseBashHook(cwd) {
+    const dir = join(cwd, ".claude");
+    const settingsPath = join(dir, "settings.json");
+    try {
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        let settings = {};
+        if (existsSync(settingsPath)) {
+            try {
+                settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+            }
+            catch {
+                settings = {};
+            }
+        }
+        const hooks = settings.hooks ?? {};
+        let added = 0;
+        const matcherHooks = buildMatcherHooks();
+        const globalHooks = buildGlobalHooks();
+        // Remove any existing unerr hooks first (handles upgrades from bare to absolute paths)
+        for (const eventType of [
+            "PreToolUse",
+            "PostToolUse",
+            "UserPromptSubmit",
+        ]) {
+            if (Array.isArray(hooks[eventType])) {
+                hooks[eventType] = hooks[eventType].filter((entry) => !isAnyUnerrHook(entry));
+            }
+        }
+        // Register matcher-based hooks (PreToolUse, PostToolUse) with resolved binary path
+        for (const hookDef of matcherHooks) {
+            const eventArray = Array.isArray(hooks[hookDef.event])
+                ? [...hooks[hookDef.event]]
+                : [];
+            eventArray.push({
+                matcher: hookDef.matcher,
+                hooks: [{ type: "command", command: hookDef.command }],
+            });
+            hooks[hookDef.event] = eventArray;
+            added++;
+        }
+        // Register global hooks (UserPromptSubmit — no matcher) with resolved binary path
+        for (const hookDef of globalHooks) {
+            const eventArray = Array.isArray(hooks[hookDef.event])
+                ? [...hooks[hookDef.event]]
+                : [];
+            if (!eventArray.some((entry) => isAnyUnerrHook(entry))) {
+                eventArray.push({
+                    hooks: [{ type: "command", command: hookDef.command }],
+                });
+                hooks[hookDef.event] = eventArray;
+                added++;
+            }
+        }
+        if (added === 0) {
+            return { ok: true, path: settingsPath, action: "already_present" };
+        }
+        settings.hooks = hooks;
+        writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`, "utf-8");
+        return { ok: true, path: settingsPath, action: "merged" };
+    }
+    catch {
+        return { ok: false, path: settingsPath, action: "failed" };
+    }
+}
+/**
+ * Remove ALL unerr hook entries from `.claude/settings.json`.
+ * Handles PreToolUse, PostToolUse, and UserPromptSubmit.
+ * Returns true if any entries were removed.
+ */
+/**
+ * S8: Built-in tools to deny when --force-tools is active.
+ * These tools have unerr MCP equivalents (file_read, search_code, file_outline).
+ */
+const DISALLOWED_TOOLS = ["Grep", "Glob"];
+/**
+ * S8: Add `permissions.deny` entries to `.claude/settings.json`.
+ * Denies Read, Grep, Glob when unerr MCP tools are confirmed available.
+ *
+ * Called by default on `unerr install claude-code`. Opt out with `--no-force-tools`.
+ * Idempotent — skips tools already denied.
+ */
+export function addDisallowedTools(cwd) {
+    const dir = join(cwd, ".claude");
+    const settingsPath = join(dir, "settings.json");
+    try {
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        let settings = {};
+        if (existsSync(settingsPath)) {
+            try {
+                settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+            }
+            catch {
+                settings = {};
+            }
+        }
+        const permissions = settings.permissions ?? {};
+        const deny = Array.isArray(permissions.deny)
+            ? [...permissions.deny]
+            : [];
+        // Migration: remove "Read" if it was previously denied by unerr
+        // (Read is needed for the Edit workflow — deny breaks native editing across all agents)
+        const readIdx = deny.indexOf("Read");
+        if (readIdx >= 0) {
+            deny.splice(readIdx, 1);
+        }
+        let added = 0;
+        for (const tool of DISALLOWED_TOOLS) {
+            if (!deny.includes(tool)) {
+                deny.push(tool);
+                added++;
+            }
+        }
+        if (added === 0) {
+            return { added: 0, path: settingsPath };
+        }
+        permissions.deny = deny;
+        settings.permissions = permissions;
+        writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`, "utf-8");
+        return { added, path: settingsPath };
+    }
+    catch {
+        return { added: 0, path: settingsPath };
+    }
+}
+/**
+ * S8: Remove unerr-added `permissions.deny` entries from `.claude/settings.json`.
+ * Removes Read, Grep, Glob from deny list.
+ * Returns true if any entries were removed.
+ */
+export function removeDisallowedTools(cwd) {
+    const settingsPath = join(cwd, ".claude", "settings.json");
+    if (!existsSync(settingsPath))
+        return false;
+    try {
+        const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+        const permissions = settings.permissions;
+        if (!permissions || !Array.isArray(permissions.deny))
+            return false;
+        const before = permissions.deny.length;
+        permissions.deny = permissions.deny.filter((tool) => !DISALLOWED_TOOLS.includes(tool));
+        const removed = before - permissions.deny.length;
+        if (removed === 0)
+            return false;
+        // Clean up empty deny array and permissions object
+        if (permissions.deny.length === 0)
+            permissions.deny = undefined;
+        if (Object.keys(permissions).length === 0)
+            settings.permissions = undefined;
+        writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`, "utf-8");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function removePreToolUseBashHook(cwd) {
+    const settingsPath = join(cwd, ".claude", "settings.json");
+    if (!existsSync(settingsPath))
+        return false;
+    try {
+        const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+        const hooks = settings.hooks;
+        if (!hooks)
+            return false;
+        let totalRemoved = 0;
+        const eventTypes = [
+            "PreToolUse",
+            "PostToolUse",
+            "UserPromptSubmit",
+        ];
+        for (const eventType of eventTypes) {
+            if (!Array.isArray(hooks[eventType]))
+                continue;
+            const before = hooks[eventType].length;
+            hooks[eventType] = hooks[eventType].filter((entry) => !isAnyUnerrHook(entry));
+            const removed = before - hooks[eventType].length;
+            totalRemoved += removed;
+            // Clean up empty arrays
+            if (hooks[eventType].length === 0)
+                delete hooks[eventType];
+        }
+        if (totalRemoved === 0)
+            return false;
+        // Clean up empty hooks object
+        if (Object.keys(hooks).length === 0)
+            settings.hooks = undefined;
+        writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`, "utf-8");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/config/hook-installer.js

@@ -0,0 +1,65 @@
+/**
+ * Hook Installer — installs CLI hooks for Claude Code PostToolUse.
+ *
+ * R.4: Generates .claude/hooks/PostToolUse.sh that pipes command output
+ * through `unerr compress-output` for graph-aware compression.
+ *
+ * The hook intercepts tool output, compresses it, and returns the compressed
+ * version to the agent — reducing context window usage by 60-90%.
+ */
+import { chmodSync, existsSync, mkdirSync, unlinkSync, writeFileSync, } from "node:fs";
+import { join } from "node:path";
+const HOOK_CONTENT = `#!/bin/bash
+# unerr PostToolUse hook — graph-aware output compression
+# Installed by: unerr init
+# Removes: unerr uninstall
+
+# Only compress large outputs (>2KB)
+if [ \${#TOOL_OUTPUT} -gt 2048 ]; then
+  echo "$TOOL_OUTPUT" | unerr compress-output
+else
+  echo "$TOOL_OUTPUT"
+fi
+`;
+/**
+ * Install the PostToolUse hook for Claude Code.
+ */
+export function installClaudeHook(cwd) {
+    const hooksDir = join(cwd, ".claude", "hooks");
+    const hookPath = join(hooksDir, "PostToolUse.sh");
+    if (existsSync(hookPath)) {
+        return { path: hookPath, action: "already_exists" };
+    }
+    try {
+        if (!existsSync(hooksDir)) {
+            mkdirSync(hooksDir, { recursive: true });
+        }
+        writeFileSync(hookPath, HOOK_CONTENT, "utf-8");
+        chmodSync(hookPath, 0o755);
+        return { path: hookPath, action: "installed" };
+    }
+    catch {
+        return { path: hookPath, action: "failed" };
+    }
+}
+/**
+ * Remove the PostToolUse hook.
+ */
+export function removeClaudeHook(cwd) {
+    const hookPath = join(cwd, ".claude", "hooks", "PostToolUse.sh");
+    if (!existsSync(hookPath))
+        return false;
+    try {
+        unlinkSync(hookPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if the Claude hook is installed.
+ */
+export function isClaudeHookInstalled(cwd) {
+    return existsSync(join(cwd, ".claude", "hooks", "PostToolUse.sh"));
+}