agentcache 0.4.2 → 0.5.0-beta.1

package/dist/{chunk-T4COG3XD.js → chunk-R5I6WWSD.js}

@@ -5,27 +5,39 @@ import { homedir } from "os";
 import { createHash } from "crypto";
 
 // src/utils/git.ts
-import { execSync } from "child_process";
-function run(cmd, cwd) {
+import { execFileSync } from "child_process";
+import { realpathSync } from "fs";
+import { isAbsolute, resolve } from "path";
+function run(args, cwd) {
   try {
-    return execSync(cmd, { cwd, encoding: "utf-8", timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] }).trim();
+    return execFileSync("git", args, {
+      cwd,
+      encoding: "utf-8",
+      timeout: 5e3,
+      stdio: ["ignore", "pipe", "pipe"]
+    }).trim();
   } catch {
     return "";
   }
 }
-function getGitContext(projectRoot) {
-  const empty = { branch: "", commit: "", recentCommits: [], modifiedFiles: [] };
-  if (!run("git rev-parse --git-dir", projectRoot)) return empty;
-  const branch = run("git rev-parse --abbrev-ref HEAD", projectRoot);
-  const commit = run("git rev-parse --short HEAD", projectRoot);
-  const recentCommits = run("git log --oneline -10", projectRoot).split("\n").filter(Boolean);
-  const modifiedFiles = run("git diff --name-only HEAD~5 HEAD", projectRoot).split("\n").filter(Boolean);
-  return { branch, commit, recentCommits, modifiedFiles };
-}
 function getGitRoot(cwd) {
-  const root = run("git rev-parse --show-toplevel", cwd);
+  const root = run(["rev-parse", "--show-toplevel"], cwd);
   return root || null;
 }
+function getGitRemote(cwd) {
+  const remote = run(["config", "--get", "remote.origin.url"], cwd);
+  return remote || null;
+}
+function getGitCommonDir(cwd) {
+  const commonDir = run(["rev-parse", "--git-common-dir"], cwd);
+  if (!commonDir) return null;
+  const absolute = isAbsolute(commonDir) ? commonDir : resolve(cwd, commonDir);
+  try {
+    return realpathSync.native(absolute);
+  } catch {
+    return null;
+  }
+}
 
 // src/utils/paths.ts
 function getDataDir() {
@@ -34,6 +46,9 @@ function getDataDir() {
 function getDbPath() {
   return join(getDataDir(), "agentcache.db");
 }
+function getSessionDbPath() {
+  return join(getDataDir(), "agentcache-v2.db");
+}
 function isInitialized() {
   return existsSync(getDbPath());
 }
@@ -66,10 +81,12 @@ function getContinueSessionsDir() {
 }
 
 export {
-  getGitContext,
   getGitRoot,
+  getGitRemote,
+  getGitCommonDir,
   getDataDir,
   getDbPath,
+  getSessionDbPath,
   isInitialized,
   migrateFromLegacy,
   findProjectRoot,

package/dist/chunk-RXGW4Q3G.js

@@ -0,0 +1,109 @@
+// src/utils/ide-detector.ts
+import { existsSync } from "fs";
+import { dirname, join, posix, win32 } from "path";
+import { homedir } from "os";
+function getRooConfigPath(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(home = homedir()) {
+  return join(home, ".codeium", "windsurf", "mcp_config.json");
+}
+function getContinueConfigPath(home = homedir()) {
+  return join(home, ".continue", "mcpServers", "agentcache.json");
+}
+function getCodexConfigPath(home = homedir()) {
+  return join(home, ".codex", "config.toml");
+}
+function resolveGooseConfigPath(options = {}) {
+  const platform = options.platform ?? process.platform;
+  const env = options.env ?? process.env;
+  const home = options.home ?? homedir();
+  const path = platform === "win32" ? win32 : posix;
+  if (env.GOOSE_PATH_ROOT !== void 0) {
+    return path.join(env.GOOSE_PATH_ROOT, "config", "config.yaml");
+  }
+  if (platform !== "win32" && env.XDG_CONFIG_HOME && path.isAbsolute(env.XDG_CONFIG_HOME)) {
+    return path.join(env.XDG_CONFIG_HOME, "goose", "config.yaml");
+  }
+  if (platform === "win32") {
+    return path.join(
+      env.APPDATA || path.join(home, "AppData", "Roaming"),
+      "Block",
+      "goose",
+      "config",
+      "config.yaml"
+    );
+  }
+  return path.join(home, ".config", "goose", "config.yaml");
+}
+function detectInstalledIdes(homeDirectory = homedir()) {
+  const home = homeDirectory;
+  const legacyRooConfigPath = join(home, ".roo", "mcp.json");
+  const gooseConfigPath = resolveGooseConfigPath({ home });
+  return [
+    {
+      adapterId: "claude-code",
+      name: "Claude Code",
+      detected: existsSync(join(home, ".claude")),
+      mcpConfigPath: join(home, ".claude.json"),
+      mcpConfigFormat: "claude-settings"
+    },
+    {
+      adapterId: "cursor",
+      name: "Cursor",
+      detected: existsSync(join(home, ".cursor")),
+      mcpConfigPath: join(home, ".cursor", "mcp.json"),
+      mcpConfigFormat: "mcp-json"
+    },
+    {
+      adapterId: "roo-code",
+      name: "Roo Code",
+      detected: existsSync(getRooConfigPath(home)) || existsSync(legacyRooConfigPath),
+      mcpConfigPath: getRooConfigPath(home),
+      legacyMcpConfigPaths: [legacyRooConfigPath],
+      mcpConfigFormat: "mcp-json"
+    },
+    {
+      adapterId: "windsurf",
+      name: "Windsurf",
+      detected: existsSync(join(home, ".codeium", "windsurf")) || existsSync(join(home, ".windsurf")),
+      mcpConfigPath: getWindsurfConfigPath(home),
+      legacyMcpConfigPaths: [join(home, ".windsurf", "mcp.json")],
+      mcpConfigFormat: "mcp-json"
+    },
+    {
+      adapterId: "continue",
+      name: "Continue",
+      detected: existsSync(join(home, ".continue")),
+      mcpConfigPath: getContinueConfigPath(home),
+      legacyMcpConfigPaths: [join(home, ".continue", "mcp.json")],
+      mcpConfigFormat: "continue-dir"
+    },
+    {
+      adapterId: "codex",
+      name: "Codex",
+      detected: existsSync(join(home, ".codex")),
+      mcpConfigPath: getCodexConfigPath(home),
+      legacyMcpConfigPaths: [join(home, ".codex", "mcp.json")],
+      mcpConfigFormat: "codex-toml"
+    },
+    {
+      adapterId: "goose",
+      name: "Goose",
+      detected: existsSync(dirname(gooseConfigPath)),
+      mcpConfigPath: gooseConfigPath,
+      mcpConfigFormat: "goose-yaml"
+    }
+  ];
+}
+
+export {
+  resolveGooseConfigPath,
+  detectInstalledIdes
+};

package/dist/chunk-XRJ6QW6N.js

@@ -0,0 +1,92 @@
+import {
+  getDataDir
+} from "./chunk-R5I6WWSD.js";
+
+// src/utils/device-id.ts
+import { randomBytes as nodeRandomBytes } from "crypto";
+import {
+  chmodSync,
+  closeSync,
+  constants,
+  existsSync,
+  fsyncSync,
+  linkSync,
+  lstatSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { join } from "path";
+var DEVICE_ID_FILE = "device-id";
+var DEVICE_ID_PATTERN = /^dev_[A-Za-z0-9_-]{32}$/;
+function loadOrCreateDeviceId(options = {}) {
+  const dataDir = options.dataDir ?? getDataDir();
+  const devicePath = join(dataDir, DEVICE_ID_FILE);
+  mkdirSync(dataDir, { recursive: true, mode: 448 });
+  const directoryStat = lstatSync(dataDir);
+  if (directoryStat.isSymbolicLink()) {
+    throw new Error("AgentCache data directory must not be a symbolic link");
+  }
+  if (!directoryStat.isDirectory()) {
+    throw new Error("AgentCache data directory must be a directory");
+  }
+  chmodSync(dataDir, 448);
+  if (existsSync(devicePath)) return readStoredDeviceId(devicePath);
+  const random = options.randomBytes ?? (() => nodeRandomBytes(24));
+  const deviceId = `dev_${random().toString("base64url")}`;
+  if (!DEVICE_ID_PATTERN.test(deviceId)) {
+    throw new Error("Generated AgentCache device identity is malformed");
+  }
+  const temporaryPath = join(
+    dataDir,
+    `.device-id.${process.pid}.${nodeRandomBytes(8).toString("hex")}.tmp`
+  );
+  let descriptor;
+  try {
+    descriptor = openSync(
+      temporaryPath,
+      constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY,
+      384
+    );
+    writeFileSync(descriptor, `${deviceId}
+`, "utf8");
+    fsyncSync(descriptor);
+    closeSync(descriptor);
+    descriptor = void 0;
+    try {
+      linkSync(temporaryPath, devicePath);
+    } catch (error) {
+      if (!isAlreadyExists(error)) throw error;
+    }
+  } finally {
+    if (descriptor !== void 0) closeSync(descriptor);
+    try {
+      unlinkSync(temporaryPath);
+    } catch {
+    }
+  }
+  return readStoredDeviceId(devicePath);
+}
+function readStoredDeviceId(devicePath) {
+  const stat = lstatSync(devicePath);
+  if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 256) {
+    throw new Error("Stored AgentCache device identity is malformed");
+  }
+  chmodSync(devicePath, 384);
+  const value = readFileSync(devicePath, "utf8").trim();
+  if (!DEVICE_ID_PATTERN.test(value)) {
+    throw new Error("Stored AgentCache device identity is malformed");
+  }
+  return value;
+}
+function isAlreadyExists(error) {
+  return Boolean(
+    error && typeof error === "object" && "code" in error && error.code === "EEXIST"
+  );
+}
+
+export {
+  loadOrCreateDeviceId
+};