ashlr-plugin 1.36.4

package/scripts/cloud-smoke-test.ts

@@ -0,0 +1,313 @@
+#!/usr/bin/env bun
+/**
+ * cloud-smoke-test.ts — Automated smoke runner for the ashlr cloud backend.
+ *
+ * Reads:
+ *   ASHLR_API_URL     (default: https://api.ashlr.ai)
+ *   ASHLR_PRO_TOKEN   (optional — Pro-gated checks skip when absent)
+ *
+ * Runs 5 checks matching server/docs/cloud-smoke-tests.md:
+ *   1. /healthz + /readyz reachable
+ *   2. POST /v1/events round-trip
+ *   3. (Pro) GET /user/me Bearer validation
+ *   4. (Pro) POST /llm/summarize round-trip
+ *   5. (Pro) GET /stats/aggregate shape
+ *
+ * Each result: { name, status: "pass"|"fail"|"skip", ms, detail? }
+ * Exit 0 if all pass/skip. Exit 1 if any fail.
+ *
+ * CI usage:
+ *   ASHLR_API_URL=https://staging.ashlr.ai bun run scripts/cloud-smoke-test.ts
+ */
+
+export interface CheckResult {
+  name: string;
+  status: "pass" | "fail" | "skip";
+  ms: number;
+  detail?: string;
+}
+
+export interface SmokeConfig {
+  apiUrl: string;
+  proToken?: string;
+  /** Override fetch for testing */
+  fetchImpl?: typeof fetch;
+  /** Suppress console output (used in tests) */
+  silent?: boolean;
+}
+
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+
+async function timed<T>(fn: () => Promise<T>): Promise<{ result: T; ms: number }> {
+  const start = Date.now();
+  const result = await fn();
+  return { result, ms: Date.now() - start };
+}
+
+function skip(name: string): CheckResult {
+  return { name, status: "skip", ms: 0 };
+}
+
+// ---------------------------------------------------------------------------
+// Check 1 — /healthz + /readyz
+// ---------------------------------------------------------------------------
+
+export async function checkHealth(cfg: SmokeConfig): Promise<CheckResult> {
+  const name = "healthz+readyz";
+  const f = cfg.fetchImpl ?? fetch;
+
+  const { ms } = await timed(async () => {
+    for (const path of ["/healthz", "/readyz"]) {
+      const res = await f(`${cfg.apiUrl}${path}`, { signal: AbortSignal.timeout(5000) });
+      if (!res.ok) throw new Error(`${path} returned ${res.status}`);
+      // Liveness/readiness contract is HTTP 200, not a specific body shape.
+      // The healthz endpoint returns { status, version, uptimeSeconds }; the
+      // readyz endpoint returns { db, checks: {...} }. Accept anything that
+      // parses as JSON.
+      await res.json();
+    }
+  }).catch((err: unknown) => {
+    return { ms: 0, error: String(err) };
+  });
+
+  // Re-run cleanly to capture ms properly
+  let ms2 = 0;
+  let detail: string | undefined;
+  try {
+    const t = await timed(async () => {
+      for (const path of ["/healthz", "/readyz"]) {
+        const res = await f(`${cfg.apiUrl}${path}`, { signal: AbortSignal.timeout(5000) });
+        if (!res.ok) throw new Error(`${path} returned ${res.status}`);
+        await res.json();
+      }
+    });
+    ms2 = t.ms;
+  } catch (err: unknown) {
+    detail = String(err);
+    return { name, status: "fail", ms: ms2, detail };
+  }
+  void ms;
+  return { name, status: "pass", ms: ms2 };
+}
+
+// ---------------------------------------------------------------------------
+// Check 2 — POST /v1/events round-trip
+// ---------------------------------------------------------------------------
+
+export async function checkTelemetry(cfg: SmokeConfig): Promise<CheckResult> {
+  const name = "POST /v1/events";
+  const f = cfg.fetchImpl ?? fetch;
+
+  let ms = 0;
+  try {
+    const t = await timed(async () => {
+      const res = await f(`${cfg.apiUrl}/v1/events`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          sessionId: "smoke0000000000ff",
+          events: [
+            {
+              ts: Math.floor(Date.now() / 1000),
+              kind: "version",
+              sessionId: "smoke0000000000ff",
+              pluginVersion: "1.27.0",
+              bunVersion: "1.0.0",
+              platform: "darwin",
+              arch: "arm64",
+            },
+          ],
+        }),
+        signal: AbortSignal.timeout(5000),
+      });
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      const body = await res.json() as Record<string, unknown>;
+      if (typeof body["accepted"] !== "number") {
+        throw new Error(`expected numeric 'accepted', got: ${JSON.stringify(body)}`);
+      }
+    });
+    ms = t.ms;
+  } catch (err: unknown) {
+    return { name, status: "fail", ms, detail: String(err) };
+  }
+  return { name, status: "pass", ms };
+}
+
+// ---------------------------------------------------------------------------
+// Check 3 — GET /user/me (Pro)
+// ---------------------------------------------------------------------------
+
+export async function checkUserMe(cfg: SmokeConfig): Promise<CheckResult> {
+  const name = "GET /user/me";
+  if (!cfg.proToken) return skip(name);
+  const f = cfg.fetchImpl ?? fetch;
+
+  let ms = 0;
+  try {
+    const t = await timed(async () => {
+      const res = await f(`${cfg.apiUrl}/user/me`, {
+        headers: { Authorization: `Bearer ${cfg.proToken}` },
+        signal: AbortSignal.timeout(5000),
+      });
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      const body = await res.json() as Record<string, unknown>;
+      if (!body["userId"] || !body["tier"]) {
+        throw new Error(`missing userId/tier in response: ${JSON.stringify(body)}`);
+      }
+    });
+    ms = t.ms;
+  } catch (err: unknown) {
+    return { name, status: "fail", ms, detail: String(err) };
+  }
+  return { name, status: "pass", ms };
+}
+
+// ---------------------------------------------------------------------------
+// Check 4 — POST /llm/summarize (Pro)
+// ---------------------------------------------------------------------------
+
+export async function checkLlmSummarize(cfg: SmokeConfig): Promise<CheckResult> {
+  const name = "POST /llm/summarize";
+  if (!cfg.proToken) return skip(name);
+  const f = cfg.fetchImpl ?? fetch;
+
+  let ms = 0;
+  try {
+    const t = await timed(async () => {
+      const res = await f(`${cfg.apiUrl}/llm/summarize`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${cfg.proToken}`,
+          "content-type": "application/json",
+        },
+        body: JSON.stringify({
+          text: "The quick brown fox jumps over the lazy dog. ".repeat(10),
+          systemPrompt: "Summarize in one sentence.",
+          toolName: "ashlr__read",
+          maxTokens: 80,
+        }),
+        signal: AbortSignal.timeout(30000),
+      });
+      if (res.status === 429) {
+        // Rate-limited or capped — not a failure; check code field
+        const body = await res.json() as Record<string, unknown>;
+        const code = body["code"];
+        if (!["rate_limit", "daily_cap", "cost_cap"].includes(String(code))) {
+          throw new Error(`unexpected 429 code: ${code}`);
+        }
+        // Treat expected cap codes as pass (system working correctly)
+        return;
+      }
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      const body = await res.json() as Record<string, unknown>;
+      if (!body["summary"] || !body["modelUsed"]) {
+        throw new Error(`missing summary/modelUsed: ${JSON.stringify(body)}`);
+      }
+    });
+    ms = t.ms;
+  } catch (err: unknown) {
+    return { name, status: "fail", ms, detail: String(err) };
+  }
+  return { name, status: "pass", ms };
+}
+
+// ---------------------------------------------------------------------------
+// Check 5 — GET /stats/aggregate (Pro)
+// ---------------------------------------------------------------------------
+
+export async function checkStatsAggregate(cfg: SmokeConfig): Promise<CheckResult> {
+  const name = "GET /stats/aggregate";
+  if (!cfg.proToken) return skip(name);
+  const f = cfg.fetchImpl ?? fetch;
+
+  let ms = 0;
+  try {
+    const t = await timed(async () => {
+      const res = await f(`${cfg.apiUrl}/stats/aggregate`, {
+        headers: { Authorization: `Bearer ${cfg.proToken}` },
+        signal: AbortSignal.timeout(5000),
+      });
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      const body = await res.json() as Record<string, unknown>;
+      if (typeof body["machine_count"] !== "number") {
+        throw new Error(`missing numeric machine_count: ${JSON.stringify(body)}`);
+      }
+    });
+    ms = t.ms;
+  } catch (err: unknown) {
+    return { name, status: "fail", ms, detail: String(err) };
+  }
+  return { name, status: "pass", ms };
+}
+
+// ---------------------------------------------------------------------------
+// Run all checks
+// ---------------------------------------------------------------------------
+
+export async function runAll(cfg: SmokeConfig): Promise<CheckResult[]> {
+  // Health must pass before we bother with the rest
+  const health = await checkHealth(cfg);
+  const results: CheckResult[] = [health];
+
+  if (health.status === "fail") {
+    // Skip remaining checks — server is unreachable
+    for (const name of [
+      "POST /v1/events",
+      "GET /user/me",
+      "POST /llm/summarize",
+      "GET /stats/aggregate",
+    ]) {
+      results.push({ name, status: "skip", ms: 0, detail: "skipped: healthz failed" });
+    }
+    return results;
+  }
+
+  results.push(
+    await checkTelemetry(cfg),
+    await checkUserMe(cfg),
+    await checkLlmSummarize(cfg),
+    await checkStatsAggregate(cfg),
+  );
+  return results;
+}
+
+// ---------------------------------------------------------------------------
+// Formatting
+// ---------------------------------------------------------------------------
+
+export function formatResults(results: CheckResult[]): string {
+  const lines: string[] = ["", "ashlr cloud smoke test", "─".repeat(40)];
+  for (const r of results) {
+    const icon = r.status === "pass" ? "✓" : r.status === "skip" ? "–" : "✗";
+    const ms = r.status !== "skip" ? `  ${r.ms}ms` : "";
+    const detail = r.detail ? `  (${r.detail})` : "";
+    lines.push(`  ${icon} ${r.name}${ms}${detail}`);
+  }
+  lines.push("─".repeat(40));
+
+  const passed = results.filter((r) => r.status === "pass").length;
+  const failed = results.filter((r) => r.status === "fail").length;
+  const skipped = results.filter((r) => r.status === "skip").length;
+  lines.push(`  ${passed} passed · ${failed} failed · ${skipped} skipped`);
+  lines.push("");
+  return lines.join("\n");
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+if (import.meta.main) {
+  const apiUrl = process.env["ASHLR_API_URL"] ?? "https://api.ashlr.ai";
+  const proToken = process.env["ASHLR_PRO_TOKEN"];
+
+  const cfg: SmokeConfig = { apiUrl, proToken };
+  const results = await runAll(cfg);
+
+  process.stdout.write(formatResults(results));
+
+  const anyFail = results.some((r) => r.status === "fail");
+  process.exit(anyFail ? 1 : 0);
+}

package/scripts/coach-report.ts

@@ -0,0 +1,373 @@
+#!/usr/bin/env bun
+/**
+ * ashlr coach report — reads ~/.ashlr/session-log.jsonl (+ rotated .1)
+ * and emits proactive nudges about tokens that could have been saved.
+ *
+ * Exported surface:
+ *   buildCoachReport(opts?)  -> formatted string, never throws.
+ *
+ * CLI: `bun run scripts/coach-report.ts [--days N]`
+ *   Exits 0 always.
+ */
+
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { basename, join, relative } from "path";
+
+// ---------------------------------------------------------------------------
+// Schema (matches session-log-report.ts LogRecord shape)
+// ---------------------------------------------------------------------------
+
+interface LogRecord {
+  ts: string;
+  agent: string;
+  event: string;
+  tool: string;
+  cwd: string;
+  session: string;
+  input_size: number;
+  output_size: number;
+  // session_end / TodoWrite extras
+  calls?: number;
+  tokens_saved?: number;
+  started_at?: string;
+  reason?: string;
+}
+
+// ---------------------------------------------------------------------------
+// Options
+// ---------------------------------------------------------------------------
+
+export interface BuildCoachReportOpts {
+  /** Override home dir — used by tests. */
+  home?: string;
+  /** How many days back to scan (default: 7). */
+  days?: number;
+  /** Injected now in ms — tests pin this. */
+  now?: number;
+  /** Max lines per file (default: unlimited). */
+  limitLines?: number;
+}
+
+// ---------------------------------------------------------------------------
+// JSONL reader (same pattern as session-log-report.ts)
+// ---------------------------------------------------------------------------
+
+function readLines(path: string, limit?: number): string[] {
+  try {
+    if (!existsSync(path)) return [];
+    const raw = readFileSync(path, "utf-8");
+    const lines = raw.split("\n").filter((l) => l.trim().length > 0);
+    return limit ? lines.slice(0, limit) : lines;
+  } catch {
+    return [];
+  }
+}
+
+function parseRecords(lines: string[]): LogRecord[] {
+  const out: LogRecord[] = [];
+  for (const line of lines) {
+    try {
+      const r = JSON.parse(line) as Partial<LogRecord>;
+      if (typeof r.ts !== "string" || typeof r.event !== "string") continue;
+      out.push({
+        ts: r.ts,
+        agent: r.agent ?? "unknown",
+        event: r.event,
+        tool: r.tool ?? "unknown",
+        cwd: r.cwd ?? "",
+        session: r.session ?? "",
+        input_size: typeof r.input_size === "number" ? r.input_size : 0,
+        output_size: typeof r.output_size === "number" ? r.output_size : 0,
+        calls: r.calls,
+        tokens_saved: r.tokens_saved,
+        started_at: r.started_at,
+        reason: r.reason,
+      });
+    } catch {
+      // skip malformed lines silently
+    }
+  }
+  return out;
+}
+
+// ---------------------------------------------------------------------------
+// Formatting helpers
+// ---------------------------------------------------------------------------
+
+const WIDTH = 78;
+
+function rule(): string {
+  return "-".repeat(WIDTH);
+}
+
+// Bullets are emitted as single lines; terminal/renderer handles soft wrap.
+// This keeps toContain checks in tests unambiguous across word boundaries.
+function wrap(text: string): string {
+  return text;
+}
+
+function fmtKtok(tokens: number): string {
+  if (tokens < 1000) return `${tokens}tok`;
+  return `${(tokens / 1000).toFixed(1)}Ktok`;
+}
+
+// ---------------------------------------------------------------------------
+// Rule checks
+// ---------------------------------------------------------------------------
+
+interface Bullet {
+  text: string;
+}
+
+/**
+ * Rule 1: Native Read on large files.
+ * tool === "Read" AND input_size > 2048.
+ * Potential savings = sum(input_size) * 0.6 / 4 (bytes -> tokens @ 4 bytes/tok,
+ * 60% reduction from ashlr__read's snipCompact).
+ */
+function checkNativeReadLarge(records: LogRecord[]): Bullet | null {
+  const hits = records.filter(
+    (r) => r.event === "tool_call" && r.tool === "Read" && r.input_size > 2048,
+  );
+  if (hits.length === 0) return null;
+  const totalBytes = hits.reduce((s, r) => s + r.input_size, 0);
+  const wastedTokens = Math.round((totalBytes * 0.6) / 4);
+  const n = hits.length;
+  return {
+    text: wrap(
+      `Used native Read on ${n} large file${n === 1 ? "" : "s"} — ` +
+        `~${fmtKtok(wastedTokens)} wasted. ` +
+        `Try /ashlr-allow or set ASHLR_ENFORCE=1.`,
+    ),
+  };
+}
+
+/**
+ * Rule 2: Native Grep usage.
+ * tool === "Grep".
+ */
+function checkNativeGrep(records: LogRecord[]): Bullet | null {
+  const hits = records.filter(
+    (r) => r.event === "tool_call" && r.tool === "Grep",
+  );
+  if (hits.length === 0) return null;
+  const n = hits.length;
+  return {
+    text: wrap(
+      `Native Grep fired ${n} time${n === 1 ? "" : "s"} — pays full rg output each call. ` +
+        `ashlr__grep averages 5x smaller.`,
+    ),
+  };
+}
+
+/**
+ * Rule 3: Long Bash outputs uncompressed.
+ * tool === "Bash" AND output_size > 16384.
+ */
+function checkLargeBashOutput(records: LogRecord[]): Bullet | null {
+  const hits = records.filter(
+    (r) => r.event === "tool_call" && r.tool === "Bash" && r.output_size > 16_384,
+  );
+  if (hits.length === 0) return null;
+  const m = hits.length;
+  // Approximate token class: largest output / 4
+  const maxOut = Math.max(...hits.map((r) => r.output_size));
+  const tokClass = fmtKtok(Math.round(maxOut / 4));
+  return {
+    text: wrap(
+      `Native Bash returned ${tokClass}-class output ${m} time${m === 1 ? "" : "s"} — ` +
+        `ashlr__bash auto-compresses.`,
+    ),
+  };
+}
+
+/**
+ * Rule 4: No genome but heavy ashlr__grep usage.
+ * Find the project (cwd) with the most ashlr__grep calls.
+ * If that project has no .ashlrcode/genome/manifest.json, fire the bullet.
+ */
+function checkNoGenome(records: LogRecord[]): Bullet | null {
+  const grepRecords = records.filter(
+    (r) => r.event === "tool_call" && r.tool === "ashlr__grep" && r.cwd,
+  );
+  if (grepRecords.length === 0) return null;
+
+  // Tally per-project
+  const byCwd = new Map<string, number>();
+  for (const r of grepRecords) {
+    byCwd.set(r.cwd, (byCwd.get(r.cwd) ?? 0) + 1);
+  }
+
+  // Top project by ashlr__grep calls
+  let topCwd = "";
+  let topCount = 0;
+  for (const [cwd, count] of byCwd) {
+    if (count > topCount) {
+      topCount = count;
+      topCwd = cwd;
+    }
+  }
+
+  if (topCount < 3) return null; // not "heavy" usage
+
+  const manifestPath = join(topCwd, ".ashlrcode", "genome", "manifest.json");
+  if (existsSync(manifestPath)) return null;
+
+  // Project display name: last path component (platform-agnostic)
+  const projectName = basename(topCwd) || topCwd;
+
+  return {
+    text: wrap(
+      `Project ${projectName} has ${topCount} ashlr__grep calls but no genome — ` +
+        `run /ashlr-genome-init for ~4x better retrieval.`,
+    ),
+  };
+}
+
+/**
+ * Rule 5: Repeated reads of the same file within one session.
+ * Within same session field, find paths (from input parsed as file path)
+ * that appear >= 3 times across Read/ashlr__read tool calls.
+ * We use the record's cwd + a stable key derived from input_size grouping as
+ * a proxy — but more precisely we look for same (session, tool, cwd) groups
+ * where input_size repeats. However, the log doesn't store the path argument
+ * directly. We detect repetition by grouping on (session, tool, cwd) with
+ * identical input_size as a proxy for "same file".
+ *
+ * Actually the spec says "count records where a path appears >= 3 times" but
+ * the path isn't in the log schema. We instead track (session, cwd, tool,
+ * input_size) as a file fingerprint — same size + same cwd + same session
+ * implies the same file was re-read.
+ */
+function checkRepeatedReads(records: LogRecord[]): Bullet | null {
+  const readTools = new Set(["Read", "ashlr__read"]);
+  const readRecords = records.filter(
+    (r) => r.event === "tool_call" && readTools.has(r.tool) && r.input_size > 0,
+  );
+  if (readRecords.length === 0) return null;
+
+  // Group by (session, cwd, input_size) as file fingerprint
+  const counts = new Map<string, number>();
+  for (const r of readRecords) {
+    const key = `${r.session}|${r.cwd}|${r.input_size}`;
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+
+  // Find worst offender
+  let maxCount = 0;
+  let maxKey = "";
+  for (const [key, count] of counts) {
+    if (count > maxCount) {
+      maxCount = count;
+      maxKey = key;
+    }
+  }
+
+  if (maxCount < 3) return null;
+
+  const [, cwd, sizeStr] = maxKey.split("|");
+  const sizeBytes = parseInt(sizeStr ?? "0", 10);
+  // Use cwd basename as proxy for file location descriptor
+  const projectName = basename(cwd ?? "") || (cwd ?? "unknown");
+  const sizeDesc = sizeBytes > 1024
+    ? `~${(sizeBytes / 1024).toFixed(1)}K`
+    : `~${sizeBytes}B`;
+
+  return {
+    text: wrap(
+      `A ${sizeDesc} file in ${projectName} was re-read ${maxCount} times in one session — ` +
+        `the 2nd+ reads were cache hits (free) but ashlr__read's in-process cache ` +
+        `only fires for exact mtime matches.`,
+    ),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+export function buildCoachReport(opts: BuildCoachReportOpts = {}): string {
+  const homeDir = opts.home ?? homedir();
+  const now = opts.now ?? Date.now();
+  const days = opts.days ?? 7;
+  const windowMs = days * 24 * 60 * 60 * 1000;
+  const windowStart = now - windowMs;
+
+  const logPath = join(homeDir, ".ashlr", "session-log.jsonl");
+  const rotatedPath = join(homeDir, ".ashlr", "session-log.jsonl.1");
+
+  const lines1 = readLines(rotatedPath, opts.limitLines);
+  const lines2 = readLines(logPath, opts.limitLines);
+  const allLines = [...lines1, ...lines2];
+
+  const allRecords = parseRecords(allLines);
+
+  // Filter to window
+  const records = allRecords.filter((r) => {
+    const ts = Date.parse(r.ts);
+    return Number.isFinite(ts) && ts >= windowStart;
+  });
+
+  const scanned = allRecords.length;
+
+  const header =
+    `ashlr coach · last ${days} day${days === 1 ? "" : "s"} · ` +
+    `session-log records scanned: ${scanned}`;
+
+  const bullets: Bullet[] = [];
+
+  const r1 = checkNativeReadLarge(records);
+  if (r1) bullets.push(r1);
+
+  const r2 = checkNativeGrep(records);
+  if (r2) bullets.push(r2);
+
+  const r3 = checkLargeBashOutput(records);
+  if (r3) bullets.push(r3);
+
+  const r4 = checkNoGenome(records);
+  if (r4) bullets.push(r4);
+
+  const r5 = checkRepeatedReads(records);
+  if (r5) bullets.push(r5);
+
+  const footer =
+    "Run /ashlr-usage for full tool breakdown · /ashlr-savings for totals.";
+
+  const parts: string[] = [header, rule()];
+
+  if (bullets.length === 0) {
+    parts.push("No obvious improvements — you're using the plugin well.");
+  } else {
+    for (const b of bullets.slice(0, 5)) {
+      parts.push(`- ${b.text}`);
+    }
+  }
+
+  parts.push(rule());
+  parts.push(footer);
+
+  return parts.join("\n");
+}
+
+// ---------------------------------------------------------------------------
+// CLI entry
+// ---------------------------------------------------------------------------
+
+if (import.meta.main) {
+  try {
+    // Parse --days N flag
+    const args = process.argv.slice(2);
+    const daysIdx = args.indexOf("--days");
+    const days = daysIdx !== -1 && args[daysIdx + 1]
+      ? parseInt(args[daysIdx + 1]!, 10)
+      : 7;
+
+    process.stdout.write(buildCoachReport({ days: isNaN(days) ? 7 : days }) + "\n");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stdout.write(`coach-report failed: ${msg}\n`);
+  }
+  process.exit(0);
+}