ashlr-plugin 1.36.4

package/hooks/posttooluse-correlate.ts

@@ -0,0 +1,122 @@
+#!/usr/bin/env bun
+/**
+ * posttooluse-correlate.ts — Correlate ashlr__* calls with prior native-tool
+ * blocks to measure redirect conversion.
+ *
+ * PostToolUse hook. When an ashlr__read / ashlr__grep / ashlr__edit /
+ * ashlr__multi_edit call completes, this hook reads the recent-blocks log
+ * written by the pretooluse-* hooks. For every block within the 10-second
+ * window, it emits a `tool_called_after_block` event with correlation metadata
+ * and then prunes the consumed entries from the log.
+ *
+ * Design:
+ *   - Best-effort only. Any error → silent continue, exit 0.
+ *   - Kill switch: ASHLR_SESSION_LOG=0 disables all telemetry.
+ *   - Window: 10 seconds (configurable via ASHLR_BLOCK_WINDOW_MS).
+ *   - Only fires for tools that are known ashlr equivalents.
+ */
+
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { flushHookTimings, recordHookTiming } from "./pretooluse-common";
+import { readRecentBlocks, pruneOldBlocks } from "./_recent-blocks";
+
+const hookStartedAt = Date.now();
+
+async function exit(code: number, outcome: "ok" | "error" = "ok"): Promise<never> {
+  recordHookTiming({
+    hook: "posttooluse-correlate",
+    durationMs: Date.now() - hookStartedAt,
+    outcome,
+  });
+  await flushHookTimings();
+  process.exit(code);
+}
+
+// Kill switch
+if (process.env.ASHLR_SESSION_LOG === "0") await exit(0);
+
+// Correlation window (default 10s)
+const WINDOW_MS = (() => {
+  const raw = process.env.ASHLR_BLOCK_WINDOW_MS;
+  if (!raw) return 10_000;
+  const n = parseInt(raw, 10);
+  return Number.isFinite(n) && n > 0 ? n : 10_000;
+})();
+
+// Map from ashlr tool → native tool it replaces (for correlation)
+const ASHLR_TO_NATIVE: Record<string, string[]> = {
+  "ashlr__read":       ["Read"],
+  "ashlr__grep":       ["Grep"],
+  "ashlr__edit":       ["Edit", "Write"],
+  "ashlr__multi_edit": ["MultiEdit"],
+  // Wave-1 tools (Track B/C) — reference them but they may not exist yet.
+  "ashlr__websearch":  ["WebSearch"],
+  "ashlr__notebook_edit": ["NotebookEdit"],
+  "ashlr__write":      ["Write"],
+};
+
+// Read stdin
+const chunks: Buffer[] = [];
+process.stdin.on("data", (c: Buffer) => chunks.push(c));
+process.stdin.on("end", async () => {
+  let payload: Record<string, unknown> = {};
+  try {
+    payload = JSON.parse(Buffer.concat(chunks).toString("utf-8")) as Record<string, unknown>;
+  } catch {
+    await exit(0);
+  }
+
+  const toolName = payload.tool_name as string | undefined;
+  if (!toolName) await exit(0);
+  // After the guard above, toolName is narrowed to string within the
+  // same block — but TypeScript can't narrow across the async exit(0)
+  // boundary. Use a local const to carry the narrowed type forward.
+  const resolvedToolName: string = toolName!;
+
+  // Only process known ashlr tools
+  const nativeEquivalents = ASHLR_TO_NATIVE[resolvedToolName];
+  if (!nativeEquivalents) await exit(0);
+
+  const now = Date.now();
+  const cutoff = now - WINDOW_MS;
+
+  // After nativeEquivalents guard, TypeScript can't narrow across async boundary.
+  const resolvedNative: string[] = nativeEquivalents!;
+
+  // Read recent blocks and find matches within window
+  const blocks = readRecentBlocks();
+  const matches = blocks.filter(
+    (b) => b.ts >= cutoff && resolvedNative.includes(b.toolName)
+  );
+
+  if (matches.length === 0) {
+    // Still prune stale entries
+    pruneOldBlocks(WINDOW_MS * 2);
+    await exit(0);
+  }
+
+  // Emit one event per matched block
+  try {
+    const { logEvent } = await import("../servers/_events");
+    for (const match of matches) {
+      await logEvent("tool_called_after_block", {
+        tool: resolvedToolName,
+        extra: {
+          nativeToolBlocked: match.toolName,
+          blockTs: match.ts,
+          latencyMs: now - match.ts,
+          pattern: match.pattern,
+          filePath: match.filePath,
+        },
+      });
+    }
+  } catch {
+    // Telemetry must never surface errors.
+  }
+
+  // Prune old entries (keep any that are still within the window but unmatched)
+  pruneOldBlocks(WINDOW_MS * 2);
+
+  await exit(0);
+});

package/hooks/posttooluse-dedupe-output.ts

@@ -0,0 +1,241 @@
+#!/usr/bin/env bun
+/**
+ * posttooluse-dedupe-output.ts — Elide duplicate tool results across turns.
+ *
+ * PostToolUse hook for Read / Grep / ashlr__read / ashlr__grep.
+ *
+ * When the same content (identified by contentSha8) was already seen from the
+ * same tool class (Read↔ashlr__read, Grep↔ashlr__grep) within the last 8
+ * turns of the current session, the result is elided in additionalContext so
+ * the model doesn't re-ingest redundant bytes.
+ *
+ * Design:
+ *   - Best-effort — never throws, always exits 0.
+ *   - Kill switch: ASHLR_SESSION_LOG=0 disables everything.
+ *   - Uses the same session-history JSONL written by posttooluse-stale-result.
+ *
+ * Hook contract (PostToolUse):
+ *   stdin  → { tool_name, tool_input?, tool_result? }
+ *   stdout → { hookSpecificOutput: { hookEventName: "PostToolUse",
+ *                                    additionalContext?: string } }
+ */
+
+import { existsSync, mkdirSync, readFileSync, appendFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+
+import {
+  readHistory,
+  resolveSessionId,
+  sha8,
+  historyDir,
+  historyPath,
+  readCurrentTurn,
+  type HistoryEntry,
+} from "../servers/_history-tracker";
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+/** How many recent turns to scan for duplicates. */
+const DEDUP_LOOKBACK_TURNS = 8;
+
+// ---------------------------------------------------------------------------
+// Tool class normalisation — Read↔ashlr__read, Grep↔ashlr__grep
+// ---------------------------------------------------------------------------
+
+type ToolClass = "read" | "grep" | "other";
+
+const TRACKED_TOOLS = new Set([
+  "Read",
+  "Grep",
+  "mcp__ashlr-efficiency__ashlr__read",
+  "mcp__ashlr-efficiency__ashlr__grep",
+  "mcp__plugin_ashlr_ashlr__ashlr__read",
+  "mcp__plugin_ashlr_ashlr__ashlr__grep",
+  "ashlr__read",
+  "ashlr__grep",
+]);
+
+function toolClass(toolName: string): ToolClass {
+  const t = toolName.toLowerCase();
+  if (t === "read" || t.endsWith("ashlr__read")) return "read";
+  if (t === "grep" || t.endsWith("ashlr__grep")) return "grep";
+  return "other";
+}
+
+// ---------------------------------------------------------------------------
+// Content extraction
+// ---------------------------------------------------------------------------
+
+function extractContent(payload: Record<string, unknown>): string {
+  const result = payload.tool_result ?? payload.tool_response ?? payload.tool_output;
+  if (result == null) return "";
+  if (typeof result === "string") return result;
+  try { return JSON.stringify(result); } catch { return ""; }
+}
+
+// ---------------------------------------------------------------------------
+// Hook output type
+// ---------------------------------------------------------------------------
+
+interface HookOutput {
+  hookSpecificOutput: {
+    hookEventName: "PostToolUse";
+    additionalContext?: string;
+  };
+}
+
+function passThrough(): HookOutput {
+  return { hookSpecificOutput: { hookEventName: "PostToolUse" } };
+}
+
+// ---------------------------------------------------------------------------
+// Dedup stats path (for bytesSaved accumulation)
+// ---------------------------------------------------------------------------
+
+export function dedupStatsPath(homeDir: string): string {
+  return join(homeDir, ".ashlr", "dedupe-stats.json");
+}
+
+export interface DedupeStats {
+  bytesSaved: number;
+  dedupeCount: number;
+}
+
+function loadDedupeStats(homeDir: string): DedupeStats {
+  try {
+    const p = dedupStatsPath(homeDir);
+    if (!existsSync(p)) return { bytesSaved: 0, dedupeCount: 0 };
+    return JSON.parse(readFileSync(p, "utf-8")) as DedupeStats;
+  } catch {
+    return { bytesSaved: 0, dedupeCount: 0 };
+  }
+}
+
+function saveDedupeStats(stats: DedupeStats, homeDir: string): void {
+  try {
+    const p = dedupStatsPath(homeDir);
+    mkdirSync(dirname(p), { recursive: true });
+    const { writeFileSync } = require("fs") as typeof import("fs");
+    writeFileSync(p, JSON.stringify(stats), "utf-8");
+  } catch {
+    // Best-effort.
+  }
+}
+
+function accumulateBytesSaved(bytes: number, homeDir: string): void {
+  try {
+    const stats = loadDedupeStats(homeDir);
+    stats.bytesSaved += bytes;
+    stats.dedupeCount += 1;
+    saveDedupeStats(stats, homeDir);
+  } catch {
+    // Best-effort.
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Main decision function (exported for tests)
+// ---------------------------------------------------------------------------
+
+export interface DecideOpts {
+  home?: string;
+  sessionId?: string;
+  now?: number;
+}
+
+export function decide(
+  payload: Record<string, unknown>,
+  opts: DecideOpts = {},
+): HookOutput {
+  if (process.env.ASHLR_SESSION_LOG === "0") return passThrough();
+
+  const toolName = payload?.tool_name;
+  if (typeof toolName !== "string" || !TRACKED_TOOLS.has(toolName)) {
+    return passThrough();
+  }
+
+  const klass = toolClass(toolName);
+  if (klass === "other") return passThrough();
+
+  const homeDir =
+    opts.home ??
+    (process.env.ASHLR_HOME_OVERRIDE?.trim() || process.env.HOME || homedir());
+  const sessionId = opts.sessionId ?? resolveSessionId();
+
+  const content = extractContent(payload);
+  if (!content) return passThrough();
+
+  const contentHash = sha8(content);
+  const contentBytes = Buffer.byteLength(content, "utf-8");
+
+  // Read last DEDUP_LOOKBACK_TURNS entries from session history.
+  const history = readHistory(sessionId, homeDir);
+  if (history.length === 0) return passThrough();
+
+  const currentTurn = history.length;
+  const lookbackStart = Math.max(0, currentTurn - DEDUP_LOOKBACK_TURNS);
+  const recentEntries = history.slice(lookbackStart);
+
+  // Find a prior turn with matching tool class AND same contentSha8.
+  const match = recentEntries.find(
+    (e: HistoryEntry) =>
+      toolClass(e.tool) === klass &&
+      e.contentSha8 === contentHash &&
+      e.turn < currentTurn,
+  );
+
+  if (!match) return passThrough();
+
+  // Duplicate found — elide and report.
+  accumulateBytesSaved(contentBytes, homeDir);
+
+  const elision =
+    `[ashlr-dedupe] identical to turn ${match.turn} result ` +
+    `(sha8=${contentHash}); content elided to save ${contentBytes}B`;
+
+  return {
+    hookSpecificOutput: {
+      hookEventName: "PostToolUse",
+      additionalContext: elision,
+    },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Stdin reading
+// ---------------------------------------------------------------------------
+
+async function readStdin(): Promise<string> {
+  const chunks: Buffer[] = [];
+  for await (const chunk of process.stdin as AsyncIterable<Buffer | string>) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+
+// ---------------------------------------------------------------------------
+// Entry point
+// ---------------------------------------------------------------------------
+
+async function main(): Promise<void> {
+  let payload: Record<string, unknown> = {};
+  try {
+    const raw = await readStdin();
+    if (raw.trim()) payload = JSON.parse(raw) as Record<string, unknown>;
+  } catch {
+    process.stdout.write(JSON.stringify(passThrough()));
+    return;
+  }
+  try {
+    process.stdout.write(JSON.stringify(decide(payload)));
+  } catch {
+    process.stdout.write(JSON.stringify(passThrough()));
+  }
+}
+
+if (import.meta.main) {
+  await main();
+}

package/hooks/posttooluse-genome-refresh.ts

@@ -0,0 +1,223 @@
+#!/usr/bin/env bun
+/**
+ * posttooluse-genome-refresh.ts — PostToolUse hook that records edited file
+ * paths to ~/.ashlr/pending-genome-refresh.txt for incremental genome refresh.
+ *
+ * Triggers on Edit, Write, MultiEdit, NotebookEdit, and all ashlr MCP edit
+ * variants. Appends the absolute file path (deduped) so the genome-refresh-
+ * worker can process them at session end.
+ *
+ * Design rules:
+ *   - Never throws, never blocks. Best-effort fire-and-forget.
+ *   - Exits 0 always.
+ *   - No stdout — must not pollute the hook channel.
+ *   - Kill switch: ASHLR_GENOME_AUTO=0
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join, dirname, resolve, isAbsolute } from "path";
+
+import { noteHookError } from "./_hook-errors";
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+export const PENDING_FILE_NAME = "pending-genome-refresh.txt";
+
+function pendingPath(home: string = homedir()): string {
+  return join(home, ".ashlr", PENDING_FILE_NAME);
+}
+
+// ---------------------------------------------------------------------------
+// Tool name detection — mirrors genome-scribe-hook.ts EDIT_TOOL_NAMES
+// ---------------------------------------------------------------------------
+
+export const WRITE_TOOL_NAMES = new Set<string>([
+  "Edit",
+  "Write",
+  "MultiEdit",
+  "NotebookEdit",
+]);
+
+export function isWriteTool(name: string | undefined): boolean {
+  if (!name) return false;
+  if (WRITE_TOOL_NAMES.has(name)) return true;
+  // mcp__plugin_ashlr_ashlr__ashlr__edit etc.
+  if (!name.startsWith("mcp__")) return false;
+  return (
+    name.endsWith("ashlr__edit") ||
+    name.endsWith("ashlr__write") ||
+    name.endsWith("ashlr__multi_edit") ||
+    name.endsWith("ashlr__notebook_edit") ||
+    name.endsWith("ashlr__edit_structural") ||
+    name.endsWith("ashlr__rename_file")
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Path extraction from tool_input
+// ---------------------------------------------------------------------------
+
+interface ToolInput {
+  file_path?: unknown;
+  path?: unknown;
+  // rename_file uses old_path / new_path
+  old_path?: unknown;
+  new_path?: unknown;
+  // MultiEdit uses edits[]
+  edits?: Array<{ file_path?: unknown }>;
+}
+
+export function extractFilePaths(toolInput: unknown): string[] {
+  if (!toolInput || typeof toolInput !== "object") return [];
+  const inp = toolInput as ToolInput;
+  const paths: string[] = [];
+
+  // Single file: file_path or path
+  for (const key of ["file_path", "path", "old_path", "new_path"] as const) {
+    const v = inp[key];
+    if (typeof v === "string" && v.trim()) paths.push(v.trim());
+  }
+
+  // MultiEdit: edits[].file_path
+  if (Array.isArray(inp.edits)) {
+    for (const e of inp.edits) {
+      if (e && typeof e === "object") {
+        const fp = (e as { file_path?: unknown }).file_path;
+        if (typeof fp === "string" && fp.trim()) paths.push(fp.trim());
+      }
+    }
+  }
+
+  // Deduplicate within this payload
+  return [...new Set(paths)];
+}
+
+// ---------------------------------------------------------------------------
+// Pending-list writer
+// ---------------------------------------------------------------------------
+
+/**
+ * Append absolute paths to the pending file, deduped.
+ * Returns true if any paths were added.
+ */
+export function appendToPending(paths: string[], home?: string): boolean {
+  if (paths.length === 0) return false;
+  const file = pendingPath(home);
+  try {
+    mkdirSync(dirname(file), { recursive: true });
+  } catch {
+    return false;
+  }
+
+  // Read existing set
+  const existing = new Set<string>();
+  if (existsSync(file)) {
+    try {
+      for (const line of readFileSync(file, "utf-8").split("\n")) {
+        const t = line.trim();
+        if (t) existing.add(t);
+      }
+    } catch (e) {
+      noteHookError("posttooluse-genome-refresh", "read-pending-list", e);
+    }
+  }
+
+  // Resolve to absolute paths and filter new-only
+  const toAdd: string[] = [];
+  for (const p of paths) {
+    const abs = isAbsolute(p) ? p : resolve(p);
+    if (!existing.has(abs)) {
+      existing.add(abs);
+      toAdd.push(abs);
+    }
+  }
+
+  if (toAdd.length === 0) return false;
+
+  try {
+    const content = [...existing].filter(Boolean).join("\n") + "\n";
+    writeFileSync(file, content, "utf-8");
+    return true;
+  } catch (e) {
+    noteHookError("posttooluse-genome-refresh", "write-pending-list", e);
+    return false;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Payload type
+// ---------------------------------------------------------------------------
+
+interface PostToolUsePayload {
+  tool_name?: string;
+  tool_input?: unknown;
+  tool_response?: Record<string, unknown>;
+}
+
+function editSucceeded(toolResponse: Record<string, unknown> | undefined): boolean {
+  if (!toolResponse) return true;
+  if (toolResponse.isError === true) return false;
+  if (toolResponse.is_error === true) return false;
+  if (typeof toolResponse.success === "boolean") return toolResponse.success;
+  return true;
+}
+
+// ---------------------------------------------------------------------------
+// Hook output (pass-through — we never block)
+// ---------------------------------------------------------------------------
+
+interface HookOutput {
+  hookSpecificOutput: { hookEventName: "PostToolUse"; additionalContext?: string };
+}
+
+export function passThrough(): HookOutput {
+  return { hookSpecificOutput: { hookEventName: "PostToolUse" } };
+}
+
+// ---------------------------------------------------------------------------
+// Core logic
+// ---------------------------------------------------------------------------
+
+export function handle(payload: PostToolUsePayload, home?: string): HookOutput {
+  try {
+    if (process.env.ASHLR_GENOME_AUTO === "0") return passThrough();
+    if (!isWriteTool(payload?.tool_name)) return passThrough();
+    if (!editSucceeded(payload.tool_response)) return passThrough();
+
+    const paths = extractFilePaths(payload.tool_input);
+    appendToPending(paths, home ?? homedir());
+  } catch (e) {
+    noteHookError("posttooluse-genome-refresh", "handle", e);
+  }
+  return passThrough();
+}
+
+// ---------------------------------------------------------------------------
+// Stdio entry point
+// ---------------------------------------------------------------------------
+
+async function main(): Promise<void> {
+  const chunks: Buffer[] = [];
+  for await (const chunk of process.stdin as AsyncIterable<Buffer | string>) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  const raw = Buffer.concat(chunks).toString("utf-8").trim();
+
+  let payload: PostToolUsePayload = {};
+  if (raw) {
+    try {
+      payload = JSON.parse(raw) as PostToolUsePayload;
+    } catch {
+      /* bad input — pass-through */
+    }
+  }
+
+  process.stdout.write(JSON.stringify(handle(payload)));
+}
+
+if (import.meta.main) {
+  await main();
+}