ashlr-plugin 1.36.4

package/hooks/session-end-stats-gc.ts

@@ -0,0 +1,80 @@
+#!/usr/bin/env bun
+/**
+ * ashlr SessionEnd hook: stats bucket GC.
+ *
+ * When a Claude Code session ends, drop its per-session bucket from
+ * ~/.ashlr/stats.json so the `sessions` map doesn't grow unboundedly as
+ * sessions come and go. Lifetime counters are preserved — only the
+ * session-scoped totals are removed.
+ *
+ * Also appends one final line to ~/.ashlr/session-log.jsonl capturing the
+ * totals from the bucket we're dropping, so the log remains a complete
+ * audit trail even after the bucket is gone.
+ *
+ * Contract: never throws, always exits 0, never blocks the shell for more
+ * than a few hundred ms.
+ */
+
+import { appendFile } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+
+import { currentSessionId, dropSessionBucket } from "../servers/_stats";
+import { maybeSyncToCloud as maybeSyncNudgeEvents, recordNudgeDismissedIfPending } from "../servers/_nudge-events";
+import { maybeCloudSync } from "../scripts/stats-cloud-sync.ts";
+
+const DEADLINE_MS = 800;
+
+async function main(): Promise<void> {
+  const sessionId = currentSessionId();
+  // Drain stdin defensively; the hook payload is unused here.
+  try {
+    if (!process.stdin.isTTY) {
+      await Promise.race([
+        (async () => {
+          for await (const _ of process.stdin as AsyncIterable<unknown>) { /* discard */ }
+        })(),
+        new Promise((r) => setTimeout(r, 50)),
+      ]);
+    }
+  } catch { /* ignore */ }
+
+  // Emit implicit-dismissal telemetry if a nudge was shown this session but
+  // never clicked. Best-effort; never blocks the GC path.
+  try {
+    await Promise.race([
+      recordNudgeDismissedIfPending(),
+      new Promise((r) => setTimeout(r, 200)),
+    ]);
+    maybeSyncNudgeEvents();
+  } catch { /* telemetry is decoration */ }
+
+  try {
+    const dropped = await Promise.race([
+      dropSessionBucket(sessionId),
+      new Promise<null>((r) => setTimeout(() => r(null), DEADLINE_MS)),
+    ]);
+    if (dropped) {
+      const summary = {
+        ts: new Date().toISOString(),
+        agent: "claude-code",
+        event: "session_end",
+        tool: "ashlr__session",
+        session: sessionId,
+        calls: dropped.calls,
+        tokens_saved: dropped.tokensSaved,
+        started_at: dropped.startedAt,
+      };
+      const logPath = join(process.env.HOME ?? homedir(), ".ashlr", "session-log.jsonl");
+      try { await appendFile(logPath, JSON.stringify(summary) + "\n"); } catch { /* best-effort */ }
+    }
+  } catch { /* GC is decoration — never break session-end */ }
+
+  // Pro-gated: push lifetime stats delta to cloud. Best-effort fire-and-forget.
+  try { maybeCloudSync(); } catch { /* stats sync is decoration */ }
+}
+
+if (import.meta.main) {
+  await main();
+  process.exit(0);
+}

package/hooks/session-log-append.sh

@@ -0,0 +1,94 @@
+#!/usr/bin/env bash
+# ashlr-plugin PostToolUse: cross-agent session log.
+#
+# Appends one JSONL line per tool invocation to `~/.ashlr/session-log.jsonl`
+# so any tool (workbench `aw-log`, Goose, OpenHands, etc.) can tail the
+# same feed. The schema is intentionally small:
+#
+#   { ts, agent, event, tool, cwd, session, input_size, output_size }
+#
+# Rules:
+#   - Never block the agent. `|| true` on every failure path.
+#   - Self-rotate: if the file passes 10 MB we rename to `.jsonl.1`.
+#   - Honor ASHLR_SESSION_LOG=0 as a kill switch.
+
+set +e
+
+if [ "${ASHLR_SESSION_LOG:-1}" = "0" ]; then
+  exit 0
+fi
+
+LOG_DIR="$HOME/.ashlr"
+LOG_FILE="$LOG_DIR/session-log.jsonl"
+ROTATED="$LOG_FILE.1"
+MAX_BYTES=10485760  # 10 MB
+
+mkdir -p "$LOG_DIR" 2>/dev/null || true
+
+# Slurp stdin once — may be empty or malformed, that's fine.
+STDIN_JSON=$(cat 2>/dev/null || true)
+
+# Rotate if the file has grown past the cap.
+if [ -f "$LOG_FILE" ]; then
+  SIZE=$(stat -f%z "$LOG_FILE" 2>/dev/null || stat -c%s "$LOG_FILE" 2>/dev/null || echo 0)
+  if [ -n "$SIZE" ] && [ "$SIZE" -ge "$MAX_BYTES" ] 2>/dev/null; then
+    mv -f "$LOG_FILE" "$ROTATED" 2>/dev/null || true
+  fi
+fi
+
+# Emit exactly one JSONL line via bun. We keep the bun stub tiny and
+# defensive: any parse error yields a minimal record rather than nothing.
+LINE=$(printf '%s' "$STDIN_JSON" | LOG_PWD="$PWD" LOG_SESSION="${CLAUDE_SESSION_ID:-}" bun -e '
+  let raw = "";
+  process.stdin.on("data", (c) => (raw += c));
+  process.stdin.on("end", () => {
+    const sizeOf = (v) => {
+      if (v == null) return 0;
+      if (typeof v === "string") return Buffer.byteLength(v, "utf8");
+      try { return Buffer.byteLength(JSON.stringify(v), "utf8"); } catch { return 0; }
+    };
+    let tool = "unknown";
+    let inSize = 0;
+    let outSize = 0;
+    try {
+      const p = raw.trim() ? JSON.parse(raw) : {};
+      if (typeof p?.tool_name === "string") tool = p.tool_name;
+      inSize = sizeOf(p?.tool_input);
+      outSize = sizeOf(p?.tool_result ?? p?.tool_response);
+    } catch { /* use defaults */ }
+    // Fallback session hash when CLAUDE_SESSION_ID is not set.
+    const sessRaw = process.env.LOG_SESSION || "";
+    let session = sessRaw;
+    if (!session) {
+      const seed = `${process.env.LOG_PWD || ""}:${process.pid}`;
+      let h = 0;
+      for (let i = 0; i < seed.length; i++) h = ((h << 5) - h + seed.charCodeAt(i)) | 0;
+      session = `h${(h >>> 0).toString(16)}`;
+    }
+    const rec = {
+      ts: new Date().toISOString(),
+      agent: "claude-code",
+      event: "tool_call",
+      tool,
+      cwd: process.env.LOG_PWD || "",
+      session,
+      input_size: inSize,
+      output_size: outSize,
+    };
+    process.stdout.write(JSON.stringify(rec));
+  });
+' 2>/dev/null)
+
+# If bun is unavailable or produced nothing, fall back to a minimal record
+# built entirely in bash so the log still captures something useful.
+if [ -z "$LINE" ]; then
+  TS=$(date -u +"%Y-%m-%dT%H:%M:%SZ" 2>/dev/null || echo "1970-01-01T00:00:00Z")
+  SESSION="${CLAUDE_SESSION_ID:-unknown}"
+  # JSON-safe cwd (escape backslashes + quotes).
+  CWD_ESC=$(printf '%s' "$PWD" | sed 's/\\/\\\\/g; s/"/\\"/g')
+  LINE="{\"ts\":\"$TS\",\"agent\":\"claude-code\",\"event\":\"tool_call\",\"tool\":\"unknown\",\"cwd\":\"$CWD_ESC\",\"session\":\"$SESSION\",\"input_size\":0,\"output_size\":0}"
+fi
+
+printf '%s\n' "$LINE" >> "$LOG_FILE" 2>/dev/null || true
+
+exit 0

package/hooks/session-log-append.ts

@@ -0,0 +1,116 @@
+#!/usr/bin/env bun
+/**
+ * session-log-append.ts — Cross-platform replacement for session-log-append.sh.
+ *
+ * Appends one JSONL line per tool invocation to ~/.ashlr/session-log.jsonl.
+ * Schema: { ts, agent, event, tool, cwd, session, input_size, output_size }
+ *
+ * Rules:
+ *   - Never block the agent. All failures are silently swallowed.
+ *   - Self-rotate: if the file passes 10 MB rename to .jsonl.1.
+ *   - Honor ASHLR_SESSION_LOG=0 as a kill switch.
+ */
+
+import { mkdirSync, statSync, renameSync, appendFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+if (process.env.ASHLR_SESSION_LOG === "0") process.exit(0);
+
+const LOG_DIR = join(
+  process.env.HOME ?? process.env.USERPROFILE ?? homedir(),
+  ".ashlr",
+);
+const LOG_FILE = join(LOG_DIR, "session-log.jsonl");
+const ROTATED_1 = LOG_FILE + ".1";
+const ROTATED_2 = LOG_FILE + ".2";
+const MAX_BYTES = 10 * 1024 * 1024; // 10 MB
+
+function agentName(): string {
+  const host = process.env.ASHLR_MCP_HOST?.trim();
+  if (host) return host;
+  return "claude-code";
+}
+
+function sizeOf(v: unknown): number {
+  if (v == null) return 0;
+  if (typeof v === "string") return Buffer.byteLength(v, "utf-8");
+  try {
+    return Buffer.byteLength(JSON.stringify(v), "utf-8");
+  } catch {
+    return 0;
+  }
+}
+
+const chunks: Buffer[] = [];
+process.stdin.on("data", (c: Buffer) => chunks.push(c));
+process.stdin.on("end", () => {
+  try {
+    mkdirSync(LOG_DIR, { recursive: true });
+  } catch {
+    process.exit(0);
+  }
+
+  // Rotate if over cap. Cascade .jsonl.1 → .jsonl.2 first so the prior
+  // rotation isn't silently clobbered when the fresh log passes the cap again.
+  try {
+    const st = statSync(LOG_FILE);
+    if (st.size >= MAX_BYTES) {
+      try {
+        try { renameSync(ROTATED_1, ROTATED_2); } catch { /* no prior .1 */ }
+        renameSync(LOG_FILE, ROTATED_1);
+      } catch {
+        /* best-effort */
+      }
+    }
+  } catch {
+    /* file doesn't exist yet */
+  }
+
+  const raw = Buffer.concat(chunks).toString("utf-8").trim();
+  let tool = "unknown";
+  let inSize = 0;
+  let outSize = 0;
+  let payloadSessionId = "";
+  try {
+    if (raw) {
+      const p = JSON.parse(raw);
+      if (typeof p?.tool_name === "string") tool = p.tool_name;
+      inSize = sizeOf(p?.tool_input);
+      outSize = sizeOf(p?.tool_result ?? p?.tool_response);
+      if (typeof p?.session_id === "string") payloadSessionId = p.session_id;
+    }
+  } catch {
+    /* use defaults */
+  }
+
+  const sessRaw = payloadSessionId || process.env.ASHLR_SESSION_ID || process.env.CLAUDE_SESSION_ID || "";
+  let session = sessRaw;
+  if (!session) {
+    const seed = `${process.cwd()}:${process.pid}`;
+    let h = 0;
+    for (let i = 0; i < seed.length; i++) {
+      h = ((h << 5) - h + seed.charCodeAt(i)) | 0;
+    }
+    session = `h${(h >>> 0).toString(16)}`;
+  }
+
+  const rec = {
+    ts: new Date().toISOString(),
+    agent: agentName(),
+    event: "tool_call",
+    tool,
+    cwd: process.cwd(),
+    session,
+    input_size: inSize,
+    output_size: outSize,
+  };
+
+  try {
+    appendFileSync(LOG_FILE, JSON.stringify(rec) + "\n", "utf-8");
+  } catch {
+    /* best-effort */
+  }
+
+  process.exit(0);
+});