agentcache 0.4.2 → 0.5.0-beta.2

package/dist/compile-all-PTWTZVP5.js

@@ -1,495 +0,0 @@
-import {
-  processClustering,
-  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-WTXSZBQE.js";
-import {
-  getDbPath,
-  getGitRoot,
-  getProjectId,
-  isInitialized
-} from "./chunk-T4COG3XD.js";
-import {
-  __esm,
-  __export,
-  __require,
-  __toCommonJS
-} from "./chunk-KFQGP6VL.js";
-
-// src/utils/transcript-parsers/goose-sqlite.ts
-var goose_sqlite_exports = {};
-__export(goose_sqlite_exports, {
-  canParse: () => canParse,
-  getGooseDbPath: () => getGooseDbPath2,
-  hasGooseSessions: () => hasGooseSessions,
-  parse: () => parse,
-  parseSession: () => parseSession
-});
-import { existsSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
-function canParse(path) {
-  return path.endsWith("goose-sessions.db") || path.includes("goose/sessions/sessions.db");
-}
-function getGooseDbPath2() {
-  return join(homedir(), ".local", "share", "goose", "sessions", "sessions.db");
-}
-function hasGooseSessions() {
-  return existsSync(getGooseDbPath2());
-}
-function parseSession(db, sessionId) {
-  const events = [];
-  const rows = db.prepare("SELECT role, content_json FROM messages WHERE session_id = ? ORDER BY created_timestamp ASC").all(sessionId);
-  for (const row of rows) {
-    try {
-      const content = JSON.parse(row.content_json);
-      if (!Array.isArray(content)) continue;
-      for (const block of content) {
-        if (row.role === "user" && block.type === "text" && block.text) {
-          events.push({ type: "message", role: "user", content: block.text });
-        } else if (row.role === "assistant" && block.type === "text" && block.text) {
-          events.push({ type: "message", role: "assistant", content: block.text });
-        } else if (row.role === "assistant" && block.type === "toolRequest") {
-          events.push({
-            type: "tool_use",
-            tool_name: block.toolCall?.value?.name || "unknown",
-            tool_input: block.toolCall?.value?.arguments ? { arguments: block.toolCall.value.arguments } : {}
-          });
-        }
-      }
-    } catch {
-      continue;
-    }
-  }
-  return events;
-}
-function parse(_path) {
-  return [];
-}
-var init_goose_sqlite = __esm({
-  "src/utils/transcript-parsers/goose-sqlite.ts"() {
-    "use strict";
-  }
-});
-
-// src/compile-all.ts
-import { spawnSync } from "child_process";
-import { existsSync as existsSync2, writeFileSync, unlinkSync } from "fs";
-import { tmpdir } from "os";
-import { join as join2, dirname } from "path";
-import { randomUUID } from "crypto";
-function detectBackend() {
-  const backends = [
-    {
-      cmd: "claude",
-      name: "Claude Code",
-      buildInvoke: () => (prompt) => {
-        const result = spawnSync("claude", ["-p", "-", "--output-format", "text"], {
-          input: prompt,
-          encoding: "utf-8",
-          timeout: 12e4,
-          maxBuffer: 10 * 1024 * 1024
-        });
-        return result.status === 0 ? result.stdout : null;
-      }
-    },
-    {
-      cmd: "codex",
-      name: "Codex",
-      buildInvoke: () => (prompt) => {
-        const tmpFile = join2(tmpdir(), `agentcache-prompt-${Date.now()}.txt`);
-        writeFileSync(tmpFile, prompt);
-        const result = spawnSync("codex", ["exec", "-", "--skip-git-repo-check"], {
-          input: prompt,
-          encoding: "utf-8",
-          timeout: 12e4,
-          maxBuffer: 10 * 1024 * 1024
-        });
-        try {
-          unlinkSync(tmpFile);
-        } catch {
-        }
-        return result.status === 0 ? result.stdout : null;
-      }
-    },
-    {
-      cmd: "gemini",
-      name: "Gemini CLI",
-      buildInvoke: () => (prompt) => {
-        const result = spawnSync("gemini", ["-p", "-"], {
-          input: prompt,
-          encoding: "utf-8",
-          timeout: 12e4,
-          maxBuffer: 10 * 1024 * 1024
-        });
-        return result.status === 0 ? result.stdout : null;
-      }
-    },
-    {
-      cmd: "copilot",
-      name: "Copilot CLI",
-      buildInvoke: () => (prompt) => {
-        const result = spawnSync("copilot", ["-p", "-"], {
-          input: prompt,
-          encoding: "utf-8",
-          timeout: 12e4,
-          maxBuffer: 10 * 1024 * 1024
-        });
-        return result.status === 0 ? result.stdout : null;
-      }
-    },
-    {
-      cmd: "aider",
-      name: "Aider",
-      buildInvoke: () => (prompt) => {
-        const tmpFile = join2(tmpdir(), `agentcache-prompt-${Date.now()}.txt`);
-        writeFileSync(tmpFile, prompt);
-        const result = spawnSync("aider", ["--message-file", tmpFile, "--yes", "--no-stream", "--no-git"], {
-          encoding: "utf-8",
-          timeout: 12e4,
-          maxBuffer: 10 * 1024 * 1024
-        });
-        try {
-          unlinkSync(tmpFile);
-        } catch {
-        }
-        return result.status === 0 ? result.stdout : null;
-      }
-    },
-    {
-      cmd: "goose",
-      name: "Goose",
-      buildInvoke: () => (prompt) => {
-        const tmpFile = join2(tmpdir(), `agentcache-prompt-${Date.now()}.txt`);
-        writeFileSync(tmpFile, prompt);
-        const result = spawnSync("goose", ["run", "--instructions", tmpFile], {
-          encoding: "utf-8",
-          timeout: 12e4,
-          maxBuffer: 10 * 1024 * 1024
-        });
-        try {
-          unlinkSync(tmpFile);
-        } catch {
-        }
-        return result.status === 0 ? result.stdout : null;
-      }
-    }
-  ];
-  for (const b of backends) {
-    try {
-      const which = spawnSync("which", [b.cmd], { encoding: "utf-8" });
-      if (which.status === 0 && which.stdout.trim()) {
-        return { name: b.name, invoke: b.buildInvoke() };
-      }
-    } catch {
-    }
-  }
-  try {
-    const ollamaCheck = spawnSync("curl", ["-s", "http://localhost:11434/api/tags"], {
-      encoding: "utf-8",
-      timeout: 3e3
-    });
-    if (ollamaCheck.status === 0 && ollamaCheck.stdout.includes("models")) {
-      const models = JSON.parse(ollamaCheck.stdout)?.models || [];
-      const model = models.find((m) => /qwen|llama|mistral|gemma/i.test(m.name))?.name || models[0]?.name;
-      if (model) {
-        return {
-          name: `Ollama (${model})`,
-          invoke: (prompt) => {
-            const result = spawnSync("curl", [
-              "-s",
-              "http://localhost:11434/api/generate",
-              "-d",
-              JSON.stringify({ model, prompt, stream: false })
-            ], { encoding: "utf-8", timeout: 12e4, maxBuffer: 10 * 1024 * 1024 });
-            if (result.status !== 0) return null;
-            try {
-              return JSON.parse(result.stdout)?.response || null;
-            } catch {
-              return null;
-            }
-          }
-        };
-      }
-    }
-  } catch {
-  }
-  const anthropicKey = process.env.ANTHROPIC_API_KEY;
-  if (anthropicKey) {
-    return {
-      name: "Anthropic API (env)",
-      invoke: (prompt) => {
-        const result = spawnSync("curl", [
-          "-s",
-          "https://api.anthropic.com/v1/messages",
-          "-H",
-          "content-type: application/json",
-          "-H",
-          `x-api-key: ${anthropicKey}`,
-          "-H",
-          "anthropic-version: 2023-06-01",
-          "-d",
-          JSON.stringify({
-            model: "claude-sonnet-4-20250514",
-            max_tokens: 4096,
-            messages: [{ role: "user", content: prompt }]
-          })
-        ], { encoding: "utf-8", timeout: 12e4, maxBuffer: 10 * 1024 * 1024 });
-        if (result.status !== 0) return null;
-        try {
-          return JSON.parse(result.stdout)?.content?.[0]?.text || null;
-        } catch {
-          return null;
-        }
-      }
-    };
-  }
-  const openaiKey = process.env.OPENAI_API_KEY;
-  if (openaiKey) {
-    return {
-      name: "OpenAI API (env)",
-      invoke: (prompt) => {
-        const result = spawnSync("curl", [
-          "-s",
-          "https://api.openai.com/v1/chat/completions",
-          "-H",
-          "content-type: application/json",
-          "-H",
-          `Authorization: Bearer ${openaiKey}`,
-          "-d",
-          JSON.stringify({
-            model: "gpt-4o-mini",
-            messages: [{ role: "user", content: prompt }]
-          })
-        ], { encoding: "utf-8", timeout: 12e4, maxBuffer: 10 * 1024 * 1024 });
-        if (result.status !== 0) return null;
-        try {
-          return JSON.parse(result.stdout)?.choices?.[0]?.message?.content || null;
-        } catch {
-          return null;
-        }
-      }
-    };
-  }
-  return null;
-}
-function discoverAllTranscripts(repo) {
-  const compiledPaths = new Set(repo.getAllCompiledTranscriptPaths());
-  const results = [];
-  const allPaths = [
-    ...findAllClaudeTranscripts(),
-    ...findAllCursorTranscripts(),
-    ...findAllContinueTranscripts(),
-    ...findAllCodexTranscripts(),
-    ...findAllRooCodeTranscripts()
-  ];
-  for (const path of allPaths) {
-    if (compiledPaths.has(path)) continue;
-    const projectRoot = inferProjectRoot(path);
-    const project = getProjectId(projectRoot);
-    results.push({ path, project, projectRoot });
-  }
-  return results;
-}
-function inferProjectRoot(transcriptPath) {
-  if (transcriptPath.includes(".claude/projects/")) {
-    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) {
-      const filePath = extractFilePath(event);
-      if (filePath) {
-        const root = getGitRoot(dirname(filePath));
-        if (root) return root;
-        return dirname(filePath);
-      }
-    }
-  } catch {
-  }
-  return process.cwd();
-}
-function extractFilePath(event) {
-  if (event.tool_input) {
-    for (const val of Object.values(event.tool_input)) {
-      if (typeof val === "string" && val.startsWith("/") && val.includes("/") && !val.includes(" ")) {
-        return val;
-      }
-    }
-  }
-  return null;
-}
-function processOneTranscript(repo, path, project, projectRoot, backend) {
-  const events = parseTranscript(path);
-  if (events.length < 3) return { created: 0, reinforced: 0, skipped: true };
-  const sessionId = `sess_${randomUUID().slice(0, 8)}`;
-  const state = startCompile(events, sessionId, project, projectRoot, repo);
-  const extractionResponse = backend.invoke(state.prompt);
-  if (!extractionResponse) return { created: 0, reinforced: 0, skipped: true };
-  const extractResult = processExtraction(repo, extractionResponse, sessionId, project, projectRoot);
-  repo.updateSessionTranscriptPath(sessionId, path);
-  if (extractResult.status === "complete") {
-    return { created: 0, reinforced: 0, skipped: false };
-  }
-  const clusterResponse = backend.invoke(extractResult.clusteringPrompt);
-  if (!clusterResponse) return { created: 0, reinforced: 0, skipped: false };
-  const clusterResult = processClustering(repo, clusterResponse, sessionId, project, projectRoot);
-  const diag = clusterResult.diagnostics;
-  const createdMatch = diag.match(/(\d+) new knowledge/);
-  const reinforcedMatch = diag.match(/(\d+) reinforced/);
-  return {
-    created: createdMatch ? parseInt(createdMatch[1]) : 0,
-    reinforced: reinforcedMatch ? parseInt(reinforcedMatch[1]) : 0,
-    skipped: false
-  };
-}
-function processGooseSessions(repo, backend) {
-  const dbPath = getGooseDbPath();
-  if (!existsSync2(dbPath)) return { processed: 0, created: 0 };
-  let Database;
-  try {
-    Database = __require("better-sqlite3");
-  } catch {
-    return { processed: 0, created: 0 };
-  }
-  const gooseDb = new Database(dbPath, { readonly: true });
-  const compiledPaths = new Set(repo.getAllCompiledTranscriptPaths());
-  const sessions = gooseDb.prepare("SELECT id, working_dir FROM sessions").all();
-  let processed = 0;
-  let totalCreated = 0;
-  for (const session of sessions) {
-    const markerPath = `goose:${session.id}`;
-    if (compiledPaths.has(markerPath)) continue;
-    const { parseSession: parseSession2 } = (init_goose_sqlite(), __toCommonJS(goose_sqlite_exports));
-    const events = parseSession2(gooseDb, session.id);
-    if (events.length < 3) continue;
-    const projectRoot = session.working_dir || process.cwd();
-    const project = getProjectId(projectRoot);
-    const sessionId = `sess_${randomUUID().slice(0, 8)}`;
-    const state = startCompile(events, sessionId, project, projectRoot, repo);
-    const extractionResponse = backend.invoke(state.prompt);
-    if (!extractionResponse) continue;
-    const extractResult = processExtraction(repo, extractionResponse, sessionId, project, projectRoot);
-    repo.updateSessionTranscriptPath(sessionId, markerPath);
-    if (extractResult.status === "needs_clustering") {
-      const clusterResponse = backend.invoke(extractResult.clusteringPrompt);
-      if (clusterResponse) {
-        processClustering(repo, clusterResponse, sessionId, project, projectRoot);
-      }
-    }
-    processed++;
-    totalCreated++;
-  }
-  gooseDb.close();
-  return { processed, created: totalCreated };
-}
-async function runCompileAll() {
-  if (!isInitialized()) {
-    console.error("AgentCache not initialized. Run: npm install -g agentcache");
-    process.exit(1);
-  }
-  if (!acquireLock()) {
-    console.error("Another compile-all process is already running. Exiting.");
-    process.exit(0);
-  }
-  process.on("exit", releaseLock);
-  process.on("SIGINT", () => {
-    releaseLock();
-    process.exit(130);
-  });
-  process.on("SIGTERM", () => {
-    releaseLock();
-    process.exit(143);
-  });
-  const backend = detectBackend();
-  if (!backend) {
-    releaseLock();
-    console.error("No LLM backend found. Install one of: claude, codex, gemini, copilot, aider, goose");
-    process.exit(1);
-  }
-  console.log(`AgentCache compile-all`);
-  console.log(`LLM backend: ${backend.name}`);
-  console.log("");
-  const repo = new SqliteKnowledgeRepository(getDbPath());
-  const transcripts = discoverAllTranscripts(repo);
-  const gooseAvailable = existsSync2(getGooseDbPath());
-  const total = transcripts.length + (gooseAvailable ? 1 : 0);
-  if (total === 0 && !gooseAvailable) {
-    console.log("No uncompiled transcripts found. Knowledge is up to date.");
-    repo.close();
-    return;
-  }
-  const estimatedMinutes = Math.ceil(transcripts.length * 0.7);
-  console.log(`Found ${transcripts.length} transcripts to process`);
-  if (gooseAvailable) console.log(`+ Goose sessions available`);
-  console.log(`Estimated time: ~${estimatedMinutes} minutes`);
-  console.log(`Started: ${(/* @__PURE__ */ new Date()).toLocaleTimeString()}`);
-  console.log("\u2500".repeat(50));
-  let processed = 0;
-  let totalCreated = 0;
-  let totalReinforced = 0;
-  let errors = 0;
-  for (const t of transcripts) {
-    processed++;
-    const label = t.path.split("/").slice(-2).join("/");
-    process.stdout.write(`[${processed}/${transcripts.length}] ${label.slice(0, 40)}... `);
-    try {
-      const result = processOneTranscript(repo, t.path, t.project, t.projectRoot, backend);
-      if (result.skipped) {
-        console.log("skipped");
-      } else {
-        totalCreated += result.created;
-        totalReinforced += result.reinforced;
-        console.log(`+${result.created} new, ${result.reinforced} reinforced`);
-      }
-    } catch (err) {
-      errors++;
-      console.log(`error: ${err.message?.slice(0, 50)}`);
-    }
-  }
-  if (gooseAvailable) {
-    process.stdout.write("Processing Goose sessions... ");
-    try {
-      const gooseResult = processGooseSessions(repo, backend);
-      console.log(`${gooseResult.processed} sessions processed`);
-    } catch (err) {
-      console.log(`error: ${err.message?.slice(0, 50)}`);
-    }
-  }
-  repo.close();
-  console.log("\u2500".repeat(50));
-  console.log(`Done: ${(/* @__PURE__ */ new Date()).toLocaleTimeString()}`);
-  console.log(`  ${processed} transcripts processed`);
-  console.log(`  ${totalCreated} knowledge items created`);
-  console.log(`  ${totalReinforced} reinforced`);
-  if (errors > 0) console.log(`  ${errors} errors`);
-}
-export {
-  runCompileAll
-};

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

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

package/dist/pre-tool-use-A4AJHZOJ.js

@@ -1,30 +0,0 @@
-import {
-  evaluatePolicy
-} from "./chunk-T7BJPANN.js";
-import {
-  SqliteKnowledgeRepository
-} from "./chunk-PSASDZQE.js";
-import {
-  findProjectRoot,
-  getDbPath,
-  getProjectId,
-  isInitialized
-} from "./chunk-T4COG3XD.js";
-import "./chunk-KFQGP6VL.js";
-
-// src/hooks/pre-tool-use.ts
-function handlePreToolUse(input) {
-  if (!isInitialized()) return {};
-  const projectRoot = findProjectRoot();
-  const repo = new SqliteKnowledgeRepository(getDbPath());
-  try {
-    const project = getProjectId(projectRoot);
-    const enforcedRules = repo.getEnforcedRules(project);
-    return evaluatePolicy(input, enforcedRules);
-  } finally {
-    repo.close();
-  }
-}
-export {
-  handlePreToolUse
-};

package/dist/session-start-DGMGEAJU.js

@@ -1,78 +0,0 @@
-import {
-  SqliteKnowledgeRepository
-} from "./chunk-PSASDZQE.js";
-import {
-  findAllClaudeTranscripts,
-  findAllCodexTranscripts,
-  findAllContinueTranscripts,
-  findAllCursorTranscripts,
-  findAllRooCodeTranscripts
-} from "./chunk-WTXSZBQE.js";
-import {
-  getDbPath,
-  getProjectId,
-  isInitialized
-} from "./chunk-T4COG3XD.js";
-import "./chunk-KFQGP6VL.js";
-
-// src/hooks/session-start.ts
-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("-")) {
-    return slug.replace(/-/g, "/");
-  }
-  return dir;
-}
-async function handleSessionStart() {
-  if (!isInitialized()) return;
-  const repo = new SqliteKnowledgeRepository(getDbPath());
-  const compiledPaths = new Set(repo.getAllCompiledTranscriptPaths());
-  const allTranscripts = [
-    ...findAllClaudeTranscripts(),
-    ...findAllCursorTranscripts(),
-    ...findAllContinueTranscripts(),
-    ...findAllCodexTranscripts(),
-    ...findAllRooCodeTranscripts()
-  ];
-  const oneMinuteAgo = Date.now() - 6e4;
-  const uncompiled = allTranscripts.filter((path) => {
-    if (compiledPaths.has(path)) return false;
-    try {
-      return statSync(path).mtimeMs < oneMinuteAgo;
-    } catch {
-      return false;
-    }
-  });
-  if (uncompiled.length === 0) {
-    repo.close();
-    return;
-  }
-  for (const path of uncompiled) {
-    const projectRoot = inferProjectRootFromTranscriptPath(path);
-    const project = getProjectId(projectRoot);
-    repo.queueTranscript({
-      id: `pend_${randomUUID().slice(0, 8)}`,
-      transcriptPath: path,
-      project,
-      projectRoot,
-      provider: "discovered",
-      queuedAt: Date.now()
-    });
-  }
-  repo.close();
-}
-export {
-  handleSessionStart
-};

package/dist/setup-CVG35TUZ.js

@@ -1,51 +0,0 @@
-import {
-  registerClaudeHooks,
-  registerMcpServer
-} 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 "./chunk-KFQGP6VL.js";
-
-// src/setup.ts
-import { mkdirSync } from "fs";
-async function runSetup() {
-  migrateFromLegacy();
-  mkdirSync(getDataDir(), { recursive: true });
-  const repo = new SqliteKnowledgeRepository(getDbPath());
-  repo.close();
-  const ides = detectInstalledIdes();
-  const detected = ides.filter((i) => i.detected);
-  console.log(`
-AgentCache setup complete.`);
-  console.log(`  Central DB: ${getDbPath()}
-`);
-  if (detected.length === 0) {
-    console.log(`  No IDEs detected. MCP server can still be used manually: agentcache serve
-`);
-    return;
-  }
-  console.log(`IDEs:`);
-  for (const ide of detected) {
-    const registered = registerMcpServer(ide);
-    console.log(`  ${ide.name}: ${registered ? "MCP registered" : "already registered"}`);
-  }
-  const hooksRegistered = registerClaudeHooks();
-  if (hooksRegistered) {
-    console.log(`
-  Claude Code hooks: registered (Stop, SessionStart, PreToolUse)`);
-  }
-  console.log(`
-Done. AgentCache compiles knowledge across all sessions and IDEs.`);
-}
-export {
-  runSetup
-};

package/dist/sqlite-NM2BVHUY.js

@@ -1,7 +0,0 @@
-import {
-  SqliteKnowledgeRepository
-} from "./chunk-PSASDZQE.js";
-import "./chunk-KFQGP6VL.js";
-export {
-  SqliteKnowledgeRepository
-};