@agentmemory/agentmemory 0.7.0

package/benchmark/scale-eval.ts

@@ -0,0 +1,398 @@
+import { SearchIndex } from "../src/state/search-index.js";
+import { VectorIndex } from "../src/state/vector-index.js";
+import { HybridSearch } from "../src/state/hybrid-search.js";
+import type { CompressedObservation } from "../src/types.js";
+import { generateScaleDataset, generateDataset } from "./dataset.js";
+import { writeFileSync } from "node:fs";
+
+function mockKV() {
+  const store = new Map<string, Map<string, unknown>>();
+  return {
+    get: async <T>(scope: string, key: string): Promise<T | null> =>
+      (store.get(scope)?.get(key) as T) ?? null,
+    set: async <T>(scope: string, key: string, data: T): Promise<T> => {
+      if (!store.has(scope)) store.set(scope, new Map());
+      store.get(scope)!.set(key, data);
+      return data;
+    },
+    delete: async (scope: string, key: string): Promise<void> => {
+      store.get(scope)?.delete(key);
+    },
+    list: async <T>(scope: string): Promise<T[]> => {
+      const entries = store.get(scope);
+      return entries ? (Array.from(entries.values()) as T[]) : [];
+    },
+  };
+}
+
+function deterministicEmbedding(text: string, dims = 384): Float32Array {
+  const arr = new Float32Array(dims);
+  const words = text.toLowerCase().split(/\W+/).filter(w => w.length > 2);
+  for (const word of words) {
+    for (let i = 0; i < word.length; i++) {
+      const idx = (word.charCodeAt(i) * 31 + i * 17) % dims;
+      arr[idx] += 1;
+      const idx2 = (word.charCodeAt(i) * 37 + i * 13 + word.length * 7) % dims;
+      arr[idx2] += 0.5;
+    }
+  }
+  const norm = Math.sqrt(arr.reduce((s, v) => s + v * v, 0));
+  if (norm > 0) for (let i = 0; i < dims; i++) arr[i] /= norm;
+  return arr;
+}
+
+function estimateTokens(text: string): number {
+  return Math.ceil(text.length / 4);
+}
+
+interface ScaleResult {
+  scale: number;
+  sessions: number;
+  index_build_ms: number;
+  index_build_per_doc_ms: number;
+  bm25_search_ms: number;
+  hybrid_search_ms: number;
+  index_size_kb: number;
+  vector_size_kb: number;
+  heap_mb: number;
+  builtin_tokens: number;
+  builtin_200line_tokens: number;
+  agentmemory_tokens: number;
+  token_savings_pct: number;
+  builtin_unreachable_pct: number;
+}
+
+interface CrossSessionResult {
+  query: string;
+  target_session: string;
+  current_session: string;
+  sessions_apart: number;
+  bm25_found: boolean;
+  bm25_rank: number;
+  hybrid_found: boolean;
+  hybrid_rank: number;
+  builtin_found: boolean;
+  latency_ms: number;
+}
+
+const SEARCH_QUERIES = [
+  "authentication middleware JWT",
+  "PostgreSQL connection pooling",
+  "Kubernetes pod crash",
+  "rate limiting API",
+  "Playwright E2E tests",
+  "Docker multi-stage build",
+  "Redis caching layer",
+  "CI/CD GitHub Actions",
+  "Prisma migration drift",
+  "monitoring Datadog alerts",
+];
+
+async function benchmarkScale(counts: number[]): Promise<ScaleResult[]> {
+  const results: ScaleResult[] = [];
+
+  for (const count of counts) {
+    console.log(`  Scale: ${count.toLocaleString()} observations...`);
+    const observations = generateScaleDataset(count);
+    const sessionCount = new Set(observations.map(o => o.sessionId)).size;
+
+    const heapBefore = process.memoryUsage().heapUsed;
+
+    const buildStart = performance.now();
+    const bm25 = new SearchIndex();
+    const vector = new VectorIndex();
+    const kv = mockKV();
+    const dims = 384;
+
+    for (const obs of observations) {
+      bm25.add(obs);
+      const text = [obs.title, obs.narrative, ...obs.concepts].join(" ");
+      vector.add(obs.id, obs.sessionId, deterministicEmbedding(text, dims));
+      await kv.set(`mem:obs:${obs.sessionId}`, obs.id, obs);
+    }
+    const buildMs = performance.now() - buildStart;
+
+    const heapAfter = process.memoryUsage().heapUsed;
+
+    const mockEmbed: any = {
+      name: "deterministic", dimensions: dims,
+      embed: async (t: string) => deterministicEmbedding(t, dims),
+      embedBatch: async (ts: string[]) => ts.map(t => deterministicEmbedding(t, dims)),
+    };
+    const hybrid = new HybridSearch(bm25, vector, mockEmbed, kv as never, 0.4, 0.6, 0);
+
+    let bm25Total = 0;
+    let hybridTotal = 0;
+    const iters = 20;
+
+    for (let i = 0; i < iters; i++) {
+      const q = SEARCH_QUERIES[i % SEARCH_QUERIES.length];
+      const s1 = performance.now();
+      bm25.search(q, 10);
+      bm25Total += performance.now() - s1;
+
+      const s2 = performance.now();
+      await hybrid.search(q, 10);
+      hybridTotal += performance.now() - s2;
+    }
+
+    const bm25Ser = bm25.serialize();
+    const vecSer = vector.serialize();
+
+    const allText = observations.map(o =>
+      `- ${o.title}: ${o.narrative.slice(0, 80)}... [${o.concepts.slice(0, 3).join(", ")}]`
+    ).join("\n");
+    const builtinTokens = estimateTokens(allText);
+
+    const truncatedText = observations.slice(0, 200).map(o =>
+      `- ${o.title}: ${o.narrative.slice(0, 60)}... [${o.concepts.slice(0, 3).join(", ")}]`
+    ).join("\n");
+    const builtin200Tokens = estimateTokens(truncatedText);
+
+    let totalResultTokens = 0;
+    for (let i = 0; i < iters; i++) {
+      const q = SEARCH_QUERIES[i % SEARCH_QUERIES.length];
+      const results = await hybrid.search(q, 10);
+      totalResultTokens += estimateTokens(JSON.stringify(results.map(r => r.observation)));
+    }
+    const agentmemoryTokens = Math.round(totalResultTokens / iters);
+
+    results.push({
+      scale: count,
+      sessions: sessionCount,
+      index_build_ms: Math.round(buildMs),
+      index_build_per_doc_ms: +(buildMs / count).toFixed(3),
+      bm25_search_ms: +(bm25Total / iters).toFixed(3),
+      hybrid_search_ms: +(hybridTotal / iters).toFixed(3),
+      index_size_kb: Math.round(Buffer.byteLength(bm25Ser, "utf-8") / 1024),
+      vector_size_kb: Math.round(Buffer.byteLength(vecSer, "utf-8") / 1024),
+      heap_mb: Math.round((heapAfter - heapBefore) / 1024 / 1024),
+      builtin_tokens: builtinTokens,
+      builtin_200line_tokens: builtin200Tokens,
+      agentmemory_tokens: agentmemoryTokens,
+      token_savings_pct: Math.round((1 - agentmemoryTokens / builtinTokens) * 100),
+      builtin_unreachable_pct: count <= 200 ? 0 : Math.round((1 - 200 / count) * 100),
+    });
+  }
+
+  return results;
+}
+
+async function benchmarkCrossSession(): Promise<CrossSessionResult[]> {
+  const { observations } = generateDataset();
+  const results: CrossSessionResult[] = [];
+
+  const bm25 = new SearchIndex();
+  const kv = mockKV();
+  const vector = new VectorIndex();
+  const dims = 384;
+
+  for (const obs of observations) {
+    bm25.add(obs);
+    const text = [obs.title, obs.narrative, ...obs.concepts].join(" ");
+    vector.add(obs.id, obs.sessionId, deterministicEmbedding(text, dims));
+    await kv.set(`mem:obs:${obs.sessionId}`, obs.id, obs);
+  }
+
+  const mockEmbed: any = {
+    name: "deterministic", dimensions: dims,
+    embed: async (t: string) => deterministicEmbedding(t, dims),
+    embedBatch: async (ts: string[]) => ts.map(t => deterministicEmbedding(t, dims)),
+  };
+  const hybrid = new HybridSearch(bm25, vector, mockEmbed, kv as never, 0.4, 0.6, 0);
+
+  const crossQueries: Array<{
+    query: string;
+    targetConcepts: string[];
+    targetSessionRange: [number, number];
+    currentSession: number;
+  }> = [
+    { query: "How did we set up OAuth providers?", targetConcepts: ["oauth", "nextauth"], targetSessionRange: [5, 9], currentSession: 29 },
+    { query: "What was the N+1 query fix?", targetConcepts: ["n+1", "eager-loading"], targetSessionRange: [10, 14], currentSession: 28 },
+    { query: "PostgreSQL full-text search setup", targetConcepts: ["full-text-search", "tsvector"], targetSessionRange: [10, 14], currentSession: 27 },
+    { query: "bcrypt password hashing configuration", targetConcepts: ["bcrypt", "password-hashing"], targetSessionRange: [5, 9], currentSession: 25 },
+    { query: "Vitest unit testing setup", targetConcepts: ["vitest", "unit-testing"], targetSessionRange: [20, 24], currentSession: 29 },
+    { query: "webhook retry exponential backoff", targetConcepts: ["webhooks", "exponential-backoff"], targetSessionRange: [15, 19], currentSession: 29 },
+    { query: "ESLint flat config migration", targetConcepts: ["eslint", "linting"], targetSessionRange: [0, 4], currentSession: 29 },
+    { query: "Kubernetes HPA autoscaling configuration", targetConcepts: ["hpa", "autoscaling", "kubernetes"], targetSessionRange: [25, 29], currentSession: 29 },
+    { query: "Prisma database seed script", targetConcepts: ["seeding", "faker", "prisma"], targetSessionRange: [10, 14], currentSession: 26 },
+    { query: "API cursor-based pagination", targetConcepts: ["cursor-based", "pagination"], targetSessionRange: [15, 19], currentSession: 29 },
+    { query: "CSRF protection double-submit cookie", targetConcepts: ["csrf", "cookies"], targetSessionRange: [5, 9], currentSession: 29 },
+    { query: "blue-green deployment rollback", targetConcepts: ["blue-green", "rollback", "zero-downtime"], targetSessionRange: [25, 29], currentSession: 29 },
+  ];
+
+  for (const cq of crossQueries) {
+    const targetObs = observations.filter(o =>
+      o.concepts.some(c => cq.targetConcepts.includes(c))
+    );
+    const targetIds = new Set(targetObs.map(o => o.id));
+
+    const start = performance.now();
+    const bm25Results = bm25.search(cq.query, 20);
+    const hybridResults = await hybrid.search(cq.query, 20);
+    const latency = performance.now() - start;
+
+    const bm25Rank = bm25Results.findIndex(r => targetIds.has(r.obsId));
+    const hybridRank = hybridResults.findIndex(r => targetIds.has(r.observation.id));
+
+    const builtinLines = 200;
+    const visibleObs = observations.slice(0, builtinLines);
+    const builtinFound = visibleObs.some(o => targetIds.has(o.id));
+
+    const sessionsApart = cq.currentSession - cq.targetSessionRange[0];
+
+    results.push({
+      query: cq.query,
+      target_session: `ses_${cq.targetSessionRange[0].toString().padStart(3, "0")}-${cq.targetSessionRange[1].toString().padStart(3, "0")}`,
+      current_session: `ses_${cq.currentSession.toString().padStart(3, "0")}`,
+      sessions_apart: sessionsApart,
+      bm25_found: bm25Rank >= 0,
+      bm25_rank: bm25Rank >= 0 ? bm25Rank + 1 : -1,
+      hybrid_found: hybridRank >= 0,
+      hybrid_rank: hybridRank >= 0 ? hybridRank + 1 : -1,
+      builtin_found: builtinFound,
+      latency_ms: latency,
+    });
+  }
+
+  return results;
+}
+
+function generateReport(scale: ScaleResult[], cross: CrossSessionResult[]): string {
+  const lines: string[] = [];
+  const w = (s: string) => lines.push(s);
+
+  w("# agentmemory v0.6.0 — Scale & Cross-Session Evaluation");
+  w("");
+  w(`**Date:** ${new Date().toISOString()}`);
+  w(`**Platform:** ${process.platform} ${process.arch}, Node ${process.version}`);
+  w("");
+
+  w("## 1. Scale: agentmemory vs Built-in Memory");
+  w("");
+  w("Every built-in agent memory (CLAUDE.md, .cursorrules, Cline's memory-bank) loads ALL memory into context every session. agentmemory searches and returns only relevant results.");
+  w("");
+  w("| Observations | Sessions | Index Build | BM25 Search | Hybrid Search | Heap | Context Tokens (built-in) | Context Tokens (agentmemory) | Savings | Built-in Unreachable |");
+  w("|-------------|----------|------------|-------------|---------------|------|--------------------------|-----------------------------|---------|--------------------|");
+
+  for (const r of scale) {
+    w(`| ${r.scale.toLocaleString()} | ${r.sessions} | ${r.index_build_ms}ms | ${r.bm25_search_ms}ms | ${r.hybrid_search_ms}ms | ${r.heap_mb}MB | ${r.builtin_tokens.toLocaleString()} | ${r.agentmemory_tokens.toLocaleString()} | ${r.token_savings_pct}% | ${r.builtin_unreachable_pct}% |`);
+  }
+
+  w("");
+  w("### What the numbers mean");
+  w("");
+  w("**Context Tokens (built-in):** How many tokens Claude Code/Cursor/Cline would consume loading ALL memory into the context window. At 5,000 observations, this is ~250K tokens — exceeding most context windows entirely.");
+  w("");
+  w("**Context Tokens (agentmemory):** How many tokens the top-10 search results consume. Stays constant regardless of corpus size.");
+  w("");
+  w("**Built-in Unreachable:** Percentage of memories that built-in systems CANNOT access because they exceed the 200-line MEMORY.md cap or context window limits. At 1,000 observations, 80% of your project history is invisible.");
+  w("");
+
+  w("### Storage Costs");
+  w("");
+  w("| Observations | BM25 Index | Vector Index (d=384) | Total Storage |");
+  w("|-------------|-----------|---------------------|---------------|");
+  for (const r of scale) {
+    const total = r.index_size_kb + r.vector_size_kb;
+    w(`| ${r.scale.toLocaleString()} | ${r.index_size_kb.toLocaleString()} KB | ${r.vector_size_kb.toLocaleString()} KB | ${(total / 1024).toFixed(1)} MB |`);
+  }
+
+  w("");
+  w("## 2. Cross-Session Retrieval");
+  w("");
+  w("Can the system find relevant information from past sessions? This is impossible for built-in memory once observations exceed the line/context cap.");
+  w("");
+  w("| Query | Target Session | Gap | BM25 Found | BM25 Rank | Hybrid Found | Hybrid Rank | Built-in Visible |");
+  w("|-------|---------------|-----|-----------|-----------|-------------|-------------|-----------------|");
+
+  for (const r of cross) {
+    w(`| ${r.query.slice(0, 40)}${r.query.length > 40 ? "..." : ""} | ${r.target_session} | ${r.sessions_apart} | ${r.bm25_found ? "Yes" : "No"} | ${r.bm25_rank > 0 ? `#${r.bm25_rank}` : "-"} | ${r.hybrid_found ? "Yes" : "No"} | ${r.hybrid_rank > 0 ? `#${r.hybrid_rank}` : "-"} | ${r.builtin_found ? "Yes" : "No"} |`);
+  }
+
+  const bm25Found = cross.filter(r => r.bm25_found).length;
+  const hybridFound = cross.filter(r => r.hybrid_found).length;
+  const builtinFound = cross.filter(r => r.builtin_found).length;
+
+  w("");
+  w(`**Summary:** agentmemory BM25 found ${bm25Found}/${cross.length} cross-session queries. Hybrid found ${hybridFound}/${cross.length}. Built-in memory (200-line cap) could only reach ${builtinFound}/${cross.length}.`);
+
+  w("");
+  w("## 3. The Context Window Problem");
+  w("");
+  w("```");
+  w("Agent context window: ~200K tokens");
+  w("System prompt + tools:  ~20K tokens");
+  w("User conversation:      ~30K tokens");
+  w("Available for memory:  ~150K tokens");
+  w("");
+  w("At 50 tokens/observation:");
+  w("  200 observations  =  10,000 tokens  (fits, but 200-line cap hits first)");
+  w("  1,000 observations =  50,000 tokens  (33% of available budget)");
+  w("  5,000 observations = 250,000 tokens  (EXCEEDS total context window)");
+  w("");
+  w("agentmemory top-10 results:");
+  w(`  Any corpus size     =  ~${scale[0]?.agentmemory_tokens.toLocaleString() || "500"} tokens  (0.3% of budget)`);
+  w("```");
+  w("");
+
+  w("## 4. What Built-in Memory Cannot Do");
+  w("");
+  w("| Capability | Built-in (CLAUDE.md) | agentmemory |");
+  w("|-----------|---------------------|-------------|");
+  w("| Semantic search | No (keyword grep only) | BM25 + vector + graph |");
+  w("| Scale beyond 200 lines | No (hard cap) | Unlimited |");
+  w("| Cross-session recall | Only if in 200-line window | Full corpus search |");
+  w("| Cross-agent sharing | No (per-agent files) | MCP + REST API |");
+  w("| Multi-agent coordination | No | Leases, signals, actions |");
+  w("| Temporal queries | No | Point-in-time graph |");
+  w("| Memory lifecycle | No (manual pruning) | Ebbinghaus decay + eviction |");
+  w("| Knowledge graph | No | Entity extraction + traversal |");
+  w("| Query expansion | No | LLM-generated reformulations |");
+  w("| Retention scoring | No | Time-frequency decay model |");
+  w("| Real-time dashboard | No (read files manually) | Viewer on :3113 |");
+  w("| Concurrent access | No (file lock) | Keyed mutex + KV store |");
+  w("");
+
+  w("## 5. When to Use What");
+  w("");
+  w("**Use built-in memory (CLAUDE.md) when:**");
+  w("- You have < 200 items to remember");
+  w("- Single agent, single project");
+  w("- Preferences and quick facts only");
+  w("- Zero setup is the priority");
+  w("");
+  w("**Use agentmemory when:**");
+  w("- Project history exceeds 200 observations");
+  w("- You need to recall specific incidents from weeks ago");
+  w("- Multiple agents work on the same codebase");
+  w("- You want semantic search (\"how does auth work?\") not just keyword matching");
+  w("- You need to track memory quality, decay, and lifecycle");
+  w("- You want a shared memory layer across Claude Code, Cursor, Windsurf, etc.");
+  w("");
+  w("Built-in memory is your sticky notes. agentmemory is the searchable database behind them.");
+  w("");
+
+  w("---");
+  w(`*Scale tests: ${scale.length} corpus sizes. Cross-session tests: ${cross.length} queries targeting specific past sessions.*`);
+
+  return lines.join("\n");
+}
+
+async function main() {
+  console.log("=== agentmemory Scale & Cross-Session Evaluation ===\n");
+
+  console.log("1. Scale benchmarks...");
+  const scaleResults = await benchmarkScale([240, 1_000, 5_000, 10_000, 50_000]);
+
+  console.log("\n2. Cross-session retrieval...");
+  const crossResults = await benchmarkCrossSession();
+
+  console.log("");
+  const report = generateReport(scaleResults, crossResults);
+  writeFileSync("benchmark/SCALE.md", report);
+  console.log(report);
+  console.log(`\nReport written to benchmark/SCALE.md`);
+}
+
+main().catch(console.error);

package/dist/cli.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/cli.mjs

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+import { execFileSync, spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+//#region src/cli.ts
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const args = process.argv.slice(2);
+if (args.includes("--help") || args.includes("-h")) {
+	console.log(`
+agentmemory — persistent memory for AI coding agents
+
+Usage: agentmemory [options]
+
+Options:
+  --help, -h         Show this help
+  --tools all|core   Tool visibility (default: core = 7 tools)
+  --no-engine        Skip auto-starting iii-engine
+  --port <N>         Override REST port (default: 3111)
+
+Environment:
+  AGENTMEMORY_TOOLS=all    Expose all 41 MCP tools
+  AGENTMEMORY_SECRET=xxx   Auth secret for REST/MCP
+  CONSOLIDATION_ENABLED=true   Enable auto-consolidation (off by default)
+  OBSIDIAN_AUTO_EXPORT=true    Auto-export on consolidation
+
+Quick start:
+  npx agentmemory             # auto-starts iii-engine, runs worker
+  npx agentmemory-mcp         # standalone MCP server (no engine needed)
+`);
+	process.exit(0);
+}
+const toolsIdx = args.indexOf("--tools");
+if (toolsIdx !== -1 && args[toolsIdx + 1]) process.env["AGENTMEMORY_TOOLS"] = args[toolsIdx + 1];
+const portIdx = args.indexOf("--port");
+if (portIdx !== -1 && args[portIdx + 1]) process.env["III_REST_PORT"] = args[portIdx + 1];
+const skipEngine = args.includes("--no-engine");
+function getRestPort() {
+	return parseInt(process.env["III_REST_PORT"] || "3111", 10) || 3111;
+}
+async function isEngineRunning() {
+	try {
+		return (await fetch(`http://localhost:${getRestPort()}/agentmemory/livez`, { signal: AbortSignal.timeout(2e3) })).ok;
+	} catch {
+		return false;
+	}
+}
+function findIiiConfig() {
+	const candidates = [
+		join(__dirname, "iii-config.yaml"),
+		join(__dirname, "..", "iii-config.yaml"),
+		join(process.cwd(), "iii-config.yaml")
+	];
+	for (const c of candidates) if (existsSync(c)) return c;
+	return "";
+}
+function whichBinary(name) {
+	const cmd = process.platform === "win32" ? "where" : "which";
+	try {
+		return execFileSync(cmd, [name], { encoding: "utf-8" }).trim().split("\n")[0];
+	} catch {
+		return null;
+	}
+}
+async function startEngine() {
+	const configPath = findIiiConfig();
+	const iiiBin = whichBinary("iii");
+	if (iiiBin && configPath) {
+		console.log(`[agentmemory] Starting iii-engine: ${iiiBin} --config ${configPath}`);
+		spawn(iiiBin, ["--config", configPath], {
+			detached: true,
+			stdio: "ignore"
+		}).unref();
+		return true;
+	}
+	const dockerCompose = join(__dirname, "..", "docker-compose.yml");
+	const dcExists = existsSync(dockerCompose) || existsSync(join(process.cwd(), "docker-compose.yml"));
+	const dockerBin = whichBinary("docker");
+	if (dockerBin && dcExists) {
+		const composeFile = existsSync(dockerCompose) ? dockerCompose : join(process.cwd(), "docker-compose.yml");
+		console.log(`[agentmemory] Starting iii-engine via Docker...`);
+		spawn(dockerBin, [
+			"compose",
+			"-f",
+			composeFile,
+			"up",
+			"-d"
+		], {
+			detached: true,
+			stdio: "ignore"
+		}).unref();
+		return true;
+	}
+	return false;
+}
+async function waitForEngine(timeoutMs) {
+	const start = Date.now();
+	while (Date.now() - start < timeoutMs) {
+		if (await isEngineRunning()) return true;
+		await new Promise((r) => setTimeout(r, 500));
+	}
+	return false;
+}
+async function main() {
+	if (!skipEngine && !await isEngineRunning()) {
+		if (!await startEngine()) {
+			console.error(`
+[agentmemory] iii-engine is not running and could not be auto-started.
+
+Install one of:
+  1. iii CLI:    npm install -g iii-engine
+  2. Docker:     docker compose up -d (with docker-compose.yml)
+
+Or run with --no-engine to connect to a remote engine.
+`);
+			process.exit(1);
+		}
+		console.log(`[agentmemory] Waiting for iii-engine to start...`);
+		if (!await waitForEngine(15e3)) {
+			const port = getRestPort();
+			console.error(`[agentmemory] iii-engine did not become ready within 15s.`);
+			console.error(`[agentmemory] Check that ports ${port}, ${port + 1}, 49134 are available.`);
+			process.exit(1);
+		}
+		console.log(`[agentmemory] iii-engine is ready.`);
+	}
+	await import("./src-QxitMPfJ.mjs");
+}
+main().catch((err) => {
+	console.error(`[agentmemory] Fatal:`, err);
+	process.exit(1);
+});
+
+//#endregion
+export {  };
+//# sourceMappingURL=cli.mjs.map

package/dist/cli.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.mjs","names":[],"sources":["../src/cli.ts"],"sourcesContent":["#!/usr/bin/env node\n\nimport { spawn, execFileSync } from \"node:child_process\";\nimport { existsSync } from \"node:fs\";\nimport { join, dirname } from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\n\nconst __dirname = dirname(fileURLToPath(import.meta.url));\n\nconst args = process.argv.slice(2);\n\nif (args.includes(\"--help\") || args.includes(\"-h\")) {\n  console.log(`\nagentmemory — persistent memory for AI coding agents\n\nUsage: agentmemory [options]\n\nOptions:\n  --help, -h         Show this help\n  --tools all|core   Tool visibility (default: core = 7 tools)\n  --no-engine        Skip auto-starting iii-engine\n  --port <N>         Override REST port (default: 3111)\n\nEnvironment:\n  AGENTMEMORY_TOOLS=all    Expose all 41 MCP tools\n  AGENTMEMORY_SECRET=xxx   Auth secret for REST/MCP\n  CONSOLIDATION_ENABLED=true   Enable auto-consolidation (off by default)\n  OBSIDIAN_AUTO_EXPORT=true    Auto-export on consolidation\n\nQuick start:\n  npx agentmemory             # auto-starts iii-engine, runs worker\n  npx agentmemory-mcp         # standalone MCP server (no engine needed)\n`);\n  process.exit(0);\n}\n\nconst toolsIdx = args.indexOf(\"--tools\");\nif (toolsIdx !== -1 && args[toolsIdx + 1]) {\n  process.env[\"AGENTMEMORY_TOOLS\"] = args[toolsIdx + 1];\n}\n\nconst portIdx = args.indexOf(\"--port\");\nif (portIdx !== -1 && args[portIdx + 1]) {\n  process.env[\"III_REST_PORT\"] = args[portIdx + 1];\n}\n\nconst skipEngine = args.includes(\"--no-engine\");\n\nfunction getRestPort(): number {\n  return parseInt(process.env[\"III_REST_PORT\"] || \"3111\", 10) || 3111;\n}\n\nasync function isEngineRunning(): Promise<boolean> {\n  try {\n    const res = await fetch(`http://localhost:${getRestPort()}/agentmemory/livez`, {\n      signal: AbortSignal.timeout(2000),\n    });\n    return res.ok;\n  } catch {\n    return false;\n  }\n}\n\nfunction findIiiConfig(): string {\n  const candidates = [\n    join(__dirname, \"iii-config.yaml\"),\n    join(__dirname, \"..\", \"iii-config.yaml\"),\n    join(process.cwd(), \"iii-config.yaml\"),\n  ];\n  for (const c of candidates) {\n    if (existsSync(c)) return c;\n  }\n  return \"\";\n}\n\nfunction whichBinary(name: string): string | null {\n  const cmd = process.platform === \"win32\" ? \"where\" : \"which\";\n  try {\n    return execFileSync(cmd, [name], { encoding: \"utf-8\" }).trim().split(\"\\n\")[0];\n  } catch {\n    return null;\n  }\n}\n\nasync function startEngine(): Promise<boolean> {\n  const configPath = findIiiConfig();\n\n  const iiiBin = whichBinary(\"iii\");\n  if (iiiBin && configPath) {\n    console.log(`[agentmemory] Starting iii-engine: ${iiiBin} --config ${configPath}`);\n    const child = spawn(iiiBin, [\"--config\", configPath], {\n      detached: true,\n      stdio: \"ignore\",\n    });\n    child.unref();\n    return true;\n  }\n\n  const dockerCompose = join(__dirname, \"..\", \"docker-compose.yml\");\n  const dcExists = existsSync(dockerCompose) || existsSync(join(process.cwd(), \"docker-compose.yml\"));\n  const dockerBin = whichBinary(\"docker\");\n\n  if (dockerBin && dcExists) {\n    const composeFile = existsSync(dockerCompose) ? dockerCompose : join(process.cwd(), \"docker-compose.yml\");\n    console.log(`[agentmemory] Starting iii-engine via Docker...`);\n    const child = spawn(dockerBin, [\"compose\", \"-f\", composeFile, \"up\", \"-d\"], {\n      detached: true,\n      stdio: \"ignore\",\n    });\n    child.unref();\n    return true;\n  }\n\n  return false;\n}\n\nasync function waitForEngine(timeoutMs: number): Promise<boolean> {\n  const start = Date.now();\n  while (Date.now() - start < timeoutMs) {\n    if (await isEngineRunning()) return true;\n    await new Promise((r) => setTimeout(r, 500));\n  }\n  return false;\n}\n\nasync function main() {\n  if (!skipEngine && !(await isEngineRunning())) {\n    const started = await startEngine();\n    if (!started) {\n      console.error(`\n[agentmemory] iii-engine is not running and could not be auto-started.\n\nInstall one of:\n  1. iii CLI:    npm install -g iii-engine\n  2. Docker:     docker compose up -d (with docker-compose.yml)\n\nOr run with --no-engine to connect to a remote engine.\n`);\n      process.exit(1);\n    }\n\n    console.log(`[agentmemory] Waiting for iii-engine to start...`);\n    const ready = await waitForEngine(15000);\n    if (!ready) {\n      const port = getRestPort();\n      console.error(`[agentmemory] iii-engine did not become ready within 15s.`);\n      console.error(`[agentmemory] Check that ports ${port}, ${port + 1}, 49134 are available.`);\n      process.exit(1);\n    }\n    console.log(`[agentmemory] iii-engine is ready.`);\n  }\n\n  await import(\"./index.js\");\n}\n\nmain().catch((err) => {\n  console.error(`[agentmemory] Fatal:`, err);\n  process.exit(1);\n});\n"],"mappings":"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"}

package/dist/docker-compose.yml

@@ -0,0 +1,14 @@
+services:
+  iii-engine:
+    image: iiidev/iii:latest
+    ports:
+      - "49134:49134"
+      - "3111:3111"
+      - "3112:3112"
+      - "9464:9464"
+    volumes:
+      - iii-data:/data
+    restart: unless-stopped
+
+volumes:
+  iii-data:

package/dist/hooks/notification.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/hooks/notification.mjs

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+//#region src/hooks/notification.ts
+const REST_URL = process.env["AGENTMEMORY_URL"] || "http://localhost:3111";
+const SECRET = process.env["AGENTMEMORY_SECRET"] || "";
+function authHeaders() {
+	const h = { "Content-Type": "application/json" };
+	if (SECRET) h["Authorization"] = `Bearer ${SECRET}`;
+	return h;
+}
+async function main() {
+	let input = "";
+	for await (const chunk of process.stdin) input += chunk;
+	let data;
+	try {
+		data = JSON.parse(input);
+	} catch {
+		return;
+	}
+	if (data.notification_type !== "permission_prompt") return;
+	const sessionId = data.session_id || "unknown";
+	try {
+		await fetch(`${REST_URL}/agentmemory/observe`, {
+			method: "POST",
+			headers: authHeaders(),
+			body: JSON.stringify({
+				hookType: "notification",
+				sessionId,
+				project: data.cwd || process.cwd(),
+				cwd: data.cwd || process.cwd(),
+				timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+				data: {
+					notification_type: data.notification_type,
+					title: data.title,
+					message: data.message
+				}
+			}),
+			signal: AbortSignal.timeout(2e3)
+		});
+	} catch {}
+}
+main();
+
+//#endregion
+export {  };
+//# sourceMappingURL=notification.mjs.map

package/dist/hooks/notification.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"notification.mjs","names":[],"sources":["../../src/hooks/notification.ts"],"sourcesContent":["#!/usr/bin/env node\n\nconst REST_URL = process.env[\"AGENTMEMORY_URL\"] || \"http://localhost:3111\";\nconst SECRET = process.env[\"AGENTMEMORY_SECRET\"] || \"\";\n\nfunction authHeaders(): Record<string, string> {\n  const h: Record<string, string> = { \"Content-Type\": \"application/json\" };\n  if (SECRET) h[\"Authorization\"] = `Bearer ${SECRET}`;\n  return h;\n}\n\nasync function main() {\n  let input = \"\";\n  for await (const chunk of process.stdin) {\n    input += chunk;\n  }\n\n  let data: Record<string, unknown>;\n  try {\n    data = JSON.parse(input);\n  } catch {\n    return;\n  }\n\n  if (data.notification_type !== \"permission_prompt\") return;\n\n  const sessionId = (data.session_id as string) || \"unknown\";\n\n  try {\n    await fetch(`${REST_URL}/agentmemory/observe`, {\n      method: \"POST\",\n      headers: authHeaders(),\n      body: JSON.stringify({\n        hookType: \"notification\",\n        sessionId,\n        project: data.cwd || process.cwd(),\n        cwd: data.cwd || process.cwd(),\n        timestamp: new Date().toISOString(),\n        data: {\n          notification_type: data.notification_type,\n          title: data.title,\n          message: data.message,\n        },\n      }),\n      signal: AbortSignal.timeout(2000),\n    });\n  } catch {\n    // fire and forget\n  }\n}\n\nmain();\n"],"mappings":";;AAEA,MAAM,WAAW,QAAQ,IAAI,sBAAsB;AACnD,MAAM,SAAS,QAAQ,IAAI,yBAAyB;AAEpD,SAAS,cAAsC;CAC7C,MAAM,IAA4B,EAAE,gBAAgB,oBAAoB;AACxE,KAAI,OAAQ,GAAE,mBAAmB,UAAU;AAC3C,QAAO;;AAGT,eAAe,OAAO;CACpB,IAAI,QAAQ;AACZ,YAAW,MAAM,SAAS,QAAQ,MAChC,UAAS;CAGX,IAAI;AACJ,KAAI;AACF,SAAO,KAAK,MAAM,MAAM;SAClB;AACN;;AAGF,KAAI,KAAK,sBAAsB,oBAAqB;CAEpD,MAAM,YAAa,KAAK,cAAyB;AAEjD,KAAI;AACF,QAAM,MAAM,GAAG,SAAS,uBAAuB;GAC7C,QAAQ;GACR,SAAS,aAAa;GACtB,MAAM,KAAK,UAAU;IACnB,UAAU;IACV;IACA,SAAS,KAAK,OAAO,QAAQ,KAAK;IAClC,KAAK,KAAK,OAAO,QAAQ,KAAK;IAC9B,4BAAW,IAAI,MAAM,EAAC,aAAa;IACnC,MAAM;KACJ,mBAAmB,KAAK;KACxB,OAAO,KAAK;KACZ,SAAS,KAAK;KACf;IACF,CAAC;GACF,QAAQ,YAAY,QAAQ,IAAK;GAClC,CAAC;SACI;;AAKV,MAAM"}

package/dist/hooks/post-tool-failure.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/hooks/post-tool-failure.mjs

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+//#region src/hooks/post-tool-failure.ts
+const REST_URL = process.env["AGENTMEMORY_URL"] || "http://localhost:3111";
+const SECRET = process.env["AGENTMEMORY_SECRET"] || "";
+function authHeaders() {
+	const h = { "Content-Type": "application/json" };
+	if (SECRET) h["Authorization"] = `Bearer ${SECRET}`;
+	return h;
+}
+async function main() {
+	let input = "";
+	for await (const chunk of process.stdin) input += chunk;
+	let data;
+	try {
+		data = JSON.parse(input);
+	} catch {
+		return;
+	}
+	if (data.is_interrupt) return;
+	const sessionId = data.session_id || "unknown";
+	try {
+		await fetch(`${REST_URL}/agentmemory/observe`, {
+			method: "POST",
+			headers: authHeaders(),
+			body: JSON.stringify({
+				hookType: "post_tool_failure",
+				sessionId,
+				project: data.cwd || process.cwd(),
+				cwd: data.cwd || process.cwd(),
+				timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+				data: {
+					tool_name: data.tool_name,
+					tool_input: typeof data.tool_input === "string" ? data.tool_input.slice(0, 4e3) : JSON.stringify(data.tool_input ?? "").slice(0, 4e3),
+					error: typeof data.error === "string" ? data.error.slice(0, 4e3) : JSON.stringify(data.error ?? "").slice(0, 4e3)
+				}
+			}),
+			signal: AbortSignal.timeout(3e3)
+		});
+	} catch {}
+}
+main();
+
+//#endregion
+export {  };
+//# sourceMappingURL=post-tool-failure.mjs.map