agentcache 0.2.4 → 0.3.1

package/README.md

@@ -27,33 +27,43 @@ No `init`. No `setup`. No config. No second command. The install itself:
 2. Detects installed IDEs (Claude Code, Cursor, Roo Code, Windsurf, Continue, Codex)
 3. Registers itself as an MCP server in each
 4. Sets up Claude Code hooks for automatic transcript recovery
+5. Spawns `compile-all` in background — compiles your entire transcript history from all IDEs immediately
 
 ## How It Works
 
 ```
-┌─────────────────────────────────────────────────────────────────┐
-│                        Your Machine                              │
-│                                                                  │
-│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐       │
-│  │  Claude  │  │  Cursor  │  │   Roo    │  │  Codex   │  ...   │
-│  │   Code   │  │          │  │   Code   │  │          │       │
-│  └────┬─────┘  └────┬─────┘  └────┬─────┘  └────┬─────┘       │
-│       │              │              │              │              │
-│       └──────────────┴──────────────┴──────────────┘              │
-│                              │                                    │
-│                    MCP Protocol (stdio)                           │
-│                              │                                    │
-│                 ┌────────────┴────────────┐                      │
-│                 │  AgentCache MCP Server   │                      │
-│                 │   (agentcache serve)     │                      │
-│                 └────────────┬────────────┘                      │
-│                              │                                    │
-│                    ┌─────────┴─────────┐                         │
-│                    │ ~/.agentcache/     │                         │
-│                    │  agentcache.db     │                         │
-│                    │  (SQLite + WAL)    │                         │
-│                    └───────────────────┘                         │
-└─────────────────────────────────────────────────────────────────┘
+┌──────────────────────────────────────────────────────────────────────┐
+│                           Your Machine                                │
+│                                                                       │
+│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐            │
+│  │  Claude  │  │  Cursor  │  │   Roo    │  │  Codex   │  ...        │
+│  │   Code   │  │          │  │   Code   │  │          │            │
+│  └────┬─────┘  └────┬─────┘  └────┬─────┘  └────┬─────┘            │
+│       │              │              │              │                   │
+│       └──────────────┴──────────────┴──────────────┘                   │
+│                              │                                         │
+│                    MCP Protocol (stdio)                                │
+│                              │                                         │
+│                 ┌────────────┴────────────┐    ┌────────────────────┐ │
+│                 │  AgentCache MCP Server   │    │  agentcache        │ │
+│                 │   (agentcache serve)     │    │  compile-all       │ │
+│                 │                          │    │  (standalone CLI)  │ │
+│                 │  spawns compile-all ─────┼───▶│                    │ │
+│                 │  when pending > 20       │    │  Uses: claude,     │ │
+│                 └────────────┬────────────┘    │  codex, gemini,    │ │
+│                              │                  │  ollama, API keys  │ │
+│                              │                  └─────────┬──────────┘ │
+│                              │                            │            │
+│                    ┌─────────┴────────────────────────────┘            │
+│                    │                                                    │
+│                    ▼                                                    │
+│           ┌───────────────────┐                                        │
+│           │ ~/.agentcache/     │                                        │
+│           │  agentcache.db     │                                        │
+│           │  compile-all.lock  │                                        │
+│           │  (SQLite + WAL)    │                                        │
+│           └───────────────────┘                                        │
+└──────────────────────────────────────────────────────────────────────┘
 ```
 
 ### The Cycle
@@ -92,9 +102,33 @@ AgentCache exposes 8 tools via the Model Context Protocol (prefixed as `mcp--age
 
 ```bash
 agentcache status          # Show knowledge stats for current project
+agentcache compile-all     # Batch-compile all unprocessed transcripts
 agentcache setup           # Re-register with IDEs (only if postinstall failed)
 ```
 
+### `compile-all` — Standalone Batch Compilation
+
+Processes all pending transcripts across every IDE without depending on MCP pipes or active sessions. Runs independently in a terminal.
+
+```bash
+agentcache compile-all
+```
+
+**LLM backend detection** (first available wins):
+1. CLI tools with stored auth: `claude`, `codex`, `gemini`, `copilot`, `aider`, `goose`
+2. Ollama running locally (`localhost:11434`)
+3. `ANTHROPIC_API_KEY` environment variable
+4. `OPENAI_API_KEY` environment variable
+
+No API keys needed if you have any coding CLI installed — it uses their stored authentication.
+
+**Automatic triggers:**
+- Runs as a background process after `npm install -g agentcache` (clears initial backlog)
+- Spawned by the MCP server when pending transcripts exceed 20 (ongoing janitor)
+- Lockfile (`~/.agentcache/compile-all.lock`) prevents concurrent runs
+
+**Transcript sources:** Claude Code, Continue, Codex, Roo Code, Goose
+
 Internal commands (called by hooks automatically, never by users):
 ```bash
 agentcache serve           # MCP server (IDEs spawn this)
@@ -119,9 +153,10 @@ One database per developer (`~/.agentcache/agentcache.db`), not per project. Rul
 
 ### Resilient to Abrupt Exits
 
-Sessions can end without warning (crash, ctrl-c, network drop). AgentCache handles this through:
+Sessions can end without warning (crash, ctrl-c, network drop, MCP pipe death). AgentCache handles this through:
 - **Incremental submission** — observations are saved as they happen, not batched at the end
-- **Transcript recovery** — for Claude Code and Continue, transcripts persist on disk and are compiled next session
+- **Transcript recovery** — transcripts persist on disk across 5 IDEs (Claude Code, Continue, Codex, Roo Code, Goose) and are compiled by `compile-all`
+- **Pipe-independent compilation** — `compile-all` runs as a standalone process, not through MCP stdio pipes that can break during long operations
 - **Pending queue in SQLite** — concurrent access is safe, nothing lost to race conditions
 
 ### Anti-Bloat
@@ -137,21 +172,18 @@ AgentCache prevents knowledge from growing unbounded:
 | IDE | MCP | Auto-Approve | Transcript Recovery | Hooks |
 |-----|-----|-------------|--------------------|----|
 | Claude Code | Yes | Yes (automatic) | Full (JSONL) | Stop, SessionStart, PreToolUse |
-| Cursor | Yes | **Manual** (see below) | Incremental only | — |
-| Roo Code | Yes | Yes (automatic) | Incremental only | — |
+| Cursor | Yes | Yes (automatic) | Incremental only | — |
+| Roo Code | Yes | Yes (automatic) | Full (JSON via compile-all) | — |
 | Windsurf | Yes | Yes (automatic) | Incremental only | — |
 | Continue | Yes | Yes (automatic) | Full (JSON) | — |
-| Codex | Yes | Yes (automatic) | Incremental only | — |
+| Codex | Yes | Yes (automatic) | Full (JSONL via compile-all) | — |
+| Goose | — | — | Full (SQLite via compile-all) | — |
 
-"Incremental only" means if the agent submits observations during the session, they're saved. If the session terminates before any submission, those observations are lost (no transcript access).
-
-### Cursor: Enable Auto-Approve
+All IDEs are fully auto-approved at install time — no manual steps required.
 
-Cursor does not support programmatic auto-approve for MCP tools. After installing, you need to manually enable it once:
+"Incremental only" means if the agent submits observations during the session, they're saved. If the session terminates before any submission, those observations are lost (no transcript access).
 
-1. Open Cursor Settings → MCP
-2. Find **agentcache** in the server list
-3. Set tool approval to **"Always allow"** (or enable "Yolo mode" in Cursor settings for all tools)
+"via compile-all" means `agentcache compile-all` discovers and processes these transcripts in batch, independent of any active MCP session.
 
 ## Data Storage
 
@@ -182,7 +214,9 @@ Extract → Normalize → Canonicalize → Cluster → Detect Contradictions →
                                                             - authority: AUTO/USER
 ```
 
-The compiler is the LLM itself (the agent in your session). AgentCache provides extraction prompts and the agent processes them — no separate API keys or LLM calls needed.
+**Two compilation paths:**
+- **In-session** — the agent in your IDE processes extraction prompts via MCP tools (no separate LLM calls needed)
+- **Batch (`compile-all`)** — runs independently using any available LLM CLI or API, processes the full backlog without depending on active sessions
 
 ## Project Identity
 
@@ -191,6 +225,41 @@ Projects are identified by a hash of their full filesystem path, not just the fo
 - Renaming a folder creates a new project identity
 - Knowledge doesn't leak between same-named projects
 
+## Roadmap
+
+### More IDEs & Coding Agents
+
+| Platform | Status |
+|----------|--------|
+| Claude Code | Supported |
+| Cursor | Supported |
+| Roo Code | Supported |
+| Windsurf | Supported |
+| Continue | Supported |
+| Codex | Supported |
+| Goose | Supported (transcript recovery via SQLite) |
+| Aider | Coming soon |
+| GitHub Copilot | Coming soon |
+| Zed AI | Coming soon |
+
+Any tool that supports MCP can use AgentCache today via `agentcache serve`. Native integrations for the above are planned to ensure zero-config setup.
+
+### Native Plugins
+
+Marketplace listings and deeper UI integrations for all supported IDEs — surfacing knowledge inline, showing compilation status, and providing one-click management of rules and decisions.
+
+### Team Knowledge Sharing
+
+Share compiled knowledge across your team. Rules and lessons that work for one developer benefit everyone.
+
+### Cloud Sync
+
+Sync your knowledge database across machines. Same developer, different computers, same knowledge.
+
+### Analytics Dashboard
+
+Visibility into what AgentCache is learning — compilation stats, knowledge growth, most-referenced rules, and session coverage.
+
 ## Contributing
 
 ```bash

package/dist/chunk-KFQGP6VL.js

@@ -0,0 +1,33 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+export {
+  __require,
+  __esm,
+  __export,
+  __toCommonJS
+};