@jmylchreest/aide-plugin 0.0.56 → 0.0.58

package/src/hooks/hud-updater.ts

@@ -0,0 +1,180 @@
+#!/usr/bin/env node
+/**
+ * HUD Updater Hook (PostToolUse)
+ *
+ * Updates the terminal status line with current aide state.
+ * Shows: mode, model tier, active agents, context usage
+ *
+ * Output is written to .aide/state/hud.txt for the terminal to display.
+ */
+
+import { statSync } from "fs";
+import { resolve, isAbsolute } from "path";
+import { Logger, debug } from "../lib/logger.js";
+import { readStdin } from "../lib/hook-utils.js";
+
+const SOURCE = "hud-updater";
+import { findAideBinary } from "../core/aide-client.js";
+import { updateToolStats } from "../core/tool-tracking.js";
+import { storePartialMemory } from "../core/partial-memory.js";
+import { recordFileRead, recordTokenEvent, estimateTokensFromSize } from "../core/read-tracking.js"; // estimateTokensFromSize used for read events
+import {
+  getAgentStates,
+  loadHudConfig,
+  getSessionState,
+  formatHud,
+  writeHudOutput,
+} from "../lib/hud.js";
+
+interface HookInput {
+  hook_event_name: string;
+  session_id: string;
+  cwd: string;
+  tool_name?: string;
+  agent_id?: string;
+  tool_input?: {
+    file_path?: string;
+    command?: string;
+    description?: string;
+    [key: string]: unknown;
+  };
+  tool_result?: {
+    success: boolean;
+    duration?: number;
+  };
+  transcript_path?: string;
+  permission_mode?: string;
+}
+
+async function main(): Promise<void> {
+  let log: Logger | null = null;
+
+  try {
+    const input = await readStdin();
+    if (!input.trim()) {
+      console.log(JSON.stringify({ continue: true }));
+      return;
+    }
+
+    const data: HookInput = JSON.parse(input);
+    const cwd = data.cwd || process.cwd();
+    const toolName = data.tool_name || "";
+    const agentId = data.agent_id || data.session_id;
+    const sessionId = data.session_id;
+
+    // Initialize logger
+    log = new Logger("hud-updater", cwd);
+    log.start("total");
+    log.debug(
+      `Processing PostToolUse for tool: ${toolName}, agent: ${agentId}, session: ${sessionId}`,
+    );
+
+    // Update session state (per-agent tracking) — delegates to core
+    if (toolName) {
+      log.start("updateSessionState");
+      const binary = findAideBinary({
+        cwd,
+        pluginRoot:
+          process.env.AIDE_PLUGIN_ROOT || process.env.CLAUDE_PLUGIN_ROOT,
+      });
+      if (binary) {
+        updateToolStats(binary, cwd, toolName, agentId);
+
+        // Write a partial memory for significant tool uses
+        storePartialMemory(binary, cwd, {
+          toolName,
+          sessionId,
+          filePath: data.tool_input?.file_path,
+          command: data.tool_input?.command,
+          description: data.tool_input?.description,
+          success: data.tool_result?.success,
+        });
+
+        // Record file reads for smart-read-hint feature
+        if (
+          toolName === "Read" &&
+          data.tool_result?.success &&
+          data.tool_input?.file_path
+        ) {
+          const fp = data.tool_input.file_path as string;
+          recordFileRead(binary, cwd, fp);
+
+          // Record token event for the read (estimate from file size)
+          try {
+            const abs = isAbsolute(fp) ? fp : resolve(cwd, fp);
+            const stat = statSync(abs);
+            const tokens = estimateTokensFromSize(stat.size);
+            recordTokenEvent(binary, cwd, "read", "Read", fp, tokens);
+          } catch {
+            // stat failed — skip token recording
+          }
+        }
+
+      }
+      log.end("updateSessionState");
+    }
+
+    // Load config and get state
+    log.start("loadHudConfig");
+    const config = loadHudConfig(cwd);
+    log.end("loadHudConfig");
+
+    log.start("getSessionState");
+    const state = getSessionState(cwd);
+    log.end("getSessionState", state);
+
+    log.start("getAgentStates");
+    const allAgents = getAgentStates(cwd);
+    // Filter to ONLY show agents from the current session
+    const agents = sessionId
+      ? allAgents.filter((a) => a.session === sessionId)
+      : [];
+    log.end("getAgentStates", {
+      total: allAgents.length,
+      filtered: agents.length,
+    });
+
+    // Format and write HUD (includes per-agent lines)
+    log.start("formatHud");
+    const hudOutput = formatHud(config, state, agents, cwd);
+    log.end("formatHud");
+    log.debug(`HUD output: ${hudOutput}`);
+
+    log.start("writeHudOutput");
+    writeHudOutput(cwd, hudOutput);
+    log.end("writeHudOutput");
+
+    log.end("total");
+    log.flush();
+
+    // Always continue
+    console.log(JSON.stringify({ continue: true }));
+  } catch (error) {
+    if (log) {
+      log.error("HUD update failed", error);
+      log.flush();
+    }
+    console.log(JSON.stringify({ continue: true }));
+  }
+}
+
+process.on("uncaughtException", (err) => {
+  debug(SOURCE, `UNCAUGHT EXCEPTION: ${err}`);
+  try {
+    console.log(JSON.stringify({ continue: true }));
+  } catch {
+    console.log('{"continue":true}');
+  }
+  process.exit(0);
+});
+process.on("unhandledRejection", (reason) => {
+  debug(SOURCE, `UNHANDLED REJECTION: ${reason}`);
+  try {
+    console.log(JSON.stringify({ continue: true }));
+  } catch {
+    console.log('{"continue":true}');
+  }
+  process.exit(0);
+});
+
+main();

package/src/hooks/permission-handler.ts

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+/**
+ * Permission Handler Hook (PermissionRequest)
+ *
+ * OPT-IN: This hook is NOT registered in plugin.json by default.
+ * To enable, add a PermissionRequest entry to .claude-plugin/plugin.json.
+ * Not available in OpenCode (no equivalent event).
+ *
+ * Validates Bash commands before permission prompts are shown.
+ * Can auto-approve safe commands or block dangerous ones.
+ *
+ * PermissionRequest data from Claude Code:
+ * - tool_name: "Bash"
+ * - tool_input: { command: "...", ... }
+ * - cwd, session_id
+ *
+ * Returns:
+ * - { allow: true } to auto-approve
+ * - { allow: false, reason: "..." } to block
+ * - { continue: true } to show normal permission prompt
+ */
+
+import { readStdin, findAideBinary, runAide } from "../lib/hook-utils.js";
+import { sanitizeForLog } from "../core/aide-client.js";
+import { debug } from "../lib/logger.js";
+
+const SOURCE = "permission-handler";
+
+interface PermissionRequestInput {
+  event: "PermissionRequest";
+  tool_name: string;
+  tool_input: {
+    command?: string;
+    [key: string]: unknown;
+  };
+  cwd: string;
+  session_id: string;
+}
+
+interface PermissionResponse {
+  allow?: boolean;
+  reason?: string;
+  continue?: boolean;
+}
+
+// Commands that are always safe to auto-approve
+const SAFE_COMMANDS = [
+  /^ls\b/,
+  /^pwd$/,
+  /^echo\b/,
+  /^cat\b/,
+  /^head\b/,
+  /^tail\b/,
+  /^wc\b/,
+  /^grep\b/,
+  /^find\b/,
+  /^which\b/,
+  /^git\s+(status|log|diff|branch|show)\b/,
+  /^git\s+stash\s+list\b/,
+  /^npm\s+(list|ls|outdated|view)\b/,
+  /^yarn\s+(list|info)\b/,
+  /^pnpm\s+(list|outdated)\b/,
+  /^node\s+--version$/,
+  /^npm\s+--version$/,
+  /^python\s+--version$/,
+  /^go\s+version$/,
+  /^cargo\s+--version$/,
+];
+
+// Commands that should be blocked without prompting
+const BLOCKED_COMMANDS = [
+  /rm\s+-rf\s+[/~]/, // rm -rf / or ~
+  /rm\s+-rf\s+\*/, // rm -rf *
+  /dd\s+.*of=\/dev\//, // dd to device
+  /mkfs\./, // format filesystem
+  /:\(\)\{:\|:&\};:/, // fork bomb
+  />\s*\/dev\/sd[a-z]/, // write to disk device
+  /curl.*\|\s*(ba)?sh/, // curl pipe to shell
+  /wget.*\|\s*(ba)?sh/, // wget pipe to shell
+];
+
+/**
+ * Log permission decision to aide-memory
+ */
+function logPermission(cwd: string, command: string, decision: string): void {
+  if (!findAideBinary(cwd)) return;
+
+  const safeCommand = sanitizeForLog(command).slice(0, 200);
+  runAide(cwd, [
+    "message",
+    "send",
+    `${decision}: ${safeCommand}`,
+    "--from=system",
+    "--type=permission",
+  ]);
+}
+
+/**
+ * Check if command matches any patterns
+ */
+function matchesPatterns(command: string, patterns: RegExp[]): boolean {
+  return patterns.some((pattern) => pattern.test(command));
+}
+
+async function main(): Promise<void> {
+  try {
+    const input = await readStdin();
+    if (!input.trim()) {
+      console.log(JSON.stringify({ continue: true }));
+      return;
+    }
+
+    const data: PermissionRequestInput = JSON.parse(input);
+
+    // Only handle Bash permissions
+    if (data.tool_name !== "Bash" || !data.tool_input?.command) {
+      console.log(JSON.stringify({ continue: true }));
+      return;
+    }
+
+    const command = data.tool_input.command;
+    const cwd = data.cwd || process.cwd();
+
+    // Check for blocked commands first
+    if (matchesPatterns(command, BLOCKED_COMMANDS)) {
+      logPermission(cwd, command, "BLOCKED");
+      const response: PermissionResponse = {
+        allow: false,
+        reason:
+          "This command has been blocked for safety. It matches a dangerous pattern.",
+      };
+      console.log(JSON.stringify(response));
+      return;
+    }
+
+    // Check for safe commands to auto-approve
+    if (matchesPatterns(command, SAFE_COMMANDS)) {
+      logPermission(cwd, command, "AUTO-APPROVED");
+      const response: PermissionResponse = {
+        allow: true,
+      };
+      console.log(JSON.stringify(response));
+      return;
+    }
+
+    // Default: show normal permission prompt
+    console.log(JSON.stringify({ continue: true }));
+  } catch (error) {
+    debug(SOURCE, `Hook error: ${error}`);
+    console.log(JSON.stringify({ continue: true }));
+  }
+}
+
+process.on("uncaughtException", (err) => {
+  debug(SOURCE, `UNCAUGHT EXCEPTION: ${err}`);
+  try {
+    console.log(JSON.stringify({ continue: true }));
+  } catch {
+    console.log('{"continue":true}');
+  }
+  process.exit(0);
+});
+process.on("unhandledRejection", (reason) => {
+  debug(SOURCE, `UNHANDLED REJECTION: ${reason}`);
+  try {
+    console.log(JSON.stringify({ continue: true }));
+  } catch {
+    console.log('{"continue":true}');
+  }
+  process.exit(0);
+});
+
+main();

package/src/hooks/persistence.ts

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+/**
+ * Persistence Hook (Stop)
+ *
+ * Prevents Claude from stopping when work is incomplete.
+ * Checks for active modes (autopilot) via aide-memory state.
+ */
+
+import { readStdin } from "../lib/hook-utils.js";
+import { findAideBinary } from "../core/aide-client.js";
+import { checkPersistence } from "../core/persistence-logic.js";
+import { debug } from "../lib/logger.js";
+
+const SOURCE = "persistence";
+
+interface HookInput {
+  hook_event_name: string;
+  session_id: string;
+  cwd: string;
+  stop_hook_active?: boolean;
+  transcript_path?: string;
+  permission_mode?: string;
+}
+
+interface HookOutput {
+  decision?: "block";
+  reason?: string;
+}
+
+async function main(): Promise<void> {
+  try {
+    const input = await readStdin();
+    if (!input.trim()) {
+      console.log(JSON.stringify({}));
+      return;
+    }
+
+    const data: HookInput = JSON.parse(input);
+    const cwd = data.cwd || process.cwd();
+
+    if (data.stop_hook_active) {
+      console.log(JSON.stringify({}));
+      return;
+    }
+
+    const binary = findAideBinary({
+      cwd,
+      pluginRoot:
+        process.env.AIDE_PLUGIN_ROOT || process.env.CLAUDE_PLUGIN_ROOT,
+    });
+    if (!binary) {
+      console.log(JSON.stringify({}));
+      return;
+    }
+
+    const result = checkPersistence(binary, cwd, data.session_id);
+    if (!result) {
+      console.log(JSON.stringify({}));
+      return;
+    }
+
+    const output: HookOutput = {
+      decision: "block",
+      reason: result.reason,
+    };
+
+    console.log(JSON.stringify(output));
+  } catch (err) {
+    debug(SOURCE, `Hook error: ${err}`);
+    console.log(JSON.stringify({}));
+  }
+}
+
+process.on("uncaughtException", (err) => {
+  debug(SOURCE, `UNCAUGHT EXCEPTION: ${err}`);
+  try {
+    console.log(JSON.stringify({}));
+  } catch {
+    console.log("{}");
+  }
+  process.exit(0);
+});
+process.on("unhandledRejection", (reason) => {
+  debug(SOURCE, `UNHANDLED REJECTION: ${reason}`);
+  try {
+    console.log(JSON.stringify({}));
+  } catch {
+    console.log("{}");
+  }
+  process.exit(0);
+});
+
+main();

package/src/hooks/pre-compact.ts

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+/**
+ * Pre-Compact Hook (PreCompact)
+ *
+ * Called before Claude Code compacts/summarizes the conversation.
+ * Preserves important context in aide-memory before summarization.
+ *
+ * PreCompact data from Claude Code:
+ * - session_id, cwd
+ * - summary_prompt (the prompt used for summarization)
+ */
+
+import { readStdin } from "../lib/hook-utils.js";
+import { findAideBinary } from "../core/aide-client.js";
+import { saveStateSnapshot as coreSaveStateSnapshot } from "../core/pre-compact-logic.js";
+import {
+  buildSessionSummaryFromState,
+  getSessionCommits,
+  storeSessionSummary,
+} from "../core/session-summary-logic.js";
+import {
+  gatherPartials,
+  buildSummaryFromPartials,
+} from "../core/partial-memory.js";
+import { debug } from "../lib/logger.js";
+
+const SOURCE = "pre-compact";
+
+interface PreCompactInput {
+  event: "PreCompact";
+  session_id: string;
+  cwd: string;
+  summary_prompt?: string;
+}
+
+async function main(): Promise<void> {
+  try {
+    const input = await readStdin();
+    if (!input.trim()) {
+      console.log(JSON.stringify({ continue: true }));
+      return;
+    }
+
+    const data: PreCompactInput = JSON.parse(input);
+    const cwd = data.cwd || process.cwd();
+    const sessionId = data.session_id || "unknown";
+
+    // Save state snapshot before compaction — delegates to core
+    const binary = findAideBinary({
+      cwd,
+      pluginRoot:
+        process.env.AIDE_PLUGIN_ROOT || process.env.CLAUDE_PLUGIN_ROOT,
+    });
+    if (binary) {
+      coreSaveStateSnapshot(binary, cwd, sessionId);
+
+      // Persist a session summary as a memory before context is compacted.
+      // This ensures the work-so-far is recoverable after compaction.
+      // Uses partials (if available) for a richer summary, falling back to git-only.
+      try {
+        const partials = gatherPartials(binary, cwd, sessionId);
+        let summary: string | null = null;
+
+        if (partials.length > 0) {
+          // Build from partials + git data
+          const commits = getSessionCommits(cwd);
+          summary = buildSummaryFromPartials(partials, commits, []);
+          debug(
+            SOURCE,
+            `Built pre-compact summary from ${partials.length} partials`,
+          );
+        }
+
+        // Fall back to state-only summary if no partials
+        if (!summary) {
+          summary = buildSessionSummaryFromState(cwd);
+        }
+
+        if (summary) {
+          // Tag as partial so the session-end summary supersedes it
+          const tags = `partial,session-summary,session:${sessionId}`;
+          (await import("child_process")).execFileSync(
+            binary,
+            ["memory", "add", "--category=session", `--tags=${tags}`, summary],
+            { cwd, stdio: "pipe", timeout: 5000 },
+          );
+          debug(
+            SOURCE,
+            `Saved pre-compaction partial session summary for ${sessionId.slice(0, 8)}`,
+          );
+        }
+      } catch (err) {
+        debug(
+          SOURCE,
+          `Failed to save pre-compaction summary (non-fatal): ${err}`,
+        );
+      }
+    }
+
+    // Always allow compaction to continue
+    console.log(JSON.stringify({ continue: true }));
+  } catch (error) {
+    debug(SOURCE, `Hook error: ${error}`);
+    console.log(JSON.stringify({ continue: true }));
+  }
+}
+
+process.on("uncaughtException", (err) => {
+  debug(SOURCE, `UNCAUGHT EXCEPTION: ${err}`);
+  try {
+    console.log(JSON.stringify({ continue: true }));
+  } catch {
+    console.log('{"continue":true}');
+  }
+  process.exit(0);
+});
+process.on("unhandledRejection", (reason) => {
+  debug(SOURCE, `UNHANDLED REJECTION: ${reason}`);
+  try {
+    console.log(JSON.stringify({ continue: true }));
+  } catch {
+    console.log('{"continue":true}');
+  }
+  process.exit(0);
+});
+
+main();

package/src/hooks/pre-tool-enforcer.ts

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+/**
+ * Pre-Tool Enforcer Hook (PreToolUse)
+ *
+ * Enforces tool access rules:
+ * - Read-only agents cannot use write tools
+ * - Injects contextual reminders
+ * - Tracks active state
+ *
+ * Core logic is in src/core/tool-enforcement.ts for cross-platform reuse.
+ */
+
+import { readStdin } from "../lib/hook-utils.js";
+import { debug } from "../lib/logger.js";
+import { evaluateToolUse } from "../core/tool-enforcement.js";
+import { findAideBinary, getState } from "../core/aide-client.js";
+
+const SOURCE = "pre-tool-enforcer";
+
+interface HookInput {
+  hook_event_name: string;
+  session_id: string;
+  cwd: string;
+  tool_name?: string;
+  agent_name?: string;
+  agent_id?: string;
+  transcript_path?: string;
+  permission_mode?: string;
+}
+
+interface HookOutput {
+  continue: boolean;
+  message?: string;
+  hookSpecificOutput?: {
+    hookEventName: string;
+    additionalContext?: string;
+  };
+}
+
+async function main(): Promise<void> {
+  try {
+    const input = await readStdin();
+    if (!input.trim()) {
+      console.log(JSON.stringify({ continue: true }));
+      return;
+    }
+
+    const data: HookInput = JSON.parse(input);
+    const toolName = data.tool_name || "";
+    const agentName = data.agent_name || "";
+    const cwd = data.cwd || process.cwd();
+
+    // Resolve active mode from aide binary (source of truth: BBolt store)
+    let activeMode: string | null = null;
+    try {
+      const binary = findAideBinary({
+        cwd,
+        pluginRoot:
+          process.env.AIDE_PLUGIN_ROOT || process.env.CLAUDE_PLUGIN_ROOT,
+      });
+      if (binary) {
+        activeMode = getState(binary, cwd, "mode");
+      }
+    } catch (err) {
+      debug(SOURCE, `Failed to resolve active mode (non-fatal): ${err}`);
+    }
+
+    const result = evaluateToolUse(
+      toolName,
+      agentName || undefined,
+      activeMode,
+    );
+
+    if (!result.allowed) {
+      const output: HookOutput = {
+        continue: false,
+        message: result.denyMessage,
+      };
+      console.log(JSON.stringify(output));
+      return;
+    }
+
+    if (result.reminder) {
+      const output: HookOutput = {
+        continue: true,
+        hookSpecificOutput: {
+          hookEventName: "PreToolUse",
+          additionalContext: result.reminder,
+        },
+      };
+      console.log(JSON.stringify(output));
+    } else {
+      console.log(JSON.stringify({ continue: true }));
+    }
+  } catch (error) {
+    debug(SOURCE, `Hook error: ${error}`);
+    console.log(JSON.stringify({ continue: true }));
+  }
+}
+
+process.on("uncaughtException", (err) => {
+  debug(SOURCE, `UNCAUGHT EXCEPTION: ${err}`);
+  try {
+    console.log(JSON.stringify({ continue: true }));
+  } catch {
+    console.log('{"continue":true}');
+  }
+  process.exit(0);
+});
+process.on("unhandledRejection", (reason) => {
+  debug(SOURCE, `UNHANDLED REJECTION: ${reason}`);
+  try {
+    console.log(JSON.stringify({ continue: true }));
+  } catch {
+    console.log('{"continue":true}');
+  }
+  process.exit(0);
+});
+
+main();