@jmylchreest/aide-plugin 0.0.57 → 0.0.58

package/src/hooks/comment-checker.ts

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+/**
+ * Comment Checker Hook (PostToolUse)
+ *
+ * Detects excessive or obvious comments in code written by AI agents.
+ * Injects a warning via additionalContext to nudge the agent toward
+ * cleaner code without blocking the tool call.
+ *
+ * Core logic is in src/core/comment-checker.ts for cross-platform reuse.
+ */
+
+import { readStdin } from "../lib/hook-utils.js";
+import { debug } from "../lib/logger.js";
+import {
+  checkComments,
+  getCheckableFilePath,
+  getContentToCheck,
+} from "../core/comment-checker.js";
+
+const SOURCE = "comment-checker";
+
+interface HookInput {
+  hook_event_name: string;
+  session_id: string;
+  cwd: string;
+  tool_name?: string;
+  agent_id?: string;
+  tool_input?: Record<string, unknown>;
+  tool_result?: {
+    success: boolean;
+    duration?: number;
+  };
+  transcript_path?: string;
+  permission_mode?: string;
+}
+
+interface HookOutput {
+  continue: true;
+  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 toolInput = data.tool_input || {};
+
+    // Only check Write/Edit/MultiEdit tool calls
+    const filePath = getCheckableFilePath(toolName, toolInput);
+    if (!filePath) {
+      console.log(JSON.stringify({ continue: true }));
+      return;
+    }
+
+    // Get the content to analyze
+    const contentResult = getContentToCheck(toolName, toolInput);
+    if (!contentResult) {
+      console.log(JSON.stringify({ continue: true }));
+      return;
+    }
+
+    const [content, isNewContent] = contentResult;
+    const result = checkComments(filePath, content, isNewContent);
+
+    if (result.hasExcessiveComments) {
+      debug(
+        SOURCE,
+        `Detected ${result.suspiciousCount} suspicious comments in ${filePath}`,
+      );
+      const output: HookOutput = {
+        continue: true,
+        hookSpecificOutput: {
+          hookEventName: "PostToolUse",
+          additionalContext: result.warning,
+        },
+      };
+      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();

package/src/hooks/context-guard.ts

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+/**
+ * Context Guard Hook (PreToolUse)
+ *
+ * Monitors Read tool calls and advises agents to use code_outline
+ * before reading large files. Also tracks code_outline/code_symbols
+ * calls so it knows which files have been outlined.
+ *
+ * This is a soft warning — it never blocks, only injects advisory context.
+ *
+ * Core logic is in src/core/context-guard.ts for cross-platform reuse.
+ */
+
+import { readStdin } from "../lib/hook-utils.js";
+import { debug } from "../lib/logger.js";
+import { checkContextGuard, checkSmartReadHint } from "../core/context-guard.js";
+import { findAideBinary } from "../core/aide-client.js";
+
+const SOURCE = "context-guard";
+
+interface HookInput {
+  hook_event_name: string;
+  session_id: string;
+  cwd: string;
+  tool_name?: string;
+  agent_name?: string;
+  agent_id?: string;
+  tool_input?: Record<string, unknown>;
+  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 toolInput = data.tool_input || {};
+    const cwd = data.cwd || process.cwd();
+    const sessionId = data.session_id || "unknown";
+
+    const result = checkContextGuard(toolName, toolInput, cwd, sessionId);
+
+    if (result.shouldAdvise && result.advisory) {
+      debug(SOURCE, `Advising on large file read`);
+      const output: HookOutput = {
+        continue: true,
+        hookSpecificOutput: {
+          hookEventName: "PreToolUse",
+          additionalContext: result.advisory,
+        },
+      };
+      console.log(JSON.stringify(output));
+    } else {
+      // Smart read hint: suggest code index for re-reads of unchanged files
+      const binary = findAideBinary({
+        cwd,
+        pluginRoot:
+          process.env.AIDE_PLUGIN_ROOT || process.env.CLAUDE_PLUGIN_ROOT,
+      });
+      const hintResult = checkSmartReadHint(toolName, toolInput, cwd, binary);
+      if (hintResult.shouldHint && hintResult.hint) {
+        debug(SOURCE, `Smart read hint triggered`);
+        const output: HookOutput = {
+          continue: true,
+          hookSpecificOutput: {
+            hookEventName: "PreToolUse",
+            additionalContext: hintResult.hint,
+          },
+        };
+        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();

package/src/hooks/context-pruning.ts

@@ -0,0 +1,216 @@
+#!/usr/bin/env node
+/**
+ * Context Pruning Hook (PostToolUse)
+ *
+ * Reduces context usage by deduplicating repeated tool outputs,
+ * annotating superseded reads, and purging large error outputs.
+ *
+ * For MCP tools: uses `updatedMCPToolOutput` to replace the output.
+ * For built-in tools: uses `additionalContext` to add dedup notes.
+ *
+ * Tracker state is persisted to a temp file per session so it survives
+ * across separate hook process invocations.
+ *
+ * Core logic is in src/core/context-pruning/ for cross-platform reuse.
+ */
+
+import { readStdin } from "../lib/hook-utils.js";
+import { debug } from "../lib/logger.js";
+import { ContextPruningTracker } from "../core/context-pruning/index.js";
+import type { ToolRecord } from "../core/context-pruning/types.js";
+import { tmpdir } from "os";
+import { join } from "path";
+import { existsSync, readFileSync, writeFileSync } from "fs";
+
+const SOURCE = "context-pruning";
+
+interface HookInput {
+  hook_event_name: string;
+  session_id: string;
+  cwd: string;
+  tool_name?: string;
+  tool_input?: Record<string, unknown>;
+  tool_output?: string;
+  mcp_server_name?: string;
+  transcript_path?: string;
+}
+
+interface HookOutput {
+  continue: boolean;
+  hookSpecificOutput?: {
+    hookEventName: string;
+    additionalContext?: string;
+    updatedMCPToolOutput?: string;
+  };
+}
+
+/** Path to the persisted tracker history for a session. */
+function historyPath(sessionId: string): string {
+  return join(tmpdir(), `aide-context-pruning-${sessionId}.json`);
+}
+
+/** Load tracker history from disk. */
+function loadHistory(sessionId: string): {
+  history: ToolRecord[];
+  hasExplainedPruning: boolean;
+} {
+  const path = historyPath(sessionId);
+  try {
+    if (existsSync(path)) {
+      const data = JSON.parse(readFileSync(path, "utf-8"));
+      return {
+        history: data.history || [],
+        hasExplainedPruning: data.hasExplainedPruning || false,
+      };
+    }
+  } catch {
+    // Corrupt file — start fresh
+  }
+  return { history: [], hasExplainedPruning: false };
+}
+
+/** Save tracker history to disk. */
+function saveHistory(
+  sessionId: string,
+  history: ToolRecord[],
+  hasExplainedPruning: boolean,
+): void {
+  const path = historyPath(sessionId);
+  try {
+    // Keep only last 200 entries to prevent unbounded growth
+    const trimmed = history.length > 200 ? history.slice(-200) : history;
+    writeFileSync(
+      path,
+      JSON.stringify({ history: trimmed, hasExplainedPruning }),
+      "utf-8",
+    );
+  } catch (err) {
+    debug(SOURCE, `Failed to save history: ${err}`);
+  }
+}
+
+/** Check if a tool is an MCP tool (aide or other MCP server). */
+function isMCPTool(toolName: string, mcpServerName?: string): boolean {
+  if (mcpServerName) return true;
+  // Convention: MCP tools often have mcp__ prefix or are aide tools
+  if (toolName.startsWith("mcp__")) return true;
+  return false;
+}
+
+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 toolInput = data.tool_input || {};
+    const toolOutput = data.tool_output || "";
+    const cwd = data.cwd || process.cwd();
+    const sessionId = data.session_id || "unknown";
+
+    // Skip if no tool output to prune
+    if (!toolOutput || toolOutput.length < 50) {
+      console.log(JSON.stringify({ continue: true }));
+      return;
+    }
+
+    // Create tracker with loaded history
+    const tracker = new ContextPruningTracker(cwd);
+    const { history: priorHistory, hasExplainedPruning } =
+      loadHistory(sessionId);
+    tracker.loadHistory(priorHistory);
+
+    // Use a synthetic callId since CC doesn't provide one
+    const callId = `cc-${sessionId}-${Date.now()}`;
+
+    // Process through pruning strategies
+    const result = tracker.process(callId, toolName, toolInput, toolOutput);
+
+    // Track whether we've explained pruning tags to the model
+    let explained = hasExplainedPruning;
+
+    // Save updated history
+    saveHistory(sessionId, tracker.getHistory(), explained);
+
+    if (result.modified) {
+      debug(
+        SOURCE,
+        `Pruned [${result.strategy}]: saved ${result.bytesSaved} bytes for ${toolName}`,
+      );
+
+      const output: HookOutput = {
+        continue: true,
+        hookSpecificOutput: {
+          hookEventName: "PostToolUse",
+        },
+      };
+
+      if (isMCPTool(toolName, data.mcp_server_name)) {
+        // For MCP tools, replace the output entirely
+        output.hookSpecificOutput!.updatedMCPToolOutput = result.output;
+      } else {
+        // For built-in tools, add context note about the dedup
+        output.hookSpecificOutput!.additionalContext = result.output.includes(
+          "[aide:dedup]",
+        )
+          ? `Note: This tool output is identical to a previous call. The full content was already provided earlier.`
+          : result.output.includes("[aide:purge]")
+            ? `Note: Error output was truncated. Re-run the command to see full output.`
+            : undefined;
+      }
+
+      // On first prune, inject explanation of pruning tags via additionalContext
+      if (!explained) {
+        const pruningNotes = [
+          "<aide-context-pruning>",
+          "Tool outputs may contain these tags from aide's context optimization:",
+          "- [aide:dedup] — This output is identical to a previous call. Refer to the earlier result.",
+          "- [aide:supersede] — A prior Read of this file is now stale after a Write/Edit.",
+          "- [aide:purge] — Large error output was trimmed. Re-run the command for full output.",
+          "</aide-context-pruning>",
+        ].join("\n");
+
+        const existing = output.hookSpecificOutput!.additionalContext || "";
+        output.hookSpecificOutput!.additionalContext = existing
+          ? `${existing}\n\n${pruningNotes}`
+          : pruningNotes;
+
+        explained = true;
+        // Persist the flag
+        saveHistory(sessionId, tracker.getHistory(), explained);
+      }
+
+      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();

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();