agentcache 0.1.0

package/dist/chunk-PYGRUQNL.js

@@ -0,0 +1,45 @@
+// 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" }
+];
+function evaluatePolicy(input, enforcedRules) {
+  const command = extractCommand(input.tool_name, input.tool_input);
+  if (!command) return {};
+  for (const block of HARDCODED_BLOCKS) {
+    if (block.pattern.test(command)) {
+      return { decision: "block", reason: block.reason };
+    }
+  }
+  for (const item of enforcedRules) {
+    if (matchesRule(item, input.tool_name, command)) {
+      return { decision: "block", reason: `Blocked by enforced rule: ${item.content}` };
+    }
+  }
+  return {};
+}
+function extractCommand(toolName, toolInput) {
+  if (toolName === "Bash" && typeof toolInput.command === "string") {
+    return toolInput.command;
+  }
+  if (toolName === "Write" && typeof toolInput.file_path === "string") {
+    return `> ${toolInput.file_path}`;
+  }
+  if (toolName === "Edit" && typeof toolInput.file_path === "string") {
+    return `edit ${toolInput.file_path}`;
+  }
+  return null;
+}
+function matchesRule(item, _toolName, command) {
+  const content = item.content.toLowerCase();
+  const cmd = command.toLowerCase();
+  const keywords = content.replace(/never|always|don't|do not|avoid|must not/gi, "").split(/\s+/).filter((w) => w.length > 3);
+  if (keywords.length === 0) return false;
+  const matchCount = keywords.filter((k) => cmd.includes(k)).length;
+  return matchCount >= Math.ceil(keywords.length * 0.5);
+}
+
+export {
+  evaluatePolicy
+};

package/dist/chunk-QGG25FWV.js

@@ -0,0 +1,173 @@
+import {
+  getClaudeTranscriptsDir,
+  getContinueSessionsDir
+} from "./chunk-VPEEZXLK.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/utils/transcript.ts
+import { readdirSync, statSync, existsSync } from "fs";
+import { join } from "path";
+
+// src/utils/transcript-parsers/claude-jsonl.ts
+var claude_jsonl_exports = {};
+__export(claude_jsonl_exports, {
+  canParse: () => canParse,
+  parse: () => parse
+});
+import { readFileSync } from "fs";
+function canParse(path) {
+  return path.endsWith(".jsonl");
+}
+function parse(path) {
+  const content = readFileSync(path, "utf-8");
+  const events = [];
+  for (const line of content.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      const obj = JSON.parse(line);
+      if (obj.type === "user" && obj.message?.content) {
+        events.push({
+          type: "message",
+          role: "user",
+          content: typeof obj.message.content === "string" ? obj.message.content : JSON.stringify(obj.message.content)
+        });
+      } else if (obj.type === "assistant" && obj.message?.content) {
+        const blocks = Array.isArray(obj.message.content) ? obj.message.content : [{ type: "text", text: obj.message.content }];
+        for (const block of blocks) {
+          if (block.type === "text" && block.text) {
+            events.push({ type: "message", role: "assistant", content: block.text });
+          } else if (block.type === "tool_use") {
+            events.push({
+              type: "tool_use",
+              tool_name: block.name,
+              tool_input: block.input
+            });
+          }
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+  return events;
+}
+
+// src/utils/transcript-parsers/continue-json.ts
+var continue_json_exports = {};
+__export(continue_json_exports, {
+  canParse: () => canParse2,
+  parse: () => parse2
+});
+import { readFileSync as readFileSync2 } from "fs";
+function canParse2(path) {
+  if (!path.endsWith(".json")) return false;
+  try {
+    const content = readFileSync2(path, "utf-8");
+    const parsed = JSON.parse(content);
+    return parsed.history && Array.isArray(parsed.history);
+  } catch {
+    return false;
+  }
+}
+function parse2(path) {
+  const content = readFileSync2(path, "utf-8");
+  const session = JSON.parse(content);
+  const events = [];
+  if (!session.history || !Array.isArray(session.history)) return events;
+  for (const entry of session.history) {
+    const msg = entry.message;
+    if (!msg) continue;
+    const role = msg.role === "user" ? "user" : msg.role === "assistant" ? "assistant" : null;
+    if (!role) continue;
+    let text = "";
+    if (typeof msg.content === "string") {
+      text = msg.content;
+    } else if (Array.isArray(msg.content)) {
+      text = msg.content.filter((b) => b.type === "text" && b.text).map((b) => b.text).join("\n");
+    }
+    if (text) {
+      events.push({ type: "message", role, content: text });
+    }
+  }
+  return events;
+}
+
+// src/utils/transcript-parsers/index.ts
+var parsers = [claude_jsonl_exports, continue_json_exports];
+function parseTranscriptAuto(path) {
+  for (const parser of parsers) {
+    if (parser.canParse(path)) return parser.parse(path);
+  }
+  return [];
+}
+
+// src/utils/transcript.ts
+function parseTranscript(path) {
+  return parseTranscriptAuto(path);
+}
+function findLatestTranscript() {
+  const baseDir = getClaudeTranscriptsDir();
+  if (!existsSync(baseDir)) return null;
+  let latest = null;
+  try {
+    const dirs = readdirSync(baseDir).map((d) => join(baseDir, d)).filter((d) => statSync(d).isDirectory());
+    for (const dir of dirs) {
+      try {
+        const files = readdirSync(dir).filter((f) => f.endsWith(".jsonl"));
+        for (const file of files) {
+          const fullPath = join(dir, file);
+          const mtime = statSync(fullPath).mtimeMs;
+          if (!latest || mtime > latest.mtime) {
+            latest = { path: fullPath, mtime };
+          }
+        }
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+    return null;
+  }
+  return latest?.path ?? null;
+}
+function findAllClaudeTranscripts() {
+  const baseDir = getClaudeTranscriptsDir();
+  if (!existsSync(baseDir)) return [];
+  const transcripts = [];
+  try {
+    const dirs = readdirSync(baseDir).map((d) => join(baseDir, d)).filter((d) => statSync(d).isDirectory());
+    for (const dir of dirs) {
+      try {
+        const files = readdirSync(dir).filter((f) => f.endsWith(".jsonl"));
+        for (const file of files) {
+          const fullPath = join(dir, file);
+          if (statSync(fullPath).size > 100) {
+            transcripts.push(fullPath);
+          }
+        }
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+  }
+  return transcripts;
+}
+function findAllContinueTranscripts() {
+  const dir = getContinueSessionsDir();
+  if (!existsSync(dir)) return [];
+  try {
+    return readdirSync(dir).filter((f) => f.endsWith(".json") && f !== "sessions.json").map((f) => join(dir, f)).filter((f) => statSync(f).size > 100);
+  } catch {
+    return [];
+  }
+}
+
+export {
+  parseTranscript,
+  findLatestTranscript,
+  findAllClaudeTranscripts,
+  findAllContinueTranscripts
+};

package/dist/chunk-RUBNVM6W.js

@@ -0,0 +1,129 @@
+// 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 = {
+  command: "agentcache",
+  args: ["serve"]
+};
+function registerMcpServer(ide) {
+  if (!ide.detected) return false;
+  if (ide.mcpConfigFormat === "claude-settings") {
+    let settings = {};
+    if (existsSync2(ide.mcpConfigPath)) {
+      try {
+        settings = JSON.parse(readFileSync(ide.mcpConfigPath, "utf-8"));
+      } catch {
+        settings = {};
+      }
+    }
+    if (!settings.mcpServers) settings.mcpServers = {};
+    if (settings.mcpServers.agentcache) return false;
+    settings.mcpServers.agentcache = MCP_ENTRY;
+    mkdirSync(dirname(ide.mcpConfigPath), { recursive: true });
+    writeFileSync(ide.mcpConfigPath, 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;
+    config.mcpServers.agentcache = MCP_ENTRY;
+    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
+};

package/dist/chunk-VPEEZXLK.js

@@ -0,0 +1,68 @@
+// src/utils/paths.ts
+import { existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { createHash } from "crypto";
+
+// src/utils/git.ts
+import { execSync } from "child_process";
+function run(cmd, cwd) {
+  try {
+    return execSync(cmd, { cwd, encoding: "utf-8", timeout: 5e3 }).trim();
+  } catch {
+    return "";
+  }
+}
+function getGitContext(projectRoot) {
+  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);
+  return root || null;
+}
+
+// src/utils/paths.ts
+function getGlobalLoopDir() {
+  return join(homedir(), ".loop");
+}
+function getDbPath() {
+  return join(getGlobalLoopDir(), "loop.db");
+}
+function isLoopInitialized() {
+  return existsSync(getDbPath());
+}
+function findProjectRoot(cwd) {
+  const dir = cwd || process.cwd();
+  const gitRoot = getGitRoot(dir);
+  return gitRoot || dir;
+}
+function getProjectId(projectRoot) {
+  const name = projectRoot.split("/").pop() || "unknown";
+  const hash = createHash("sha256").update(projectRoot).digest("hex").slice(0, 6);
+  return `${name}-${hash}`;
+}
+function getProjectDisplayName(projectRoot) {
+  return projectRoot.split("/").pop() || "unknown";
+}
+function getClaudeTranscriptsDir() {
+  return join(homedir(), ".claude", "projects");
+}
+function getContinueSessionsDir() {
+  return join(homedir(), ".continue", "sessions");
+}
+
+export {
+  getGitContext,
+  getGlobalLoopDir,
+  getDbPath,
+  isLoopInitialized,
+  findProjectRoot,
+  getProjectId,
+  getProjectDisplayName,
+  getClaudeTranscriptsDir,
+  getContinueSessionsDir
+};

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+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-QB36C2TH.js");
+  await runSetup();
+});
+program.command("serve").description("Start Loop 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");
+  let payload;
+  try {
+    let data = "";
+    for await (const chunk of process.stdin) {
+      data += chunk;
+    }
+    if (data.trim()) {
+      payload = JSON.parse(data);
+    }
+  } catch {
+  }
+  await handleStop(payload);
+});
+program.command("discover").description("SessionStart hook: discover uncompiled transcripts").action(async () => {
+  const { handleSessionStart } = await import("./session-start-ILEPFZZC.js");
+  await handleSessionStart();
+});
+program.command("enforce").description("PreToolUse hook: policy enforcement").action(async () => {
+  const { handlePreToolUse } = await import("./pre-tool-use-2P5P6JWE.js");
+  let data = "";
+  for await (const chunk of process.stdin) {
+    data += chunk;
+  }
+  try {
+    const input = JSON.parse(data);
+    const result = handlePreToolUse(input);
+    process.stdout.write(JSON.stringify(result));
+  } catch {
+    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");
+    return;
+  }
+  const { SqliteKnowledgeRepository } = await import("./sqlite-5V565IV3.js");
+  const repo = new SqliteKnowledgeRepository(getDbPath());
+  const projectRoot = findProjectRoot();
+  const project = getProjectId(projectRoot);
+  const displayName = getProjectDisplayName(projectRoot);
+  const items = repo.getKnowledgeForContext(project);
+  const rules = items.filter((i) => i.type === "rule");
+  const lessons = items.filter((i) => i.type === "lesson");
+  const decisions = items.filter((i) => i.type === "decision");
+  const context = items.filter((i) => i.type === "context");
+  const globalItems = items.filter((i) => i.scope === "global");
+  const projectItems = items.filter((i) => i.scope === "project");
+  const pending = repo.getPendingCount();
+  repo.close();
+  console.log(`Loop \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`);
+});
+program.parse();

package/dist/mcp.d.ts

@@ -0,0 +1,3 @@
+declare function startMcpServer(): Promise<void>;
+
+export { startMcpServer };