@jmylchreest/aide-plugin 0.0.60 → 0.0.62

package/src/hooks/search-enrichment.ts

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+/**
+ * Search Enrichment Hook (PreToolUse)
+ *
+ * Enriches Grep tool calls with code index context — symbol definitions,
+ * file locations, and reference counts. This gives the agent structural
+ * awareness without additional tool calls.
+ *
+ * This is a soft advisory — it never blocks, only injects additive context.
+ *
+ * Core logic is in src/core/search-enrichment.ts for cross-platform reuse.
+ */
+
+import { readStdin } from "../lib/hook-utils.js";
+import { debug } from "../lib/logger.js";
+import { checkSearchEnrichment } from "../core/search-enrichment.js";
+import { findAideBinary } from "../core/aide-client.js";
+import { recordTokenEvent } from "../core/read-tracking.js";
+
+const SOURCE = "search-enrichment";
+
+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>;
+}
+
+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 binary = findAideBinary({
+      cwd,
+      pluginRoot:
+        process.env.AIDE_PLUGIN_ROOT || process.env.CLAUDE_PLUGIN_ROOT,
+    });
+
+    const result = checkSearchEnrichment(toolName, toolInput, cwd, binary);
+
+    if (result.shouldEnrich && result.enrichment) {
+      debug(SOURCE, `Enriching grep with code index context`);
+
+      // Record token event for search enrichment
+      if (binary) {
+        try {
+          const tokens = Math.round(result.enrichment.length / 3.0);
+          recordTokenEvent(binary, cwd, "context_injected", "enrichment", "search-enrichment", tokens);
+        } catch {
+          // Non-fatal
+        }
+      }
+
+      const output: HookOutput = {
+        continue: true,
+        hookSpecificOutput: {
+          hookEventName: "PreToolUse",
+          additionalContext: result.enrichment,
+        },
+      };
+      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/session-start.ts

@@ -26,6 +26,7 @@ import { homedir } from "os";
 import { Logger, debug, setDebugCwd } from "../lib/logger.js";
 import { readStdin, detectPlatform } from "../lib/hook-utils.js";
 import { findAideBinary, ensureAideBinary } from "../lib/aide-downloader.js";
+import { recordTokenEvent } from "../core/read-tracking.js";
 import {
   ensureDirectories as coreEnsureDirectories,
   loadConfig as coreLoadConfig,
@@ -458,6 +459,28 @@ async function main(): Promise<void> {
     log.end("buildWelcomeContext");
     debugLog(`buildWelcomeContext complete (${Date.now() - hookStart}ms)`);
 
+    // Record token events for context injection
+    try {
+      const binary = findAideBinary(cwd);
+      if (binary && context) {
+        const memoryTokens = Math.round(
+          ([...memories.static.global, ...memories.static.project, ...memories.dynamic.sessions]
+            .join("").length) / 3.0
+        );
+        const decisionTokens = Math.round(
+          memories.static.decisions.join("").length / 3.0
+        );
+        if (memoryTokens > 0) {
+          recordTokenEvent(binary, cwd, "context_injected", "memory", "session-start", memoryTokens);
+        }
+        if (decisionTokens > 0) {
+          recordTokenEvent(binary, cwd, "context_injected", "decision", "session-start", decisionTokens);
+        }
+      }
+    } catch {
+      // Non-fatal — don't break session start for token tracking
+    }
+
     log.end("total");
     log.info("Session start complete");
     debugLog(`Flushing logs to ${log.getLogFile()}...`);

package/src/hooks/skill-injector.ts

@@ -25,6 +25,8 @@ import {
   formatSkillsContext as coreFormatSkillsContext,
 } from "../core/skill-matcher.js";
 import type { Skill } from "../core/types.js";
+import { findAideBinary } from "../core/aide-client.js";
+import { recordObserveEvent } from "../core/read-tracking.js";
 
 const SOURCE = "skill-injector";
 
@@ -201,6 +203,33 @@ async function main(): Promise<void> {
       log.info(
         `Injecting ${matched.length} skills: ${matched.map((s) => s.name).join(", ")}`,
       );
+
+      const skillContext = formatSkillsContext(matched);
+
+      // Record one observe event per matched skill so the dashboard can
+      // attribute injected tokens to the specific skills (not just a
+      // single "skill-injector" aggregate). Subtype="skill" keeps the
+      // category roll-up; Name carries the per-skill identifier.
+      try {
+        const binary = findAideBinary({ cwd });
+        if (binary) {
+          for (const skill of matched) {
+            const text = `### ${skill.name}\n${skill.description ?? ""}\n${skill.content}`;
+            const tokens = Math.round(text.length / 3.0);
+            recordObserveEvent(binary, cwd, {
+              kind: "injection",
+              name: skill.name,
+              category: "inject",
+              subtype: "skill",
+              tokens,
+              file: SOURCE,
+            });
+          }
+        }
+      } catch {
+        // Non-fatal
+      }
+
       debugLog(`Flushing logs...`);
       log.flush();
       debugLog(`Hook complete (${Date.now() - hookStart}ms total)`);
@@ -209,7 +238,7 @@ async function main(): Promise<void> {
         continue: true,
         hookSpecificOutput: {
           hookEventName: "UserPromptSubmit",
-          additionalContext: formatSkillsContext(matched),
+          additionalContext: skillContext,
         },
       };
       console.log(JSON.stringify(output));

package/src/hooks/subagent-tracker.ts

@@ -20,12 +20,6 @@ import { Logger } from "../lib/logger.js";
 import { readStdin, setMemoryState } from "../lib/hook-utils.js";
 import { findAideBinary } from "../core/aide-client.js";
 import { refreshHud } from "../lib/hud.js";
-import {
-  getWorktreeForAgent,
-  markWorktreeComplete,
-  discoverWorktrees,
-  Worktree,
-} from "../lib/worktree.js";
 
 // Global logger instance
 let log: Logger | null = null;
@@ -207,36 +201,15 @@ function fetchSubagentMemories(cwd: string): {
 /**
  * Build context for subagent injection
  */
-function buildSubagentContext(
-  memories: {
-    global: string[];
-    project: string[];
-    decisions: string[];
-  },
-  worktree?: Worktree,
-): string {
+function buildSubagentContext(memories: {
+  global: string[];
+  project: string[];
+  decisions: string[];
+}): string {
   const lines: string[] = [];
 
   lines.push("<aide-subagent-context>");
 
-  // Inject worktree information if this is a swarm agent
-  if (worktree) {
-    lines.push("");
-    lines.push("## Swarm Worktree");
-    lines.push("");
-    lines.push(`You are working in an isolated git worktree for swarm mode.`);
-    lines.push(`- **Worktree Path**: ${worktree.path}`);
-    lines.push(`- **Branch**: ${worktree.branch}`);
-    lines.push(`- **Story ID**: ${worktree.taskId || "unknown"}`);
-    lines.push("");
-    lines.push(
-      `**IMPORTANT**: All file operations should be performed in: ${worktree.path}`,
-    );
-    lines.push(
-      `Commit your changes to the ${worktree.branch} branch when complete.`,
-    );
-  }
-
   if (memories.global.length > 0) {
     lines.push("");
     lines.push("## User Preferences");
@@ -349,46 +322,6 @@ async function processSubagentStart(
   refreshHud(cwd, session_id);
   log?.end("refreshHud");
 
-  // Auto-discover any worktrees created by the orchestrator via git commands
-  // This ensures we track worktrees even if they weren't created via our library
-  log?.start("discoverWorktrees");
-  const discovered = discoverWorktrees(cwd);
-  if (discovered.length > 0) {
-    log?.info(`Auto-discovered ${discovered.length} worktrees`);
-  }
-  log?.end("discoverWorktrees", { discovered: discovered.length });
-
-  // Check if this agent has an associated worktree (swarm mode)
-  // Match by agent_id or by pattern in worktree name
-  log?.start("checkWorktree");
-  let worktree = getWorktreeForAgent(cwd, agent_id);
-
-  // If no direct match, try to match by agent_id pattern in worktree name
-  // This handles cases where worktree was created before agent_id was known
-  if (!worktree) {
-    const { loadWorktreeState } = await import("../lib/worktree.js");
-    const state = loadWorktreeState(cwd);
-    // Look for worktree with matching name pattern (e.g., "story-auth" matches "agent-auth")
-    const agentPattern = agent_id.replace(/^agent-/, "");
-    worktree = state.active.find(
-      (w) => w.name.includes(agentPattern) && !w.agentId,
-    );
-    if (worktree) {
-      // Assign this agent to the worktree
-      worktree.agentId = agent_id;
-      const { saveWorktreeState } = await import("../lib/worktree.js");
-      saveWorktreeState(cwd, state);
-      log?.info(`Assigned worktree ${worktree.name} to agent ${agent_id}`);
-    }
-  }
-
-  if (worktree) {
-    log?.info(
-      `Found worktree for agent ${agent_id}: ${worktree.path} (branch: ${worktree.branch})`,
-    );
-  }
-  log?.end("checkWorktree", { hasWorktree: !!worktree });
-
   // Fetch memories for subagent context injection
   log?.start("fetchMemories");
   const memories = fetchSubagentMemories(cwd);
@@ -399,9 +332,9 @@ async function processSubagentStart(
   });
 
   // Always build and inject context (messaging section is unconditional)
-  const context = buildSubagentContext(memories, worktree);
+  const context = buildSubagentContext(memories);
   log?.info(
-    `Injecting context for subagent: ${memories.global.length} preferences, ${memories.project.length} project, ${memories.decisions.length} decisions, worktree=${!!worktree}`,
+    `Injecting context for subagent: ${memories.global.length} preferences, ${memories.project.length} project, ${memories.decisions.length} decisions`,
   );
   return context;
 }
@@ -422,17 +355,6 @@ async function processSubagentStop(data: SubagentStopInput): Promise<void> {
   setAgentState(cwd, agent_id, "endedAt", new Date().toISOString());
   log?.end("updateAgentStatus");
 
-  // Mark worktree as agent-complete if this agent had one (swarm mode)
-  // The worktree stays for merge review - cleanup happens after worktree-resolve
-  log?.start("checkWorktreeComplete");
-  const worktreeMarked = markWorktreeComplete(cwd, agent_id);
-  if (worktreeMarked) {
-    log?.info(
-      `Marked worktree as agent-complete for ${agent_id} - ready for merge review`,
-    );
-  }
-  log?.end("checkWorktreeComplete", { worktreeMarked });
-
   // Refresh HUD to remove the completed agent
   log?.start("refreshHud");
   refreshHud(cwd, session_id);

package/src/hooks/task-completed.ts

@@ -98,23 +98,6 @@ function commandSucceeds(cmd: string, cwd: string): boolean {
   return true;
 }
 
-/**
- * Get command output or null on failure (cross-platform via cross-spawn)
- */
-function getCommandOutput(cmd: string, cwd: string): string | null {
-  const [bin, args] = splitCommand(cmd);
-  if (!which.sync(bin, { nothrow: true })) {
-    debug(SOURCE, `Binary not found in PATH: ${bin}`);
-    return null;
-  }
-  const result = spawn.sync(bin, args, { cwd, stdio: "pipe", timeout: 30000 });
-  if (result.status !== 0 || !result.stdout) {
-    debug(SOURCE, `getCommandOutput failed for: ${cmd}: exit ${result.status}`);
-    return null;
-  }
-  return result.stdout.toString().trim();
-}
-
 /**
  * Detect project type (typescript, go, python)
  */

package/src/hooks/tool-observe.ts

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+/**
+ * Tool Observe Hook (PostToolUse)
+ *
+ * Single-purpose: record every Claude-native tool invocation as an
+ * observe.KindToolCall event. Mirror image of the MCP middleware on the Go
+ * side — together they give the dashboard complete tool-call coverage.
+ *
+ * All taxonomy (tool → category/subtype) and the recording itself live in
+ * src/core/tool-observe.ts so the OpenCode tool.execute.after handler can
+ * reuse the same logic.
+ */
+
+import { readStdin } from "../lib/hook-utils.js";
+import { findAideBinary } from "../core/aide-client.js";
+import { recordToolEvent } from "../core/tool-observe.js";
+import { debug } from "../lib/logger.js";
+
+const SOURCE = "tool-observe";
+
+interface HookInput {
+  hook_event_name: string;
+  session_id: string;
+  cwd: string;
+  tool_name?: string;
+  tool_input?: Record<string, unknown>;
+  tool_result?: { success: boolean };
+  // Claude Code passes the tool's actual output payload as tool_response.
+  // Shape varies per tool (string for Bash, object for others).
+  tool_response?: unknown;
+}
+
+function outputContinue(): void {
+  try {
+    console.log(JSON.stringify({ continue: true }));
+  } catch {
+    console.log('{"continue":true}');
+  }
+}
+
+async function main(): Promise<void> {
+  try {
+    const input = await readStdin();
+    if (!input.trim()) {
+      outputContinue();
+      return;
+    }
+    const data: HookInput = JSON.parse(input);
+    const cwd = data.cwd || process.cwd();
+    const toolName = data.tool_name;
+    if (!toolName) {
+      outputContinue();
+      return;
+    }
+    const binary = findAideBinary({
+      cwd,
+      pluginRoot:
+        process.env.AIDE_PLUGIN_ROOT || process.env.CLAUDE_PLUGIN_ROOT,
+    });
+    if (!binary) {
+      outputContinue();
+      return;
+    }
+    recordToolEvent(binary, cwd, {
+      toolName,
+      toolInput: data.tool_input as ToolInput,
+      toolResponse: data.tool_response,
+      success: data.tool_result?.success,
+      sessionId: data.session_id,
+    });
+  } catch (err) {
+    debug(SOURCE, `Hook error: ${err}`);
+  }
+  outputContinue();
+}
+
+type ToolInput = {
+  file_path?: string;
+  offset?: number;
+  limit?: number;
+  command?: string;
+  pattern?: string;
+};
+
+process.on("uncaughtException", (err) => {
+  debug(SOURCE, `UNCAUGHT EXCEPTION: ${err}`);
+  outputContinue();
+  process.exit(0);
+});
+
+process.on("unhandledRejection", (reason) => {
+  debug(SOURCE, `UNHANDLED REJECTION: ${reason}`);
+  outputContinue();
+  process.exit(0);
+});
+
+main();

package/src/lib/aide-downloader.ts

@@ -193,14 +193,6 @@ export function getDownloadUrls(): string[] {
   return [`https://github.com/jmylchreest/aide/releases/latest/download/${binaryName}`];
 }
 
-/**
- * Get the download URL for the current platform (first priority URL).
- * @deprecated Use getDownloadUrls() for fallback support.
- */
-export function getDownloadUrl(): string {
-  return getDownloadUrls()[0];
-}
-
 /**
  * Get the plugin root directory (where package.json lives)
  */

package/src/lib/hook-utils.ts

@@ -146,19 +146,6 @@ export function getMemoryState(
   return getState(binary, cwd, key, agentId);
 }
 
-/**
- * Delete a state key from aide
- */
-export function deleteMemoryState(
-  cwd: string,
-  key: string,
-  agentId?: string,
-): boolean {
-  const binary = findAideBinary(cwd);
-  if (!binary) return false;
-  return deleteState(binary, cwd, key, agentId);
-}
-
 /**
  * Clear all state for an agent
  */

package/src/lib/logger.ts

@@ -19,7 +19,7 @@
  *   touch .aide/.debug           # sentinel file (live toggle)
  */
 
-import { existsSync, mkdirSync, appendFileSync, writeFileSync } from "fs";
+import { existsSync, mkdirSync, appendFileSync } from "fs";
 import { join } from "path";
 
 export type LogLevel = "debug" | "info" | "warn" | "error";
@@ -195,21 +195,6 @@ export class Logger {
     }
   }
 
-  /**
-   * Time a synchronous operation
-   */
-  timeSync<T>(label: string, fn: () => T): T {
-    this.start(label);
-    try {
-      const result = fn();
-      this.end(label);
-      return result;
-    } catch (err) {
-      this.end(label, { error: String(err) });
-      throw err;
-    }
-  }
-
   /**
    * Format entries for file output
    */
@@ -265,43 +250,6 @@ export class Logger {
     }
   }
 
-  /**
-   * Write to a custom log file (relative to .aide/_logs/)
-   */
-  writeToFile(filename: string, content: string): void {
-    if (!this.enabled) return;
-
-    try {
-      this.ensureLogDir();
-      const filepath = join(this.logDir, filename);
-      writeFileSync(filepath, content);
-    } catch {
-      // Silently fail
-    }
-  }
-
-  /**
-   * Append to a custom log file (relative to .aide/_logs/)
-   */
-  appendToFile(filename: string, content: string): void {
-    if (!this.enabled) return;
-
-    try {
-      this.ensureLogDir();
-      const filepath = join(this.logDir, filename);
-      appendFileSync(filepath, content);
-    } catch {
-      // Silently fail
-    }
-  }
-
-  /**
-   * Get the log directory path
-   */
-  getLogDir(): string {
-    return this.logDir;
-  }
-
   /**
    * Get the main log file path
    */
@@ -318,21 +266,6 @@ export class Logger {
   }
 }
 
-/**
- * Create a singleton logger instance for quick use
- *
- * Note: Currently not used by hooks. Hooks create Logger instances
- * directly for more control. Exported for potential future use.
- */
-let defaultLogger: Logger | null = null;
-
-export function getLogger(source: string, cwd?: string): Logger {
-  if (!defaultLogger || defaultLogger["source"] !== source) {
-    defaultLogger = new Logger(source, cwd);
-  }
-  return defaultLogger;
-}
-
 // Debug log state - tracks cwd for file-based logging
 let debugLogCwd = process.cwd();
 

package/src/lib/usage.ts

@@ -50,12 +50,6 @@ export interface RealtimeUsage {
   messagesToday: number;
 }
 
-export interface UsageSummary {
-  limits: APILimits | null;
-  realtime: RealtimeUsage;
-  timestamp: string;
-}
-
 interface OAuthCredentials {
   claudeAiOauth?: {
     accessToken: string;
@@ -89,14 +83,7 @@ let apiLimitsCache: CacheEntry<APILimits> | null = null;
 const API_CACHE_TTL = 30_000; // 30 seconds
 
 let realtimeCache: CacheEntry<RealtimeUsage> | null = null;
-let realtimeCacheTTL = 60_000; // 1 minute default, configurable
-
-/**
- * Set the cache TTL for realtime usage data (JSONL scanning).
- */
-export function setRealtimeCacheTTL(ms: number): void {
-  realtimeCacheTTL = ms;
-}
+const realtimeCacheTTL = 60_000;
 
 // =============================================================================
 // OAuth API
@@ -430,22 +417,6 @@ async function scanSingleFile(
 // Combined Usage
 // =============================================================================
 
-/**
- * Get combined usage data: API limits + local token counts.
- */
-export async function getUsage(): Promise<UsageSummary> {
-  const [limits, realtime] = await Promise.all([
-    fetchAPILimits(),
-    scanTokenUsage(),
-  ]);
-
-  return {
-    limits: limits.error ? null : limits,
-    realtime,
-    timestamp: new Date().toISOString(),
-  };
-}
-
 /**
  * Get usage formatted for HUD display.
  * Prioritizes API percentages, falls back to token counts.