crewswarm-cli 0.1.0

package/dist/memory.mjs

@@ -0,0 +1,850 @@
+// src/memory/agentkeeper.ts
+import { appendFile, mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { randomUUID } from "node:crypto";
+function tokenize(text) {
+  return new Set(
+    text.toLowerCase().replace(/[^a-z0-9\s_-]/g, " ").split(/\s+/).filter((t) => t.length > 2)
+  );
+}
+function similarity(a, b) {
+  if (a.size === 0 || b.size === 0) return 0;
+  let intersection = 0;
+  for (const token of a) {
+    if (b.has(token)) intersection++;
+  }
+  return intersection / Math.max(a.size, b.size);
+}
+var AgentKeeper = class {
+  constructor(baseDir, options = {}) {
+    this.writeCount = 0;
+    const storageBase = options.storageDir || process.env.CREW_MEMORY_DIR || baseDir;
+    this.storePath = join(storageBase, ".crew", "agentkeeper.jsonl");
+    this.maxEntries = options.maxEntries ?? 500;
+    this.maxBytes = options.maxBytes ?? 2e6;
+    this.maxAgeDays = options.maxAgeDays ?? 30;
+    this.autoCompactEvery = options.autoCompactEvery ?? 20;
+    this.semanticDedupe = options.semanticDedupe ?? true;
+    this.dedupeThreshold = options.dedupeThreshold ?? 0.9;
+  }
+  redactText(input) {
+    let out = String(input || "");
+    const replacements = [
+      [/\bsk-[A-Za-z0-9]{16,}\b/g, "[REDACTED_API_KEY]"],
+      [/\b(?:ghp|gho|ghu|ghs|github_pat)_[A-Za-z0-9_]{16,}\b/g, "[REDACTED_GITHUB_TOKEN]"],
+      [/\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi, "[REDACTED_EMAIL]"],
+      [/\beyJ[A-Za-z0-9_\-]{8,}\.[A-Za-z0-9_\-]{8,}\.[A-Za-z0-9_\-]{8,}\b/g, "[REDACTED_JWT]"],
+      [/\b[A-Fa-f0-9]{40,}\b/g, "[REDACTED_HEX_TOKEN]"],
+      [/\b[A-Za-z0-9+/]{80,}={0,2}\b/g, "[REDACTED_BASE64_BLOB]"]
+    ];
+    for (const [rx, replacement] of replacements) {
+      out = out.replace(rx, replacement);
+    }
+    return out;
+  }
+  sanitizeText(input, maxChars = 6e3) {
+    const redacted = this.redactText(String(input || ""));
+    if (redacted.length <= maxChars) return redacted;
+    return `${redacted.slice(0, maxChars)}
+... [truncated ${redacted.length - maxChars} chars]`;
+  }
+  sanitizeMetadata(value, depth = 0) {
+    if (depth > 3) return "[TRUNCATED_DEPTH]";
+    if (value === null || value === void 0) return value;
+    if (typeof value === "string") return this.sanitizeText(value, 1e3);
+    if (typeof value === "number" || typeof value === "boolean") return value;
+    if (Array.isArray(value)) return value.slice(0, 50).map((item) => this.sanitizeMetadata(item, depth + 1));
+    if (typeof value === "object") {
+      const out = {};
+      for (const [k, v] of Object.entries(value).slice(0, 100)) {
+        out[k] = this.sanitizeMetadata(v, depth + 1);
+      }
+      return out;
+    }
+    return String(value);
+  }
+  normalizeStructured(structured) {
+    if (!structured) return void 0;
+    const out = {};
+    if (structured.problem) out.problem = this.sanitizeText(structured.problem, 1200);
+    if (Array.isArray(structured.plan)) {
+      out.plan = structured.plan.slice(0, 50).map((step) => this.sanitizeText(step, 300));
+    }
+    if (Array.isArray(structured.edits)) {
+      out.edits = structured.edits.slice(0, 100).map((edit) => ({
+        path: edit.path ? this.sanitizeText(edit.path, 300) : void 0,
+        summary: edit.summary ? this.sanitizeText(edit.summary, 300) : void 0
+      }));
+    }
+    if (structured.validation) {
+      out.validation = {
+        lintPassed: Boolean(structured.validation.lintPassed),
+        testsPassed: Boolean(structured.validation.testsPassed),
+        notes: structured.validation.notes ? this.sanitizeText(structured.validation.notes, 600) : void 0
+      };
+    }
+    if (structured.outcome) out.outcome = this.sanitizeText(structured.outcome, 600);
+    return out;
+  }
+  estimateStoreBytes(entries) {
+    return entries.reduce((sum, entry) => sum + Buffer.byteLength(JSON.stringify(entry) + "\n", "utf8"), 0);
+  }
+  pruneEntries(entries) {
+    const now = Date.now();
+    const maxAgeMs = Math.max(1, this.maxAgeDays) * 24 * 60 * 60 * 1e3;
+    let kept = entries.filter((entry) => {
+      const ts = Date.parse(entry.timestamp || "");
+      if (!Number.isFinite(ts)) return true;
+      return now - ts <= maxAgeMs;
+    });
+    if (kept.length > this.maxEntries) {
+      kept = kept.slice(-this.maxEntries);
+    }
+    while (kept.length > 1 && this.estimateStoreBytes(kept) > this.maxBytes) {
+      kept = kept.slice(1);
+    }
+    return kept;
+  }
+  dedupeSemantically(entries) {
+    if (!this.semanticDedupe || entries.length < 2) return entries;
+    const keptNewestFirst = [];
+    const keptTokens = [];
+    const descending = entries.slice().reverse();
+    for (const entry of descending) {
+      const entryText = `${entry.task || ""}
+${String(entry.result || "").slice(0, 1200)}`;
+      const entryTokenSet = tokenize(entryText);
+      if (entryTokenSet.size < 6) {
+        keptNewestFirst.push(entry);
+        keptTokens.push(entryTokenSet);
+        continue;
+      }
+      let duplicate = false;
+      for (let i = 0; i < keptNewestFirst.length; i += 1) {
+        const existing = keptNewestFirst[i];
+        if (existing.tier !== entry.tier) continue;
+        if ((existing.agent || "") !== (entry.agent || "")) continue;
+        if (keptTokens[i].size < 6) continue;
+        const sim = similarity(entryTokenSet, keptTokens[i]);
+        if (sim >= this.dedupeThreshold) {
+          duplicate = true;
+          break;
+        }
+      }
+      if (!duplicate) {
+        keptNewestFirst.push(entry);
+        keptTokens.push(entryTokenSet);
+      }
+    }
+    return keptNewestFirst.reverse();
+  }
+  async maybeAutoCompact() {
+    this.writeCount += 1;
+    if (this.writeCount % this.autoCompactEvery !== 0) return;
+    try {
+      await this.compact();
+    } catch {
+    }
+  }
+  /** Append a new memory entry. */
+  async record(entry) {
+    await mkdir(dirname(this.storePath), { recursive: true });
+    const full = {
+      ...entry,
+      id: randomUUID(),
+      task: this.sanitizeText(entry.task, 1200),
+      result: this.sanitizeText(entry.result, 6e3),
+      structured: this.normalizeStructured(entry.structured),
+      metadata: this.sanitizeMetadata(entry.metadata),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const line = JSON.stringify(full) + "\n";
+    await appendFile(this.storePath, line, "utf8");
+    await this.maybeAutoCompact();
+    return full;
+  }
+  /** Best-effort append: never throws, returns success state. */
+  async recordSafe(entry) {
+    try {
+      const saved = await this.record(entry);
+      return { ok: true, entry: saved };
+    } catch (error) {
+      return { ok: false, error: error.message };
+    }
+  }
+  /** Load all entries from the JSONL store. */
+  async loadAll() {
+    let raw;
+    try {
+      raw = await readFile(this.storePath, "utf8");
+    } catch {
+      return [];
+    }
+    const entries = [];
+    for (const line of raw.split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        entries.push(JSON.parse(line));
+      } catch {
+      }
+    }
+    return entries;
+  }
+  /**
+   * Retrieve entries similar to the given task description.
+   * Returns up to `maxResults` matches sorted by similarity score descending.
+   */
+  async recall(task, maxResults = 5, options = {}) {
+    const entries = await this.loadAll();
+    if (entries.length === 0) return [];
+    const queryTokens = tokenize(task);
+    const now = options.nowMs || Date.now();
+    const hints = new Set((options.pathHints || []).map((x) => String(x || "").trim()).filter(Boolean));
+    const scored = [];
+    for (const entry of entries) {
+      const entryTokens = tokenize(entry.task);
+      const sim = similarity(queryTokens, entryTokens);
+      let recencyBoost = 0;
+      const ts = Date.parse(entry.timestamp || "");
+      if (Number.isFinite(ts)) {
+        const ageDays = Math.max(0, (now - ts) / (24 * 60 * 60 * 1e3));
+        recencyBoost = Math.max(0, 1 - Math.min(ageDays, 30) / 30) * 0.15;
+      }
+      let successBoost = 0;
+      const success = Boolean(entry.metadata?.success) || Boolean(entry.structured?.outcome?.toLowerCase().includes("success"));
+      if (options.preferSuccessful !== false && success) {
+        successBoost = 0.1;
+      }
+      let pathBoost = 0;
+      if (hints.size > 0) {
+        const entryPaths = /* @__PURE__ */ new Set();
+        for (const edit of entry.structured?.edits || []) {
+          if (edit.path) entryPaths.add(edit.path);
+        }
+        const metadataPaths = entry.metadata?.paths;
+        if (Array.isArray(metadataPaths)) {
+          for (const p of metadataPaths) {
+            entryPaths.add(String(p || ""));
+          }
+        }
+        let overlap = 0;
+        for (const h of hints) {
+          if (entryPaths.has(h)) overlap += 1;
+        }
+        if (overlap > 0) {
+          pathBoost = Math.min(0.2, overlap / Math.max(1, hints.size) * 0.2);
+        }
+      }
+      const score = sim + recencyBoost + successBoost + pathBoost;
+      if (score > 0.15) {
+        scored.push({ entry, score: Math.round(score * 100) / 100 });
+      }
+    }
+    scored.sort((a, b) => b.score - a.score);
+    return scored.slice(0, maxResults);
+  }
+  /**
+   * Format recalled memories into a context block for prompt injection.
+   * Recent entries shown full, older entries compressed (progressive disclosure pattern).
+   */
+  async recallAsContext(task, maxResults = 3, options = {}) {
+    const matches = await this.recall(task, maxResults, options);
+    if (matches.length === 0) return "";
+    const lines = ["## Prior Task Memory"];
+    const keepFullCount = Math.min(5, Math.ceil(matches.length * 0.5));
+    for (let i = 0; i < matches.length; i++) {
+      const m = matches[i];
+      const isFull = i < keepFullCount;
+      if (isFull) {
+        const resultPreview = m.entry.result.length > 400 ? m.entry.result.slice(0, 400) + "..." : m.entry.result;
+        lines.push(`### [${m.entry.tier}] ${m.entry.task} (score: ${m.score})`);
+        if (m.entry.agent) lines.push(`Agent: ${m.entry.agent}`);
+        lines.push(`Result: ${resultPreview}`);
+        lines.push("");
+      } else {
+        const hasError = /error|failed|exception/i.test(m.entry.result);
+        const statusIcon = hasError ? "\u274C" : "\u2713";
+        const preview = m.entry.result.slice(0, 120);
+        lines.push(`### ${statusIcon} [${m.entry.tier}] ${m.entry.task}`);
+        lines.push(`${preview}... [${hasError ? "failed" : "completed"}]`);
+        lines.push("");
+      }
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Compact the store: keep only the most recent `maxEntries` entries.
+   */
+  async compact() {
+    const entries = await this.loadAll();
+    const entriesBefore = entries.length;
+    let bytesBefore = 0;
+    try {
+      const st = await stat(this.storePath);
+      bytesBefore = st.size;
+    } catch {
+      bytesBefore = 0;
+    }
+    const deduped = this.dedupeSemantically(entries);
+    const kept = this.pruneEntries(deduped);
+    if (kept.length === entries.length) {
+      return { entriesBefore, entriesAfter: kept.length, bytesFreed: 0 };
+    }
+    const content = kept.map((e) => JSON.stringify(e)).join("\n") + "\n";
+    await writeFile(this.storePath, content, "utf8");
+    let bytesAfter = 0;
+    try {
+      const st = await stat(this.storePath);
+      bytesAfter = st.size;
+    } catch {
+      bytesAfter = content.length;
+    }
+    return {
+      entriesBefore,
+      entriesAfter: kept.length,
+      bytesFreed: Math.max(0, bytesBefore - bytesAfter)
+    };
+  }
+  /** Get summary stats. */
+  async stats() {
+    const entries = await this.loadAll();
+    const byTier = {};
+    const byAgent = {};
+    for (const e of entries) {
+      byTier[e.tier] = (byTier[e.tier] || 0) + 1;
+      if (e.agent) byAgent[e.agent] = (byAgent[e.agent] || 0) + 1;
+    }
+    return { entries: entries.length, byTier, byAgent, bytes: this.estimateStoreBytes(entries) };
+  }
+};
+
+// src/pipeline/agent-memory.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join as join2, resolve } from "node:path";
+var AgentMemory = class {
+  constructor(agentId, options) {
+    const baseDir = options?.storageDir || process.env.CREW_MEMORY_DIR || process.cwd();
+    this.storageDir = resolve(baseDir, ".crew", "agent-memory");
+    this.ensureStorageDir();
+    this.state = this.loadOrCreate(agentId);
+  }
+  /**
+   * Store a fact in agent memory
+   */
+  remember(content, options = {}) {
+    const fact = {
+      id: randomUUID2(),
+      content,
+      critical: options.critical || false,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      tags: options.tags || [],
+      provider: options.provider
+    };
+    this.state.facts.push(fact);
+    this.state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.persist();
+    return fact.id;
+  }
+  /**
+   * Remove a fact by ID
+   */
+  forget(factId) {
+    const before = this.state.facts.length;
+    this.state.facts = this.state.facts.filter((f) => f.id !== factId);
+    if (this.state.facts.length < before) {
+      this.state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.persist();
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Recall facts optimized for current context
+   * Priority: critical facts first, then most recent
+   */
+  recall(options = {}) {
+    const budget = options.tokenBudget || 2e3;
+    const estimatedCharsPerToken = 4;
+    const charBudget = budget * estimatedCharsPerToken;
+    let facts = this.state.facts;
+    if (options.criticalOnly) {
+      facts = facts.filter((f) => f.critical);
+    }
+    if (options.tags && options.tags.length > 0) {
+      facts = facts.filter(
+        (f) => options.tags.some((tag) => f.tags.includes(tag))
+      );
+    }
+    if (options.provider) {
+      facts = facts.filter((f) => !f.provider || f.provider === options.provider);
+    }
+    facts.sort((a, b) => {
+      if (a.critical && !b.critical) return -1;
+      if (!a.critical && b.critical) return 1;
+      return new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime();
+    });
+    const selected = [];
+    let used = 0;
+    for (const fact of facts) {
+      const block = `[${fact.critical ? "CRITICAL" : "INFO"}] ${fact.content}
+`;
+      if (used + block.length > charBudget) break;
+      selected.push(fact);
+      used += block.length;
+    }
+    if (selected.length === 0) return "";
+    const header = "=== AGENT MEMORY (Context from previous decisions) ===\n";
+    const body = selected.map(
+      (f) => `[${f.critical ? "CRITICAL" : "INFO"}] ${f.content}`
+    ).join("\n");
+    const footer = "\n=== END AGENT MEMORY ===\n";
+    return header + body + footer;
+  }
+  /**
+   * Search facts by lexical similarity for brokered retrieval.
+   */
+  search(query, options = {}) {
+    const maxResults = Math.max(1, Number(options.maxResults || 5));
+    const qTokens = new Set(
+      String(query || "").toLowerCase().replace(/[^a-z0-9\s_-]/g, " ").split(/\s+/).filter((t) => t.length > 2)
+    );
+    let facts = this.state.facts.slice();
+    if (options.tags && options.tags.length > 0) {
+      facts = facts.filter((f) => options.tags.some((tag) => f.tags.includes(tag)));
+    }
+    if (options.provider) {
+      facts = facts.filter((f) => !f.provider || f.provider === options.provider);
+    }
+    const score = (fact) => {
+      const toks = new Set(
+        String(fact.content || "").toLowerCase().replace(/[^a-z0-9\s_-]/g, " ").split(/\s+/).filter((t) => t.length > 2)
+      );
+      if (qTokens.size === 0 || toks.size === 0) return 0;
+      let inter = 0;
+      for (const t of qTokens) {
+        if (toks.has(t)) inter += 1;
+      }
+      const sim = inter / Math.max(qTokens.size, toks.size);
+      return sim + (fact.critical ? 0.1 : 0);
+    };
+    const ranked = facts.map((f) => ({ fact: f, score: score(f) })).filter((x) => x.score > 0.12).sort((a, b) => b.score - a.score).slice(0, maxResults).map((x) => x.fact);
+    return ranked;
+  }
+  /**
+   * Get memory statistics
+   */
+  stats() {
+    const facts = this.state.facts || [];
+    const timestamps = facts.map((f) => f.timestamp).sort();
+    const providers = Array.from(new Set(
+      facts.map((f) => f.provider).filter(Boolean)
+    ));
+    return {
+      totalFacts: facts.length,
+      criticalFacts: facts.filter((f) => f.critical).length,
+      providers,
+      oldestFact: timestamps[0] || null,
+      newestFact: timestamps[timestamps.length - 1] || null
+    };
+  }
+  /**
+   * Clear all facts (useful for testing)
+   */
+  clear() {
+    this.state.facts = [];
+    this.state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.persist();
+  }
+  loadOrCreate(agentId) {
+    const path = this.getStatePath(agentId);
+    if (existsSync(path)) {
+      try {
+        const raw = readFileSync(path, "utf8");
+        return JSON.parse(raw);
+      } catch (err) {
+        console.warn(`[AgentMemory] Failed to load state for ${agentId}, creating new`);
+      }
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    return {
+      agentId,
+      facts: [],
+      createdAt: now,
+      updatedAt: now
+    };
+  }
+  persist() {
+    const path = this.getStatePath(this.state.agentId);
+    writeFileSync(path, JSON.stringify(this.state, null, 2), "utf8");
+  }
+  getStatePath(agentId) {
+    return join2(this.storageDir, `${agentId}.json`);
+  }
+  ensureStorageDir() {
+    if (!existsSync(this.storageDir)) {
+      mkdirSync(this.storageDir, { recursive: true });
+    }
+  }
+};
+
+// src/memory/broker.ts
+import { resolve as resolve3, join as join4 } from "node:path";
+
+// src/collections/index.ts
+import { readdir, readFile as readFile2, stat as stat2 } from "node:fs/promises";
+import { extname, join as join3, relative, resolve as resolve2 } from "node:path";
+var DOC_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".mdx", ".txt", ".rst", ".adoc"]);
+var CODE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".json",
+  ".py",
+  ".go",
+  ".rs",
+  ".java",
+  ".kt",
+  ".swift",
+  ".sh",
+  ".bash",
+  ".zsh",
+  ".yaml",
+  ".yml",
+  ".toml"
+]);
+var IGNORED_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".crew",
+  ".next",
+  ".turbo",
+  "coverage",
+  "__pycache__"
+]);
+function tokenize2(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s_-]/g, " ").split(/\s+/).filter((t) => t.length > 1);
+}
+function hashToken(token, dim) {
+  let h = 2166136261;
+  for (let i = 0; i < token.length; i++) {
+    h ^= token.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return Math.abs(h) % dim;
+}
+function toHashedVector(text, dim = 256) {
+  const vec = new Float64Array(dim);
+  const toks = tokenize2(text);
+  for (const t of toks) {
+    vec[hashToken(t, dim)] += 1;
+  }
+  let norm = 0;
+  for (let i = 0; i < dim; i++) norm += vec[i] * vec[i];
+  norm = Math.sqrt(norm);
+  if (norm > 0) {
+    for (let i = 0; i < dim; i++) vec[i] /= norm;
+  }
+  return vec;
+}
+function cosineSimilarity(a, b) {
+  const dim = Math.min(a.length, b.length);
+  let dot = 0;
+  for (let i = 0; i < dim; i++) {
+    dot += a[i] * b[i];
+  }
+  return dot;
+}
+function chunkFile(content, source) {
+  const lines = content.split("\n");
+  const chunks = [];
+  let currentLines = [];
+  let currentStart = 1;
+  const flush = () => {
+    const text = currentLines.join("\n").trim();
+    if (text.length > 0) {
+      chunks.push({ source, startLine: currentStart, text, score: 0 });
+    }
+    currentLines = [];
+  };
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (/^#{1,4}\s/.test(line) && currentLines.length > 0) {
+      flush();
+      currentStart = i + 1;
+    }
+    currentLines.push(line);
+    if (currentLines.length >= 40 && !/^#{1,4}\s/.test(line)) {
+      flush();
+      currentStart = i + 2;
+    }
+  }
+  flush();
+  return chunks;
+}
+async function walkDocs(rootDir, includeCode = false) {
+  const files = [];
+  async function walk(dir) {
+    let entries;
+    try {
+      entries = await readdir(dir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (IGNORED_DIRS.has(entry)) continue;
+      const fullPath = join3(dir, entry);
+      let st;
+      try {
+        st = await stat2(fullPath);
+      } catch {
+        continue;
+      }
+      if (st.isDirectory()) {
+        await walk(fullPath);
+      } else {
+        const ext = extname(entry).toLowerCase();
+        if (DOC_EXTENSIONS.has(ext) || includeCode && CODE_EXTENSIONS.has(ext)) {
+          files.push(fullPath);
+        }
+      }
+    }
+  }
+  await walk(rootDir);
+  return files;
+}
+async function buildCollectionIndex(paths, options = {}) {
+  const allChunks = [];
+  const roots = paths.map((p) => resolve2(p));
+  let fileCount = 0;
+  for (const rootPath of roots) {
+    let st;
+    try {
+      st = await stat2(rootPath);
+    } catch {
+      continue;
+    }
+    const files = st.isDirectory() ? await walkDocs(rootPath, Boolean(options.includeCode)) : [rootPath];
+    for (const file of files) {
+      let content;
+      try {
+        content = await readFile2(file, "utf8");
+      } catch {
+        continue;
+      }
+      fileCount++;
+      const rel = relative(resolve2(rootPath, st.isDirectory() ? "." : ".."), file);
+      const chunks = chunkFile(content, rel);
+      allChunks.push(...chunks);
+    }
+  }
+  const terms = /* @__PURE__ */ new Map();
+  for (let i = 0; i < allChunks.length; i++) {
+    const tokens = tokenize2(allChunks[i].text);
+    for (const token of tokens) {
+      if (!terms.has(token)) terms.set(token, /* @__PURE__ */ new Set());
+      terms.get(token).add(i);
+    }
+  }
+  return {
+    root: roots[0] || ".",
+    fileCount,
+    chunkCount: allChunks.length,
+    terms,
+    chunks: allChunks
+  };
+}
+function searchCollection(index, query, maxResults = 10) {
+  const queryTokens = tokenize2(query);
+  if (queryTokens.length === 0) {
+    return { query, hits: [], totalChunks: index.chunkCount };
+  }
+  const scores = new Float64Array(index.chunkCount);
+  for (const token of queryTokens) {
+    const matchingChunks = index.terms.get(token);
+    if (!matchingChunks) continue;
+    const idf = Math.log(1 + index.chunkCount / matchingChunks.size);
+    for (const idx of matchingChunks) {
+      scores[idx] += idf;
+    }
+  }
+  const candidates = [];
+  for (let i = 0; i < scores.length; i++) {
+    if (scores[i] > 0) {
+      candidates.push({ idx: i, score: scores[i] });
+    }
+  }
+  candidates.sort((a, b) => b.score - a.score);
+  const queryVector = toHashedVector(query);
+  const maxTfidf = candidates.length > 0 ? candidates[0].score : 1;
+  const tfidfWeight = 0.7;
+  const vectorWeight = 0.3;
+  const hybrid = candidates.map((c) => {
+    const chunk = index.chunks[c.idx];
+    const chunkVector = toHashedVector(chunk.text);
+    const cosine = Math.max(0, cosineSimilarity(queryVector, chunkVector));
+    const tfidfNorm = maxTfidf > 0 ? c.score / maxTfidf : 0;
+    const hybridScore = tfidfNorm * tfidfWeight + cosine * vectorWeight;
+    return { idx: c.idx, score: hybridScore };
+  });
+  hybrid.sort((a, b) => b.score - a.score);
+  const hits = hybrid.slice(0, maxResults).map((c) => ({
+    ...index.chunks[c.idx],
+    score: Math.round(c.score * 1e3) / 1e3
+  }));
+  return { query, hits, totalChunks: index.chunkCount };
+}
+
+// src/memory/broker.ts
+function tokenize3(text) {
+  return new Set(
+    String(text || "").toLowerCase().replace(/[^a-z0-9\s_-]/g, " ").split(/\s+/).filter((t) => t.length > 2)
+  );
+}
+function similarity2(a, b) {
+  if (a.size === 0 || b.size === 0) return 0;
+  let intersection = 0;
+  for (const token of a) {
+    if (b.has(token)) intersection += 1;
+  }
+  return intersection / Math.max(a.size, b.size);
+}
+function mapKeeperHit(m) {
+  return {
+    source: "agentkeeper",
+    score: Number(m.score || 0),
+    title: `[${m.entry.tier}] ${m.entry.task}`,
+    text: m.entry.result,
+    metadata: {
+      agent: m.entry.agent,
+      runId: m.entry.runId,
+      timestamp: m.entry.timestamp
+    }
+  };
+}
+function mapFactHit(f, score) {
+  return {
+    source: "agent-memory",
+    score: Number(score.toFixed(3)),
+    title: `[${f.critical ? "CRITICAL" : "INFO"}] ${f.tags.join(", ") || "memory-fact"}`,
+    text: f.content,
+    metadata: {
+      critical: f.critical,
+      tags: f.tags,
+      timestamp: f.timestamp,
+      provider: f.provider
+    }
+  };
+}
+function mapCollectionHit(c) {
+  return {
+    source: "collections",
+    score: Number(c.score || 0),
+    title: `${c.source}:${c.startLine}`,
+    text: c.text,
+    metadata: {
+      path: c.source,
+      startLine: c.startLine
+    }
+  };
+}
+function normalizeCollectionPathForDedupe(input) {
+  const value = String(input || "").replace(/\\/g, "/").replace(/^\.\/+/, "");
+  if (value.startsWith("docs/")) return value.slice("docs/".length);
+  return value;
+}
+var MemoryBroker = class {
+  constructor(projectDir, options = {}) {
+    this.docsIndexCache = /* @__PURE__ */ new Map();
+    this.projectDir = resolve3(projectDir);
+    this.keeper = new AgentKeeper(this.projectDir, {
+      storageDir: options.storageDir || process.env.CREW_MEMORY_DIR
+    });
+    this.factMemory = new AgentMemory(options.crewId || "crew-lead", {
+      storageDir: options.storageDir || process.env.CREW_MEMORY_DIR || this.projectDir
+    });
+  }
+  scoreFacts(query, facts, max) {
+    const queryTokens = tokenize3(query);
+    const scored = facts.map((f) => {
+      const sim = similarity2(queryTokens, tokenize3(f.content));
+      const criticalBoost = f.critical ? 0.3 : 0;
+      const tagBoost = f.tags.some((t) => query.toLowerCase().includes(t.toLowerCase())) ? 0.15 : 0;
+      return { fact: f, score: sim + criticalBoost + tagBoost };
+    }).filter((x) => x.score > 0.08);
+    scored.sort((a, b) => {
+      if (a.fact.critical && !b.fact.critical) return -1;
+      if (!a.fact.critical && b.fact.critical) return 1;
+      return b.score - a.score;
+    });
+    return scored.slice(0, max).map((x) => mapFactHit(x.fact, x.score));
+  }
+  async getDocsIndex(paths, includeCode) {
+    const key = `${paths.map((p) => resolve3(p)).join("|")}::${includeCode ? "code" : "docs"}`;
+    if (this.docsIndexCache.has(key)) return this.docsIndexCache.get(key);
+    const idx = await buildCollectionIndex(paths, { includeCode });
+    this.docsIndexCache.set(key, idx);
+    return idx;
+  }
+  async recall(query, options = {}) {
+    const maxResults = Math.max(1, Number(options.maxResults || 5));
+    const includeDocs = options.includeDocs !== false;
+    const includeCode = Boolean(options.includeCode);
+    const docsPaths = options.docsPaths && options.docsPaths.length > 0 ? options.docsPaths : [join4(this.projectDir, "docs"), this.projectDir];
+    const [keeperHits, factHits, collectionHits] = await Promise.all([
+      this.keeper.recall(query, Math.max(maxResults, 8), {
+        preferSuccessful: options.preferSuccessful !== false,
+        pathHints: options.pathHints || []
+      }),
+      this.factMemory.search(query, { maxResults: Math.max(maxResults, 8) }),
+      includeDocs ? (async () => {
+        const index = await this.getDocsIndex(docsPaths, includeCode);
+        return searchCollection(index, query, Math.max(maxResults, 8)).hits;
+      })() : Promise.resolve([])
+    ]);
+    const merged = [
+      ...keeperHits.map(mapKeeperHit),
+      ...this.scoreFacts(query, factHits, Math.max(maxResults, 8)),
+      ...collectionHits.map(mapCollectionHit)
+    ];
+    merged.sort((a, b) => b.score - a.score);
+    const seen = /* @__PURE__ */ new Set();
+    const deduped = [];
+    for (const hit of merged) {
+      let signature = `${hit.source}|${hit.title}|${hit.text.slice(0, 180)}`;
+      if (hit.source === "collections") {
+        const path = normalizeCollectionPathForDedupe(String(hit.metadata?.path || hit.title.split(":")[0] || ""));
+        const startLine = Number(hit.metadata?.startLine || 0);
+        signature = `${hit.source}|${path}|${startLine}|${hit.text.slice(0, 220)}`;
+      }
+      if (seen.has(signature)) continue;
+      seen.add(signature);
+      deduped.push(hit);
+      if (deduped.length >= maxResults) break;
+    }
+    return deduped;
+  }
+  async recallAsContext(query, options = {}) {
+    const hits = await this.recall(query, options);
+    if (hits.length === 0) return "";
+    const lines = ["## Shared Memory + RAG Context"];
+    for (const h of hits) {
+      const preview = h.text.length > 260 ? `${h.text.slice(0, 260)}...` : h.text;
+      lines.push(`### [${h.source}] ${h.title} (score: ${h.score.toFixed(3)})`);
+      lines.push(preview);
+      lines.push("");
+    }
+    return lines.join("\n");
+  }
+};
+export {
+  AgentKeeper,
+  AgentMemory,
+  MemoryBroker
+};
+//# sourceMappingURL=memory.mjs.map