ashlr-plugin 1.36.4

package/scripts/stats-cloud-sync.ts

@@ -0,0 +1,261 @@
+#!/usr/bin/env bun
+/**
+ * stats-cloud-sync.ts — Delta push of lifetime stats to the ashlr Pro backend.
+ *
+ * Reads local stats (via _stats.ts readStats()), computes the delta since the
+ * last successful sync (cursor stored in ~/.ashlr/stats-sync-cursor.json), and
+ * POSTs to POST /stats/sync.
+ *
+ * Privacy:
+ *   - machineId is a one-way SHA-256 hash of os.hostname() — the raw hostname
+ *     is never sent. The hash lets the backend deduplicate machine uploads
+ *     without learning the hostname.
+ *   - Only pure counts are sent (calls, tokensSaved, byTool, byDay). No paths,
+ *     no file content, no CWD.
+ *
+ * Cursor shape: { syncedAt: ISO, calls: number, tokensSaved: number }
+ *   - `calls` and `tokensSaved` are the lifetime totals at the time of the
+ *     last successful sync. The delta is (current - cursor). We send the
+ *     full current lifetime snapshot (not just the delta numbers) because the
+ *     server uses upsert/idempotent semantics — re-sending the same payload is
+ *     safe and avoids a separate delta endpoint.
+ *
+ * Best-effort: never throws, never blocks. On network failure the cursor is left
+ * untouched so the next call will retry the full accumulation.
+ */
+
+import { createHash } from "crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { hostname } from "os";
+import { join } from "path";
+
+import { readStats } from "../servers/_stats.ts";
+
+// ---------------------------------------------------------------------------
+// Paths
+// ---------------------------------------------------------------------------
+
+function ashlrDir(): string {
+  return join(process.env.HOME ?? process.env.USERPROFILE ?? "~", ".ashlr");
+}
+
+export function cursorPath(): string {
+  return join(ashlrDir(), "stats-sync-cursor.json");
+}
+
+export function proTokenPath(): string {
+  return join(ashlrDir(), "pro-token");
+}
+
+/**
+ * Public-leaderboard opt-in from ~/.ashlr/config.json { "leaderboard": ... }.
+ * Returns true ("public"), false ("off"), or undefined (unset → server keeps
+ * the user's current setting). Default is therefore OFF.
+ */
+export function readLeaderboardOptIn(): boolean | undefined {
+  try {
+    const cfg = JSON.parse(readFileSync(join(ashlrDir(), "config.json"), "utf-8")) as {
+      leaderboard?: unknown;
+    };
+    if (cfg.leaderboard === "public") return true;
+    if (cfg.leaderboard === "off") return false;
+    return undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Pro-token resolution
+// Priority: ASHLR_PRO_TOKEN env var → ~/.ashlr/pro-token file
+// ---------------------------------------------------------------------------
+
+export function resolveProToken(): string | null {
+  const env = process.env["ASHLR_PRO_TOKEN"];
+  if (env && env.trim().length > 0) return env.trim();
+  try {
+    const p = proTokenPath();
+    if (!existsSync(p)) return null;
+    const tok = readFileSync(p, "utf-8").trim();
+    return tok.length > 0 ? tok : null;
+  } catch {
+    return null;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// machineId — SHA-256 of hostname, first 16 hex chars.
+// Stable per machine; one-way so the server never sees the raw hostname.
+// ---------------------------------------------------------------------------
+
+export function machineId(): string {
+  return createHash("sha256").update(hostname()).digest("hex").slice(0, 16);
+}
+
+// ---------------------------------------------------------------------------
+// Cursor
+// ---------------------------------------------------------------------------
+
+interface SyncCursor {
+  syncedAt: string;
+  calls: number;
+  tokensSaved: number;
+}
+
+export function readCursor(): SyncCursor | null {
+  try {
+    const raw = readFileSync(cursorPath(), "utf-8");
+    const parsed = JSON.parse(raw) as Partial<SyncCursor>;
+    if (
+      typeof parsed.syncedAt === "string" &&
+      typeof parsed.calls === "number" &&
+      typeof parsed.tokensSaved === "number"
+    ) {
+      return parsed as SyncCursor;
+    }
+  } catch {
+    /* missing or corrupt — treat as first sync */
+  }
+  return null;
+}
+
+function writeCursor(cursor: SyncCursor): void {
+  try {
+    mkdirSync(ashlrDir(), { recursive: true });
+    writeFileSync(cursorPath(), JSON.stringify(cursor));
+  } catch {
+    /* best-effort */
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Core push logic — exported so tests can call it directly
+// ---------------------------------------------------------------------------
+
+export interface SyncResult {
+  skipped: boolean;
+  reason?: string;
+  ok?: boolean;
+  status?: number;
+  error?: string;
+}
+
+export async function pushStatsToCloud(opts: {
+  apiUrl?: string;
+  proToken?: string;
+}): Promise<SyncResult> {
+  const token = opts.proToken ?? resolveProToken();
+  if (!token) return { skipped: true, reason: "no-pro-token" };
+  if (process.env["ASHLR_STATS_UPLOAD"] === "0") {
+    return { skipped: true, reason: "kill-switch" };
+  }
+
+  const apiUrl = opts.apiUrl ?? process.env["ASHLR_API_URL"] ?? "https://api.ashlr.ai";
+
+  let stats: Awaited<ReturnType<typeof readStats>>;
+  try {
+    stats = await readStats();
+  } catch {
+    return { skipped: false, error: "read-stats-failed" };
+  }
+
+  const cursor = readCursor();
+
+  // Skip if nothing has changed since last sync.
+  if (
+    cursor &&
+    cursor.calls === stats.lifetime.calls &&
+    cursor.tokensSaved === stats.lifetime.tokensSaved
+  ) {
+    return { skipped: true, reason: "no-delta" };
+  }
+
+  // Build a pure-counts payload — byTool and byDay collapse to tokensSaved-only
+  // maps to match the server's ByToolSchema / ByDaySchema.
+  const byTool: Record<string, number> = {};
+  for (const [k, v] of Object.entries(stats.lifetime.byTool)) {
+    byTool[k] = v.tokensSaved;
+  }
+  const byDay: Record<string, number> = {};
+  for (const [k, v] of Object.entries(stats.lifetime.byDay)) {
+    byDay[k] = v.tokensSaved;
+  }
+
+  const leaderboardOptIn = readLeaderboardOptIn();
+
+  const body = {
+    apiToken: token,
+    stats: {
+      lifetime: {
+        calls:       stats.lifetime.calls,
+        tokensSaved: stats.lifetime.tokensSaved,
+        byTool,
+        byDay,
+      },
+    },
+    // machineId is informational — the server deduplicates on apiToken+machineId.
+    machineId: machineId(),
+    // Public-leaderboard opt-in — sent only when explicitly set (else the
+    // server leaves the user's current setting unchanged). Default OFF.
+    ...(leaderboardOptIn !== undefined ? { leaderboard_opt_in: leaderboardOptIn } : {}),
+  };
+
+  try {
+    const res = await fetch(`${apiUrl}/stats/sync`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(10_000),
+    });
+
+    if (res.ok) {
+      // Persist cursor only on success. Failures leave cursor untouched → retry.
+      writeCursor({
+        syncedAt: new Date().toISOString(),
+        calls: stats.lifetime.calls,
+        tokensSaved: stats.lifetime.tokensSaved,
+      });
+      return { skipped: false, ok: true, status: res.status };
+    }
+    return { skipped: false, ok: false, status: res.status, error: `http-${res.status}` };
+  } catch (e) {
+    return { skipped: false, ok: false, error: e instanceof Error ? e.message : "network-error" };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Fire-and-forget entry point — called from session hooks
+// ---------------------------------------------------------------------------
+
+/**
+ * Best-effort cloud sync. Gated on Pro token presence. Never throws, never
+ * blocks the caller. Rate-limited: at most once per 5 minutes (tracked via
+ * cursor syncedAt). For use at SessionEnd to flush the final stats.
+ */
+export function maybeCloudSync(): void {
+  const token = resolveProToken();
+  if (!token) return;
+  if (process.env["ASHLR_STATS_UPLOAD"] === "0") return;
+
+  // Rate-limit: if cursor is recent (< 5 min), skip.
+  const cursor = readCursor();
+  if (cursor) {
+    const age = Date.now() - new Date(cursor.syncedAt).getTime();
+    if (age < 5 * 60 * 1000) return;
+  }
+
+  // Detach — never await this
+  void pushStatsToCloud({ proToken: token });
+}
+
+if (import.meta.main) {
+  const result = await pushStatsToCloud({});
+  if (result.skipped) {
+    process.stderr.write(`[ashlr:stats-sync] skipped (${result.reason})\n`);
+  } else if (result.ok) {
+    process.stderr.write(`[ashlr:stats-sync] pushed ok (HTTP ${result.status})\n`);
+  } else {
+    process.stderr.write(`[ashlr:stats-sync] failed: ${result.error}\n`);
+  }
+  process.exit(0);
+}

package/scripts/telemetry-flush.ts

@@ -0,0 +1,160 @@
+#!/usr/bin/env bun
+/**
+ * telemetry-flush.ts — Read the local telemetry buffer and POST to the
+ * maintainer's collection endpoint.
+ *
+ * Usage:
+ *   bun run scripts/telemetry-flush.ts          # manual flush
+ *   (also called from session-end hook and hourly background task)
+ *
+ * Endpoint: ASHLR_TELEMETRY_URL env (default: https://telemetry.ashlr.ai/v1/events)
+ *
+ * POST shape:
+ *   { sessionId: <hashed-string>, events: TelemetryRecord[] }
+ *
+ * Response shape (2xx):
+ *   { accepted: number }
+ *
+ * On success: truncate buffer to entries newer than the flush horizon.
+ * On error: leave buffer untouched, log to stderr (best-effort), retry next cycle.
+ *
+ * Privacy: only anonymized, bucketed event shapes are sent. No file paths,
+ * no patterns, no content. See docs/telemetry.md for the full contract.
+ *
+ * Design rules:
+ *   - Never throws from main(). All errors are swallowed.
+ *   - Never blocks tool functionality.
+ *   - 10s network timeout to prevent indefinite hangs.
+ */
+
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import {
+  isTelemetryEnabled,
+  readTelemetryBuffer,
+  truncateTelemetryBuffer,
+  getOrCreateTelemetrySessionId,
+  looksLikePath,
+  type TelemetryRecord,
+} from "../servers/_telemetry";
+
+// ---------------------------------------------------------------------------
+// Config
+// ---------------------------------------------------------------------------
+
+const DEFAULT_ENDPOINT = "https://telemetry.ashlr.ai/v1/events";
+const FLUSH_TIMEOUT_MS = 10_000;
+const MAX_EVENTS_PER_FLUSH = 500; // avoid huge payloads
+
+function home(): string {
+  return process.env.HOME ?? homedir();
+}
+
+function endpoint(): string {
+  return (process.env.ASHLR_TELEMETRY_URL ?? DEFAULT_ENDPOINT).trim();
+}
+
+// ---------------------------------------------------------------------------
+// Safety guard: strip any record with path-like strings before sending
+// ---------------------------------------------------------------------------
+
+function isSafeRecord(r: TelemetryRecord): boolean {
+  for (const v of Object.values(r)) {
+    if (typeof v === "string" && looksLikePath(v)) return false;
+  }
+  return true;
+}
+
+// ---------------------------------------------------------------------------
+// Flush
+// ---------------------------------------------------------------------------
+
+interface FlushResult {
+  skipped?: string;
+  sent?: number;
+  error?: string;
+  ok: boolean;
+}
+
+export async function flush(homeDir: string = home()): Promise<FlushResult> {
+  if (!isTelemetryEnabled(homeDir)) {
+    return { ok: true, skipped: "telemetry-off" };
+  }
+
+  const records = readTelemetryBuffer(homeDir);
+  if (records.length === 0) {
+    return { ok: true, skipped: "empty-buffer" };
+  }
+
+  // Batch: take the oldest MAX_EVENTS_PER_FLUSH records.
+  const batch = records.slice(0, MAX_EVENTS_PER_FLUSH).filter(isSafeRecord);
+  if (batch.length === 0) {
+    return { ok: true, skipped: "no-safe-records" };
+  }
+
+  // Flush horizon: the max ts in this batch. After a successful POST we drop
+  // everything <= this horizon so re-flush never double-counts.
+  const horizonTs = Math.max(...batch.map((r) => r.ts));
+
+  const sessionId = getOrCreateTelemetrySessionId(homeDir);
+
+  const body = JSON.stringify({ sessionId, events: batch });
+
+  // 10-second timeout via AbortController.
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), FLUSH_TIMEOUT_MS);
+
+  try {
+    const res = await fetch(endpoint(), {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body,
+      signal: controller.signal,
+    });
+
+    clearTimeout(timeout);
+
+    if (res.ok) {
+      // Success: prune flushed entries from buffer.
+      truncateTelemetryBuffer(horizonTs, homeDir);
+      return { ok: true, sent: batch.length };
+    } else {
+      // Non-2xx: leave buffer alone, log, retry next cycle.
+      return {
+        ok: false,
+        error: `HTTP ${res.status}: ${res.statusText}`,
+      };
+    }
+  } catch (err) {
+    clearTimeout(timeout);
+    const msg = err instanceof Error ? err.message : String(err);
+    return { ok: false, error: msg };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// CLI entry point
+// ---------------------------------------------------------------------------
+
+async function main(): Promise<void> {
+  const result = await flush();
+  if (result.skipped) {
+    process.stderr.write(`[ashlr-telemetry] flush skipped: ${result.skipped}\n`);
+    return;
+  }
+  if (result.ok) {
+    process.stderr.write(`[ashlr-telemetry] flushed ${result.sent ?? 0} events\n`);
+  } else {
+    // Silent drop on error — never surface to the user.
+    process.stderr.write(`[ashlr-telemetry] flush failed (will retry): ${result.error ?? "unknown"}\n`);
+  }
+}
+
+if (import.meta.main) {
+  await main().catch(() => {
+    // Final safety net — main() itself should never throw, but just in case.
+    process.exit(0);
+  });
+  process.exit(0);
+}

package/scripts/telemetry-status.ts

@@ -0,0 +1,266 @@
+#!/usr/bin/env bun
+/**
+ * telemetry-status.ts — Telemetry snapshot for /ashlr-status --telemetry.
+ *
+ * Reports:
+ *   - LLM provider that would be selected right now
+ *   - Embedding cache: total entries + last-100 hit rate
+ *   - Genome: sections present + last-50 grep fire-rate
+ *   - Block→ashlr conversion ratio (24h rolling)
+ *
+ * Contract: always exit 0. No external dependencies beyond the ashlr data
+ * files already present on disk. Falls back to "—" for any missing data.
+ */
+
+import { existsSync, readFileSync, readdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { isTelemetryEnabled, readTelemetryBuffer } from "../servers/_telemetry";
+import { readHookTimingsDetailed } from "./hook-timing-reader.ts";
+
+const HOME = process.env.HOME ?? homedir();
+const ASHLR_DIR = join(HOME, ".ashlr");
+
+// ---------------------------------------------------------------------------
+// LLM provider detection
+// ---------------------------------------------------------------------------
+
+function detectLlmProvider(): string {
+  // Anthropic: ANTHROPIC_API_KEY set in env, or ~/.claude/credentials.json
+  if (process.env.ANTHROPIC_API_KEY) {
+    return "anthropic (ANTHROPIC_API_KEY set)";
+  }
+  try {
+    const credPath = join(HOME, ".claude", "credentials.json");
+    if (existsSync(credPath)) {
+      const creds = JSON.parse(readFileSync(credPath, "utf-8")) as Record<string, unknown>;
+      if (creds.anthropicApiKey || creds.ANTHROPIC_API_KEY) {
+        return "anthropic (credentials.json)";
+      }
+    }
+  } catch {
+    // ignore
+  }
+
+  // ONNX: check for onnxruntime-node availability
+  try {
+    require.resolve("onnxruntime-node");
+    return "onnx (bundled runtime)";
+  } catch {
+    // not available
+  }
+
+  // Local: check for Ollama or LM Studio
+  const ollamaUrl = process.env.ASHLR_EMBED_URL ?? "http://localhost:11434";
+  if (ollamaUrl.includes("11434")) {
+    return "local/ollama (if running) → snipCompact fallback";
+  }
+
+  return "snipCompact-only (no LLM provider configured)";
+}
+
+// ---------------------------------------------------------------------------
+// Embedding cache stats
+// ---------------------------------------------------------------------------
+
+function readEmbedCacheStats(): { totalEntries: number; last100HitRate: string } {
+  let totalEntries = 0;
+  let last100HitRate = "—";
+
+  // Total entries from embed-calibration.jsonl (each line = one lookup)
+  try {
+    const calPath = join(ASHLR_DIR, "embed-calibration.jsonl");
+    if (existsSync(calPath)) {
+      const lines = readFileSync(calPath, "utf-8")
+        .split("\n")
+        .filter((l) => l.trim());
+      totalEntries = lines.length;
+
+      // Last 100 calls hit rate
+      const last100 = lines.slice(-100);
+      if (last100.length > 0) {
+        let hits = 0;
+        for (const line of last100) {
+          try {
+            const r = JSON.parse(line) as { hit?: boolean };
+            if (r.hit === true) hits++;
+          } catch {
+            // skip
+          }
+        }
+        const rate = Math.round((hits / last100.length) * 100);
+        last100HitRate = `${rate}%`;
+      }
+    }
+  } catch {
+    // ignore
+  }
+
+  return { totalEntries, last100HitRate };
+}
+
+// ---------------------------------------------------------------------------
+// Genome stats
+// ---------------------------------------------------------------------------
+
+function readGenomeStats(): { sections: string; fireRate: string } {
+  // Count sections in .ashlrcode/genome/ relative to cwd
+  let sections = "—";
+  const genomePath = join(process.cwd(), ".ashlrcode", "genome");
+  if (existsSync(genomePath)) {
+    try {
+      // Count .md files in the genome directory
+      const files = readdirSync(genomePath, { withFileTypes: true });
+      const mdCount = files.filter((f) => f.isFile() && f.name.endsWith(".md")).length;
+      sections = `${mdCount}`;
+    } catch {
+      sections = "present (count unavailable)";
+    }
+  } else {
+    sections = "0 (no genome — run /ashlr-genome-init)";
+  }
+
+  // Fire rate from last 50 ashlr__grep calls in session-log.jsonl
+  let fireRate = "—";
+  try {
+    const logPath = join(ASHLR_DIR, "session-log.jsonl");
+    if (existsSync(logPath)) {
+      const lines = readFileSync(logPath, "utf-8")
+        .split("\n")
+        .filter((l) => l.trim());
+
+      // Find last 50 ashlr__grep tool_call events + genome_route_taken events
+      const grepRelated = lines
+        .map((l) => {
+          try { return JSON.parse(l) as { event?: string; tool?: string }; }
+          catch { return null; }
+        })
+        .filter((r): r is { event: string; tool?: string } =>
+          r !== null && typeof r.event === "string" &&
+          (r.tool === "ashlr__grep" || r.event === "genome_route_taken")
+        )
+        .slice(-100); // look at recent history
+
+      // Count total grep calls and genome-routed ones in last 50 grep-related events
+      const last50 = grepRelated.slice(-50);
+      const totalGreps = last50.filter((r) => r.tool === "ashlr__grep").length;
+      const genomeRouted = last50.filter((r) => r.event === "genome_route_taken").length;
+
+      if (totalGreps > 0) {
+        const rate = Math.round((genomeRouted / totalGreps) * 100);
+        fireRate = `${rate}%`;
+      } else if (grepRelated.length > 0) {
+        fireRate = "0% (no recent grep calls)";
+      }
+    }
+  } catch {
+    // ignore
+  }
+
+  return { sections, fireRate };
+}
+
+// ---------------------------------------------------------------------------
+// Block→ashlr conversion ratio (24h)
+// ---------------------------------------------------------------------------
+
+export function readConversionRatio(
+  homeDir: string = HOME,
+  nowMs: number = Date.now(),
+): string {
+  const windowMs = 24 * 60 * 60 * 1000;
+  const cutoff = nowMs - windowMs;
+  let blocks = 0;
+  let converted = 0;
+
+  // Blocks from hook-timings.jsonl (outcome === "block")
+  const timingRead = readHookTimingsDetailed({
+    path: join(homeDir, ".ashlr", "hook-timings.jsonl"),
+    sinceMs: cutoff,
+  });
+  for (const r of timingRead.rows) {
+    const ts = typeof r.ts === "string" ? Date.parse(r.ts) : 0;
+    if (Number.isFinite(ts) && ts >= cutoff && r.outcome === "block") blocks++;
+  }
+
+  // Conversions from session-log.jsonl (event === "tool_called_after_block")
+  try {
+    const logPath = join(homeDir, ".ashlr", "session-log.jsonl");
+    if (existsSync(logPath)) {
+      const lines = readFileSync(logPath, "utf-8").split("\n").filter((l) => l.trim());
+      for (const line of lines) {
+        try {
+          const r = JSON.parse(line) as { ts?: string; event?: string };
+          const ts = typeof r.ts === "string" ? Date.parse(r.ts) : 0;
+          if (Number.isFinite(ts) && ts >= cutoff && r.event === "tool_called_after_block") {
+            converted++;
+          }
+        } catch {
+          // skip
+        }
+      }
+    }
+  } catch {
+    // ignore
+  }
+
+  if (timingRead.coverage === "partial") {
+    return "— unavailable (partial hook-timing coverage; 24h)";
+  }
+  if (blocks === 0 && converted === 0) return "— (no data yet)";
+  const rate = blocks > 0 ? Math.round((converted / blocks) * 100) : 0;
+  return `${blocks} blocks / ${converted} converted = ${rate}% (24h)`;
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+// ---------------------------------------------------------------------------
+// Opt-in telemetry status
+// ---------------------------------------------------------------------------
+
+function readOptInTelemetryStatus(): string {
+  const enabled = isTelemetryEnabled(HOME);
+  if (!enabled) {
+    return "OFF (default) · to enable: ASHLR_TELEMETRY=on or config.json { \"telemetry\": \"opt-in\" }";
+  }
+  // Count buffered events.
+  let bufferCount = 0;
+  try {
+    const records = readTelemetryBuffer(HOME);
+    bufferCount = records.length;
+  } catch {
+    /* ignore */
+  }
+  return `ON · buffer: ${bufferCount} events · to disable: ASHLR_TELEMETRY=off`;
+}
+
+async function main(): Promise<void> {
+  const provider = detectLlmProvider();
+  const { totalEntries, last100HitRate } = readEmbedCacheStats();
+  const { sections, fireRate } = readGenomeStats();
+  const conversionRatio = readConversionRatio();
+  const optInStatus = readOptInTelemetryStatus();
+
+  const embedStr = totalEntries > 0
+    ? `${totalEntries.toLocaleString()} entries · last-100 hit rate ${last100HitRate}`
+    : `0 entries · ${last100HitRate}`;
+
+  const genomeStr = `${sections} sections · last-50 grep fire-rate ${fireRate}`;
+
+  process.stdout.write([
+    "## Telemetry snapshot",
+    `  llm-provider:   ${provider}`,
+    `  embed-cache:    ${embedStr}`,
+    `  genome:         ${genomeStr}`,
+    `  block→ashlr:    ${conversionRatio}`,
+    `  opt-in telemetry: ${optInStatus}`,
+    "",
+  ].join("\n"));
+}
+
+if (import.meta.main) {
+  await main();
+  process.exit(0);
+}