agentcache 0.1.3 → 0.2.0

package/README.md

@@ -23,7 +23,7 @@ npm install -g agentcache
 Done. Start a new session in any IDE. AgentCache is already running.
 
 No `init`. No `setup`. No config. No second command. The install itself:
-1. Creates `~/.loop/loop.db` (your knowledge store)
+1. Creates `~/.agentcache/agentcache.db` (your knowledge store)
 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
@@ -49,7 +49,8 @@ No `init`. No `setup`. No config. No second command. The install itself:
 │                 └────────────┬────────────┘                      │
 │                              │                                    │
 │                    ┌─────────┴─────────┐                         │
-│                    │  ~/.loop/loop.db   │                         │
+│                    │ ~/.agentcache/     │                         │
+│                    │  agentcache.db     │                         │
 │                    │  (SQLite + WAL)    │                         │
 │                    └───────────────────┘                         │
 └─────────────────────────────────────────────────────────────────┘
@@ -57,8 +58,8 @@ No `init`. No `setup`. No config. No second command. The install itself:
 
 ### The Cycle
 
-1. **Session starts** — agent calls `loop_inject_context` → gets compiled rules, lessons, decisions
-2. **During session** — agent calls `loop_compile_submit` incrementally as it learns things
+1. **Session starts** — agent calls `agentcache_inject_context` → gets compiled rules, lessons, decisions
+2. **During session** — agent calls `agentcache_compile_submit` incrementally as it learns things
 3. **Session ends** — knowledge is already saved. If agent didn't submit (abrupt exit), transcript recovery handles it next session.
 
 ### Knowledge Types
@@ -78,14 +79,14 @@ AgentCache exposes 8 tools via the Model Context Protocol:
 
 | Tool | Purpose |
 |------|---------|
-| `loop_inject_context` | Load compiled knowledge at session start |
-| `loop_compile_submit` | Submit observations incrementally during session |
-| `loop_compile_cluster` | Resolve clustering when observations overlap existing knowledge |
-| `loop_compile_extract` | Process queued transcripts from previous sessions |
-| `loop_enforce` | Check tool calls against enforced policy rules |
-| `loop_save_observation` | Save a permanent observation (USER authority, never auto-deprecated) |
-| `loop_get_knowledge` | Query the knowledge database |
-| `loop_deprecate_knowledge` | Mark knowledge as deprecated when it's no longer valid |
+| `agentcache_inject_context` | Load compiled knowledge at session start |
+| `agentcache_compile_submit` | Submit observations incrementally during session |
+| `agentcache_compile_cluster` | Resolve clustering when observations overlap existing knowledge |
+| `agentcache_compile_extract` | Process queued transcripts from previous sessions |
+| `agentcache_enforce` | Check tool calls against enforced policy rules |
+| `agentcache_save_observation` | Save a permanent observation (USER authority, never auto-deprecated) |
+| `agentcache_get_knowledge` | Query the knowledge database |
+| `agentcache_deprecate_knowledge` | Mark knowledge as deprecated when it's no longer valid |
 
 ## CLI Commands
 
@@ -114,7 +115,7 @@ AgentCache uses MCP (Model Context Protocol) as its only interface. Any IDE that
 
 ### Developer-Scoped
 
-One database per developer (`~/.loop/loop.db`), not per project. Rules and lessons learned in one project benefit all your projects. Project-specific decisions stay scoped to their project.
+One database per developer (`~/.agentcache/agentcache.db`), not per project. Rules and lessons learned in one project benefit all your projects. Project-specific decisions stay scoped to their project.
 
 ### Resilient to Abrupt Exits
 
@@ -133,24 +134,32 @@ AgentCache prevents knowledge from growing unbounded:
 
 ## Supported IDEs
 
-| IDE | MCP | Transcript Recovery | Hooks |
-|-----|-----|--------------------|----|
-| Claude Code | Yes | Full (JSONL) | Stop, SessionStart, PreToolUse |
-| Cursor | Yes | Incremental only | — |
-| Roo Code | Yes | Incremental only | — |
-| Windsurf | Yes | Incremental only | — |
-| Continue | Yes | Full (JSON) | — |
-| Codex | Yes | Incremental only | — |
+| 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 | — |
+| Windsurf | Yes | Yes (automatic) | Incremental only | — |
+| Continue | Yes | Yes (automatic) | Full (JSON) | — |
+| Codex | Yes | Yes (automatic) | Incremental only | — |
 
 "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
+
+Cursor does not support programmatic auto-approve for MCP tools. After installing, you need to manually enable it once:
+
+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)
+
 ## Data Storage
 
-All data lives in `~/.loop/loop.db` (SQLite with WAL mode for concurrent access).
+All data lives in `~/.agentcache/agentcache.db` (SQLite with WAL mode for concurrent access).
 
 ```
-~/.loop/
-└── loop.db          # All knowledge, observations, sessions, pending queue
+~/.agentcache/
+└── agentcache.db    # All knowledge, observations, sessions, pending queue
 ```
 
 No data leaves your machine. No network calls. No telemetry. No accounts.
@@ -185,8 +194,8 @@ Projects are identified by a hash of their full filesystem path, not just the fo
 ## Contributing
 
 ```bash
-git clone https://github.com/raghav-a21ai/loop-eng
-cd loop-eng
+git clone https://github.com/raghav-a21ai/agentcache
+cd agentcache
 npm install
 npm run build
 npm test

package/dist/chunk-LDQPTAZ7.js

@@ -0,0 +1,282 @@
+// 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 { execSync } from "child_process";
+function findNodeBinary() {
+  try {
+    return execSync("which node", { encoding: "utf-8" }).trim();
+  } catch {
+    return "node";
+  }
+}
+function findAgentcacheScript() {
+  try {
+    const binPath = execSync("which agentcache", { encoding: "utf-8" }).trim();
+    return binPath;
+  } catch {
+    return join2(dirname(dirname(__dirname)), "dist", "cli.js");
+  }
+}
+function isVscodeExtensionIde(ide) {
+  return ide.name === "Roo Code" || ide.name === "Continue";
+}
+var ALL_TOOLS = [
+  "agentcache_inject_context",
+  "agentcache_compile_submit",
+  "agentcache_compile_cluster",
+  "agentcache_compile_extract",
+  "agentcache_enforce",
+  "agentcache_save_observation",
+  "agentcache_get_knowledge",
+  "agentcache_deprecate_knowledge"
+];
+function registerMcpServer(ide) {
+  if (!ide.detected) return false;
+  if (ide.mcpConfigFormat === "claude-settings") {
+    return registerClaudeCode();
+  }
+  if (ide.mcpConfigFormat === "mcp-json") {
+    return registerMcpJson(ide);
+  }
+  if (ide.mcpConfigFormat === "continue-dir") {
+    return registerContinue(ide);
+  }
+  if (ide.mcpConfigFormat === "codex-toml") {
+    return registerCodex(ide);
+  }
+  return false;
+}
+function registerClaudeCode() {
+  const claudeJsonPath = join2(homedir2(), ".claude.json");
+  let config = {};
+  if (existsSync2(claudeJsonPath)) {
+    try {
+      config = JSON.parse(readFileSync(claudeJsonPath, "utf-8"));
+    } catch {
+      config = {};
+    }
+  }
+  if (!config.mcpServers) config.mcpServers = {};
+  let serverRegistered = false;
+  if (!config.mcpServers.agentcache) {
+    config.mcpServers.agentcache = {
+      type: "stdio",
+      command: "agentcache",
+      args: ["serve"],
+      env: {}
+    };
+    writeFileSync(claudeJsonPath, JSON.stringify(config, null, 2));
+    serverRegistered = true;
+  }
+  const settingsPath = join2(homedir2(), ".claude", "settings.json");
+  if (existsSync2(join2(homedir2(), ".claude"))) {
+    let settings = {};
+    if (existsSync2(settingsPath)) {
+      try {
+        settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+      } catch {
+        settings = {};
+      }
+    }
+    if (!settings.permissions) settings.permissions = {};
+    if (!settings.permissions.allow) settings.permissions.allow = [];
+    const allowList = settings.permissions.allow;
+    const mcpPerms = ALL_TOOLS.map((t) => `mcp__agentcache__${t}`);
+    let permsUpdated = false;
+    for (const perm of mcpPerms) {
+      if (!allowList.includes(perm)) {
+        allowList.push(perm);
+        permsUpdated = true;
+      }
+    }
+    if (permsUpdated) {
+      writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+    }
+  }
+  return serverRegistered;
+}
+function registerMcpJson(ide) {
+  let config = {};
+  if (existsSync2(ide.mcpConfigPath)) {
+    try {
+      config = JSON.parse(readFileSync(ide.mcpConfigPath, "utf-8"));
+    } catch {
+      config = {};
+    }
+  }
+  if (!config.mcpServers) config.mcpServers = {};
+  const existing = config.mcpServers.agentcache;
+  if (isVscodeExtensionIde(ide)) {
+    const nodeBin = findNodeBinary();
+    const script = findAgentcacheScript();
+    config.mcpServers.agentcache = {
+      command: nodeBin,
+      args: [script, "serve"],
+      alwaysAllow: ALL_TOOLS,
+      disabled: false
+    };
+  } else if (!existing) {
+    const agentcacheBin = findAgentcacheScript();
+    config.mcpServers.agentcache = {
+      command: agentcacheBin,
+      args: ["serve"]
+    };
+  } else {
+    return false;
+  }
+  mkdirSync(dirname(ide.mcpConfigPath), { recursive: true });
+  writeFileSync(ide.mcpConfigPath, JSON.stringify(config, null, 2));
+  return !existing;
+}
+function registerContinue(ide) {
+  const configPath = ide.mcpConfigPath;
+  if (existsSync2(configPath)) {
+    try {
+      const existing = JSON.parse(readFileSync(configPath, "utf-8"));
+      if (existing.mcpServers?.agentcache) return false;
+    } catch {
+    }
+  }
+  const nodeBin = findNodeBinary();
+  const script = findAgentcacheScript();
+  const config = {
+    mcpServers: {
+      agentcache: {
+        command: nodeBin,
+        args: [script, "serve"]
+      }
+    }
+  };
+  mkdirSync(dirname(configPath), { recursive: true });
+  writeFileSync(configPath, JSON.stringify(config, null, 2));
+  return true;
+}
+function registerCodex(ide) {
+  const configPath = ide.mcpConfigPath;
+  if (existsSync2(configPath)) {
+    const content = readFileSync(configPath, "utf-8");
+    if (content.includes("[mcp_servers.agentcache]")) return false;
+  }
+  const agentcacheBin = findAgentcacheScript();
+  const tomlBlock = `
+[mcp_servers.agentcache]
+command = "${agentcacheBin}"
+args = ["serve"]
+default_tools_approval_mode = "auto"
+`;
+  mkdirSync(dirname(configPath), { recursive: true });
+  if (existsSync2(configPath)) {
+    appendFileSync(configPath, tomlBlock);
+  } else {
+    writeFileSync(configPath, tomlBlock.trimStart());
+  }
+  return true;
+}
+function registerClaudeHooks() {
+  const settingsPath = join2(homedir2(), ".claude", "settings.json");
+  if (!existsSync2(join2(homedir2(), ".claude"))) return false;
+  let settings = {};
+  if (existsSync2(settingsPath)) {
+    try {
+      settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+    } catch {
+      settings = {};
+    }
+  }
+  if (!settings.hooks) settings.hooks = {};
+  const hooks = settings.hooks;
+  const agentcacheHooks = {
+    Stop: [{ matcher: "", hooks: [{ type: "command", command: "agentcache compile-session" }] }],
+    SessionStart: [{ matcher: "", hooks: [{ type: "command", command: "agentcache discover" }] }],
+    PreToolUse: [{ matcher: "", hooks: [{ type: "command", command: "agentcache enforce" }] }]
+  };
+  let registered = false;
+  for (const [event, hookConfig] of Object.entries(agentcacheHooks)) {
+    if (!hooks[event]) hooks[event] = [];
+    const existing = hooks[event];
+    const hasAgentcache = existing.some((h) => h.hooks?.some((hh) => hh.command?.includes("agentcache")));
+    if (!hasAgentcache) {
+      hooks[event].push(...hookConfig);
+      registered = true;
+    }
+  }
+  if (registered) {
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+  }
+  return registered;
+}
+
+export {
+  detectInstalledIdes,
+  registerMcpServer,
+  registerClaudeHooks
+};

package/dist/{chunk-QGG25FWV.js → chunk-OSFK44XC.js}

@@ -1,7 +1,7 @@
 import {
   getClaudeTranscriptsDir,
   getContinueSessionsDir
-} from "./chunk-VPEEZXLK.js";
+} from "./chunk-WHP4Z32Z.js";
 import {
   __export
 } from "./chunk-MLKGABMK.js";

package/dist/{chunk-PYGRUQNL.js → chunk-T7BJPANN.js}

@@ -1,8 +1,8 @@
 // src/policy/engine.ts
 var HARDCODED_BLOCKS = [
-  { pattern: /git\s+push\s+--force\s+(origin\s+)?(main|master)/i, reason: "Force-push to main/master is blocked by Loop policy" },
-  { pattern: /rm\s+-rf\s+[\/~]/i, reason: "Destructive rm -rf on root or home is blocked by Loop policy" },
-  { pattern: />\s*(.*\.(env|pem|key))/i, reason: "Writing to sensitive files (.env, .pem, .key) is blocked by Loop policy" }
+  { pattern: /git\s+push\s+--force\s+(origin\s+)?(main|master)/i, reason: "Force-push to main/master is blocked by AgentCache policy" },
+  { pattern: /rm\s+-rf\s+[\/~]/i, reason: "Destructive rm -rf on root or home is blocked by AgentCache policy" },
+  { pattern: />\s*(.*\.(env|pem|key))/i, reason: "Writing to sensitive files (.env, .pem, .key) is blocked by AgentCache policy" }
 ];
 function evaluatePolicy(input, enforcedRules) {
   const command = extractCommand(input.tool_name, input.tool_input);

package/dist/{chunk-VPEEZXLK.js → chunk-WHP4Z32Z.js}

@@ -1,6 +1,6 @@
 // src/utils/paths.ts
-import { existsSync } from "fs";
-import { join } from "path";
+import { existsSync, renameSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
 import { homedir } from "os";
 import { createHash } from "crypto";
 
@@ -26,15 +26,23 @@ function getGitRoot(cwd) {
 }
 
 // src/utils/paths.ts
-function getGlobalLoopDir() {
-  return join(homedir(), ".loop");
+function getDataDir() {
+  return join(homedir(), ".agentcache");
 }
 function getDbPath() {
-  return join(getGlobalLoopDir(), "loop.db");
+  return join(getDataDir(), "agentcache.db");
 }
-function isLoopInitialized() {
+function isInitialized() {
   return existsSync(getDbPath());
 }
+function migrateFromLegacy() {
+  const legacyDb = join(homedir(), ".loop", "loop.db");
+  const newDb = getDbPath();
+  if (existsSync(legacyDb) && !existsSync(newDb)) {
+    mkdirSync(dirname(newDb), { recursive: true });
+    renameSync(legacyDb, newDb);
+  }
+}
 function findProjectRoot(cwd) {
   const dir = cwd || process.cwd();
   const gitRoot = getGitRoot(dir);
@@ -57,9 +65,10 @@ function getContinueSessionsDir() {
 
 export {
   getGitContext,
-  getGlobalLoopDir,
+  getDataDir,
   getDbPath,
-  isLoopInitialized,
+  isInitialized,
+  migrateFromLegacy,
   findProjectRoot,
   getProjectId,
   getProjectDisplayName,

package/dist/cli.js

@@ -4,16 +4,16 @@
 import { Command } from "commander";
 var program = new Command();
 program.name("agentcache").description("Engineering Knowledge Compiler \u2014 universal, zero-config").version("0.3.0");
-program.command("setup").description("Detect IDEs and register Loop (runs automatically on install)").action(async () => {
-  const { runSetup } = await import("./setup-C6PI6YD7.js");
+program.command("setup").description("Detect IDEs and register AgentCache (runs automatically on install)").action(async () => {
+  const { runSetup } = await import("./setup-YCFTG2KT.js");
   await runSetup();
 });
-program.command("serve").description("Start Loop MCP server (spawned by IDEs automatically)").action(async () => {
+program.command("serve").description("Start AgentCache MCP server (spawned by IDEs automatically)").action(async () => {
   const { startMcpServer } = await import("./mcp.js");
   await startMcpServer();
 });
 program.command("compile-session").description("Stop hook: queue transcript for compilation").action(async () => {
-  const { handleStop } = await import("./stop-DRL3LXFQ.js");
+  const { handleStop } = await import("./stop-6MKD743B.js");
   let payload;
   try {
     let data = "";
@@ -28,11 +28,11 @@ program.command("compile-session").description("Stop hook: queue transcript for
   await handleStop(payload);
 });
 program.command("discover").description("SessionStart hook: discover uncompiled transcripts").action(async () => {
-  const { handleSessionStart } = await import("./session-start-ILEPFZZC.js");
+  const { handleSessionStart } = await import("./session-start-BIY7CBXU.js");
   await handleSessionStart();
 });
 program.command("enforce").description("PreToolUse hook: policy enforcement").action(async () => {
-  const { handlePreToolUse } = await import("./pre-tool-use-2P5P6JWE.js");
+  const { handlePreToolUse } = await import("./pre-tool-use-TPCPTJXS.js");
   let data = "";
   for await (const chunk of process.stdin) {
     data += chunk;
@@ -45,10 +45,10 @@ program.command("enforce").description("PreToolUse hook: policy enforcement").ac
     process.stdout.write("{}");
   }
 });
-program.command("status").description("Show Loop knowledge stats").action(async () => {
-  const { getDbPath, isLoopInitialized, findProjectRoot, getProjectId, getProjectDisplayName } = await import("./paths-TWJ7GAJY.js");
-  if (!isLoopInitialized()) {
-    console.log("Loop not initialized. Run: agentcache setup");
+program.command("status").description("Show AgentCache knowledge stats").action(async () => {
+  const { getDbPath, isInitialized, findProjectRoot, getProjectId, getProjectDisplayName } = await import("./paths-LEZQCRKI.js");
+  if (!isInitialized()) {
+    console.log("AgentCache not initialized. Run: agentcache setup");
     return;
   }
   const { SqliteKnowledgeRepository } = await import("./sqlite-5V565IV3.js");
@@ -65,7 +65,7 @@ program.command("status").description("Show Loop knowledge stats").action(async
   const projectItems = items.filter((i) => i.scope === "project");
   const pending = repo.getPendingCount();
   repo.close();
-  console.log(`Loop \u2014 ${displayName} (${project})`);
+  console.log(`AgentCache \u2014 ${displayName} (${project})`);
   console.log(`  ${items.length} items (${globalItems.length} global, ${projectItems.length} project)`);
   console.log(`  ${rules.length} rules | ${lessons.length} lessons | ${decisions.length} decisions | ${context.length} context`);
   if (pending > 0) console.log(`  ${pending} sessions pending compilation`);

package/dist/mcp.js

@@ -1,16 +1,16 @@
 import {
   evaluatePolicy
-} from "./chunk-PYGRUQNL.js";
+} from "./chunk-T7BJPANN.js";
 import {
   parseTranscript
-} from "./chunk-QGG25FWV.js";
+} from "./chunk-OSFK44XC.js";
 import {
   findProjectRoot,
   getDbPath,
   getGitContext,
   getProjectId,
-  isLoopInitialized
-} from "./chunk-VPEEZXLK.js";
+  isInitialized
+} from "./chunk-WHP4Z32Z.js";
 import {
   SqliteKnowledgeRepository
 } from "./chunk-MMSMDJ4O.js";
@@ -528,7 +528,7 @@ function saveCompileRun(repo, sessionId, project, observationsProcessed, autoRei
 }
 function formatDiagnostics(extracted, autoReinforced, created, reinforced, superseded, deprecated, ignored, project, sessionId) {
   return [
-    `Loop Compiler v${COMPILER_VERSION}`,
+    `AgentCache Compiler v${COMPILER_VERSION}`,
     `Project: ${project} | Session: ${sessionId}`,
     `  ${extracted} observations processed`,
     autoReinforced > 0 ? `  ${autoReinforced} auto-reinforced (no LLM needed)` : "",
@@ -570,7 +570,7 @@ async function startMcpServer() {
     { name: "agentcache", version: "0.1.0" },
     {
       capabilities: { tools: {} },
-      instructions: "AgentCache is your knowledge cache. At the START of every session, call loop_inject_context to load compiled rules, lessons, decisions, and context. Submit observations INCREMENTALLY via loop_compile_submit as you learn them \u2014 do not wait until session end."
+      instructions: "AgentCache is your knowledge cache. At the START of every session, call agentcache_inject_context to load compiled rules, lessons, decisions, and context. Submit observations INCREMENTALLY via agentcache_compile_submit as you learn them \u2014 do not wait until session end."
     }
   );
   server.oninitialized = async () => {
@@ -582,7 +582,7 @@ async function startMcpServer() {
   server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: [
       {
-        name: "loop_inject_context",
+        name: "agentcache_inject_context",
         description: "Get compiled engineering knowledge for this project. Returns global rules/lessons (apply everywhere) + project-specific decisions/context. Call this at the START of every session.",
         inputSchema: {
           type: "object",
@@ -593,7 +593,7 @@ async function startMcpServer() {
         }
       },
       {
-        name: "loop_compile_submit",
+        name: "agentcache_compile_submit",
         description: "Submit observations extracted from your session. Call this INCREMENTALLY \u2014 each time you learn a rule, lesson, decision, or context item. Do NOT batch until end of session; sessions can terminate without warning.",
         inputSchema: {
           type: "object",
@@ -619,12 +619,12 @@ async function startMcpServer() {
         }
       },
       {
-        name: "loop_compile_cluster",
-        description: "Submit clustering decisions when loop_compile_submit returns needs_clustering. Determines whether observations create new knowledge or relate to existing items.",
+        name: "agentcache_compile_cluster",
+        description: "Submit clustering decisions when agentcache_compile_submit returns needs_clustering. Determines whether observations create new knowledge or relate to existing items.",
         inputSchema: {
           type: "object",
           properties: {
-            sessionId: { type: "string", description: "Session ID from loop_compile_submit response" },
+            sessionId: { type: "string", description: "Session ID from agentcache_compile_submit response" },
             clusters: {
               type: "array",
               items: {
@@ -644,8 +644,8 @@ async function startMcpServer() {
         }
       },
       {
-        name: "loop_compile_extract",
-        description: "For PREVIOUS sessions stored as transcript files. Reads a queued transcript and returns an extraction prompt for you to process. After processing, call loop_compile_submit with the results.",
+        name: "agentcache_compile_extract",
+        description: "For PREVIOUS sessions stored as transcript files. Reads a queued transcript and returns an extraction prompt for you to process. After processing, call agentcache_compile_submit with the results.",
         inputSchema: {
           type: "object",
           properties: {
@@ -655,8 +655,8 @@ async function startMcpServer() {
         }
       },
       {
-        name: "loop_enforce",
-        description: "Check if a tool call is allowed by Loop's policy rules. Call this BEFORE executing risky operations (file deletions, force pushes, etc). Returns allow or block with reason.",
+        name: "agentcache_enforce",
+        description: "Check if a tool call is allowed by AgentCache policy rules. Call this BEFORE executing risky operations (file deletions, force pushes, etc). Returns allow or block with reason.",
         inputSchema: {
           type: "object",
           properties: {
@@ -668,7 +668,7 @@ async function startMcpServer() {
         }
       },
       {
-        name: "loop_save_observation",
+        name: "agentcache_save_observation",
         description: "Save a single observation immediately with USER authority (never overwritten by compiler). Use for important rules or decisions that should persist permanently.",
         inputSchema: {
           type: "object",
@@ -683,8 +683,8 @@ async function startMcpServer() {
         }
       },
       {
-        name: "loop_get_knowledge",
-        description: "Query knowledge items from Loop's compiled database.",
+        name: "agentcache_get_knowledge",
+        description: "Query knowledge items from AgentCache knowledge database.",
         inputSchema: {
           type: "object",
           properties: {
@@ -697,7 +697,7 @@ async function startMcpServer() {
         }
       },
       {
-        name: "loop_deprecate_knowledge",
+        name: "agentcache_deprecate_knowledge",
         description: "Mark a knowledge item as deprecated. Use when a rule, lesson, or decision is no longer valid. Works on both auto-compiled and user-saved items.",
         inputSchema: {
           type: "object",
@@ -711,15 +711,15 @@ async function startMcpServer() {
     ]
   }));
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    if (!isLoopInitialized()) {
-      return { content: [{ type: "text", text: "Loop not initialized. Run: agentcache setup" }], isError: true };
+    if (!isInitialized()) {
+      return { content: [{ type: "text", text: "AgentCache not initialized. Run: agentcache setup" }], isError: true };
     }
     const repo = new SqliteKnowledgeRepository(getDbPath());
     const projectRoot = getResolvedProjectRoot();
     const detectedProject = getResolvedProjectId();
     try {
       switch (request.params.name) {
-        case "loop_inject_context": {
+        case "agentcache_inject_context": {
           const args = request.params.arguments || {};
           const project = args.project || detectedProject;
           const items = repo.getKnowledgeForContext(project);
@@ -740,17 +740,17 @@ async function startMcpServer() {
           if (context.length) {
             output += "# Context\n" + context.map((c) => `- ${c.content}`).join("\n") + "\n\n";
           }
-          if (!output) output = "No compiled knowledge yet. This will populate as you use Loop across sessions.\n";
+          if (!output) output = "No compiled knowledge yet. This will populate as you use AgentCache across sessions.\n";
           const pendingCount = repo.getPendingCount();
           if (pendingCount > 0) {
-            output = `<!-- ${pendingCount} previous session(s) pending compilation. Call loop_compile_extract to process. -->
+            output = `<!-- ${pendingCount} previous session(s) pending compilation. Call agentcache_compile_extract to process. -->
 
 ` + output;
           }
-          output += "\n---\nIMPORTANT: Submit observations incrementally as they happen during this session.\nWhen you learn something (rule, lesson, decision, context), call loop_compile_submit immediately.\nDo NOT wait until the end \u2014 sessions can terminate without warning.\n";
+          output += "\n---\nIMPORTANT: Submit observations incrementally as they happen during this session.\nWhen you learn something (rule, lesson, decision, context), call agentcache_compile_submit immediately.\nDo NOT wait until the end \u2014 sessions can terminate without warning.\n";
           return { content: [{ type: "text", text: output.trim() }] };
         }
-        case "loop_compile_submit": {
+        case "agentcache_compile_submit": {
           const args = request.params.arguments;
           const project = args.project || detectedProject;
           const sessionId = `sess_${randomUUID4().slice(0, 8)}`;
@@ -768,14 +768,14 @@ async function startMcpServer() {
             content: [{ type: "text", text: JSON.stringify({ status: "needs_clustering", sessionId: result.sessionId, clusteringContext: result.clusteringPrompt }) }]
           };
         }
-        case "loop_compile_cluster": {
+        case "agentcache_compile_cluster": {
           const args = request.params.arguments;
           const project = args.project || detectedProject;
           const responseText = JSON.stringify({ clusters: args.clusters });
           const result = processClustering(repo, responseText, args.sessionId, project, projectRoot);
           return { content: [{ type: "text", text: JSON.stringify({ status: "complete", diagnostics: result.diagnostics }) }] };
         }
-        case "loop_compile_extract": {
+        case "agentcache_compile_extract": {
           const args = request.params.arguments || {};
           const entry = repo.popPendingTranscript();
           if (!entry) {
@@ -793,14 +793,14 @@ async function startMcpServer() {
           const state = startCompile(events, sessionId, project, entry.projectRoot || projectRoot, repo, entry.transcriptPath);
           return { content: [{ type: "text", text: JSON.stringify({ sessionId: state.sessionId, prompt: state.prompt }) }] };
         }
-        case "loop_enforce": {
+        case "agentcache_enforce": {
           const args = request.params.arguments;
           const project = args.project || detectedProject;
           const input = { tool_name: args.tool_name, tool_input: args.tool_input || {} };
           const result = evaluatePolicy(input, repo.getEnforcedRules(project));
           return { content: [{ type: "text", text: JSON.stringify(result) }] };
         }
-        case "loop_save_observation": {
+        case "agentcache_save_observation": {
           const args = request.params.arguments;
           const project = args.project || detectedProject;
           const scope = args.scope || defaultScope(args.type);
@@ -849,7 +849,7 @@ async function startMcpServer() {
           });
           return { content: [{ type: "text", text: JSON.stringify({ saved: true, scope }) }] };
         }
-        case "loop_get_knowledge": {
+        case "agentcache_get_knowledge": {
           const args = request.params.arguments || {};
           const project = args.project || detectedProject;
           const items = repo.getKnowledgeItems(project, {
@@ -860,7 +860,7 @@ async function startMcpServer() {
           const summary = filtered.map((i) => `[${i.id}] [${i.scope}/${i.confidence}] (${i.type}) ${i.content}`).join("\n");
           return { content: [{ type: "text", text: summary || "No knowledge items found." }] };
         }
-        case "loop_deprecate_knowledge": {
+        case "agentcache_deprecate_knowledge": {
           const args = request.params.arguments;
           const item = repo.getKnowledgeItem(args.id);
           if (!item) {

package/dist/{paths-TWJ7GAJY.js → paths-LEZQCRKI.js}

@@ -2,20 +2,22 @@ import {
   findProjectRoot,
   getClaudeTranscriptsDir,
   getContinueSessionsDir,
+  getDataDir,
   getDbPath,
-  getGlobalLoopDir,
   getProjectDisplayName,
   getProjectId,
-  isLoopInitialized
-} from "./chunk-VPEEZXLK.js";
+  isInitialized,
+  migrateFromLegacy
+} from "./chunk-WHP4Z32Z.js";
 import "./chunk-MLKGABMK.js";
 export {
   findProjectRoot,
   getClaudeTranscriptsDir,
   getContinueSessionsDir,
+  getDataDir,
   getDbPath,
-  getGlobalLoopDir,
   getProjectDisplayName,
   getProjectId,
-  isLoopInitialized
+  isInitialized,
+  migrateFromLegacy
 };

package/dist/postinstall.js

@@ -2,11 +2,12 @@ import {
   detectInstalledIdes,
   registerClaudeHooks,
   registerMcpServer
-} from "./chunk-7FIT3LNA.js";
+} from "./chunk-LDQPTAZ7.js";
 import {
+  getDataDir,
   getDbPath,
-  getGlobalLoopDir
-} from "./chunk-VPEEZXLK.js";
+  migrateFromLegacy
+} from "./chunk-WHP4Z32Z.js";
 import {
   SqliteKnowledgeRepository
 } from "./chunk-MMSMDJ4O.js";
@@ -18,7 +19,8 @@ if (process.env.CI) {
   process.exit(0);
 }
 try {
-  mkdirSync(getGlobalLoopDir(), { recursive: true });
+  migrateFromLegacy();
+  mkdirSync(getDataDir(), { recursive: true });
   const repo = new SqliteKnowledgeRepository(getDbPath());
   repo.close();
   const ides = detectInstalledIdes().filter((i) => i.detected);

package/dist/{pre-tool-use-2P5P6JWE.js → pre-tool-use-TPCPTJXS.js}

@@ -1,12 +1,12 @@
 import {
   evaluatePolicy
-} from "./chunk-PYGRUQNL.js";
+} from "./chunk-T7BJPANN.js";
 import {
   findProjectRoot,
   getDbPath,
   getProjectId,
-  isLoopInitialized
-} from "./chunk-VPEEZXLK.js";
+  isInitialized
+} from "./chunk-WHP4Z32Z.js";
 import {
   SqliteKnowledgeRepository
 } from "./chunk-MMSMDJ4O.js";
@@ -14,7 +14,7 @@ import "./chunk-MLKGABMK.js";
 
 // src/hooks/pre-tool-use.ts
 function handlePreToolUse(input) {
-  if (!isLoopInitialized()) return {};
+  if (!isInitialized()) return {};
   const projectRoot = findProjectRoot();
   const repo = new SqliteKnowledgeRepository(getDbPath());
   try {

package/dist/{session-start-ILEPFZZC.js → session-start-BIY7CBXU.js}

@@ -1,12 +1,12 @@
 import {
   findAllClaudeTranscripts,
   findAllContinueTranscripts
-} from "./chunk-QGG25FWV.js";
+} from "./chunk-OSFK44XC.js";
 import {
   getDbPath,
   getProjectId,
-  isLoopInitialized
-} from "./chunk-VPEEZXLK.js";
+  isInitialized
+} from "./chunk-WHP4Z32Z.js";
 import {
   SqliteKnowledgeRepository
 } from "./chunk-MMSMDJ4O.js";
@@ -25,7 +25,7 @@ function inferProjectRootFromTranscriptPath(path) {
   return dir;
 }
 async function handleSessionStart() {
-  if (!isLoopInitialized()) return;
+  if (!isInitialized()) return;
   const repo = new SqliteKnowledgeRepository(getDbPath());
   const compiledPaths = new Set(repo.getAllCompiledTranscriptPaths());
   const allTranscripts = [

package/dist/{setup-C6PI6YD7.js → setup-YCFTG2KT.js}

@@ -2,11 +2,12 @@ import {
   detectInstalledIdes,
   registerClaudeHooks,
   registerMcpServer
-} from "./chunk-7FIT3LNA.js";
+} from "./chunk-LDQPTAZ7.js";
 import {
+  getDataDir,
   getDbPath,
-  getGlobalLoopDir
-} from "./chunk-VPEEZXLK.js";
+  migrateFromLegacy
+} from "./chunk-WHP4Z32Z.js";
 import {
   SqliteKnowledgeRepository
 } from "./chunk-MMSMDJ4O.js";
@@ -15,13 +16,14 @@ import "./chunk-MLKGABMK.js";
 // src/setup.ts
 import { mkdirSync } from "fs";
 async function runSetup() {
-  mkdirSync(getGlobalLoopDir(), { recursive: true });
+  migrateFromLegacy();
+  mkdirSync(getDataDir(), { recursive: true });
   const repo = new SqliteKnowledgeRepository(getDbPath());
   repo.close();
   const ides = detectInstalledIdes();
   const detected = ides.filter((i) => i.detected);
   console.log(`
-Loop setup complete.`);
+AgentCache setup complete.`);
   console.log(`  Central DB: ${getDbPath()}
 `);
   if (detected.length === 0) {
@@ -40,7 +42,7 @@ Loop setup complete.`);
   Claude Code hooks: registered (Stop, SessionStart, PreToolUse)`);
   }
   console.log(`
-Done. Loop compiles knowledge across all sessions and IDEs.`);
+Done. AgentCache compiles knowledge across all sessions and IDEs.`);
 }
 export {
   runSetup

package/dist/{stop-DRL3LXFQ.js → stop-6MKD743B.js}

@@ -1,12 +1,12 @@
 import {
   findLatestTranscript
-} from "./chunk-QGG25FWV.js";
+} from "./chunk-OSFK44XC.js";
 import {
   findProjectRoot,
   getDbPath,
   getProjectId,
-  isLoopInitialized
-} from "./chunk-VPEEZXLK.js";
+  isInitialized
+} from "./chunk-WHP4Z32Z.js";
 import {
   SqliteKnowledgeRepository
 } from "./chunk-MMSMDJ4O.js";
@@ -15,7 +15,7 @@ import "./chunk-MLKGABMK.js";
 // src/hooks/stop.ts
 import { randomUUID } from "crypto";
 async function handleStop(payload) {
-  if (!isLoopInitialized()) return;
+  if (!isInitialized()) return;
   const transcriptPath = payload?.transcript_path || findLatestTranscript();
   if (!transcriptPath) return;
   const repo = new SqliteKnowledgeRepository(getDbPath());

package/package.json

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

package/dist/chunk-7FIT3LNA.js

@@ -1,207 +0,0 @@
-// 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 rooDetected() {
-  return existsSync(getRooConfigPath());
-}
-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: rooDetected(),
-      mcpConfigPath: getRooConfigPath(),
-      mcpConfigFormat: "mcp-json"
-    },
-    {
-      name: "Windsurf",
-      detected: existsSync(join(home, ".windsurf")),
-      mcpConfigPath: join(home, ".windsurf", "mcp.json"),
-      mcpConfigFormat: "mcp-json"
-    },
-    {
-      name: "Continue",
-      detected: existsSync(join(home, ".continue")),
-      mcpConfigPath: join(home, ".continue", "mcp.json"),
-      mcpConfigFormat: "mcp-json"
-    },
-    {
-      name: "Codex",
-      detected: existsSync(join(home, ".codex")),
-      mcpConfigPath: join(home, ".codex", "mcp.json"),
-      mcpConfigFormat: "mcp-json"
-    }
-  ];
-}
-
-// src/utils/ide-registrar.ts
-import { existsSync as existsSync2, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { join as join2, dirname } from "path";
-import { homedir as homedir2 } from "os";
-import { execSync } from "child_process";
-function findNodeBinary() {
-  try {
-    return execSync("which node", { encoding: "utf-8" }).trim();
-  } catch {
-    return "node";
-  }
-}
-function findAgentcacheScript() {
-  try {
-    const binPath = execSync("which agentcache", { encoding: "utf-8" }).trim();
-    return binPath;
-  } catch {
-    return join2(dirname(dirname(__dirname)), "dist", "cli.js");
-  }
-}
-function isVscodeExtensionIde(ide) {
-  return ide.name === "Roo Code";
-}
-var ALL_TOOLS = [
-  "loop_inject_context",
-  "loop_compile_submit",
-  "loop_compile_cluster",
-  "loop_compile_extract",
-  "loop_enforce",
-  "loop_save_observation",
-  "loop_get_knowledge",
-  "loop_deprecate_knowledge"
-];
-function registerMcpServer(ide) {
-  if (!ide.detected) return false;
-  if (ide.mcpConfigFormat === "claude-settings") {
-    const claudeJsonPath = join2(homedir2(), ".claude.json");
-    let config = {};
-    if (existsSync2(claudeJsonPath)) {
-      try {
-        config = JSON.parse(readFileSync(claudeJsonPath, "utf-8"));
-      } catch {
-        config = {};
-      }
-    }
-    if (!config.mcpServers) config.mcpServers = {};
-    if (config.mcpServers.agentcache) return false;
-    config.mcpServers.agentcache = {
-      type: "stdio",
-      command: "agentcache",
-      args: ["serve"],
-      env: {}
-    };
-    writeFileSync(claudeJsonPath, JSON.stringify(config, null, 2));
-    const settingsPath = join2(homedir2(), ".claude", "settings.json");
-    if (existsSync2(join2(homedir2(), ".claude"))) {
-      let settings = {};
-      if (existsSync2(settingsPath)) {
-        try {
-          settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
-        } catch {
-          settings = {};
-        }
-      }
-      if (!settings.permissions) settings.permissions = {};
-      if (!settings.permissions.allow) settings.permissions.allow = [];
-      const allowList = settings.permissions.allow;
-      const mcpPerms = ALL_TOOLS.map((t) => `mcp__agentcache__${t}`);
-      for (const perm of mcpPerms) {
-        if (!allowList.includes(perm)) {
-          allowList.push(perm);
-        }
-      }
-      writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
-    }
-    return true;
-  }
-  if (ide.mcpConfigFormat === "mcp-json") {
-    let config = {};
-    if (existsSync2(ide.mcpConfigPath)) {
-      try {
-        config = JSON.parse(readFileSync(ide.mcpConfigPath, "utf-8"));
-      } catch {
-        config = {};
-      }
-    }
-    if (!config.mcpServers) config.mcpServers = {};
-    if (config.mcpServers.agentcache) return false;
-    if (isVscodeExtensionIde(ide)) {
-      const nodeBin = findNodeBinary();
-      const script = findAgentcacheScript();
-      config.mcpServers.agentcache = {
-        command: nodeBin,
-        args: [script, "serve"],
-        alwaysAllow: ALL_TOOLS,
-        disabled: false
-      };
-    } else {
-      config.mcpServers.agentcache = {
-        command: "agentcache",
-        args: ["serve"]
-      };
-    }
-    mkdirSync(dirname(ide.mcpConfigPath), { recursive: true });
-    writeFileSync(ide.mcpConfigPath, JSON.stringify(config, null, 2));
-    return true;
-  }
-  return false;
-}
-function registerClaudeHooks() {
-  const settingsPath = join2(homedir2(), ".claude", "settings.json");
-  if (!existsSync2(join2(homedir2(), ".claude"))) return false;
-  let settings = {};
-  if (existsSync2(settingsPath)) {
-    try {
-      settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
-    } catch {
-      settings = {};
-    }
-  }
-  if (!settings.hooks) settings.hooks = {};
-  const hooks = settings.hooks;
-  const loopHooks = {
-    Stop: [{ matcher: "", hooks: [{ type: "command", command: "agentcache compile-session" }] }],
-    SessionStart: [{ matcher: "", hooks: [{ type: "command", command: "agentcache discover" }] }],
-    PreToolUse: [{ matcher: "", hooks: [{ type: "command", command: "agentcache enforce" }] }]
-  };
-  let registered = false;
-  for (const [event, hookConfig] of Object.entries(loopHooks)) {
-    if (!hooks[event]) hooks[event] = [];
-    const existing = hooks[event];
-    const hasLoop = existing.some((h) => h.hooks?.some((hh) => hh.command?.includes("agentcache")));
-    if (!hasLoop) {
-      hooks[event].push(...hookConfig);
-      registered = true;
-    }
-  }
-  if (registered) {
-    writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
-  }
-  return registered;
-}
-
-export {
-  detectInstalledIdes,
-  registerMcpServer,
-  registerClaudeHooks
-};