engramx 1.0.1 → 2.0.0

package/CHANGELOG.md

@@ -4,6 +4,124 @@ All notable changes to engram are documented here. Format based on
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); versioning follows
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.0.0] — 2026-04-17 — "Ecosystem"
+
+The biggest release since v1.0.0. Completes the v2.0 roadmap Phases 1–4:
+Foundation, Web Dashboard, Integration Expansion, and Solidification.
+640 tests (up from 579). All changes backward-compatible with v1.x graph
+files — existing `.engram/graph.db` files auto-migrate to schema v7.
+
+### Added — Phase 3 (Integration Expansion)
+
+- **`engram gen-windsurfrules`** — generate `.windsurfrules` for Windsurf
+  (Codeium) IDE. Plain markdown (no frontmatter), auto-picked-up by Windsurf
+  on every chat session. Supports `--watch` for live regeneration on graph
+  changes. See `docs/integrations/README.md`.
+- **Integration docs**: `docs/integrations/neovim.md` (codecompanion +
+  avante.nvim via mcphub), `docs/integrations/cursor-mcp.md` (Cursor's
+  native MCP support alongside the MDC path), `docs/integrations/emacs.md`
+  (gptel + gptel-mcp), plus a new `docs/integrations/README.md` index that
+  maps every supported IDE to its mechanism.
+
+### Added — Phase 4 (Solidification)
+
+- **Provider plugin system** — third-party context providers installable
+  at `~/.engram/plugins/*.mjs`. Each plugin default-exports a
+  `ContextProviderPlugin` object and is dynamically loaded by the resolver.
+  Validation-before-install refuses malformed plugins; duplicate names
+  can't shadow built-ins. New CLI:
+  - `engram plugin list` — show installed plugins with tier/budget/version
+  - `engram plugin install <file.mjs>` — validate + copy into plugins dir
+  - `engram plugin remove <filename>`
+- **`engram cache` CLI namespace** — inspect and manage the context cache:
+  - `engram cache stats` — hit rate, entries per layer, hot file count
+  - `engram cache clear` — flush all layers
+  - `engram cache warm` — pre-warm hot files from access frequency
+- **Schema rollback** — `engram db rollback --to <version>` reverts the
+  schema with automatic backup at `<dbPath>.bak-v<fromVersion>`. Requires
+  explicit `--yes` confirmation (data loss). Rollback is in-session only;
+  reopen auto-migrates forward again by design — the backup is the
+  recovery path for pinning an older version.
+- **Schema v7** — adds `query_cache` and `pattern_cache` tables with
+  `idx_query_cache_file` index. Retroactive DOWN migrations defined for
+  versions 1–7 so any version is rollback-target-safe.
+
+### Added — Phase 1 (Foundation)
+
+- **Tree-sitter grammar bundling** — 6 WASM grammar files (TypeScript, TSX,
+  JavaScript, Python, Go, Rust) now ship inside the npm package at
+  `dist/grammars/`. The `engram:ast` provider works out of the box for npm
+  users without needing local `node_modules` tree-sitter packages.
+  New: `scripts/bundle-grammars.mjs` (pure Node ESM, no tsx dep).
+  `npm run build` bundles them automatically; `build:nogrammars` as escape hatch.
+- **Incremental indexing** — `init()` accepts `{ incremental: true }` and the
+  CLI accepts `--incremental` to skip files whose mtime hasn't changed since
+  last index. File mtimes persisted as JSON in the stats table. On engram's
+  own source (117 TS files): 53ms vs 244ms full init — **78% faster**.
+- **`.engramignore` support** — gitignore-like syntax for excluding directories
+  and files from indexing. Loaded from project root.
+- **Memory cache system** (`src/intelligence/cache.ts`, ~330 LOC) — 3-layer
+  compound savings engine:
+  - **Query result cache** — resolved context packets per file, SQLite-backed
+    + in-memory LRU (100 entries). Invalidated on file mtime change.
+    Benchmarked at 23μs/op, 99% hit rate under 10k random reads.
+  - **Pattern cache** — structural query answers memoized with graph version
+    tracking. LRU (50 entries). Auto-invalidates on graph mutation.
+  - **Hot file cache** — `warmHotFiles()` pre-loads top-N most-accessed files
+    at SessionStart for zero first-hit latency.
+  - `engram cache` CLI namespace (stats/clear/warm) — planned for Phase 4.
+- **9 new HTTP API endpoints** serving the dashboard + external integrations:
+  - `GET /api/hook-log` — paginated hook log entries
+  - `GET /api/hook-log/summary` — aggregated event/tool/decision stats
+  - `GET /api/tokens` — cumulative token savings
+  - `GET /api/files/heatmap` — file interception frequency ranking
+  - `GET /api/providers/health` — component status
+  - `GET /api/cache/stats` — cache hit/miss rates, entry counts
+  - `GET /api/graph/nodes` — paginated graph nodes
+  - `GET /api/graph/god-nodes` — top-connected entities
+  - `GET /api/sse` — Server-Sent Events, 1s hook-log polling, auto-cleans on
+    disconnect
+  - Load tested at 200 concurrent mixed requests in 295ms (~1.5ms/req).
+
+### Added — Phase 2 (Web Dashboard)
+
+- **Zero-dependency web dashboard at `GET /ui`** — 35KB self-contained
+  HTML/CSS/JS as TypeScript template literals. No external CDNs, no build
+  pipeline, works offline / on air-gapped machines.
+  - Security: CSP meta tag (`default-src 'self'; connect-src 'self'`) + single
+    `esc()` helper at every JS→HTML boundary defends against XSS from
+    attacker-controllable file paths/labels mined from repos.
+  - 6 tabs: Overview, Sessions, Activity (live SSE), Files, Graph (Canvas 2D
+    force-directed, ~200 LOC, handles <500 nodes at 60fps with pan/zoom/click),
+    Providers.
+  - SVG chart library (`ui-components.ts`): donut, stacked bars, sparkline,
+    cache/graph stat blocks. Zero dependencies.
+- **`engram ui` CLI command** — auto-starts the HTTP server if not running
+  (PID file check), opens the default browser to `http://127.0.0.1:7337/ui`.
+  `--no-open` flag for print-only mode.
+
+### Changed
+
+- `npm run build` now always bundles tree-sitter grammars into `dist/grammars/`
+  (previously only `prepublishOnly` did, which masked the missing-grammar
+  scenario for anyone testing a built `dist/` locally).
+- `--incremental` flag wired into the CLI (previously API-only and undiscoverable).
+- Default skip directories expanded: added `.next`, `.nuxt`, `coverage`,
+  `target`, `venv`, `.venv`, `.cache`, `.turbo`, `.output`, `.git`.
+- `extractFile()` now returns `lineCount` from content already parsed,
+  eliminating a redundant `readFileSync` per file during extraction.
+- `GraphStore` extended with `runSql()`, `prepare()` (public), and
+  `removeNodesForFile()` for incremental mode and cache module.
+- Test count: 579 → 640 (+61 tests: 7 incremental + 17 cache + 15 API + 6
+  windsurf + 5 rollback + 11 plugin-loader).
+
+### Fixed
+
+- `dist/grammars/` was empty after `npm run build` alone — only populated by
+  `prepublishOnly`. Masked in dev by `grammar-loader.ts` falling back to
+  `node_modules/tree-sitter-*/`, but shipped broken to anyone running `dist/`
+  locally after build. Root cause: tsup's `clean: true` wiped the dir.
+
 ## [1.0.0] — 2026-04-17 — "Protocol"
 
 ### Added

package/README.md

@@ -5,6 +5,7 @@
 <p align="center">
   <a href="#install"><strong>Install</strong></a> ·
   <a href="#quickstart"><strong>Quickstart</strong></a> ·
+  <a href="#dashboard"><strong>Dashboard</strong></a> ·
   <a href="#benchmark"><strong>Benchmark</strong></a> ·
   <a href="#ide-integrations"><strong>IDE Integrations</strong></a> ·
   <a href="#http-api"><strong>HTTP API</strong></a> ·
@@ -14,17 +15,22 @@
 
 <p align="center">
   <a href="https://github.com/NickCirv/engram/actions"><img src="https://github.com/NickCirv/engram/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
+  <a href="https://www.npmjs.com/package/engramx"><img src="https://img.shields.io/npm/v/engramx?color=blue" alt="npm version"></a>
   <img src="https://img.shields.io/badge/license-Apache%202.0-blue" alt="License">
   <img src="https://img.shields.io/badge/node-%3E%3D20-brightgreen" alt="Node">
-  <img src="https://img.shields.io/badge/tests-579%20passing-brightgreen" alt="Tests">
-  <img src="https://img.shields.io/badge/providers-8-blue" alt="8 Providers">
-  <img src="https://img.shields.io/badge/token%20savings-88%25%20proven-orange" alt="88% Proven Savings">
+  <img src="https://img.shields.io/badge/tests-640%20passing-brightgreen" alt="Tests">
+  <img src="https://img.shields.io/badge/providers-8%20%2B%20plugins-blue" alt="8 Providers + plugins">
+  <img src="https://img.shields.io/badge/token%20savings-88.1%25%20measured-orange" alt="88% Proven Savings">
   <img src="https://img.shields.io/badge/native%20deps-zero-green" alt="Zero native deps">
   <img src="https://img.shields.io/badge/LLM%20cost-$0-green" alt="Zero LLM cost">
 </p>
 
 ---
 
+> **v2.0 "Ecosystem" shipped 2026-04-17** — web dashboard at `engram ui`, 3-layer memory cache (23μs/op at 99% hit rate), provider plugin system (`~/.engram/plugins/*.mjs`), `engram cache` CLI, schema rollback with automatic backup, incremental re-indexing (78% faster on large repos), auto-bundled tree-sitter grammars, Windsurf + Neovim + Emacs integrations. See [CHANGELOG.md](CHANGELOG.md) for the full diff.
+
+---
+
 # The context spine for AI coding agents.
 
 engram intercepts every file read your AI agent makes and replaces it with a pre-assembled context packet — structure, decisions, git history, library docs, and known issues — from 8 providers, delivered in a single ~500-token response. The agent gets what it needs without reading the file. You stop paying for context you've already paid for.
@@ -42,6 +48,55 @@ That's the full setup. The next Claude Code session starts with a project brief
 
 ---
 
+## Dashboard
+
+A zero-dependency web dashboard ships built-in. One command, opens in your browser:
+
+```bash
+engram ui
+```
+
+<p align="center">
+  <img src="assets/screenshots/01-overview.png" alt="engram dashboard — Overview tab" width="100%">
+</p>
+
+The **Overview** tab: real metrics from your sessions — tokens saved, cost saved at $3/M rate, session-level hit rate, cache performance, graph health.
+
+<p align="center">
+  <img src="assets/screenshots/03-activity.png" alt="engram dashboard — Activity tab" width="100%">
+</p>
+
+**Activity** — live hook events streamed via Server-Sent Events. See every `Read` / `Edit` / `Write` decision (deny = intercepted, passthrough = engram couldn't help). Per-tool breakdown on the right shows where the savings come from.
+
+<p align="center">
+  <img src="assets/screenshots/04-files.png" alt="engram dashboard — Files heatmap" width="100%">
+</p>
+
+**Files** — the heatmap ranks your hot files by interception count. Cursor knows this view.
+
+<p align="center">
+  <img src="assets/screenshots/05-graph.png" alt="engram dashboard — Knowledge graph visualization" width="100%">
+</p>
+
+**Graph** — Canvas 2D force-directed visualization of the knowledge graph. God nodes are larger and labeled. Drag to pan, scroll to zoom, click for details. 300+ nodes at 60fps.
+
+<p align="center">
+  <img src="assets/screenshots/06-providers.png" alt="engram dashboard — Providers + cache health" width="100%">
+</p>
+
+**Providers** — component health (HTTP / LSP / AST / IDE count) and per-layer cache stats (entries + cross-session hit counts).
+
+### Design
+
+- **35KB total** — one HTTP response, zero external CDN calls, works offline and on air-gapped machines.
+- **Zero runtime dependencies** — all CSS and JS inlined as TypeScript template literals; SVG charts and Canvas 2D graph hand-rolled (~400 LOC total).
+- **CSP-hardened** — `default-src 'self'; connect-src 'self'` meta tag plus `esc()` at every data-to-HTML boundary. Defends against attacker-controlled file paths and labels mined from untrusted repos.
+- **Live-updating** — SSE stream pushes new hook events to the Activity tab within 1 second.
+
+See also the **Sessions** tab (cumulative breakdown + sparkline) in [`assets/screenshots/02-sessions.png`](assets/screenshots/02-sessions.png).
+
+---
+
 ## Benchmark
 
 Measured across 10 structured coding tasks against a baseline of reading the relevant files directly. No synthetic data. No cherry-picked queries.
@@ -128,12 +183,14 @@ Requires Node.js 20+. Zero native dependencies. No build tools. Local SQLite via
 cd ~/my-project
 engram init                      # scan codebase → .engram/graph.db (~40ms, 0 tokens)
 engram install-hook              # wire the Sentinel into Claude Code
+engram ui                        # open the web dashboard in your browser
 ```
 
 Open a Claude Code session. When the agent reads a well-covered file you will see a system-reminder with the structural summary instead of file contents. After the session:
 
 ```bash
-engram hook-stats                # what was intercepted, tokens saved
+engram hook-stats                # what was intercepted, tokens saved (CLI)
+engram ui                        # same data, richer view, real-time updates
 engram hook-preview src/auth.ts  # dry-run: see what the hook would inject for one file
 ```
 
@@ -165,10 +222,13 @@ engram hooks install             # auto-rebuild graph on every git commit
 | IDE | Integration | Setup |
 |-----|------------|-------|
 | **Claude Code** | Hook-based interception (native, automatic) | `engram install-hook` |
-| **Continue.dev** | `@engram` context provider | See [docs/integrations/continue.md](docs/integrations/continue.md) |
-| **Cursor** | MDC generation | `engram gen-mdc` |
-| **Zed** | Context server | `engram context-server` |
+| **Cursor** | MDC snapshot + native MCP | `engram gen-mdc` &middot; [docs/integrations/cursor-mcp.md](docs/integrations/cursor-mcp.md) |
+| **Continue.dev** | `@engram` context provider | [docs/integrations/continue.md](docs/integrations/continue.md) |
+| **Zed** | Context server (`/engram`) | `engram context-server` |
 | **Aider** | Context file generation | `engram gen-aider` |
+| **Windsurf** (Codeium) | `.windsurfrules` snapshot + MCP | `engram gen-windsurfrules` |
+| **Neovim** | MCP via codecompanion / avante | [docs/integrations/neovim.md](docs/integrations/neovim.md) |
+| **Emacs** | MCP via gptel-mcp | [docs/integrations/emacs.md](docs/integrations/emacs.md) |
 
 Per-IDE setup guides are in [`docs/integrations/`](docs/integrations/).
 

package/dist/{aider-context-TNGSXMVY.js → aider-context-BC5R2ZTA.js}

@@ -7,7 +7,7 @@ function buildSection(heading, lines) {
   return [`## ${heading}`, "", ...lines, ""].join("\n");
 }
 async function generateAiderContext(projectRoot) {
-  const { getStore } = await import("./core-77MHT3QV.js");
+  const { getStore } = await import("./core-6IY5L6II.js");
   const store = await getStore(projectRoot);
   try {
     const allNodes = store.getAllNodes();

package/dist/cache-AK6CF3BC.js

@@ -0,0 +1,10 @@
+import {
+  ContextCache,
+  _resetContextCache,
+  getContextCache
+} from "./chunk-CIQQ5Y3S.js";
+export {
+  ContextCache,
+  _resetContextCache,
+  getContextCache
+};

package/dist/chunk-22INHMKB.js

@@ -0,0 +1,31 @@
+// src/tuner/config.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+var DEFAULTS = {
+  confidenceThreshold: 0.7,
+  totalTokenBudget: 600,
+  providers: {}
+};
+function readConfig(projectRoot) {
+  const configPath = join(projectRoot, ".engram", "config.json");
+  if (!existsSync(configPath)) return DEFAULTS;
+  try {
+    const raw = JSON.parse(readFileSync(configPath, "utf-8"));
+    return {
+      ...DEFAULTS,
+      ...raw,
+      providers: { ...DEFAULTS.providers, ...raw.providers ?? {} }
+    };
+  } catch {
+    return DEFAULTS;
+  }
+}
+function writeConfig(projectRoot, config) {
+  const configPath = join(projectRoot, ".engram", "config.json");
+  writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+}
+
+export {
+  readConfig,
+  writeConfig
+};

package/dist/chunk-533LR4I7.js

@@ -0,0 +1,220 @@
+// src/intercept/stats.ts
+var ESTIMATED_TOKENS_PER_READ_DENY = 1200;
+function summarizeHookLog(entries) {
+  const byEvent = {};
+  const byTool = {};
+  const byDecision = {};
+  let readDenyCount = 0;
+  let firstEntryTs = null;
+  let lastEntryTs = null;
+  for (const entry of entries) {
+    const event = entry.event ?? "unknown";
+    byEvent[event] = (byEvent[event] ?? 0) + 1;
+    const tool = entry.tool ?? "unknown";
+    byTool[tool] = (byTool[tool] ?? 0) + 1;
+    if (entry.decision) {
+      byDecision[entry.decision] = (byDecision[entry.decision] ?? 0) + 1;
+    }
+    if (event === "PreToolUse" && tool === "Read" && entry.decision === "deny") {
+      readDenyCount += 1;
+    }
+    const ts = entry.ts;
+    if (typeof ts === "string") {
+      if (firstEntryTs === null || ts < firstEntryTs) firstEntryTs = ts;
+      if (lastEntryTs === null || ts > lastEntryTs) lastEntryTs = ts;
+    }
+  }
+  return {
+    totalInvocations: entries.length,
+    byEvent: Object.freeze(byEvent),
+    byTool: Object.freeze(byTool),
+    byDecision: Object.freeze(byDecision),
+    readDenyCount,
+    estimatedTokensSaved: readDenyCount * ESTIMATED_TOKENS_PER_READ_DENY,
+    firstEntry: firstEntryTs,
+    lastEntry: lastEntryTs
+  };
+}
+function formatStatsSummary(summary) {
+  if (summary.totalInvocations === 0) {
+    return "engram hook stats: no log entries yet.\n\nRun engram install-hook in a project, then use Claude Code to see interceptions.";
+  }
+  const lines = [];
+  lines.push(`engram hook stats (${summary.totalInvocations} invocations)`);
+  lines.push("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  if (summary.firstEntry && summary.lastEntry) {
+    lines.push(`Time range: ${summary.firstEntry} \u2192 ${summary.lastEntry}`);
+    lines.push("");
+  }
+  lines.push("By event:");
+  const eventEntries = Object.entries(summary.byEvent).sort(
+    (a, b) => b[1] - a[1]
+  );
+  for (const [event, count] of eventEntries) {
+    const pct = (count / summary.totalInvocations * 100).toFixed(1);
+    lines.push(`  ${event.padEnd(18)} ${String(count).padStart(5)} (${pct}%)`);
+  }
+  lines.push("");
+  lines.push("By tool:");
+  const toolEntries = Object.entries(summary.byTool).filter(([k]) => k !== "unknown").sort((a, b) => b[1] - a[1]);
+  for (const [tool, count] of toolEntries) {
+    lines.push(`  ${tool.padEnd(18)} ${String(count).padStart(5)}`);
+  }
+  if (toolEntries.length === 0) {
+    lines.push("  (no tool-tagged entries)");
+  }
+  lines.push("");
+  const decisionEntries = Object.entries(summary.byDecision);
+  if (decisionEntries.length > 0) {
+    lines.push("PreToolUse decisions:");
+    for (const [decision, count] of decisionEntries.sort(
+      (a, b) => b[1] - a[1]
+    )) {
+      lines.push(`  ${decision.padEnd(18)} ${String(count).padStart(5)}`);
+    }
+    lines.push("");
+  }
+  if (summary.readDenyCount > 0) {
+    lines.push(
+      `Estimated tokens saved: ~${summary.estimatedTokensSaved.toLocaleString()}`
+    );
+    lines.push(
+      `  (${summary.readDenyCount} Read denies \xD7 ${ESTIMATED_TOKENS_PER_READ_DENY} tok/deny avg)`
+    );
+  } else {
+    lines.push("Estimated tokens saved: 0");
+    lines.push("  (no PreToolUse:Read denies recorded yet)");
+  }
+  return lines.join("\n");
+}
+
+// src/intercept/component-status.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { tmpdir, homedir } from "os";
+function statusPath(projectRoot) {
+  return join(projectRoot, ".engram", "component-status.json");
+}
+function readCachedStatus(projectRoot) {
+  const path = statusPath(projectRoot);
+  if (!existsSync(path)) return null;
+  try {
+    const raw = JSON.parse(readFileSync(path, "utf-8"));
+    if (Date.now() - raw.generatedAt > 3e4) return null;
+    return raw;
+  } catch {
+    return null;
+  }
+}
+function checkHttp(projectRoot) {
+  return existsSync(join(projectRoot, ".engram", "http-server.pid"));
+}
+function checkLsp(projectRoot) {
+  if (existsSync(join(projectRoot, ".engram", "lsp-available"))) return true;
+  const tmp = tmpdir();
+  const candidates = [
+    join(tmp, "tsserver.sock"),
+    join(tmp, "typescript-language-server.sock")
+  ];
+  return candidates.some((c) => existsSync(c));
+}
+function checkAst(projectRoot) {
+  try {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+      join(here, "..", "grammars"),
+      // from dist/intercept/
+      join(here, "..", "..", "dist", "grammars")
+      // from src/intercept/ dev
+    ];
+    for (const dir of candidates) {
+      if (existsSync(dir)) return true;
+    }
+  } catch {
+  }
+  if (existsSync(join(projectRoot, "node_modules", "web-tree-sitter"))) return true;
+  return false;
+}
+function countIdeAdapters(projectRoot) {
+  let count = 0;
+  if (existsSync(join(projectRoot, ".cursor", "rules", "engram-context.mdc"))) {
+    count += 1;
+  }
+  const continueConfig = join(homedir(), ".continue", "config.json");
+  if (existsSync(continueConfig)) {
+    try {
+      const cfg = readFileSync(continueConfig, "utf-8");
+      if (cfg.includes("engram")) count += 1;
+    } catch {
+    }
+  }
+  const zedSettings = join(homedir(), ".config", "zed", "settings.json");
+  if (existsSync(zedSettings)) {
+    try {
+      const cfg = readFileSync(zedSettings, "utf-8");
+      if (cfg.includes("engram")) count += 1;
+    } catch {
+    }
+  }
+  for (const f of ["settings.local.json", "settings.json"]) {
+    const claudeSettings = join(projectRoot, ".claude", f);
+    if (existsSync(claudeSettings)) {
+      try {
+        const cfg = readFileSync(claudeSettings, "utf-8");
+        if (cfg.includes("engram")) {
+          count += 1;
+          break;
+        }
+      } catch {
+      }
+    }
+  }
+  if (existsSync(join(projectRoot, ".windsurfrules"))) count += 1;
+  if (existsSync(join(projectRoot, ".aider-context.md"))) count += 1;
+  if (existsSync(join(projectRoot, ".context", "index.md"))) count += 1;
+  return count;
+}
+function refreshComponentStatus(projectRoot) {
+  const now = Date.now();
+  const components = [
+    { name: "http", available: checkHttp(projectRoot), checkedAt: now },
+    { name: "lsp", available: checkLsp(projectRoot), checkedAt: now },
+    { name: "ast", available: checkAst(projectRoot), checkedAt: now }
+  ];
+  const ideCount = countIdeAdapters(projectRoot);
+  const report = {
+    components,
+    ideCount,
+    generatedAt: now
+  };
+  try {
+    writeFileSync(statusPath(projectRoot), JSON.stringify(report), "utf-8");
+  } catch {
+  }
+  return report;
+}
+function getComponentStatus(projectRoot) {
+  const cached = readCachedStatus(projectRoot);
+  if (cached) return cached;
+  return refreshComponentStatus(projectRoot);
+}
+function formatHudStatus(report) {
+  const parts = [];
+  for (const c of report.components) {
+    const icon = c.available ? "\u2713" : "\u2717";
+    parts.push(`${c.name.toUpperCase()} ${icon}`);
+  }
+  if (report.ideCount > 0) {
+    parts.push(`${report.ideCount} IDE${report.ideCount > 1 ? "s" : ""}`);
+  }
+  return parts.join(" | ");
+}
+
+export {
+  ESTIMATED_TOKENS_PER_READ_DENY,
+  summarizeHookLog,
+  formatStatsSummary,
+  getComponentStatus,
+  formatHudStatus
+};

package/dist/{chunk-QOG4K427.js → chunk-C6GBUOAL.js}

@@ -310,7 +310,7 @@ function writeToFile(filePath, summary) {
   writeFileSync2(filePath, newContent);
 }
 async function autogen(projectRoot, target, task) {
-  const { getStore } = await import("./core-77MHT3QV.js");
+  const { getStore } = await import("./core-6IY5L6II.js");
   const store = await getStore(projectRoot);
   try {
     let view = VIEWS.general;