agentcache 0.3.0 → 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
@@ -138,15 +173,18 @@ AgentCache prevents knowledge from growing unbounded:
 |-----|-----|-------------|--------------------|----|
 | Claude Code | Yes | Yes (automatic) | Full (JSONL) | Stop, SessionStart, PreToolUse |
 | Cursor | Yes | Yes (automatic) | Incremental only | — |
-| Roo Code | 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) | — |
 
 All IDEs are fully auto-approved at install time — no manual steps required.
 
 "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).
 
+"via compile-all" means `agentcache compile-all` discovers and processes these transcripts in batch, independent of any active MCP session.
+
 ## Data Storage
 
 All data lives in `~/.agentcache/agentcache.db` (SQLite with WAL mode for concurrent access).
@@ -176,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
 
@@ -197,7 +237,7 @@ Projects are identified by a hash of their full filesystem path, not just the fo
 | Windsurf | Supported |
 | Continue | Supported |
 | Codex | Supported |
-| Goose (Block) | Coming soon |
+| Goose | Supported (transcript recovery via SQLite) |
 | Aider | Coming soon |
 | GitHub Copilot | Coming soon |
 | Zed AI | Coming soon |

package/dist/{chunk-IER56P6A.js → chunk-R4SJESNM.js}

@@ -428,6 +428,97 @@ function formatItems(items) {
   }).join("\n") + "\n";
 }
 
+// src/knowledge/passes/7b-skill-projector.ts
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var MAX_SKILL_TOKENS = 5e3;
+var AVG_CHARS_PER_TOKEN = 4;
+var MAX_SKILL_CHARS = MAX_SKILL_TOKENS * AVG_CHARS_PER_TOKEN;
+function projectToSkills(items, projectRoot) {
+  const active = items.filter((i) => i.status === "active");
+  const globalItems = active.filter((i) => i.scope === "global");
+  const projectItems = active.filter((i) => i.scope === "project");
+  writeGlobalSkill(globalItems);
+  writeProjectSkill(projectItems, projectRoot);
+}
+function writeGlobalSkill(items) {
+  const skillDir = join(homedir(), ".agentcache", "skills", "developer-knowledge");
+  mkdirSync2(skillDir, { recursive: true });
+  const rules = items.filter((i) => i.type === "rule").sort(byConfidence);
+  const lessons = items.filter((i) => i.type === "lesson").sort(byConfidence);
+  const body = buildSkillBody(rules, lessons, [], []);
+  const content = buildSkillFile(
+    "developer-knowledge",
+    "Engineering rules and lessons learned across all projects \u2014 compiled automatically from coding sessions by AgentCache",
+    body
+  );
+  writeFileSync2(join(skillDir, "SKILL.md"), truncateToLimit(content), "utf-8");
+}
+function writeProjectSkill(items, projectRoot) {
+  if (!projectRoot || projectRoot === process.cwd()) return;
+  if (items.length === 0) return;
+  const skillDir = join(projectRoot, ".agentcache", "skills", "project-knowledge");
+  mkdirSync2(skillDir, { recursive: true });
+  const rules = items.filter((i) => i.type === "rule").sort(byConfidence);
+  const lessons = items.filter((i) => i.type === "lesson").sort(byConfidence);
+  const decisions = items.filter((i) => i.type === "decision").sort(byConfidence);
+  const context = items.filter((i) => i.type === "context").sort((a, b) => b.lastSeenAt - a.lastSeenAt);
+  const body = buildSkillBody(rules, lessons, decisions, context);
+  const content = buildSkillFile(
+    "project-knowledge",
+    "Project-specific decisions, rules, context, and lessons \u2014 compiled automatically from coding sessions by AgentCache",
+    body
+  );
+  writeFileSync2(join(skillDir, "SKILL.md"), truncateToLimit(content), "utf-8");
+}
+function buildSkillFile(name, description, body) {
+  return `---
+name: ${name}
+description: "${description}"
+---
+
+${body}`;
+}
+function buildSkillBody(rules, lessons, decisions, context) {
+  let out = "";
+  if (rules.length > 0) {
+    out += "## Rules\n\nFollow these without exception:\n\n";
+    out += rules.map((r) => `- ${r.content}${enforceTag(r)}`).join("\n") + "\n\n";
+  }
+  if (lessons.length > 0) {
+    out += "## Lessons\n\nPitfalls learned from past sessions:\n\n";
+    out += lessons.map((l) => `- ${l.content}`).join("\n") + "\n\n";
+  }
+  if (decisions.length > 0) {
+    out += "## Decisions\n\nArchitectural choices in effect \u2014 do not contradict:\n\n";
+    out += decisions.map((d) => `- ${d.content}`).join("\n") + "\n\n";
+  }
+  if (context.length > 0) {
+    out += "## Current Context\n\nActive project state (may be temporal):\n\n";
+    out += context.map((c) => `- ${c.content}`).join("\n") + "\n\n";
+  }
+  return out.trimEnd() + "\n";
+}
+function enforceTag(item) {
+  return item.enforce ? " [ENFORCED]" : "";
+}
+function byConfidence(a, b) {
+  const order = { high: 3, medium: 2, low: 1 };
+  return (order[b.confidence] || 0) - (order[a.confidence] || 0);
+}
+function truncateToLimit(content) {
+  if (content.length <= MAX_SKILL_CHARS) return content;
+  const lines = content.split("\n");
+  let result = "";
+  for (const line of lines) {
+    if ((result + line + "\n").length > MAX_SKILL_CHARS - 50) break;
+    result += line + "\n";
+  }
+  result += "\n<!-- Truncated to stay within 5000 token skill budget -->\n";
+  return result;
+}
+
 // src/knowledge/compiler.ts
 var COMPILER_VERSION = "0.1.0";
 function startCompile(events, sessionId, project, projectRoot, repo, transcriptPath) {
@@ -472,7 +563,9 @@ function processExtraction(repo, responseText, sessionId, project, projectRoot)
   repo.saveObservations(normalized);
   if (canonicalized.needsClustering.length === 0) {
     saveCompileRun(repo, sessionId, project, normalized.length, canonicalized.autoReinforced.length, 0, 0, 0, 0, 0, Date.now());
-    projectToMarkdown(repo.getKnowledgeItems(project, { status: "active" }), getDataDir(), COMPILER_VERSION);
+    const activeItems = repo.getKnowledgeItems(project, { status: "active" });
+    projectToMarkdown(activeItems, getDataDir(), COMPILER_VERSION);
+    projectToSkills(activeItems, projectRoot);
     return {
       status: "complete",
       diagnostics: formatDiagnostics(normalized.length, canonicalized.autoReinforced.length, 0, 0, 0, 0, 0, project, sessionId)
@@ -539,7 +632,9 @@ function processClustering(repo, responseText, sessionId, project, projectRoot)
   }
   const totalObs = sessionObs.length;
   saveCompileRun(repo, sessionId, project, totalObs, 0, compiled.created.length, compiled.reinforced.length, compiled.superseded.length, compiled.deprecated.length, compiled.ignored, startedAt);
-  projectToMarkdown(repo.getKnowledgeItems(project, { status: "active" }), getDataDir(), COMPILER_VERSION);
+  const activeItems = repo.getKnowledgeItems(project, { status: "active" });
+  projectToMarkdown(activeItems, getDataDir(), COMPILER_VERSION);
+  projectToSkills(activeItems, projectRoot);
   return {
     status: "complete",
     diagnostics: formatDiagnostics(totalObs, 0, compiled.created.length, compiled.reinforced.length, compiled.superseded.length, compiled.deprecated.length, compiled.ignored, project, sessionId)

package/dist/cli.js

@@ -3,7 +3,7 @@
 // src/cli.ts
 import { Command } from "commander";
 var program = new Command();
-program.name("agentcache").description("Engineering Knowledge Compiler \u2014 universal, zero-config").version("0.3.0");
+program.name("agentcache").description("Engineering Knowledge Compiler \u2014 universal, zero-config").version("0.3.1");
 program.command("setup").description("Detect IDEs and register AgentCache (runs automatically on install)").action(async () => {
   const { runSetup } = await import("./setup-5APZETPV.js");
   await runSetup();
@@ -46,7 +46,7 @@ program.command("enforce").description("PreToolUse hook: policy enforcement").ac
   }
 });
 program.command("compile-all").description("Batch-compile all unprocessed transcripts using an available LLM CLI").action(async () => {
-  const { runCompileAll } = await import("./compile-all-RWCAU7MO.js");
+  const { runCompileAll } = await import("./compile-all-DOQ5XU5K.js");
   await runCompileAll();
 });
 program.command("status").description("Show AgentCache knowledge stats").action(async () => {

package/dist/{compile-all-RWCAU7MO.js → compile-all-DOQ5XU5K.js}

@@ -2,7 +2,7 @@ import {
   processClustering,
   processExtraction,
   startCompile
-} from "./chunk-IER56P6A.js";
+} from "./chunk-R4SJESNM.js";
 import {
   acquireLock,
   releaseLock

package/dist/mcp.js

@@ -6,7 +6,7 @@ import {
   processClustering,
   processExtraction,
   startCompile
-} from "./chunk-IER56P6A.js";
+} from "./chunk-R4SJESNM.js";
 import {
   spawnCompileAll
 } from "./chunk-RXBTPJVW.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentcache",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Knowledge cache for AI agents — learns how you work, remembers across sessions, works everywhere",
   "type": "module",
   "license": "MIT",