agentcache 0.1.2 → 0.1.4

package/README.md

@@ -133,17 +133,25 @@ 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).

package/dist/chunk-MKQKD2PY.js

@@ -0,0 +1,273 @@
+// 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 = [
+  "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") {
+    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 = {};
+  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;
+}
+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 = {};
+  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 {
+    const agentcacheBin = findAgentcacheScript();
+    config.mcpServers.agentcache = {
+      command: agentcacheBin,
+      args: ["serve"]
+    };
+  }
+  mkdirSync(dirname(ide.mcpConfigPath), { recursive: true });
+  writeFileSync(ide.mcpConfigPath, JSON.stringify(config, null, 2));
+  return true;
+}
+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 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
+};

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.0");
 program.command("setup").description("Detect IDEs and register Loop (runs automatically on install)").action(async () => {
-  const { runSetup } = await import("./setup-5Z5AHD2U.js");
+  const { runSetup } = await import("./setup-YHD2FO4N.js");
   await runSetup();
 });
 program.command("serve").description("Start Loop MCP server (spawned by IDEs automatically)").action(async () => {

package/dist/postinstall.js

@@ -2,7 +2,7 @@ import {
   detectInstalledIdes,
   registerClaudeHooks,
   registerMcpServer
-} from "./chunk-LYEV4B2E.js";
+} from "./chunk-MKQKD2PY.js";
 import {
   getDbPath,
   getGlobalLoopDir

package/dist/{setup-5Z5AHD2U.js → setup-YHD2FO4N.js}

@@ -2,7 +2,7 @@ import {
   detectInstalledIdes,
   registerClaudeHooks,
   registerMcpServer
-} from "./chunk-LYEV4B2E.js";
+} from "./chunk-MKQKD2PY.js";
 import {
   getDbPath,
   getGlobalLoopDir

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "agentcache",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Knowledge cache for AI agents — learns how you work, remembers across sessions, works everywhere",
   "type": "module",
   "license": "MIT",
   "author": "a21.ai",
   "repository": {
     "type": "git",
-    "url": "https://github.com/raghav-a21ai/loop-eng"
+    "url": "https://github.com/raghav-a21ai/agentcache"
   },
-  "homepage": "https://github.com/raghav-a21ai/loop-eng#readme",
+  "homepage": "https://github.com/raghav-a21ai/agentcache#readme",
   "keywords": [
     "ai",
     "mcp",

package/dist/chunk-LYEV4B2E.js

@@ -1,135 +0,0 @@
-// src/utils/ide-detector.ts
-import { existsSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
-function detectInstalledIdes() {
-  const home = homedir();
-  return [
-    {
-      name: "Claude Code",
-      detected: existsSync(join(home, ".claude")),
-      mcpConfigPath: join(home, ".claude", "settings.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(join(home, ".roo")),
-      mcpConfigPath: join(home, ".roo", "mcp.json"),
-      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";
-var MCP_ENTRY_STDIO = {
-  type: "stdio",
-  command: "agentcache",
-  args: ["serve"],
-  env: {}
-};
-var MCP_ENTRY_SIMPLE = {
-  command: "agentcache",
-  args: ["serve"]
-};
-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 = MCP_ENTRY_STDIO;
-    writeFileSync(claudeJsonPath, JSON.stringify(config, 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;
-    config.mcpServers.agentcache = MCP_ENTRY_SIMPLE;
-    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
-};