cofactor-memory 0.1.0

package/dist/index.js

@@ -0,0 +1,1183 @@
+// src/index.ts
+import path8 from "path";
+
+// src/core/indexer.ts
+import path3 from "path";
+
+// src/core/catalysts.ts
+import crypto from "crypto";
+
+// src/core/entities.ts
+import path from "path";
+
+// src/core/text.ts
+var stopwords = /* @__PURE__ */ new Set([
+  "a",
+  "about",
+  "above",
+  "after",
+  "again",
+  "against",
+  "all",
+  "also",
+  "am",
+  "an",
+  "and",
+  "any",
+  "are",
+  "as",
+  "at",
+  "be",
+  "because",
+  "been",
+  "before",
+  "being",
+  "below",
+  "between",
+  "both",
+  "but",
+  "by",
+  "can",
+  "did",
+  "do",
+  "does",
+  "doing",
+  "down",
+  "during",
+  "each",
+  "few",
+  "for",
+  "from",
+  "further",
+  "had",
+  "has",
+  "have",
+  "having",
+  "he",
+  "her",
+  "here",
+  "hers",
+  "herself",
+  "him",
+  "himself",
+  "his",
+  "how",
+  "i",
+  "if",
+  "in",
+  "into",
+  "is",
+  "it",
+  "its",
+  "itself",
+  "just",
+  "me",
+  "more",
+  "most",
+  "my",
+  "myself",
+  "no",
+  "nor",
+  "not",
+  "now",
+  "of",
+  "off",
+  "on",
+  "once",
+  "only",
+  "or",
+  "other",
+  "our",
+  "ours",
+  "ourselves",
+  "out",
+  "over",
+  "own",
+  "same",
+  "she",
+  "should",
+  "so",
+  "some",
+  "such",
+  "than",
+  "that",
+  "the",
+  "their",
+  "theirs",
+  "them",
+  "themselves",
+  "then",
+  "there",
+  "these",
+  "they",
+  "this",
+  "those",
+  "through",
+  "to",
+  "too",
+  "under",
+  "until",
+  "up",
+  "very",
+  "was",
+  "we",
+  "were",
+  "what",
+  "when",
+  "where",
+  "which",
+  "while",
+  "who",
+  "whom",
+  "why",
+  "will",
+  "with",
+  "you",
+  "your",
+  "yours",
+  "yourself",
+  "yourselves"
+]);
+var aliases = {
+  auth: ["authentication", "identity", "login", "session"],
+  authentication: ["auth", "identity", "login", "session"],
+  build: ["ship", "implement", "create", "make"],
+  changed: ["shift", "pivot", "direction", "rewrite"],
+  change: ["shift", "pivot", "direction", "rewrite"],
+  complexity: ["risk", "friction", "maintenance", "tradeoff"],
+  cost: ["budget", "price", "expense", "tradeoff"],
+  decision: ["choice", "adr", "direction", "tradeoff"],
+  direction: ["change", "shift", "strategy", "decision"],
+  memory: ["recall", "context", "knowledge", "notes"],
+  notes: ["memory", "knowledge", "writing", "docs"],
+  problem: ["issue", "risk", "blocker", "challenge"],
+  search: ["retrieval", "recall", "find", "lookup"],
+  session: ["auth", "authentication", "identity", "login"],
+  tension: ["tradeoff", "conflict", "risk", "constraint"],
+  user: ["customer", "person", "people", "reader"]
+};
+function extractFrontmatter(raw) {
+  if (!raw.startsWith("---\n") && !raw.startsWith("---\r\n")) {
+    return { frontmatter: {}, body: raw };
+  }
+  const normalized = raw.replace(/\r\n/g, "\n");
+  const end = normalized.indexOf("\n---\n", 4);
+  if (end === -1) {
+    return { frontmatter: {}, body: raw };
+  }
+  const block = normalized.slice(4, end);
+  const body = normalized.slice(end + "\n---\n".length);
+  return { frontmatter: parseSimpleYaml(block), body };
+}
+function parseSimpleYaml(block) {
+  const data = {};
+  const lines = block.split("\n");
+  let activeArrayKey;
+  for (const rawLine of lines) {
+    const line = rawLine.trimEnd();
+    if (!line.trim() || line.trimStart().startsWith("#")) {
+      continue;
+    }
+    const itemMatch = line.match(/^\s*-\s+(.+)$/);
+    if (itemMatch && activeArrayKey) {
+      const current = data[activeArrayKey];
+      const values = Array.isArray(current) ? current : [];
+      values.push(cleanYamlValue(itemMatch[1] ?? ""));
+      data[activeArrayKey] = values;
+      continue;
+    }
+    activeArrayKey = void 0;
+    const match = line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+    if (!match) {
+      continue;
+    }
+    const key = match[1].toLowerCase();
+    const value = match[2] ?? "";
+    if (!value.trim()) {
+      data[key] = [];
+      activeArrayKey = key;
+      continue;
+    }
+    const arrayMatch = value.trim().match(/^\[(.*)]$/);
+    if (arrayMatch) {
+      data[key] = arrayMatch[1].split(",").map(cleanYamlValue).filter(Boolean);
+      continue;
+    }
+    data[key] = cleanYamlValue(value);
+  }
+  return data;
+}
+function cleanYamlValue(value) {
+  return value.trim().replace(/^['"]|['"]$/g, "");
+}
+function frontmatterDate(frontmatter, keys) {
+  for (const key of keys) {
+    const value = frontmatter[key];
+    if (typeof value === "string" && value.trim()) {
+      const date = new Date(value);
+      if (!Number.isNaN(date.getTime())) {
+        return date.toISOString();
+      }
+    }
+  }
+  return void 0;
+}
+function frontmatterList(frontmatter, key) {
+  const value = frontmatter[key];
+  if (!value) {
+    return [];
+  }
+  if (Array.isArray(value)) {
+    return value.map(normalizeTag).filter(Boolean);
+  }
+  return value.split(",").map(normalizeTag).filter(Boolean);
+}
+function normalizeTag(tag) {
+  return tag.trim().replace(/^#/, "").toLowerCase();
+}
+function markdownTitle(body, fallback) {
+  const heading = body.match(/^#\s+(.+)$/m);
+  if (heading?.[1]) {
+    return heading[1].trim();
+  }
+  return fallback.replace(/\.[^.]+$/, "").replace(/[-_]+/g, " ");
+}
+function stripMarkdown(raw) {
+  return raw.replace(/```[\s\S]*?```/g, " ").replace(/`([^`]+)`/g, "$1").replace(/!\[[^\]]*]\([^)]*\)/g, " ").replace(/\[([^\]]+)]\([^)]*\)/g, "$1").replace(/\[\[([^\]|#]+)(?:#[^\]|]+)?(?:\|([^\]]+))?]]/g, "$2 $1").replace(/^#{1,6}\s+/gm, "").replace(/[*_~>|-]+/g, " ").replace(/\s+/g, " ").trim();
+}
+function tokenize(text, includeAliases = true) {
+  const normalized = stripMarkdown(text).toLowerCase().replace(/['’]/g, "").replace(/[^a-z0-9]+/g, " ");
+  const base = normalized.split(/\s+/).map(stem).filter((token) => token.length > 1 && !stopwords.has(token));
+  if (!includeAliases) {
+    return base;
+  }
+  const expanded = [];
+  for (const token of base) {
+    expanded.push(token);
+    const synonymSet = aliases[token];
+    if (synonymSet) {
+      expanded.push(...synonymSet.map(stem));
+    }
+  }
+  return expanded;
+}
+function topTerms(tokens, limit = 8) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const token of tokens) {
+    counts.set(token, (counts.get(token) ?? 0) + 1);
+  }
+  return [...counts.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, limit).map(([term]) => term);
+}
+function phraseTerms(text, limit = 8) {
+  const tokens = tokenize(text, false);
+  const counts = /* @__PURE__ */ new Map();
+  for (let size = 2; size <= 3; size += 1) {
+    for (let index = 0; index <= tokens.length - size; index += 1) {
+      const phrase = tokens.slice(index, index + size).join(" ");
+      if (phrase.length > 4) {
+        counts.set(phrase, (counts.get(phrase) ?? 0) + 1);
+      }
+    }
+  }
+  return [...counts.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, limit).map(([term]) => term);
+}
+function splitWords(text) {
+  return stripMarkdown(text).split(/\s+/).filter(Boolean);
+}
+function chunkByWords(text, chunkSize, overlap) {
+  const words = splitWords(text);
+  if (words.length <= chunkSize) {
+    return [words.join(" ")];
+  }
+  const chunks = [];
+  const step = Math.max(1, chunkSize - overlap);
+  for (let start = 0; start < words.length; start += step) {
+    const chunk = words.slice(start, start + chunkSize).join(" ");
+    if (chunk.trim()) {
+      chunks.push(chunk);
+    }
+    if (start + chunkSize >= words.length) {
+      break;
+    }
+  }
+  return chunks;
+}
+function snippet(text, maxChars = 900) {
+  const clean = stripMarkdown(text);
+  if (clean.length <= maxChars) {
+    return clean;
+  }
+  return `${clean.slice(0, maxChars - 1).trim()}...`;
+}
+function stem(token) {
+  if (token.length > 5 && token.endsWith("ing")) {
+    return token.slice(0, -3);
+  }
+  if (token.length > 4 && token.endsWith("ied")) {
+    return `${token.slice(0, -3)}y`;
+  }
+  if (token.length > 4 && token.endsWith("ed")) {
+    return token.slice(0, -2);
+  }
+  if (token.length > 4 && token.endsWith("es")) {
+    return token.slice(0, -2);
+  }
+  if (token.length > 3 && token.endsWith("s")) {
+    return token.slice(0, -1);
+  }
+  return token;
+}
+
+// src/core/entities.ts
+function entityId(type, name) {
+  return `${type}:${normalizeEntityName(type, name)}`;
+}
+function normalizeEntityName(type, name) {
+  const clean = name.trim().replace(/\s+/g, " ");
+  if (type === "tag") {
+    return normalizeTag(clean);
+  }
+  if (type === "folder") {
+    return clean.replace(/^\/+|\/+$/g, "");
+  }
+  return clean;
+}
+function entityDisplayName(type, name) {
+  if (type === "tag") {
+    return `#${name}`;
+  }
+  if (type === "link") {
+    return `[[${name}]]`;
+  }
+  if (name === ".") {
+    return "root folder";
+  }
+  return name ? `folder:${name}` : "folder:.";
+}
+function entityTypeFromId(id) {
+  const type = id.split(":", 1)[0];
+  if (type === "tag" || type === "link" || type === "folder") {
+    return type;
+  }
+  throw new Error(`Unknown entity type in id: ${id}`);
+}
+function entityNameFromId(id) {
+  const separator = id.indexOf(":");
+  return separator === -1 ? id : id.slice(separator + 1);
+}
+function extractEntities(body, frontmatter, relativePath) {
+  const tags = new Set(frontmatterList(frontmatter, "tags"));
+  const links = /* @__PURE__ */ new Set();
+  const folders = /* @__PURE__ */ new Set(["."]);
+  for (const match of body.matchAll(/(^|[\s([{>])#([A-Za-z][A-Za-z0-9_/-]{1,64})\b/g)) {
+    const tag = normalizeTag(match[2] ?? "");
+    if (tag) {
+      tags.add(tag);
+    }
+  }
+  for (const match of body.matchAll(/\[\[([^\]|#]+)(?:#[^\]|]+)?(?:\|[^\]]+)?]]/g)) {
+    const link = normalizeEntityName("link", match[1] ?? "");
+    if (link) {
+      links.add(link);
+    }
+  }
+  const dirname = path.dirname(relativePath).replace(/\\/g, "/");
+  if (dirname !== ".") {
+    const parts = dirname.split("/").filter(Boolean);
+    for (let index = 0; index < parts.length; index += 1) {
+      folders.add(parts.slice(0, index + 1).join("/"));
+    }
+  }
+  const entityIds = [
+    ...[...tags].map((name) => entityId("tag", name)),
+    ...[...links].map((name) => entityId("link", name)),
+    ...[...folders].map((name) => entityId("folder", name))
+  ];
+  return {
+    entityIds: [...new Set(entityIds)].sort(),
+    folders: [...folders].sort(),
+    links: [...links].sort(),
+    tags: [...tags].sort()
+  };
+}
+
+// src/core/time.ts
+var dayMs = 24 * 60 * 60 * 1e3;
+function ageInDays(dateIso, now = /* @__PURE__ */ new Date()) {
+  const date = new Date(dateIso);
+  if (Number.isNaN(date.getTime())) {
+    return 0;
+  }
+  return Math.max(0, (now.getTime() - date.getTime()) / dayMs);
+}
+function recencyScore(dateIso, halfLifeDays, now = /* @__PURE__ */ new Date()) {
+  return Math.exp(-Math.log(2) * ageInDays(dateIso, now) / Math.max(1, halfLifeDays));
+}
+function quarterLabel(dateIso) {
+  const date = new Date(dateIso);
+  if (Number.isNaN(date.getTime())) {
+    return "unknown";
+  }
+  return `${date.getUTCFullYear()} Q${Math.floor(date.getUTCMonth() / 3) + 1}`;
+}
+function inferTrend(dates, now = /* @__PURE__ */ new Date()) {
+  if (dates.length === 0) {
+    return "stable";
+  }
+  const ages = dates.map((date) => ageInDays(date, now));
+  const recent = ages.filter((age) => age <= 90).length;
+  const previous = ages.filter((age) => age > 90 && age <= 365).length;
+  const freshest = Math.min(...ages);
+  if (recent >= Math.max(2, previous * 1.35)) {
+    return "rising";
+  }
+  if (freshest <= 120) {
+    return "active";
+  }
+  if (freshest > 365) {
+    return "dormant";
+  }
+  return "stable";
+}
+function frequencyInLastYear(dates, now = /* @__PURE__ */ new Date()) {
+  return dates.filter((date) => ageInDays(date, now) <= 365).length;
+}
+function minIso(dates) {
+  return dates.reduce((min, value) => value < min ? value : min, dates[0] ?? (/* @__PURE__ */ new Date(0)).toISOString());
+}
+function maxIso(dates) {
+  return dates.reduce((max, value) => value > max ? value : max, dates[0] ?? (/* @__PURE__ */ new Date(0)).toISOString());
+}
+
+// src/core/vector.ts
+function buildIdf(tokenSets) {
+  const docFrequency = /* @__PURE__ */ new Map();
+  for (const tokens of tokenSets) {
+    for (const token of new Set(tokens)) {
+      docFrequency.set(token, (docFrequency.get(token) ?? 0) + 1);
+    }
+  }
+  const count = Math.max(1, tokenSets.length);
+  const idf = {};
+  for (const [token, frequency] of docFrequency.entries()) {
+    idf[token] = Math.log((count + 1) / (frequency + 1)) + 1;
+  }
+  return idf;
+}
+function vectorizeText(text, idf) {
+  return vectorizeTokens(tokenize(text), idf);
+}
+function vectorizeTokens(tokens, idf) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const token of tokens) {
+    counts.set(token, (counts.get(token) ?? 0) + 1);
+  }
+  const vector = {};
+  const defaultIdf = Object.keys(idf).length > 0 ? Math.max(...Object.values(idf)) : 1;
+  for (const [token, count] of counts.entries()) {
+    vector[token] = (1 + Math.log(count)) * (idf[token] ?? defaultIdf);
+  }
+  return normalizeVector(vector);
+}
+function normalizeVector(vector) {
+  const norm = Math.sqrt(Object.values(vector).reduce((sum, value) => sum + value * value, 0));
+  if (!norm) {
+    return vector;
+  }
+  const normalized = {};
+  for (const [term, value] of Object.entries(vector)) {
+    normalized[term] = value / norm;
+  }
+  return normalized;
+}
+function cosine(a, b) {
+  let score = 0;
+  const [small, large] = Object.keys(a).length < Object.keys(b).length ? [a, b] : [b, a];
+  for (const [term, value] of Object.entries(small)) {
+    score += value * (large[term] ?? 0);
+  }
+  return score;
+}
+
+// src/core/catalysts.ts
+function buildCatalysts(entities, documents, chunks, idf) {
+  const documentById = new Map(documents.map((document) => [document.id, document]));
+  const catalysts = [];
+  for (const entity of entities) {
+    const entityChunks = chunks.filter((chunk) => chunk.entities.includes(entity.id));
+    if (entityChunks.length === 0) {
+      continue;
+    }
+    const entityDocuments = [
+      ...new Map(
+        entityChunks.map((chunk) => documentById.get(chunk.docId)).filter((document) => Boolean(document)).map((document) => [document.id, document])
+      ).values()
+    ];
+    const texts = entityChunks.map((chunk) => chunk.content).join("\n");
+    const terms = pickTerms(texts, entity.topTerms);
+    const timeline = entityDocuments.map((document) => document.createdAt).sort();
+    const era = eraLabel(timeline);
+    const displayName = entityDisplayName(entity.type, entity.name);
+    const candidates = catalystTexts(displayName, entity.type, era, terms, entityChunks);
+    for (const text of candidates) {
+      const vector = vectorizeText(`${displayName} ${text} ${terms.join(" ")}`, idf);
+      const topChunks = entityChunks.map((chunk) => ({ chunkId: chunk.id, score: cosine(vector, chunk.vector) })).filter((match) => match.score > 0).sort((a, b) => b.score - a.score).slice(0, 24);
+      catalysts.push({
+        context: terms.slice(0, 5).join(" / "),
+        entityId: entity.id,
+        entityName: entity.name,
+        entityType: entity.type,
+        era,
+        id: catalystId(entity.id, text),
+        terms,
+        text,
+        topChunks,
+        vector
+      });
+    }
+  }
+  return catalysts;
+}
+function refreshCatalystTopChunks(catalysts, chunks) {
+  return catalysts.map((catalyst) => ({
+    ...catalyst,
+    topChunks: chunks.map((chunk) => ({ chunkId: chunk.id, score: cosine(catalyst.vector, chunk.vector) })).filter((match) => match.score > 0).sort((a, b) => b.score - a.score).slice(0, 32)
+  }));
+}
+function pickTerms(text, seedTerms) {
+  const phrases = phraseTerms(text, 6).map((term) => term.replace(/\s+/g, "_"));
+  const words = topTerms(tokenize(text), 12);
+  return [.../* @__PURE__ */ new Set([...seedTerms, ...phrases, ...words])].slice(0, 10);
+}
+function catalystTexts(displayName, type, era, terms, chunks) {
+  const [a = "this thread", b = "nearby ideas", c = "older context", d = "new evidence"] = terms;
+  const scope = type === "folder" ? displayName : `the ${displayName} material`;
+  const sorted = [...chunks].sort((left, right) => left.createdAt.localeCompare(right.createdAt));
+  const earlyTerm = sorted.length > 1 ? topTerms(tokenize(sorted[0].content), 1)[0] ?? a : a;
+  const recentTerm = sorted.length > 1 ? topTerms(tokenize(sorted[sorted.length - 1].content), 1)[0] ?? b : b;
+  return [
+    `What keeps connecting ${readable(a)} with ${readable(b)} across ${scope}?`,
+    `Where does ${scope} show tension between ${readable(a)} and ${readable(c)}?`,
+    `How did ${scope} shift from ${readable(earlyTerm)} toward ${readable(recentTerm)} during ${era}?`,
+    `Which older notes about ${readable(c)} still matter when ${readable(d)} appears?`
+  ].filter((text, index, all) => all.indexOf(text) === index);
+}
+function eraLabel(dates) {
+  if (dates.length === 0) {
+    return "unknown";
+  }
+  const first = quarterLabel(minIso(dates));
+  const last = quarterLabel(maxIso(dates));
+  return first === last ? first : `${first} to ${last}`;
+}
+function readable(term) {
+  return term.replace(/_/g, " ");
+}
+function catalystId(entityId2, text) {
+  const hash = crypto.createHash("sha1").update(`${entityId2}
+${text}`).digest("hex").slice(0, 12);
+  return `cat_${hash}`;
+}
+
+// src/core/discover.ts
+import { promises as fs } from "fs";
+import path2 from "path";
+async function discoverDocuments(rootPath, config) {
+  const root = path2.resolve(rootPath);
+  const files = await walk(root, config);
+  const sortedFiles = files.sort((a, b) => a.localeCompare(b)).slice(0, config.maxFiles);
+  const documents = await Promise.all(
+    sortedFiles.map(async (filePath) => readDocument(root, filePath))
+  );
+  return documents.filter((document) => document.wordCount > 0);
+}
+async function readDocument(root, filePath) {
+  const content = await fs.readFile(filePath, "utf8");
+  const stat = await fs.stat(filePath);
+  const relativePath = path2.relative(root, filePath).replace(/\\/g, "/");
+  const { frontmatter, body } = extractFrontmatter(content);
+  const cleanText = stripMarkdown(body);
+  const fallbackCreated = stat.birthtimeMs > 0 ? stat.birthtime : stat.mtime;
+  const createdAt = frontmatterDate(frontmatter, ["created", "created_at", "date"]) ?? fallbackCreated.toISOString();
+  const modifiedAt = frontmatterDate(frontmatter, ["modified", "updated", "updated_at"]) ?? stat.mtime.toISOString();
+  const extracted = extractEntities(body, frontmatter, relativePath);
+  return {
+    content: body,
+    createdAt,
+    entities: extracted.entityIds,
+    folders: extracted.folders,
+    frontmatter,
+    id: stableFileId(relativePath),
+    links: extracted.links,
+    modifiedAt,
+    path: filePath,
+    relativePath,
+    tags: extracted.tags,
+    title: markdownTitle(body, path2.basename(filePath)),
+    wordCount: splitWords(cleanText).length
+  };
+}
+async function walk(root, config) {
+  const files = [];
+  const excluded = new Set(config.excludedDirs);
+  const extensions = new Set(config.extensions.map((extension) => extension.toLowerCase()));
+  async function visit(directory) {
+    const entries = await fs.readdir(directory, { withFileTypes: true });
+    for (const entry of entries) {
+      const absolutePath = path2.join(directory, entry.name);
+      if (entry.isDirectory()) {
+        if (!excluded.has(entry.name)) {
+          await visit(absolutePath);
+        }
+        continue;
+      }
+      if (entry.isFile() && extensions.has(path2.extname(entry.name).toLowerCase())) {
+        files.push(absolutePath);
+      }
+    }
+  }
+  await visit(root);
+  return files;
+}
+function stableFileId(relativePath) {
+  return Buffer.from(relativePath).toString("base64url");
+}
+
+// src/core/defaults.ts
+var INDEX_VERSION = "0.1";
+var STORE_DIR = ".cofactor";
+var INDEX_FILE = "index.json";
+var CONFIG_FILE = "config.json";
+var TARGETS_DIR = "targets";
+var defaultConfig = {
+  chunkOverlapWords: 48,
+  chunkSizeWords: 260,
+  excludedDirs: [
+    ".git",
+    ".hg",
+    ".svn",
+    ".cofactor",
+    ".obsidian",
+    ".trash",
+    ".venv",
+    "coverage",
+    "dist",
+    "node_modules"
+  ],
+  extensions: [".md", ".mdx", ".txt"],
+  maxFiles: 1024,
+  maxResults: 8,
+  minEntityDocuments: 1,
+  recencyHalfLifeDays: 180,
+  selectedEntityLimit: 48
+};
+function mergeConfig(overrides) {
+  if (!overrides) {
+    return { ...defaultConfig, excludedDirs: [...defaultConfig.excludedDirs] };
+  }
+  return {
+    ...defaultConfig,
+    ...overrides,
+    excludedDirs: overrides.excludedDirs ?? [...defaultConfig.excludedDirs],
+    extensions: overrides.extensions ?? [...defaultConfig.extensions]
+  };
+}
+
+// src/core/indexer.ts
+async function createIndex(vaultPath, options = {}, kind = "vault", sourceVaultPath) {
+  const config = mergeConfig(options.config);
+  const root = path3.resolve(vaultPath);
+  const documents = await discoverDocuments(root, config);
+  const chunkShells = documents.flatMap((document) => documentChunks(document, config));
+  const tokenSets = chunkShells.map((chunk) => chunk.tokens);
+  const idf = buildIdf(tokenSets);
+  const chunks = chunkShells.map((chunk) => ({
+    ...chunk,
+    vector: vectorizeTokens(chunk.tokens, idf)
+  }));
+  const entities = selectEntities(documents, chunks, idf, config.selectedEntityLimit);
+  const catalysts = buildCatalysts(entities, documents, chunks, idf);
+  const entityCatalystIds = /* @__PURE__ */ new Map();
+  for (const catalyst of catalysts) {
+    const list = entityCatalystIds.get(catalyst.entityId) ?? [];
+    list.push(catalyst.id);
+    entityCatalystIds.set(catalyst.entityId, list);
+  }
+  return {
+    appliedTargets: [],
+    catalysts,
+    chunks,
+    config,
+    documents,
+    entities: entities.map((entity) => ({
+      ...entity,
+      catalystIds: entityCatalystIds.get(entity.id) ?? []
+    })),
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    idf,
+    kind,
+    sourceVaultPath,
+    stats: {
+      catalystCount: catalysts.length,
+      chunkCount: chunks.length,
+      documentCount: documents.length,
+      entityCount: entities.length
+    },
+    targetPath: kind === "target" ? root : void 0,
+    vaultPath: root,
+    version: INDEX_VERSION
+  };
+}
+function documentChunks(document, config) {
+  return chunkByWords(document.content, config.chunkSizeWords, config.chunkOverlapWords).map(
+    (content, ordinal) => ({
+      content,
+      createdAt: document.createdAt,
+      docId: document.id,
+      entities: document.entities,
+      filePath: document.path,
+      id: `${document.id}:${ordinal}`,
+      modifiedAt: document.modifiedAt,
+      ordinal,
+      relativePath: document.relativePath,
+      title: document.title,
+      tokens: tokenize(`${document.title} ${content}`)
+    })
+  );
+}
+function selectEntities(documents, chunks, idf, limit) {
+  const docsByEntity = /* @__PURE__ */ new Map();
+  const chunksByEntity = /* @__PURE__ */ new Map();
+  for (const document of documents) {
+    for (const entity of document.entities) {
+      const list = docsByEntity.get(entity) ?? [];
+      list.push(document);
+      docsByEntity.set(entity, list);
+    }
+  }
+  for (const chunk of chunks) {
+    for (const entity of chunk.entities) {
+      const list = chunksByEntity.get(entity) ?? [];
+      list.push(chunk);
+      chunksByEntity.set(entity, list);
+    }
+  }
+  const candidates = [];
+  for (const [id, entityDocuments] of docsByEntity.entries()) {
+    const entityChunks = chunksByEntity.get(id) ?? [];
+    const dates = entityDocuments.map((document) => document.createdAt);
+    const type = entityTypeFromId(id);
+    const name = entityNameFromId(id);
+    const entityText = entityChunks.map((chunk) => chunk.content).join("\n");
+    const terms = weightedTerms(entityText, idf);
+    const score = entityDocuments.length * 2 + entityChunks.length + frequencyInLastYear(dates) * 1.5 + recencyScore(maxIso(dates), 180) * 2;
+    candidates.push({
+      activityTrend: inferTrend(dates),
+      catalystIds: [],
+      chunkCount: entityChunks.length,
+      documentCount: entityDocuments.length,
+      firstSeen: minIso(dates),
+      frequency12m: frequencyInLastYear(dates),
+      id,
+      lastSeen: maxIso(dates),
+      name,
+      score,
+      topTerms: terms,
+      type
+    });
+  }
+  return candidates.sort((left, right) => right.score - left.score).slice(0, limit);
+}
+function weightedTerms(text, idf) {
+  const tokens = tokenize(text);
+  const counts = /* @__PURE__ */ new Map();
+  for (const token of tokens) {
+    counts.set(token, (counts.get(token) ?? 0) + 1);
+  }
+  const scored = [...counts.entries()].map(([token, count]) => [token, count * (idf[token] ?? 1)]).sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0])).slice(0, 12).map(([token]) => token);
+  return scored.length ? scored : topTerms(tokens, 8);
+}
+
+// src/core/store.ts
+import { promises as fs2 } from "fs";
+import path4 from "path";
+function storePath(vaultPath) {
+  return path4.join(path4.resolve(vaultPath), STORE_DIR);
+}
+function indexPath(vaultPath) {
+  return path4.join(storePath(vaultPath), INDEX_FILE);
+}
+function configPath(vaultPath) {
+  return path4.join(storePath(vaultPath), CONFIG_FILE);
+}
+function targetsPath(vaultPath) {
+  return path4.join(storePath(vaultPath), TARGETS_DIR);
+}
+function targetIndexPath(vaultPath, targetId2) {
+  return path4.join(targetsPath(vaultPath), `${targetId2}.json`);
+}
+async function readConfig(vaultPath) {
+  try {
+    const raw = await fs2.readFile(configPath(vaultPath), "utf8");
+    return mergeConfig(JSON.parse(raw));
+  } catch (error) {
+    if (isNotFound(error)) {
+      return mergeConfig();
+    }
+    throw error;
+  }
+}
+async function writeConfig(vaultPath, config) {
+  await fs2.mkdir(storePath(vaultPath), { recursive: true });
+  await fs2.writeFile(configPath(vaultPath), `${JSON.stringify(config, null, 2)}
+`);
+}
+async function readIndex(vaultPath) {
+  const raw = await fs2.readFile(indexPath(vaultPath), "utf8");
+  return JSON.parse(raw);
+}
+async function writeIndex(vaultPath, index) {
+  await fs2.mkdir(storePath(vaultPath), { recursive: true });
+  await fs2.writeFile(indexPath(vaultPath), `${JSON.stringify(index, null, 2)}
+`);
+}
+async function readTargetIndex(vaultPath, target) {
+  const baseIndex = await readIndex(vaultPath);
+  const appliedTarget = resolveAppliedTarget(baseIndex.appliedTargets, target);
+  if (!appliedTarget) {
+    throw new Error(`No applied target matches "${target}". Run cofactor apply ${target} first.`);
+  }
+  const raw = await fs2.readFile(appliedTarget.indexPath, "utf8");
+  return JSON.parse(raw);
+}
+async function writeTargetIndex(vaultPath, targetId2, index) {
+  await fs2.mkdir(targetsPath(vaultPath), { recursive: true });
+  const filePath = targetIndexPath(vaultPath, targetId2);
+  await fs2.writeFile(filePath, `${JSON.stringify(index, null, 2)}
+`);
+  return filePath;
+}
+function resolveAppliedTarget(targets, requested) {
+  const absolute = path4.resolve(requested);
+  return targets.find(
+    (target) => target.id === requested || target.path === requested || target.path === absolute || path4.basename(target.path) === requested
+  );
+}
+function isNotFound(error) {
+  return Boolean(error && typeof error === "object" && "code" in error && error.code === "ENOENT");
+}
+
+// src/core/apply.ts
+import crypto2 from "crypto";
+import path5 from "path";
+async function applyCorpus(vaultPath, targetPathInput, options = {}) {
+  const targetPath = path5.resolve(targetPathInput);
+  const vaultIndex = await readIndex(vaultPath);
+  const config = options.config ? { ...vaultIndex.config, ...options.config } : await readConfig(vaultPath);
+  const targetIndex = await createIndex(targetPath, { config }, "target", path5.resolve(vaultPath));
+  targetIndex.idf = vaultIndex.idf;
+  targetIndex.chunks = targetIndex.chunks.map((chunk) => ({
+    ...chunk,
+    vector: vectorizeTokens(chunk.tokens, vaultIndex.idf)
+  }));
+  targetIndex.catalysts = refreshCatalystTopChunks(vaultIndex.catalysts, targetIndex.chunks);
+  targetIndex.entities = [];
+  targetIndex.stats = {
+    ...targetIndex.stats,
+    catalystCount: targetIndex.catalysts.length,
+    entityCount: 0
+  };
+  const id = targetId(targetPath);
+  const indexFilePath = await writeTargetIndex(vaultPath, id, targetIndex);
+  const appliedTarget = {
+    appliedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    docCount: targetIndex.documents.length,
+    id,
+    indexPath: indexFilePath,
+    path: targetPath
+  };
+  const remainingTargets = vaultIndex.appliedTargets.filter((target) => target.id !== id);
+  const nextVaultIndex = {
+    ...vaultIndex,
+    appliedTargets: [...remainingTargets, appliedTarget].sort((a, b) => a.path.localeCompare(b.path))
+  };
+  await writeIndex(vaultPath, nextVaultIndex);
+  return {
+    target: appliedTarget,
+    targetIndex,
+    vaultIndex: nextVaultIndex
+  };
+}
+function targetId(targetPath) {
+  return crypto2.createHash("sha1").update(path5.resolve(targetPath)).digest("hex").slice(0, 12);
+}
+
+// src/core/agents.ts
+import { promises as fs3 } from "fs";
+import path6 from "path";
+var startMarker = "<!-- cofactor:start -->";
+var endMarker = "<!-- cofactor:end -->";
+async function installAgentInstructions(vaultPathInput, agent) {
+  const vaultPath = path6.resolve(vaultPathInput);
+  const files = [];
+  if (agent === "codex") {
+    const agentsFile = path6.join(vaultPath, "AGENTS.md");
+    await upsertBlock(agentsFile, codexBlock());
+    files.push(agentsFile);
+    const skillDir = path6.join(vaultPath, ".agents", "skills", "cofactor");
+    await fs3.mkdir(skillDir, { recursive: true });
+    const skillFile = path6.join(skillDir, "SKILL.md");
+    await fs3.writeFile(skillFile, codexSkill());
+    files.push(skillFile);
+    return { files };
+  }
+  const claudeFile = path6.join(vaultPath, "CLAUDE.md");
+  await upsertBlock(claudeFile, claudeBlock());
+  files.push(claudeFile);
+  return { files };
+}
+async function upsertBlock(filePath, block) {
+  let existing = "";
+  try {
+    existing = await fs3.readFile(filePath, "utf8");
+  } catch (error) {
+    if (!isNotFound2(error)) {
+      throw error;
+    }
+  }
+  const wrapped = `${startMarker}
+${block.trim()}
+${endMarker}`;
+  const markerPattern = new RegExp(`${escapeRegex(startMarker)}[\\s\\S]*?${escapeRegex(endMarker)}`);
+  const next = markerPattern.test(existing) ? existing.replace(markerPattern, wrapped) : `${existing.trimEnd()}${existing.trim() ? "\n\n" : ""}${wrapped}
+`;
+  await fs3.writeFile(filePath, next);
+}
+function codexBlock() {
+  return `
+## Cofactor Memory
+
+Use \`cofactor petri --json\` before broad research or implementation work in this repository to load the local knowledge graph. Use \`cofactor catalyze "<question>" --json\` when the current task needs relevant notes, decisions, or cross-corpus context. The same tools are exposed over stdio with \`cofactor mcp\`. The index lives in \`${STORE_DIR}/\`; refresh it with \`cofactor init\` after substantial note changes.
+`;
+}
+function claudeBlock() {
+  return `
+## Cofactor Memory
+
+Before broad reasoning tasks, run \`cofactor petri --json\` to inspect local entities and catalysts. For a specific question, run \`cofactor catalyze "<question>" --json\` and use the returned catalysts plus documents as working memory. Claude Desktop can also run \`cofactor mcp\` as a stdio MCP server. Refresh the index with \`cofactor init\` when notes change.
+`;
+}
+function codexSkill() {
+  return `---
+name: cofactor
+description: Use local Cofactor memory before repository research, planning, or implementation tasks.
+---
+
+Run \`cofactor petri --json\` to inspect indexed entities and catalysts for the current repository. Run \`cofactor catalyze "<question>" --json\` to retrieve the most relevant indexed notes for a specific task. Use \`cofactor mcp\` when a client supports Model Context Protocol tools over stdio.
+`;
+}
+function escapeRegex(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function isNotFound2(error) {
+  return Boolean(error && typeof error === "object" && "code" in error && error.code === "ENOENT");
+}
+
+// src/core/mcp.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+
+// src/core/search.ts
+import path7 from "path";
+async function catalyze(query, options = {}) {
+  const vaultPath = path7.resolve(options.vaultPath ?? process.cwd());
+  const index = options.target ? await readTargetIndex(vaultPath, options.target) : await readIndex(vaultPath);
+  return searchIndex(index, query, {
+    limit: options.limit ?? index.config.maxResults,
+    target: options.target,
+    vaultPath
+  });
+}
+function searchIndex(index, query, options) {
+  const queryVector = vectorizeText(query, index.idf);
+  const catalystMatches = rankCatalysts(index.catalysts, queryVector).slice(0, 10);
+  const catalystChunkScores = /* @__PURE__ */ new Map();
+  for (const match of catalystMatches) {
+    for (const linkedChunk of match.catalyst.topChunks) {
+      const weightedScore = linkedChunk.score * match.score;
+      const list = catalystChunkScores.get(linkedChunk.chunkId) ?? [];
+      list.push({ catalyst: match.catalyst, score: weightedScore });
+      catalystChunkScores.set(linkedChunk.chunkId, list);
+    }
+  }
+  const scored = index.chunks.map((chunk) => scoreChunk(chunk, queryVector, catalystChunkScores.get(chunk.id) ?? [], index)).filter((result) => result.score > 0).sort((a, b) => b.score - a.score).slice(0, options.limit);
+  return {
+    catalysts: catalystMatches.slice(0, 5),
+    query,
+    results: scored.map((result) => ({
+      catalystIds: result.catalystIds,
+      content: snippet(result.chunk.content),
+      filePath: result.chunk.filePath,
+      score: Number(result.score.toFixed(6)),
+      title: result.chunk.title
+    })),
+    target: options.target,
+    vaultPath: options.vaultPath ?? index.vaultPath
+  };
+}
+async function petri(vaultPathInput = process.cwd(), query) {
+  const vaultPath = path7.resolve(vaultPathInput);
+  const index = await readIndex(vaultPath);
+  if (!query) {
+    return {
+      appliedTargets: index.appliedTargets,
+      catalysts: index.catalysts.slice(0, 24),
+      entities: index.entities,
+      stats: index.stats,
+      vaultPath
+    };
+  }
+  const queryVector = vectorizeText(query, index.idf);
+  const catalystMatches = rankCatalysts(index.catalysts, queryVector).slice(0, 20);
+  const catalystIds = new Set(catalystMatches.map((match) => match.catalyst.id));
+  const entityIds = new Set(catalystMatches.map((match) => match.catalyst.entityId));
+  return {
+    appliedTargets: index.appliedTargets,
+    catalysts: index.catalysts.filter((catalyst) => catalystIds.has(catalyst.id)).slice(0, 20),
+    entities: index.entities.filter((entity) => entityIds.has(entity.id)).slice(0, 12),
+    query,
+    stats: index.stats,
+    vaultPath
+  };
+}
+function rankCatalysts(catalysts, queryVector) {
+  return catalysts.map((catalyst) => ({
+    catalyst,
+    score: cosine(queryVector, catalyst.vector)
+  })).filter((match) => match.score > 0).sort((a, b) => b.score - a.score);
+}
+function scoreChunk(chunk, queryVector, catalystMatches, index) {
+  const directScore = cosine(queryVector, chunk.vector);
+  const catalystScore = catalystMatches.reduce((max, match) => Math.max(max, match.score), 0);
+  const recency = recencyScore(chunk.modifiedAt, index.config.recencyHalfLifeDays);
+  const relevance = directScore + catalystScore;
+  const score = relevance > 0 ? directScore * 0.58 + catalystScore * 0.92 + recency * 0.04 : 0;
+  const catalystIds = [...new Set(catalystMatches.map((match) => match.catalyst.id))].slice(0, 5);
+  return {
+    catalystIds,
+    chunk,
+    score
+  };
+}
+function formatSearchResults(response) {
+  const payload = {
+    catalysts: response.catalysts.map((match) => ({
+      entity: match.catalyst.entityName,
+      id: match.catalyst.id,
+      score: Number(match.score.toFixed(6)),
+      text: match.catalyst.text
+    })),
+    query: response.query,
+    results: response.results,
+    target: response.target,
+    vaultPath: response.vaultPath
+  };
+  return JSON.stringify(payload, null, 2);
+}
+function formatPetri(response) {
+  return JSON.stringify(response, null, 2);
+}
+
+// src/core/mcp.ts
+async function runMcpServer(defaultVaultPath = process.cwd()) {
+  const server = new McpServer({
+    name: "cofactor",
+    version: "0.1.0"
+  });
+  server.registerTool(
+    "petri",
+    {
+      description: "Inspect the local Cofactor entity/catalyst graph for working memory before broad reasoning tasks.",
+      inputSchema: {
+        query: z.string().optional().describe("Optional query for narrowing entities and catalysts."),
+        vaultPath: z.string().optional().describe("Path to the indexed vault. Defaults to the server cwd.")
+      }
+    },
+    async ({ query, vaultPath }) => {
+      const response = await petri(vaultPath ?? defaultVaultPath, query);
+      return {
+        content: [
+          {
+            text: JSON.stringify(response, null, 2),
+            type: "text"
+          }
+        ]
+      };
+    }
+  );
+  server.registerTool(
+    "catalyze",
+    {
+      description: "Search an indexed local corpus through precomputed catalyst questions and return relevant documents.",
+      inputSchema: {
+        limit: z.number().int().positive().optional().describe("Maximum number of results."),
+        query: z.string().min(1).describe("Search question."),
+        target: z.string().optional().describe("Optional applied target id, path, or basename."),
+        vaultPath: z.string().optional().describe("Path to the indexed vault. Defaults to the server cwd.")
+      }
+    },
+    async ({ limit, query, target, vaultPath }) => {
+      const response = await catalyze(query, {
+        limit,
+        target,
+        vaultPath: vaultPath ?? defaultVaultPath
+      });
+      return {
+        content: [
+          {
+            text: JSON.stringify(response, null, 2),
+            type: "text"
+          }
+        ]
+      };
+    }
+  );
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+// src/index.ts
+async function indexVault(vaultPathInput = process.cwd(), options = {}) {
+  const vaultPath = path8.resolve(vaultPathInput);
+  const previousConfig = await readConfig(vaultPath);
+  const config = options.config ? { ...previousConfig, ...options.config } : previousConfig;
+  const index = await createIndex(vaultPath, { ...options, config });
+  await writeConfig(vaultPath, config);
+  await writeIndex(vaultPath, index);
+  return index;
+}
+async function loadIndex(vaultPathInput = process.cwd()) {
+  return readIndex(path8.resolve(vaultPathInput));
+}
+async function refreshVault(vaultPathInput = process.cwd(), options = {}) {
+  return indexVault(vaultPathInput, options);
+}
+export {
+  applyCorpus,
+  catalyze,
+  createIndex,
+  formatPetri,
+  formatSearchResults,
+  indexVault,
+  installAgentInstructions,
+  loadIndex,
+  petri,
+  readConfig,
+  readIndex,
+  readTargetIndex,
+  refreshVault,
+  runMcpServer,
+  searchIndex
+};
+//# sourceMappingURL=index.js.map