ashlr-plugin 1.36.4

package/scripts/context-db-migrate.ts

@@ -0,0 +1,137 @@
+#!/usr/bin/env bun
+/**
+ * context-db-migrate — CLI utility for managing the ashlr context database.
+ *
+ * Usage:
+ *   bun run scripts/context-db-migrate.ts [command]
+ *
+ * Commands:
+ *   migrate   Run migrations on ~/.ashlr/context.db (default)
+ *   version   Print current schema version
+ *   status    Print schema version + row counts
+ *
+ * Environment:
+ *   ASHLR_CONTEXT_DB_HOME   Override home directory (for testing)
+ *   ASHLR_CONTEXT_DB_DISABLE=1  No-op mode (migration prints a notice and exits)
+ */
+
+import { Database } from "bun:sqlite";
+import { existsSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { openContextDb, getSchemaVersion, SCHEMA_VERSION } from "../servers/_embedding-cache";
+
+function getDbPath(home?: string): string {
+  const dir = join(home ?? homedir(), ".ashlr");
+  return join(dir, "context.db");
+}
+
+function printUsage(): void {
+  console.log(`
+context-db-migrate — ashlr context database migration CLI
+
+Usage:
+  bun run scripts/context-db-migrate.ts [command]
+
+Commands:
+  migrate   Apply pending schema migrations (default)
+  version   Print current schema version stored in db
+  status    Print schema version + row counts + db path
+
+Environment:
+  ASHLR_CONTEXT_DB_HOME      Override home directory (for testing)
+  ASHLR_CONTEXT_DB_DISABLE=1 No-op mode — prints notice and exits
+`.trim());
+}
+
+async function cmdMigrate(): Promise<void> {
+  if (process.env.ASHLR_CONTEXT_DB_DISABLE === "1") {
+    console.log("[context-db-migrate] ASHLR_CONTEXT_DB_DISABLE=1 — skipping migration (no-op mode).");
+    process.exit(0);
+  }
+
+  const home = process.env.ASHLR_CONTEXT_DB_HOME;
+  const db = openContextDb(home);
+
+  console.log(`[context-db-migrate] Migration complete. Target schema version: ${SCHEMA_VERSION}`);
+  db.close();
+}
+
+async function cmdVersion(): Promise<void> {
+  if (process.env.ASHLR_CONTEXT_DB_DISABLE === "1") {
+    console.log("Schema version: N/A (ASHLR_CONTEXT_DB_DISABLE=1)");
+    return;
+  }
+
+  const home = process.env.ASHLR_CONTEXT_DB_HOME;
+  const dbPath = getDbPath(home);
+
+  if (!existsSync(dbPath)) {
+    console.log(`Schema version: 0 (db not yet created at ${dbPath})`);
+    return;
+  }
+
+  const rawDb = new Database(dbPath, { readonly: true });
+  const version = getSchemaVersion(rawDb);
+  rawDb.close();
+  console.log(`Schema version: ${version} (target: ${SCHEMA_VERSION})`);
+}
+
+async function cmdStatus(): Promise<void> {
+  if (process.env.ASHLR_CONTEXT_DB_DISABLE === "1") {
+    console.log("Status: disabled (ASHLR_CONTEXT_DB_DISABLE=1)");
+    return;
+  }
+
+  const home = process.env.ASHLR_CONTEXT_DB_HOME;
+  const dbPath = getDbPath(home);
+
+  if (!existsSync(dbPath)) {
+    console.log(`Context db not yet created.\nExpected path: ${dbPath}`);
+    return;
+  }
+
+  const db = openContextDb(home);
+  const s = db.stats();
+  db.close();
+
+  const rawDb = new Database(dbPath, { readonly: true });
+  const version = getSchemaVersion(rawDb);
+  rawDb.close();
+
+  const sizeMb = (s.dbBytes / (1024 * 1024)).toFixed(2);
+  console.log(`Context DB Status
+  Path:             ${dbPath}
+  Schema version:   ${version} (target: ${SCHEMA_VERSION})
+  Total embeddings: ${s.totalEmbeddings}
+  Projects tracked: ${s.projects}
+  DB size:          ${sizeMb} MB
+  Hit rate (last 1000): ${(s.hitRateLast1000 * 100).toFixed(1)}%`);
+}
+
+// ---------------------------------------------------------------------------
+// Entry point
+// ---------------------------------------------------------------------------
+
+const cmd = process.argv[2] ?? "migrate";
+
+switch (cmd) {
+  case "migrate":
+    await cmdMigrate();
+    break;
+  case "version":
+    await cmdVersion();
+    break;
+  case "status":
+    await cmdStatus();
+    break;
+  case "--help":
+  case "-h":
+  case "help":
+    printUsage();
+    break;
+  default:
+    console.error(`Unknown command: ${cmd}`);
+    printUsage();
+    process.exit(1);
+}

package/scripts/context-status.ts

@@ -0,0 +1,43 @@
+#!/usr/bin/env bun
+/**
+ * context-status.ts — Pretty-print embedding cache stats.
+ *
+ * Called by the /ashlr-context-status slash command.
+ *
+ * Output format:
+ *
+ *   ashlr context-db
+ *     embeddings:  42
+ *     projects:    3
+ *     db size:     0.12 MB
+ *     hit rate:    73.0%  (last 1000 retrievals)
+ *     embedder:    bm25 (dim=256)  |  remote: http://localhost:11434/api/embeddings
+ *
+ * Respects ASHLR_CONTEXT_DB_DISABLE=1.
+ */
+
+import { openContextDb } from "../servers/_embedding-cache";
+import { EMBED_DIM } from "../servers/_embedding-model";
+
+if (process.env.ASHLR_CONTEXT_DB_DISABLE === "1") {
+  console.log("ashlr context-db: disabled (ASHLR_CONTEXT_DB_DISABLE=1)");
+  process.exit(0);
+}
+
+const db = openContextDb();
+const s = db.stats();
+db.close();
+
+const mbSize = (s.dbBytes / (1024 * 1024)).toFixed(2);
+const hitPct = (s.hitRateLast1000 * 100).toFixed(1);
+
+const embedderLine = process.env.ASHLR_EMBED_URL
+  ? `bm25 (dim=${EMBED_DIM}) + remote: ${process.env.ASHLR_EMBED_URL}`
+  : `bm25 (dim=${EMBED_DIM})`;
+
+console.log(`ashlr context-db`);
+console.log(`  embeddings:  ${s.totalEmbeddings}`);
+console.log(`  projects:    ${s.projects}`);
+console.log(`  db size:     ${mbSize} MB`);
+console.log(`  hit rate:    ${hitPct}%  (last 1000 retrievals)`);
+console.log(`  embedder:    ${embedderLine}`);

package/scripts/demo-run.ts

@@ -0,0 +1,255 @@
+#!/usr/bin/env bun
+/**
+ * demo-run.ts — 30-second scripted showcase of ashlr token savings.
+ *
+ * Usage:
+ *   bun run scripts/demo-run.ts [--cwd <dir>]
+ *
+ * Behavior:
+ *   1. Finds a largish source file (>2KB) in the target directory.
+ *   2. Reads it via snipCompact (same path as ashlr__read) — reports bytes.
+ *   3. Greps for a common pattern — reports bytes.
+ *   4. Shows totals + projected lifetime savings from ~/.ashlr/stats.json.
+ *
+ * Contract:
+ *   - Exits 0 always.
+ *   - Never writes files.
+ *   - Output <= 30 lines, plain text, width <= 80.
+ *   - Safe to run repeatedly.
+ */
+
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { homedir } from "os";
+import { join, extname, relative } from "path";
+import { spawnSync } from "child_process";
+
+import { snipCompact, type Message } from "@ashlr/core-efficiency";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function print(s: string): void {
+  process.stdout.write(s + "\n");
+}
+
+function fmtBytes(n: number): string {
+  if (n < 1024) return `${n} B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
+  return `${(n / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+function pct(saved: number, original: number): string {
+  if (original <= 0) return "0%";
+  return `${Math.round((saved / original) * 100)}%`;
+}
+
+/** Walk directory up to maxDepth, collect files matching predicate. */
+function walkFiles(
+  dir: string,
+  pred: (p: string) => boolean,
+  maxDepth = 3,
+): string[] {
+  const results: string[] = [];
+  function walk(d: string, depth: number): void {
+    if (depth > maxDepth) return;
+    let entries: string[];
+    try {
+      entries = readdirSync(d);
+    } catch {
+      return;
+    }
+    for (const name of entries) {
+      if (name.startsWith(".") || name === "node_modules") continue;
+      const full = join(d, name);
+      let st;
+      try {
+        st = statSync(full);
+      } catch {
+        continue;
+      }
+      if (st.isDirectory()) {
+        walk(full, depth + 1);
+      } else if (pred(full)) {
+        results.push(full);
+      }
+    }
+  }
+  walk(dir, 0);
+  return results;
+}
+
+const SOURCE_EXTS = new Set([
+  ".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".rs", ".java",
+  ".rb", ".c", ".cpp", ".h", ".cs", ".swift", ".kt",
+]);
+
+/** Find the largest source file > 2KB, up to 500KB. */
+function findDemoFile(cwd: string): string | null {
+  const candidates = walkFiles(cwd, (p) => SOURCE_EXTS.has(extname(p)));
+  const sized = candidates
+    .map((p) => ({ p, size: statSync(p).size }))
+    .filter(({ size }) => size > 2048 && size < 500 * 1024)
+    .sort((a, b) => b.size - a.size);
+  return sized[0]?.p ?? null;
+}
+
+/** Apply snipCompact exactly as ashlr__read does (without summarization). */
+function compactRead(content: string): string {
+  const msgs: Message[] = [
+    {
+      role: "user",
+      content: [{ type: "tool_result", tool_use_id: "demo-read", content }],
+    },
+  ];
+  const compact = snipCompact(msgs);
+  const block = (compact[0]!.content as { type: string; content: string }[])[0]!;
+  return (block as { content: string }).content;
+}
+
+/** Run ripgrep and return raw output bytes + truncated text. */
+function runGrep(pattern: string, cwd: string): { rawBytes: number; outBytes: number } {
+  // Resolve rg binary (mirrors efficiency-server logic).
+  const rgBin =
+    (typeof (globalThis as { Bun?: { which(b: string): string | null } }).Bun !== "undefined"
+      ? (globalThis as { Bun: { which(b: string): string | null } }).Bun.which("rg")
+      : null) ??
+    ["/opt/homebrew/bin/rg", "/usr/local/bin/rg", "/usr/bin/rg"].find((p) => {
+      try { require("fs").accessSync(p); return true; } catch { return false; }
+    }) ??
+    "rg";
+
+  const res = spawnSync(rgBin, ["--json", "-n", "--", pattern, cwd], {
+    encoding: "utf-8",
+    timeout: 8_000,
+  });
+  const raw = res.stdout ?? "";
+  const truncated =
+    raw.length > 4000 ? raw.slice(0, 2000) + "\n\n[...truncated...]\n\n" + raw.slice(-1000) : raw;
+  return { rawBytes: raw.length, outBytes: truncated.length };
+}
+
+/** Read lifetime stats for projection. */
+function readLifetimeStats(): { calls: number; tokensSaved: number } {
+  // Prefer $HOME when explicitly set so tests (and container/shell overrides)
+  // work uniformly on Windows, where `homedir()` reads USERPROFILE instead.
+  const home = process.env.HOME ?? homedir();
+  const p = join(home, ".ashlr", "stats.json");
+  if (!existsSync(p)) return { calls: 0, tokensSaved: 0 };
+  try {
+    const data = JSON.parse(readFileSync(p, "utf-8")) as {
+      lifetime?: { calls?: number; tokensSaved?: number };
+    };
+    return {
+      calls: data.lifetime?.calls ?? 0,
+      tokensSaved: data.lifetime?.tokensSaved ?? 0,
+    };
+  } catch {
+    return { calls: 0, tokensSaved: 0 };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+function main(): void {
+  // Parse --cwd arg
+  const args = process.argv.slice(2);
+  let cwd = process.cwd();
+  const cwdIdx = args.indexOf("--cwd");
+  if (cwdIdx !== -1 && args[cwdIdx + 1]) {
+    cwd = args[cwdIdx + 1]!;
+  }
+
+  const lines: string[] = [];
+
+  lines.push("ashlr 30-second demo");
+  lines.push("=".repeat(40));
+  lines.push(`project: ${cwd}`);
+  lines.push("");
+
+  // Step 1: find a source file
+  const demoFile = findDemoFile(cwd);
+  if (!demoFile) {
+    lines.push("no suitable source file found (need >2KB source file)");
+    lines.push("tip: run from a project directory with source code.");
+    lines.forEach(print);
+    process.exit(0);
+  }
+
+  const relPath = relative(cwd, demoFile);
+  const rawContent = readFileSync(demoFile, "utf-8");
+  const rawBytes = Buffer.byteLength(rawContent, "utf-8");
+
+  // Step 2: ashlr__read (snipCompact)
+  const compacted = compactRead(rawContent);
+  const compactBytes = Buffer.byteLength(compacted, "utf-8");
+  const readSaved = Math.max(0, rawBytes - compactBytes);
+  const readTokSaved = Math.ceil(readSaved / 4);
+
+  lines.push(`[1] ashlr__read  ${relPath}`);
+  lines.push(`    original : ${fmtBytes(rawBytes)}`);
+  lines.push(`    compacted: ${fmtBytes(compactBytes)}  (${pct(readSaved, rawBytes)} smaller)`);
+  lines.push(`    tokens saved: ~${readTokSaved.toLocaleString()}`);
+  lines.push("");
+
+  // Step 3: ashlr__grep
+  const pattern = "import|function";
+  const { rawBytes: grepRaw, outBytes: grepOut } = runGrep(pattern, cwd);
+  const grepSaved = Math.max(0, grepRaw - grepOut);
+  const grepTokSaved = Math.ceil(grepSaved / 4);
+
+  lines.push(`[2] ashlr__grep  pattern: "${pattern}"`);
+  if (grepRaw === 0) {
+    lines.push(`    ripgrep not available — skipping grep demo`);
+  } else {
+    lines.push(`    raw rg output : ${fmtBytes(grepRaw)}`);
+    lines.push(`    truncated to  : ${fmtBytes(grepOut)}  (${pct(grepSaved, grepRaw)} smaller)`);
+    lines.push(`    tokens saved: ~${grepTokSaved.toLocaleString()}`);
+  }
+  lines.push("");
+
+  // Step 4: totals + projection
+  const demoTokSaved = readTokSaved + grepTokSaved;
+  const lifetime = readLifetimeStats();
+  const lifetimeTokSaved = lifetime.tokensSaved + demoTokSaved;
+
+  // Rough projection: extrapolate from lifetime average calls-per-day
+  // Assume ~5 working days/week, 50 weeks/year = 250 days.
+  const COST_PER_M_TOK = 3.0; // sonnet-4.5 input
+  const lifetimeCost = (lifetimeTokSaved * COST_PER_M_TOK) / 1_000_000;
+
+  lines.push(`[3] totals`);
+  lines.push(`    this demo saved: ~${demoTokSaved.toLocaleString()} tokens`);
+  lines.push(
+    `    lifetime total : ~${lifetimeTokSaved.toLocaleString()} tokens` +
+      `  (≈ $${lifetimeCost.toFixed(2)})`,
+  );
+
+  if (lifetime.calls >= 10) {
+    // Enough data to project: average tok/call, assume 50 calls/day typical session.
+    const avgTokPerCall = lifetime.tokensSaved / lifetime.calls;
+    const projectedAnnualTok = avgTokPerCall * 50 * 250;
+    const projectedAnnualCost = (projectedAnnualTok * COST_PER_M_TOK) / 1_000_000;
+    lines.push(
+      `    projected annual: ~${Math.round(projectedAnnualTok / 1000)}K tokens` +
+        `  ≈ $${projectedAnnualCost.toFixed(0)}/yr`,
+    );
+  }
+
+  lines.push("");
+  lines.push("install: https://plugin.ashlr.ai");
+
+  // Trim to 30 lines
+  const out = lines.slice(0, 30);
+  out.forEach(print);
+}
+
+try {
+  main();
+} catch (err) {
+  const msg = err instanceof Error ? err.message : String(err);
+  process.stdout.write(`demo-run error: ${msg}\n`);
+}
+process.exit(0);

package/scripts/deploy-smoke.sh

@@ -0,0 +1,140 @@
+#!/usr/bin/env bash
+# deploy-smoke.sh — post-deploy smoke test for ashlr production endpoints.
+#
+# Usage:
+#   ASHLR_TOKEN=<api_token> ./scripts/deploy-smoke.sh
+#
+# Required env:
+#   ASHLR_TOKEN   — a valid provisioned API token (from `bun run issue-token`)
+#
+# Optional env:
+#   SITE_URL      — override site base (default: https://plugin.ashlr.ai)
+#   API_URL       — override API base  (default: https://api.ashlr.ai)
+#
+# Exit codes:
+#   0  — all checks passed
+#   1  — one or more checks failed
+
+set -euo pipefail
+
+SITE_URL="${SITE_URL:-https://plugin.ashlr.ai}"
+API_URL="${API_URL:-https://api.ashlr.ai}"
+TOKEN="${ASHLR_TOKEN:-}"
+
+RED='\033[0;31m'
+GRN='\033[0;32m'
+YLW='\033[0;33m'
+RST='\033[0m'
+
+PASS=0
+FAIL=0
+
+pass() { echo -e "${GRN}PASS${RST}  $1"; PASS=$((PASS + 1)); }
+fail() { echo -e "${RED}FAIL${RST}  $1"; FAIL=$((FAIL + 1)); }
+info() { echo -e "${YLW}----${RST}  $1"; }
+
+# ---------------------------------------------------------------------------
+# 1. Site health
+# ---------------------------------------------------------------------------
+info "Checking site health: ${SITE_URL}"
+
+STATUS=$(curl -sf -o /dev/null -w "%{http_code}" "${SITE_URL}" || echo "000")
+if [ "$STATUS" = "200" ]; then
+  pass "GET ${SITE_URL} → 200"
+else
+  fail "GET ${SITE_URL} → ${STATUS} (expected 200)"
+fi
+
+# robots.txt
+STATUS=$(curl -sf -o /dev/null -w "%{http_code}" "${SITE_URL}/robots.txt" || echo "000")
+if [ "$STATUS" = "200" ]; then
+  pass "GET ${SITE_URL}/robots.txt → 200"
+else
+  fail "GET ${SITE_URL}/robots.txt → ${STATUS}"
+fi
+
+# sitemap.xml
+STATUS=$(curl -sf -o /dev/null -w "%{http_code}" "${SITE_URL}/sitemap.xml" || echo "000")
+if [ "$STATUS" = "200" ]; then
+  pass "GET ${SITE_URL}/sitemap.xml → 200"
+else
+  fail "GET ${SITE_URL}/sitemap.xml → ${STATUS}"
+fi
+
+# ---------------------------------------------------------------------------
+# 2. API health
+# ---------------------------------------------------------------------------
+info "Checking API health: ${API_URL}"
+
+HEALTH=$(curl -sf "${API_URL}/" || echo "{}")
+OK=$(echo "$HEALTH" | grep -o '"ok":true' || echo "")
+if [ -n "$OK" ]; then
+  pass "GET ${API_URL}/ → {ok: true}"
+else
+  fail "GET ${API_URL}/ → unexpected body: ${HEALTH}"
+fi
+
+# ---------------------------------------------------------------------------
+# 3. Badge endpoint (no auth — public)
+# ---------------------------------------------------------------------------
+info "Checking badge endpoint"
+
+if [ -z "$TOKEN" ]; then
+  info "ASHLR_TOKEN not set — skipping authenticated badge + stats checks"
+else
+  # Upload a minimal stats payload to create a user record
+  SYNC_STATUS=$(curl -sf -o /dev/null -w "%{http_code}" \
+    -X POST "${API_URL}/stats/sync" \
+    -H "Authorization: Bearer ${TOKEN}" \
+    -H "Content-Type: application/json" \
+    -d '{"stats":{"lifetime":{"calls":42,"tokensSaved":99000,"byTool":{},"byDay":{}}}}' \
+    || echo "000")
+
+  if [ "$SYNC_STATUS" = "200" ]; then
+    pass "POST ${API_URL}/stats/sync → 200"
+  else
+    fail "POST ${API_URL}/stats/sync → ${SYNC_STATUS} (expected 200)"
+  fi
+
+  # Derive userId from token (first 8 chars as a smoke proxy — real impl uses DB lookup)
+  # Instead, hit the aggregate endpoint to get the userId
+  AGG=$(curl -sf \
+    -H "Authorization: Bearer ${TOKEN}" \
+    "${API_URL}/stats/aggregate" || echo "{}")
+  USER_ID=$(echo "$AGG" | grep -o '"user_id":"[^"]*"' | cut -d'"' -f4 || echo "")
+
+  if [ -n "$USER_ID" ]; then
+    pass "GET ${API_URL}/stats/aggregate → user_id present"
+
+    # Badge SVG
+    BADGE=$(curl -sf "${API_URL}/u/${USER_ID}/badge.svg" || echo "")
+    if echo "$BADGE" | grep -q "<svg"; then
+      pass "GET ${API_URL}/u/${USER_ID}/badge.svg → SVG content"
+    else
+      fail "GET ${API_URL}/u/${USER_ID}/badge.svg → missing <svg element"
+    fi
+
+    # Check badge has token metric text
+    if echo "$BADGE" | grep -qi "saved\|tokens\|calls"; then
+      pass "Badge SVG contains expected metric text"
+    else
+      fail "Badge SVG missing metric text"
+    fi
+  else
+    fail "GET ${API_URL}/stats/aggregate → user_id missing in response: ${AGG}"
+  fi
+fi
+
+# ---------------------------------------------------------------------------
+# Summary
+# ---------------------------------------------------------------------------
+echo ""
+echo -e "Results: ${GRN}${PASS} passed${RST}  ${RED}${FAIL} failed${RST}"
+
+if [ "$FAIL" -gt 0 ]; then
+  echo -e "${RED}Smoke test FAILED${RST}"
+  exit 1
+else
+  echo -e "${GRN}Smoke test PASSED${RST}"
+  exit 0
+fi