agentcache 0.4.1 → 0.4.2

package/README.md

@@ -1,243 +1,163 @@
 # AgentCache
 
-Your AI coding agents forget everything between sessions. AgentCache fixes that — it learns what you know, remembers it across sessions, and injects it into every future agent automatically, across every IDE.
-
-> "Don't mock the database in integration tests — we got burned when mocked tests passed but prod migration failed"
-
-That lesson, learned once, becomes a permanent rule. Every future session with every IDE gets it. You never say it again.
-
-## What it does
-
-AgentCache observes your coding sessions and compiles reusable knowledge — rules, lessons, architectural decisions, project context — into a local database. Every future session gets that knowledge injected at the start, regardless of IDE or LLM.
-
-- **Learns** from what your agents discover during sessions
-- **Injects** relevant knowledge at the start of every new session
-- **Works everywhere** — any IDE, any LLM, simultaneously
-- **Stays local** — SQLite on your machine, nothing leaves your disk
-
-## Install
+**Your codebase learns.** AgentCache compiles what your AI agents discover into a `SKILL.md` that every future session — in any IDE, with any LLM — reads automatically.
 
 ```bash
 npm install -g agentcache
 ```
 
-Done. Start a session in any IDE — AgentCache is already running.
+That's it. No config. No accounts. No sync server.
 
-No init. No setup. No config. The install:
+---
 
-1. Creates `~/.agentcache/agentcache.db`
-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 to process your existing transcript history
+## The Problem
+
+You tell Claude "don't mock the database in integration tests." It forgets. You tell Cursor the same thing. You tell Codex. You repeat yourself across every IDE, every session, every project.
 
-## Team knowledge — without a sync server
+Your agents are amnesiac. Your knowledge evaporates.
 
-Compiled project knowledge is written to `<repo>/.agentcache/skills/project-knowledge/SKILL.md`. Commit it. Every teammate gets your team's accumulated decisions and context on clone, automatically picked up by any Agent Skills-compatible tool.
+## What AgentCache Does
+
+After a few sessions, AgentCache produces a `SKILL.md` in your repo:
 
 ```markdown
+# Project Knowledge
+
+## Rules
+- Never mock the database in integration tests — we got burned when mocks passed but prod migration failed
+- Always use snake_case for database columns
+- Run type-check before committing
+
 ## Decisions
 - Using Drizzle ORM over Prisma for raw SQL escape hatches
 - PostgreSQL for all persistent state, Redis for ephemeral cache only
 
-## Current Context
+## Context
 - Migrating from REST to GraphQL, both coexist until Q3
+- Auth service rewrite driven by compliance (not tech debt)
 ```
 
-No sync server. No accounts. Just git.
+This file lives at `<repo>/.agentcache/skills/project-knowledge/SKILL.md`. It's auto-discovered by **38+ tools** that support the Agent Skills spec — no MCP connection required. Commit it. Every teammate gets your team's accumulated knowledge on clone.
+
+**The database is local. The output is git.**
 
-## How it works
+## How It Works
 
 ```
-┌────────────────────────────────────────────────────────────────────────┐
-│                           Your Machine                                 │
-│                                                                        │
-│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐              │
-│  │  Claude  │  │  Cursor  │  │   Roo    │  │  Codex   │  ...         │
-│  │   Code   │  │          │  │   Code   │  │          │              │
-│  └────┬─────┘  └────┬─────┘  └────┬─────┘  └────┬─────┘              │
-│       └─────────────┴─────────────┴─────────────┘                     │
-│                              │ MCP Protocol (stdio)                    │
-│                 ┌────────────┴────────────┐                            │
-│                 │  AgentCache MCP Server  │                            │
-│                 └────────────┬────────────┘                            │
-│                              │                                         │
-│                    ┌─────────┴──────────┐                              │
-│                    │  ~/.agentcache/    │                              │
-│                    │  agentcache.db     │                              │
-│                    │  (SQLite + WAL)    │                              │
-│                    └────────────────────┘                              │
-└────────────────────────────────────────────────────────────────────────┘
+Session 1 (Claude Code)     Session 2 (Cursor)     Session 3 (Codex)
+       │                           │                       │
+       └───────────────────────────┴───────────────────────┘
+                                   │
+                          AgentCache (MCP Server)
+                                   │
+                    ┌───────────────┴───────────────┐
+                    │                               │
+              ~/.agentcache/                  <repo>/.agentcache/
+              agentcache.db                  skills/.../SKILL.md
+              (local SQLite)                 (committed to git)
 ```
 
-### The cycle
+1. **Session starts** → agent calls `inject_context` → gets compiled rules, lessons, decisions
+2. **During session** → agent calls `compile_submit` as it learns things
+3. **Session ends** → knowledge compiles into the database
+4. **Periodically** → database projects into `SKILL.md` for git distribution
 
-1. **Session starts** — agent calls `inject_context` → receives compiled rules, lessons, decisions
-2. **During session** — agent calls `compile_submit` incrementally as it learns things
-3. **Session ends** — observations are already saved. If the session terminates unexpectedly, transcript recovery handles it next time.
+Knowledge compounds. One lesson stated once propagates to every future session across every IDE.
 
-### Knowledge types
+## Install
 
-| Type | Scope | Example |
-|------|-------|---------|
-| Rule | Global | "Always use snake_case for database columns" |
-| Lesson | Global | "Don't mock the database in integration tests — mocked tests passed but prod migration failed" |
-| Decision | Project | "Using Drizzle ORM over Prisma because we need raw SQL escape hatches" |
-| Context | Project | "Currently migrating from REST to GraphQL, both coexist" |
+```bash
+npm install -g agentcache
+```
 
-Rules and lessons are global — they apply to all your projects. Decisions and context are project-scoped.
+The install automatically:
+1. Creates `~/.agentcache/agentcache.db`
+2. Detects your IDEs (Claude Code, Cursor, Roo Code, Windsurf, Continue, Codex)
+3. Registers as an MCP server in each — with auto-approve
+4. Sets up Claude Code hooks for transcript recovery
+5. Compiles your existing transcript history in the background
+
+**Zero config. Zero setup. Start a session and it's working.**
 
-## Security model
+## Supported IDEs
 
-AgentCache creates a persistent feedback loop: agents write observations → observations compile into knowledge → knowledge injects into future sessions. This is the product's core value **and** its main attack surface. Both are the same thing.
+| IDE | MCP | Auto-Approve | Transcript Recovery |
+|-----|-----|-------------|-------------------|
+| Claude Code | ✓ | ✓ | Full (hooks + JSONL) |
+| Cursor | ✓ | ✓ | Full (agent transcripts) |
+| Roo Code (VS Code) | ✓ | ✓ | Full (task history) |
+| Codex | ✓ | ✓ | Full (session JSONL) |
+| Continue | ✓ | ✓ | Full (session JSON) |
+| Windsurf | ✓ | ✓ | Incremental only |
+| Goose | — | — | Full (SQLite) |
 
-### What the security model guarantees
+All IDEs share the same knowledge database. A rule learned in Claude Code is injected in Cursor the next time you open it.
 
-- **Quarantine by default** — AUTO observations (agent-submitted) are never injected until confirmed across 2+ independent sessions. A single prompt-injected `compile_submit` call cannot poison your knowledge base — it lands in quarantine and requires independent reinforcement before it's ever served.
-- **Enforced rules are human-only** — The enforce mechanism (which blocks agent tool calls) can only be set via CLI (`agentcache add-rule --enforce`). No MCP tool can create policy an agent is subject to.
-- **Scope gate** — Agent-submitted observations are always project-scoped. Promotion to global scope requires explicit human action (USER authority). An agent cannot write a global rule.
-- **Quarantine ≠ absent** — Quarantined items are captured and visible in `agentcache review`. They just don't inject. The review command is how you clear or promote them.
+## Security Model
 
-### What the security model does not guarantee
+AgentCache creates a feedback loop: agents write observations → observations compile → knowledge injects into future sessions. This is the product's value **and** its attack surface.
 
-- `compile-all` processes raw transcripts that may contain injected content. Extraction prompt hardening raises the bar, but a sufficiently crafted transcript can still produce a quarantined (non-injecting) entry. Review your pending queue periodically.
-- `locked` mode disables `compile_submit` entirely and requires human-triggered batch compilation. It reduces the attack surface significantly but `compile-all` against a poisoned transcript is still a vector.
+**Quarantine gate**: Agent-submitted observations require confirmation across 2+ independent sessions before injection. A single prompt-injected `compile_submit` cannot poison your knowledge.
 
-### Security modes
+**Human-only enforcement**: Policy rules (that block tool calls) can only be created via CLI. No MCP tool can create policy.
 
-Configure in `~/.agentcache/config.json`:
+**Scope gate**: Agent-submitted observations are always project-scoped. Global requires explicit human action.
+
+### Security Modes
 
 ```json
 { "security": "auto" }
 ```
 
-| Mode | Behavior | For |
-|------|----------|-----|
-| `auto` (default) | Quarantine — AUTO items inject after 2+ session confirmations | Solo devs, indie shops |
-| `review` | All new items land in quarantine. Nothing injects until `agentcache review` approves it | BFSI, healthcare, regulated environments |
-| `locked` | `compile_submit` disabled. Compile-all only, human-triggered batch review | Maximum control |
+| Mode | Behavior |
+|------|----------|
+| `auto` | Quarantine — new items inject after 2+ session confirmations |
+| `review` | Nothing injects until `agentcache review` approves it |
+| `locked` | `compile_submit` disabled. Human-triggered batch only |
 
-## CLI commands
+## CLI
 
 ```bash
-agentcache status          # Knowledge stats for current project
-agentcache doctor          # Diagnose installation problems
-agentcache review          # List quarantined items, approve or reject
-agentcache promote <id>    # Promote a single item past quarantine
-agentcache add-rule "never commit secrets" --enforce  # Create enforced policy (human only)
-agentcache add-rule "use tabs" --global              # Global rule across all projects
-agentcache compile-all     # Batch-compile all unprocessed transcripts
-agentcache setup           # Re-register with IDEs (only if postinstall failed)
+agentcache doctor                          # Diagnose installation
+agentcache status                          # Knowledge stats
+agentcache review                          # Approve/reject quarantined items
+agentcache promote <id>                    # Approve a single item
+agentcache add-rule "never force push" --enforce   # Create policy (human-only)
+agentcache compile-all                     # Batch-compile all transcripts
+agentcache setup                           # Re-register with IDEs
 ```
 
-## compile-all — batch compilation
-
-Processes all pending transcripts without depending on active MCP sessions.
+## compile-all
 
-**LLM backend (first available wins):**
+Processes all uncompiled transcripts from all IDEs using the first available LLM backend:
 
-1. CLI tools with stored auth: `claude`, `codex`, `gemini`, `copilot`, `aider`, `goose`
+1. CLI tools: `claude`, `codex`, `gemini`, `copilot`, `aider`, `goose`
 2. Ollama at `localhost:11434`
 3. `ANTHROPIC_API_KEY` or `OPENAI_API_KEY`
 
-**Triggers automatically:**
+Runs automatically on install and when pending transcripts exceed 20.
 
-- After `npm install -g agentcache` (clears initial backlog)
-- When pending transcripts exceed 20 (background janitor)
-- Lockfile prevents concurrent runs
-
-## MCP tools
-
-| Tool | Purpose |
-|------|---------|
-| `inject_context` | Load compiled knowledge at session start |
-| `compile_submit` | Submit observations incrementally during session |
-| `compile_cluster` | Resolve clustering when observations overlap existing knowledge |
-| `compile_extract` | Process queued transcripts from previous sessions |
-| `enforce` | Check tool calls against enforced policy rules |
-| `save_observation` | Save a permanent observation (USER authority, never auto-deprecated) |
-| `get_knowledge` | Query the knowledge database |
-| `deprecate_knowledge` | Mark knowledge as deprecated |
-
-## How knowledge compiles
-
-```
-Observations (raw)
-    │
-    ▼
-Extract → Normalize → Canonicalize → Cluster → Detect Contradictions → Compile
-                                                                          │
-                              ┌───────────────────────────────────────────┘
-                              │
-                         PENDING store
-                              │
-                    ┌─────────┴──────────┐
-                    │                    │
-              AUTO items           USER items
-         (quarantine gate)      (inject immediately)
-         2+ sessions before
-            injection
-```
-
-**Two compilation paths:**
-
-- **In-session** — agent processes extraction via MCP tools in your IDE
-- **Batch** — `compile-all` runs independently, processes full backlog
-
-**Two output formats:**
-
-- **MCP injection** — structured context via `inject_context`
-- **SKILL.md** — Agent Skills spec files auto-discovered by 38+ tools without MCP
-
-## Design principles
-
-**Zero config** — `npm install -g agentcache` is the only step. No dotfiles, no init, no config to maintain.
-
-**Universal** — MCP is the only interface. Any IDE, any LLM. No IDE-specific code paths.
-
-**Developer-scoped** — One database per developer, not per project. Global knowledge (rules, lessons) benefits all your projects. Project knowledge stays scoped.
-
-**Resilient to abrupt exits** — Incremental submission + transcript recovery + pipe-independent compilation means knowledge survives crashes, ctrl-c, and MCP disconnects.
-
-**Anti-bloat** — Confidence promotion, 30-day decay on unused items, budget caps (20 rules / 10 lessons / 10 decisions / 5 context per session), priority ranking.
-
-## Supported IDEs
-
-| IDE | MCP | Auto-Approve | Transcript Recovery | Hooks |
-|-----|-----|-------------|-------------------|-------|
-| Claude Code | Yes | Yes | Full (JSONL) | Stop, SessionStart, PreToolUse |
-| Cursor | Yes | Yes | Incremental only | — |
-| Roo Code | Yes | Yes | Full (JSON via compile-all) | — |
-| Windsurf | Yes | Yes | Incremental only | — |
-| Continue | Yes | Yes | Full (JSON) | — |
-| Codex | Yes | Yes | Full (JSONL via compile-all) | — |
-| Goose | — | — | Full (SQLite via compile-all) | — |
-| Aider | Coming soon | | | |
-| GitHub Copilot | Coming soon | | | |
-| Zed AI | Coming soon | | | |
-
-## Data storage
+## Data
 
 ```
 ~/.agentcache/
-├── agentcache.db                          # Knowledge, observations, sessions, pending queue
-├── config.json                            # Security mode and settings
-├── compile-all.lock                       # Prevents concurrent compilation
-└── skills/developer-knowledge/SKILL.md    # Global skill (auto-generated)
-```
+├── agentcache.db          # Knowledge database (SQLite + WAL)
+├── config.json            # Security mode
+└── compile-all.lock       # Prevents concurrent compilation
 
-No data leaves your machine. No network calls. No telemetry. No accounts.
-
-### Project identity
+<repo>/.agentcache/
+└── skills/project-knowledge/SKILL.md   # Git-committed team knowledge
+```
 
-Projects are identified by a hash of their full filesystem path. `/work/api` and `/personal/api` are different projects. Knowledge never leaks between same-named projects in different locations.
+No network calls. No telemetry. No accounts. Everything stays on your machine (except what you choose to commit).
 
-## Roadmap
+## Principles
 
-- **Native plugins** — Marketplace listings and deeper UI integrations for all supported IDEs
-- **Team knowledge sharing** — Share compiled knowledge across your team
-- **Cloud sync** — Same developer, different machines, same knowledge
-- **Analytics dashboard** — Compilation stats, knowledge growth, most-referenced rules
+- **Zero config** — `npm install -g` is the only step
+- **Universal** — MCP protocol, any IDE, any LLM
+- **Git-native output** — SKILL.md is the distribution mechanism
+- **Secure by default** — quarantine gate, scope restrictions, human-only policy
+- **Anti-bloat** — 30-day decay, budget caps, confidence promotion
 
 ## Contributing
 
@@ -246,7 +166,7 @@ git clone https://github.com/raghav-a21ai/agentcache
 cd agentcache
 npm install
 npm run build
-npm test
+npm test   # 205 tests
 ```
 
 ## License

package/dist/chunk-5UO7NJPQ.js

@@ -0,0 +1,71 @@
+// src/utils/ide-detector.ts
+import { existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+function getRooConfigPath() {
+  const home = homedir();
+  if (process.platform === "darwin") {
+    return join(home, "Library/Application Support/Code/User/globalStorage/rooveterinaryinc.roo-cline/settings/mcp_settings.json");
+  }
+  if (process.platform === "win32") {
+    return join(process.env.APPDATA || join(home, "AppData/Roaming"), "Code/User/globalStorage/rooveterinaryinc.roo-cline/settings/mcp_settings.json");
+  }
+  return join(home, ".config/Code/User/globalStorage/rooveterinaryinc.roo-cline/settings/mcp_settings.json");
+}
+function getWindsurfConfigPath() {
+  const home = homedir();
+  return join(home, ".codeium", "windsurf", "mcp_config.json");
+}
+function getContinueConfigPath() {
+  const home = homedir();
+  return join(home, ".continue", "mcpServers", "agentcache.json");
+}
+function getCodexConfigPath() {
+  const home = homedir();
+  return join(home, ".codex", "config.toml");
+}
+function detectInstalledIdes() {
+  const home = homedir();
+  return [
+    {
+      name: "Claude Code",
+      detected: existsSync(join(home, ".claude")),
+      mcpConfigPath: join(home, ".claude.json"),
+      mcpConfigFormat: "claude-settings"
+    },
+    {
+      name: "Cursor",
+      detected: existsSync(join(home, ".cursor")),
+      mcpConfigPath: join(home, ".cursor", "mcp.json"),
+      mcpConfigFormat: "mcp-json"
+    },
+    {
+      name: "Roo Code",
+      detected: existsSync(getRooConfigPath()),
+      mcpConfigPath: getRooConfigPath(),
+      mcpConfigFormat: "mcp-json"
+    },
+    {
+      name: "Windsurf",
+      detected: existsSync(join(home, ".codeium", "windsurf")) || existsSync(join(home, ".windsurf")),
+      mcpConfigPath: getWindsurfConfigPath(),
+      mcpConfigFormat: "mcp-json"
+    },
+    {
+      name: "Continue",
+      detected: existsSync(join(home, ".continue")),
+      mcpConfigPath: getContinueConfigPath(),
+      mcpConfigFormat: "continue-dir"
+    },
+    {
+      name: "Codex",
+      detected: existsSync(join(home, ".codex")),
+      mcpConfigPath: getCodexConfigPath(),
+      mcpConfigFormat: "codex-toml"
+    }
+  ];
+}
+
+export {
+  detectInstalledIdes
+};

package/dist/{chunk-JVLMZU5I.js → chunk-SLRKWMSE.js}

@@ -1,75 +1,7 @@
-// src/utils/ide-detector.ts
-import { existsSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
-function getRooConfigPath() {
-  const home = homedir();
-  if (process.platform === "darwin") {
-    return join(home, "Library/Application Support/Code/User/globalStorage/rooveterinaryinc.roo-cline/settings/mcp_settings.json");
-  }
-  if (process.platform === "win32") {
-    return join(process.env.APPDATA || join(home, "AppData/Roaming"), "Code/User/globalStorage/rooveterinaryinc.roo-cline/settings/mcp_settings.json");
-  }
-  return join(home, ".config/Code/User/globalStorage/rooveterinaryinc.roo-cline/settings/mcp_settings.json");
-}
-function getWindsurfConfigPath() {
-  const home = homedir();
-  return join(home, ".codeium", "windsurf", "mcp_config.json");
-}
-function getContinueConfigPath() {
-  const home = homedir();
-  return join(home, ".continue", "mcpServers", "agentcache.json");
-}
-function getCodexConfigPath() {
-  const home = homedir();
-  return join(home, ".codex", "config.toml");
-}
-function detectInstalledIdes() {
-  const home = homedir();
-  return [
-    {
-      name: "Claude Code",
-      detected: existsSync(join(home, ".claude")),
-      mcpConfigPath: join(home, ".claude.json"),
-      mcpConfigFormat: "claude-settings"
-    },
-    {
-      name: "Cursor",
-      detected: existsSync(join(home, ".cursor")),
-      mcpConfigPath: join(home, ".cursor", "mcp.json"),
-      mcpConfigFormat: "mcp-json"
-    },
-    {
-      name: "Roo Code",
-      detected: existsSync(getRooConfigPath()),
-      mcpConfigPath: getRooConfigPath(),
-      mcpConfigFormat: "mcp-json"
-    },
-    {
-      name: "Windsurf",
-      detected: existsSync(join(home, ".codeium", "windsurf")) || existsSync(join(home, ".windsurf")),
-      mcpConfigPath: getWindsurfConfigPath(),
-      mcpConfigFormat: "mcp-json"
-    },
-    {
-      name: "Continue",
-      detected: existsSync(join(home, ".continue")),
-      mcpConfigPath: getContinueConfigPath(),
-      mcpConfigFormat: "continue-dir"
-    },
-    {
-      name: "Codex",
-      detected: existsSync(join(home, ".codex")),
-      mcpConfigPath: getCodexConfigPath(),
-      mcpConfigFormat: "codex-toml"
-    }
-  ];
-}
-
 // src/utils/ide-registrar.ts
-import { existsSync as existsSync2, mkdirSync, readFileSync, writeFileSync, appendFileSync } from "fs";
-import { join as join2, dirname } from "path";
-import { homedir as homedir2 } from "os";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, appendFileSync } from "fs";
+import { join, dirname } from "path";
+import { homedir } from "os";
 import { execSync } from "child_process";
 function findNodeBinary() {
   try {
@@ -83,7 +15,7 @@ function findAgentcacheScript() {
     const binPath = execSync("which agentcache", { encoding: "utf-8" }).trim();
     return binPath;
   } catch {
-    return join2(dirname(dirname(__dirname)), "dist", "cli.js");
+    return join(dirname(dirname(__dirname)), "dist", "cli.js");
   }
 }
 function isVscodeExtensionIde(ide) {
@@ -116,9 +48,9 @@ function registerMcpServer(ide) {
   return false;
 }
 function registerClaudeCode() {
-  const claudeJsonPath = join2(homedir2(), ".claude.json");
+  const claudeJsonPath = join(homedir(), ".claude.json");
   let config = {};
-  if (existsSync2(claudeJsonPath)) {
+  if (existsSync(claudeJsonPath)) {
     try {
       config = JSON.parse(readFileSync(claudeJsonPath, "utf-8"));
     } catch {
@@ -137,10 +69,10 @@ function registerClaudeCode() {
     writeFileSync(claudeJsonPath, JSON.stringify(config, null, 2));
     serverRegistered = true;
   }
-  const settingsPath = join2(homedir2(), ".claude", "settings.json");
-  if (existsSync2(join2(homedir2(), ".claude"))) {
+  const settingsPath = join(homedir(), ".claude", "settings.json");
+  if (existsSync(join(homedir(), ".claude"))) {
     let settings = {};
-    if (existsSync2(settingsPath)) {
+    if (existsSync(settingsPath)) {
       try {
         settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
       } catch {
@@ -164,7 +96,7 @@ function registerClaudeCode() {
 }
 function registerMcpJson(ide) {
   let config = {};
-  if (existsSync2(ide.mcpConfigPath)) {
+  if (existsSync(ide.mcpConfigPath)) {
     try {
       config = JSON.parse(readFileSync(ide.mcpConfigPath, "utf-8"));
     } catch {
@@ -212,7 +144,7 @@ function registerContinue(ide) {
 }
 function registerCodex(ide) {
   const configPath = ide.mcpConfigPath;
-  if (existsSync2(configPath)) {
+  if (existsSync(configPath)) {
     const content = readFileSync(configPath, "utf-8");
     if (content.includes("[mcp_servers.agentcache]")) return false;
   }
@@ -223,7 +155,7 @@ args = ["serve"]
 default_tools_approval_mode = "auto"
 `;
   mkdirSync(dirname(configPath), { recursive: true });
-  if (existsSync2(configPath)) {
+  if (existsSync(configPath)) {
     appendFileSync(configPath, tomlBlock);
   } else {
     writeFileSync(configPath, tomlBlock.trimStart());
@@ -231,10 +163,10 @@ default_tools_approval_mode = "auto"
   return true;
 }
 function registerClaudeHooks() {
-  const settingsPath = join2(homedir2(), ".claude", "settings.json");
-  if (!existsSync2(join2(homedir2(), ".claude"))) return false;
+  const settingsPath = join(homedir(), ".claude", "settings.json");
+  if (!existsSync(join(homedir(), ".claude"))) return false;
   let settings = {};
-  if (existsSync2(settingsPath)) {
+  if (existsSync(settingsPath)) {
     try {
       settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
     } catch {
@@ -265,7 +197,6 @@ function registerClaudeHooks() {
 }
 
 export {
-  detectInstalledIdes,
   registerMcpServer,
   registerClaudeHooks
 };

package/dist/{chunk-IGCH7SZT.js → chunk-WTXSZBQE.js}

@@ -139,19 +139,62 @@ function parse3(path) {
   return events;
 }
 
-// src/utils/transcript-parsers/roo-code-json.ts
-var roo_code_json_exports = {};
-__export(roo_code_json_exports, {
+// src/utils/transcript-parsers/cursor-jsonl.ts
+var cursor_jsonl_exports = {};
+__export(cursor_jsonl_exports, {
   canParse: () => canParse4,
   parse: () => parse4
 });
 import { readFileSync as readFileSync4 } from "fs";
 function canParse4(path) {
-  return path.includes("roo-cline/tasks/") && path.endsWith("api_conversation_history.json");
+  if (!path.endsWith(".jsonl")) return false;
+  return path.includes(".cursor/projects/") && path.includes("/agent-transcripts/");
 }
 function parse4(path) {
   const content = readFileSync4(path, "utf-8");
   const events = [];
+  for (const line of content.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      const obj = JSON.parse(line);
+      if (obj.role === "user" && obj.message?.content) {
+        const blocks = Array.isArray(obj.message.content) ? obj.message.content : [{ type: "text", text: obj.message.content }];
+        const text = blocks.filter((c) => c.type === "text").map((c) => c.text).join("\n");
+        if (text) events.push({ type: "message", role: "user", content: text });
+      } else if (obj.role === "assistant" && obj.message?.content) {
+        const blocks = Array.isArray(obj.message.content) ? obj.message.content : [{ type: "text", text: obj.message.content }];
+        for (const block of blocks) {
+          if (block.type === "text" && block.text) {
+            events.push({ type: "message", role: "assistant", content: block.text });
+          } else if (block.type === "tool_use") {
+            events.push({
+              type: "tool_use",
+              tool_name: block.name,
+              tool_input: block.input
+            });
+          }
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+  return events;
+}
+
+// src/utils/transcript-parsers/roo-code-json.ts
+var roo_code_json_exports = {};
+__export(roo_code_json_exports, {
+  canParse: () => canParse5,
+  parse: () => parse5
+});
+import { readFileSync as readFileSync5 } from "fs";
+function canParse5(path) {
+  return path.includes("roo-cline/tasks/") && path.endsWith("api_conversation_history.json");
+}
+function parse5(path) {
+  const content = readFileSync5(path, "utf-8");
+  const events = [];
   try {
     const messages = JSON.parse(content);
     if (!Array.isArray(messages)) return [];
@@ -182,7 +225,7 @@ function parse4(path) {
 }
 
 // src/utils/transcript-parsers/index.ts
-var parsers = [codex_jsonl_exports, roo_code_json_exports, claude_jsonl_exports, continue_json_exports];
+var parsers = [codex_jsonl_exports, cursor_jsonl_exports, roo_code_json_exports, claude_jsonl_exports, continue_json_exports];
 function parseTranscriptAuto(path) {
   for (const parser of parsers) {
     if (parser.canParse(path)) return parser.parse(path);
@@ -194,6 +237,31 @@ function parseTranscriptAuto(path) {
 function parseTranscript(path) {
   return parseTranscriptAuto(path);
 }
+function findLatestTranscript() {
+  const baseDir = getClaudeTranscriptsDir();
+  if (!existsSync(baseDir)) return null;
+  let latest = null;
+  try {
+    const dirs = readdirSync(baseDir).map((d) => join(baseDir, d)).filter((d) => statSync(d).isDirectory());
+    for (const dir of dirs) {
+      try {
+        const files = readdirSync(dir).filter((f) => f.endsWith(".jsonl"));
+        for (const file of files) {
+          const fullPath = join(dir, file);
+          const mtime = statSync(fullPath).mtimeMs;
+          if (!latest || mtime > latest.mtime) {
+            latest = { path: fullPath, mtime };
+          }
+        }
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+    return null;
+  }
+  return latest?.path ?? null;
+}
 function findAllClaudeTranscripts() {
   const baseDir = getClaudeTranscriptsDir();
   if (!existsSync(baseDir)) return [];
@@ -247,6 +315,37 @@ function findAllCodexTranscripts() {
   walkDir(baseDir);
   return transcripts;
 }
+function findAllCursorTranscripts() {
+  const baseDir = join(homedir(), ".cursor", "projects");
+  if (!existsSync(baseDir)) return [];
+  const transcripts = [];
+  try {
+    for (const projectDir of readdirSync(baseDir)) {
+      const agentDir = join(baseDir, projectDir, "agent-transcripts");
+      if (!existsSync(agentDir)) continue;
+      try {
+        for (const sessionDir of readdirSync(agentDir)) {
+          const sessionPath = join(agentDir, sessionDir);
+          if (!statSync(sessionPath).isDirectory()) continue;
+          try {
+            for (const file of readdirSync(sessionPath)) {
+              if (file.endsWith(".jsonl")) {
+                const full = join(sessionPath, file);
+                if (statSync(full).size > 100) {
+                  transcripts.push(full);
+                }
+              }
+            }
+          } catch {
+          }
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return transcripts;
+}
 function findAllRooCodeTranscripts() {
   const possibleDirs = [
     join(homedir(), "Library", "Application Support", "Code", "User", "globalStorage", "rooveterinaryinc.roo-cline", "tasks"),
@@ -267,15 +366,23 @@ function findAllRooCodeTranscripts() {
   }
   return transcripts;
 }
+function findAllGooseSessionIds() {
+  const dbPath = join(homedir(), ".local", "share", "goose", "sessions", "sessions.db");
+  if (!existsSync(dbPath)) return [];
+  return [dbPath];
+}
 function getGooseDbPath() {
   return join(homedir(), ".local", "share", "goose", "sessions", "sessions.db");
 }
 
 export {
   parseTranscript,
+  findLatestTranscript,
   findAllClaudeTranscripts,
   findAllContinueTranscripts,
   findAllCodexTranscripts,
+  findAllCursorTranscripts,
   findAllRooCodeTranscripts,
+  findAllGooseSessionIds,
   getGooseDbPath
 };

package/dist/cli.js

@@ -5,7 +5,7 @@ import { Command } from "commander";
 var program = new Command();
 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-45BVUDXN.js");
+  const { runSetup } = await import("./setup-CVG35TUZ.js");
   await runSetup();
 });
 program.command("serve").description("Start AgentCache MCP server (spawned by IDEs automatically)").action(async () => {
@@ -14,7 +14,7 @@ program.command("serve").description("Start AgentCache MCP server (spawned by ID
 });
 program.command("compile-session").description("Stop hook: queue transcript for compilation").action(async () => {
   try {
-    const { handleStop } = await import("./stop-TPCRE7RE.js");
+    const { handleStop } = await import("./stop-WGGRX6TQ.js");
     let payload;
     try {
       let data = "";
@@ -34,7 +34,7 @@ program.command("compile-session").description("Stop hook: queue transcript for
 });
 program.command("discover").description("SessionStart hook: discover uncompiled transcripts").action(async () => {
   try {
-    const { handleSessionStart } = await import("./session-start-EIHYCS3J.js");
+    const { handleSessionStart } = await import("./session-start-DGMGEAJU.js");
     await handleSessionStart();
   } catch (err) {
     process.stderr.write(`agentcache discover: ${err.message}
@@ -47,7 +47,7 @@ program.command("enforce").description("PreToolUse hook: policy enforcement").ac
     data += chunk;
   }
   try {
-    const { handlePreToolUse } = await import("./pre-tool-use-7F7NTHCS.js");
+    const { handlePreToolUse } = await import("./pre-tool-use-A4AJHZOJ.js");
     const input = JSON.parse(data);
     const result = handlePreToolUse(input);
     process.stdout.write(JSON.stringify(result));
@@ -202,40 +202,99 @@ program.command("doctor").description("Diagnose AgentCache installation and repo
     warning("Not initialized yet \u2014 run: agentcache setup");
   }
   console.log("\nIDE registrations:");
-  const claudeJson = join(homedir(), ".claude.json");
-  if (existsSync(claudeJson)) {
-    try {
-      const config = JSON.parse(readFileSync(claudeJson, "utf-8"));
-      if (config.mcpServers?.agentcache) {
-        pass("Claude Code: registered");
+  const { detectInstalledIdes } = await import("./ide-detector-5TRCR4F5.js");
+  const ides = detectInstalledIdes();
+  for (const ide of ides) {
+    if (!ide.detected) continue;
+    if (ide.mcpConfigFormat === "claude-settings") {
+      const claudeJson = join(homedir(), ".claude.json");
+      if (existsSync(claudeJson)) {
+        try {
+          const config = JSON.parse(readFileSync(claudeJson, "utf-8"));
+          if (config.mcpServers?.agentcache) {
+            pass("Claude Code: registered");
+          } else {
+            warning("Claude Code: detected but not registered");
+          }
+        } catch {
+          warning("Claude Code: config unreadable");
+        }
       } else {
-        warning("Claude Code: ~/.claude.json exists but no agentcache server");
+        warning("Claude Code: detected but not registered");
       }
-    } catch {
-      warning("Claude Code: ~/.claude.json unreadable");
-    }
-  } else {
-    warning("Claude Code: not registered");
-  }
-  const settingsPath = join(homedir(), ".claude", "settings.json");
-  if (existsSync(settingsPath)) {
-    try {
-      const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
-      const perms = settings.permissions?.allow || [];
-      if (perms.some((p) => p.includes("agentcache"))) {
-        pass("Claude Code permissions: auto-approved");
+      const settingsPath = join(homedir(), ".claude", "settings.json");
+      if (existsSync(settingsPath)) {
+        try {
+          const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+          const perms = settings.permissions?.allow || [];
+          if (perms.some((p) => p.includes("agentcache"))) {
+            pass("Claude Code permissions: auto-approved");
+          } else {
+            warning("Claude Code permissions: not in allow list");
+          }
+          if (settings.hooks?.Stop?.some((h) => JSON.stringify(h).includes("agentcache"))) {
+            pass("Claude Code hooks: registered");
+          } else {
+            warning("Claude Code hooks: not registered");
+          }
+        } catch {
+          warning("Claude Code settings: unreadable");
+        }
+      }
+    } else if (ide.mcpConfigFormat === "codex-toml") {
+      if (existsSync(ide.mcpConfigPath)) {
+        try {
+          const content = readFileSync(ide.mcpConfigPath, "utf-8");
+          if (content.includes("[mcp_servers.agentcache]")) {
+            pass(`${ide.name}: registered`);
+          } else {
+            warning(`${ide.name}: detected but not registered`);
+          }
+        } catch {
+          warning(`${ide.name}: config unreadable`);
+        }
       } else {
-        warning("Claude Code permissions: not in allow list");
+        warning(`${ide.name}: detected but not registered`);
       }
-      if (settings.hooks?.Stop?.some((h) => JSON.stringify(h).includes("agentcache"))) {
-        pass("Claude Code hooks: registered");
+    } else {
+      if (existsSync(ide.mcpConfigPath)) {
+        try {
+          const config = JSON.parse(readFileSync(ide.mcpConfigPath, "utf-8"));
+          if (config.mcpServers?.agentcache) {
+            pass(`${ide.name}: registered`);
+          } else {
+            warning(`${ide.name}: detected but not registered`);
+          }
+        } catch {
+          warning(`${ide.name}: config unreadable`);
+        }
       } else {
-        warning("Claude Code hooks: not registered");
+        warning(`${ide.name}: detected but not registered`);
       }
-    } catch {
-      warning("Claude Code settings: unreadable");
     }
   }
+  const notDetected = ides.filter((i) => !i.detected).map((i) => i.name);
+  if (notDetected.length > 0) {
+    console.log(`  \xB7 Not detected: ${notDetected.join(", ")}`);
+  }
+  console.log("\nTranscript sources:");
+  const { findAllClaudeTranscripts, findAllCursorTranscripts, findAllContinueTranscripts, findAllCodexTranscripts, findAllRooCodeTranscripts } = await import("./transcript-JWSGSDSF.js");
+  const sources = [
+    { name: "Claude Code", fn: findAllClaudeTranscripts },
+    { name: "Cursor", fn: findAllCursorTranscripts },
+    { name: "Continue", fn: findAllContinueTranscripts },
+    { name: "Codex", fn: findAllCodexTranscripts },
+    { name: "Roo Code", fn: findAllRooCodeTranscripts }
+  ];
+  let totalTranscripts = 0;
+  for (const src of sources) {
+    const count = src.fn().length;
+    totalTranscripts += count;
+    if (count > 0) pass(`${src.name}: ${count} transcripts`);
+  }
+  if (totalTranscripts === 0) {
+    warning("No transcripts found from any IDE");
+  }
   console.log("\nLLM backends (for compile-all):");
   const backends = ["claude", "codex", "gemini", "copilot", "aider", "goose"];
   const found = [];
@@ -267,7 +326,7 @@ ${ok} passed, ${warn} warnings, ${fail} errors`);
   if (fail > 0) process.exit(1);
 });
 program.command("compile-all").description("Batch-compile all unprocessed transcripts using an available LLM CLI").action(async () => {
-  const { runCompileAll } = await import("./compile-all-7ESDEBFG.js");
+  const { runCompileAll } = await import("./compile-all-PTWTZVP5.js");
   await runCompileAll();
 });
 program.command("status").description("Show AgentCache knowledge stats").action(async () => {

package/dist/{compile-all-7ESDEBFG.js → compile-all-PTWTZVP5.js}

@@ -3,28 +3,29 @@ import {
   processExtraction,
   startCompile
 } from "./chunk-CUBZRYS5.js";
+import "./chunk-GGAATZKM.js";
+import {
+  acquireLock,
+  releaseLock
+} from "./chunk-JUDLOBOC.js";
+import {
+  SqliteKnowledgeRepository
+} from "./chunk-PSASDZQE.js";
 import {
   findAllClaudeTranscripts,
   findAllCodexTranscripts,
   findAllContinueTranscripts,
+  findAllCursorTranscripts,
   findAllRooCodeTranscripts,
   getGooseDbPath,
   parseTranscript
-} from "./chunk-IGCH7SZT.js";
-import {
-  acquireLock,
-  releaseLock
-} from "./chunk-JUDLOBOC.js";
-import "./chunk-GGAATZKM.js";
+} from "./chunk-WTXSZBQE.js";
 import {
   getDbPath,
   getGitRoot,
   getProjectId,
   isInitialized
 } from "./chunk-T4COG3XD.js";
-import {
-  SqliteKnowledgeRepository
-} from "./chunk-PSASDZQE.js";
 import {
   __esm,
   __export,
@@ -294,6 +295,7 @@ function discoverAllTranscripts(repo) {
   const results = [];
   const allPaths = [
     ...findAllClaudeTranscripts(),
+    ...findAllCursorTranscripts(),
     ...findAllContinueTranscripts(),
     ...findAllCodexTranscripts(),
     ...findAllRooCodeTranscripts()
@@ -311,6 +313,14 @@ function inferProjectRoot(transcriptPath) {
     const slug = transcriptPath.split(".claude/projects/")[1]?.split("/")[0] || "";
     if (slug.startsWith("-")) return slug.replace(/-/g, "/");
   }
+  if (transcriptPath.includes(".cursor/projects/")) {
+    const slug = transcriptPath.split(".cursor/projects/")[1]?.split("/")[0] || "";
+    if (slug) {
+      const asPath = "/" + slug.replace(/-/g, "/");
+      const root = getGitRoot(asPath);
+      if (root) return root;
+    }
+  }
   try {
     const events = parseTranscript(transcriptPath);
     for (const event of events) {

package/dist/ide-detector-5TRCR4F5.js

@@ -0,0 +1,7 @@
+import {
+  detectInstalledIdes
+} from "./chunk-5UO7NJPQ.js";
+import "./chunk-KFQGP6VL.js";
+export {
+  detectInstalledIdes
+};

package/dist/mcp.js

@@ -7,14 +7,17 @@ import {
   startCompile
 } from "./chunk-CUBZRYS5.js";
 import {
-  parseTranscript
-} from "./chunk-IGCH7SZT.js";
+  computeCanonicalHash
+} from "./chunk-GGAATZKM.js";
 import {
   spawnCompileAll
 } from "./chunk-JUDLOBOC.js";
 import {
-  computeCanonicalHash
-} from "./chunk-GGAATZKM.js";
+  SqliteKnowledgeRepository
+} from "./chunk-PSASDZQE.js";
+import {
+  parseTranscript
+} from "./chunk-WTXSZBQE.js";
 import {
   findProjectRoot,
   getDataDir,
@@ -22,9 +25,6 @@ import {
   getProjectId,
   isInitialized
 } from "./chunk-T4COG3XD.js";
-import {
-  SqliteKnowledgeRepository
-} from "./chunk-PSASDZQE.js";
 import "./chunk-KFQGP6VL.js";
 
 // src/mcp.ts

package/dist/postinstall.js

@@ -2,18 +2,20 @@ import {
   spawnCompileAll
 } from "./chunk-JUDLOBOC.js";
 import {
-  detectInstalledIdes,
   registerClaudeHooks,
   registerMcpServer
-} from "./chunk-JVLMZU5I.js";
+} from "./chunk-SLRKWMSE.js";
+import {
+  SqliteKnowledgeRepository
+} from "./chunk-PSASDZQE.js";
+import {
+  detectInstalledIdes
+} from "./chunk-5UO7NJPQ.js";
 import {
   getDataDir,
   getDbPath,
   migrateFromLegacy
 } from "./chunk-T4COG3XD.js";
-import {
-  SqliteKnowledgeRepository
-} from "./chunk-PSASDZQE.js";
 import "./chunk-KFQGP6VL.js";
 
 // src/postinstall.ts

package/dist/{session-start-EIHYCS3J.js → session-start-DGMGEAJU.js}

@@ -1,17 +1,18 @@
+import {
+  SqliteKnowledgeRepository
+} from "./chunk-PSASDZQE.js";
 import {
   findAllClaudeTranscripts,
   findAllCodexTranscripts,
   findAllContinueTranscripts,
+  findAllCursorTranscripts,
   findAllRooCodeTranscripts
-} from "./chunk-IGCH7SZT.js";
+} from "./chunk-WTXSZBQE.js";
 import {
   getDbPath,
   getProjectId,
   isInitialized
 } from "./chunk-T4COG3XD.js";
-import {
-  SqliteKnowledgeRepository
-} from "./chunk-PSASDZQE.js";
 import "./chunk-KFQGP6VL.js";
 
 // src/hooks/session-start.ts
@@ -19,6 +20,14 @@ import { statSync } from "fs";
 import { basename, dirname } from "path";
 import { randomUUID } from "crypto";
 function inferProjectRootFromTranscriptPath(path) {
+  if (path.includes(".claude/projects/")) {
+    const slug2 = path.split(".claude/projects/")[1]?.split("/")[0] || "";
+    if (slug2.startsWith("-")) return slug2.replace(/-/g, "/");
+  }
+  if (path.includes(".cursor/projects/")) {
+    const slug2 = path.split(".cursor/projects/")[1]?.split("/")[0] || "";
+    if (slug2) return "/" + slug2.replace(/-/g, "/");
+  }
   const dir = dirname(path);
   const slug = basename(dir);
   if (slug.startsWith("-")) {
@@ -32,6 +41,7 @@ async function handleSessionStart() {
   const compiledPaths = new Set(repo.getAllCompiledTranscriptPaths());
   const allTranscripts = [
     ...findAllClaudeTranscripts(),
+    ...findAllCursorTranscripts(),
     ...findAllContinueTranscripts(),
     ...findAllCodexTranscripts(),
     ...findAllRooCodeTranscripts()

package/dist/{setup-45BVUDXN.js → setup-CVG35TUZ.js}

@@ -1,16 +1,18 @@
 import {
-  detectInstalledIdes,
   registerClaudeHooks,
   registerMcpServer
-} from "./chunk-JVLMZU5I.js";
+} from "./chunk-SLRKWMSE.js";
+import {
+  SqliteKnowledgeRepository
+} from "./chunk-PSASDZQE.js";
+import {
+  detectInstalledIdes
+} from "./chunk-5UO7NJPQ.js";
 import {
   getDataDir,
   getDbPath,
   migrateFromLegacy
 } from "./chunk-T4COG3XD.js";
-import {
-  SqliteKnowledgeRepository
-} from "./chunk-PSASDZQE.js";
 import "./chunk-KFQGP6VL.js";
 
 // src/setup.ts

package/dist/transcript-JWSGSDSF.js

@@ -0,0 +1,24 @@
+import {
+  findAllClaudeTranscripts,
+  findAllCodexTranscripts,
+  findAllContinueTranscripts,
+  findAllCursorTranscripts,
+  findAllGooseSessionIds,
+  findAllRooCodeTranscripts,
+  findLatestTranscript,
+  getGooseDbPath,
+  parseTranscript
+} from "./chunk-WTXSZBQE.js";
+import "./chunk-T4COG3XD.js";
+import "./chunk-KFQGP6VL.js";
+export {
+  findAllClaudeTranscripts,
+  findAllCodexTranscripts,
+  findAllContinueTranscripts,
+  findAllCursorTranscripts,
+  findAllGooseSessionIds,
+  findAllRooCodeTranscripts,
+  findLatestTranscript,
+  getGooseDbPath,
+  parseTranscript
+};

package/package.json

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

package/dist/{pre-tool-use-7F7NTHCS.js → pre-tool-use-A4AJHZOJ.js}

@@ -1,15 +1,15 @@
 import {
   evaluatePolicy
 } from "./chunk-T7BJPANN.js";
+import {
+  SqliteKnowledgeRepository
+} from "./chunk-PSASDZQE.js";
 import {
   findProjectRoot,
   getDbPath,
   getProjectId,
   isInitialized
 } from "./chunk-T4COG3XD.js";
-import {
-  SqliteKnowledgeRepository
-} from "./chunk-PSASDZQE.js";
 import "./chunk-KFQGP6VL.js";
 
 // src/hooks/pre-tool-use.ts

package/dist/{stop-TPCRE7RE.js → stop-WGGRX6TQ.js}

@@ -1,12 +1,12 @@
+import {
+  SqliteKnowledgeRepository
+} from "./chunk-PSASDZQE.js";
 import {
   findProjectRoot,
   getDbPath,
   getProjectId,
   isInitialized
 } from "./chunk-T4COG3XD.js";
-import {
-  SqliteKnowledgeRepository
-} from "./chunk-PSASDZQE.js";
 import "./chunk-KFQGP6VL.js";
 
 // src/hooks/stop.ts