@neat.is/core 0.2.5

package/dist/chunk-WX55TLUT.js

@@ -0,0 +1,184 @@
+// src/registry.ts
+import { promises as fs } from "fs";
+import os from "os";
+import path from "path";
+import {
+  RegistryFileSchema
+} from "@neat.is/types";
+var LOCK_TIMEOUT_MS = 5e3;
+var LOCK_RETRY_MS = 50;
+function neatHome() {
+  const override = process.env.NEAT_HOME;
+  if (override && override.length > 0) return path.resolve(override);
+  return path.join(os.homedir(), ".neat");
+}
+function registryPath() {
+  return path.join(neatHome(), "projects.json");
+}
+function registryLockPath() {
+  return path.join(neatHome(), "projects.json.lock");
+}
+async function normalizeProjectPath(input) {
+  const resolved = path.resolve(input);
+  try {
+    return await fs.realpath(resolved);
+  } catch {
+    return resolved;
+  }
+}
+async function writeAtomically(target, contents) {
+  await fs.mkdir(path.dirname(target), { recursive: true });
+  const tmp = `${target}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2, 8)}.tmp`;
+  const fd = await fs.open(tmp, "w");
+  try {
+    await fd.writeFile(contents, "utf8");
+    await fd.sync();
+  } finally {
+    await fd.close();
+  }
+  await fs.rename(tmp, target);
+}
+async function acquireLock(lockPath, timeoutMs = LOCK_TIMEOUT_MS) {
+  const deadline = Date.now() + timeoutMs;
+  await fs.mkdir(path.dirname(lockPath), { recursive: true });
+  while (true) {
+    try {
+      const fd = await fs.open(lockPath, "wx");
+      await fd.close();
+      return;
+    } catch (err) {
+      const code = err.code;
+      if (code !== "EEXIST") throw err;
+      if (Date.now() >= deadline) {
+        throw new Error(
+          `neat registry: timed out after ${timeoutMs}ms waiting for ${lockPath}. Another neat process is holding the lock; if no such process exists, remove the file by hand.`
+        );
+      }
+      await new Promise((r) => setTimeout(r, LOCK_RETRY_MS));
+    }
+  }
+}
+async function releaseLock(lockPath) {
+  await fs.unlink(lockPath).catch(() => {
+  });
+}
+async function withLock(fn) {
+  const lock = registryLockPath();
+  await acquireLock(lock);
+  try {
+    return await fn();
+  } finally {
+    await releaseLock(lock);
+  }
+}
+async function readRegistry() {
+  const file = registryPath();
+  let raw;
+  try {
+    raw = await fs.readFile(file, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return { version: 1, projects: [] };
+    }
+    throw err;
+  }
+  const parsed = JSON.parse(raw);
+  return RegistryFileSchema.parse(parsed);
+}
+async function writeRegistry(reg) {
+  const validated = RegistryFileSchema.parse(reg);
+  await writeAtomically(registryPath(), JSON.stringify(validated, null, 2) + "\n");
+}
+var ProjectNameCollisionError = class extends Error {
+  projectName;
+  constructor(name) {
+    super(`neat registry: a project named "${name}" is already registered`);
+    this.name = "ProjectNameCollisionError";
+    this.projectName = name;
+  }
+};
+async function addProject(opts) {
+  const resolvedPath = await normalizeProjectPath(opts.path);
+  return withLock(async () => {
+    const reg = await readRegistry();
+    const byName = reg.projects.find((p) => p.name === opts.name);
+    const byPath = reg.projects.find((p) => p.path === resolvedPath);
+    if (byName && byName.path !== resolvedPath) {
+      throw new ProjectNameCollisionError(opts.name);
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    if (byName && byName.path === resolvedPath) {
+      byName.lastSeenAt = now;
+      if (opts.languages) byName.languages = opts.languages;
+      if (opts.status) byName.status = opts.status;
+      await writeRegistry(reg);
+      return byName;
+    }
+    if (byPath && byPath.name !== opts.name) {
+      throw new ProjectNameCollisionError(byPath.name);
+    }
+    const entry = {
+      name: opts.name,
+      path: resolvedPath,
+      registeredAt: now,
+      languages: opts.languages ?? [],
+      status: opts.status ?? "active"
+    };
+    reg.projects.push(entry);
+    await writeRegistry(reg);
+    return entry;
+  });
+}
+async function getProject(name) {
+  const reg = await readRegistry();
+  return reg.projects.find((p) => p.name === name);
+}
+async function listProjects() {
+  const reg = await readRegistry();
+  return reg.projects;
+}
+async function setStatus(name, status) {
+  return withLock(async () => {
+    const reg = await readRegistry();
+    const entry = reg.projects.find((p) => p.name === name);
+    if (!entry) throw new Error(`neat registry: no project named "${name}"`);
+    entry.status = status;
+    await writeRegistry(reg);
+    return entry;
+  });
+}
+async function touchLastSeen(name, at = (/* @__PURE__ */ new Date()).toISOString()) {
+  await withLock(async () => {
+    const reg = await readRegistry();
+    const entry = reg.projects.find((p) => p.name === name);
+    if (!entry) return;
+    entry.lastSeenAt = at;
+    await writeRegistry(reg);
+  });
+}
+async function removeProject(name) {
+  return withLock(async () => {
+    const reg = await readRegistry();
+    const idx = reg.projects.findIndex((p) => p.name === name);
+    if (idx < 0) return void 0;
+    const [removed] = reg.projects.splice(idx, 1);
+    await writeRegistry(reg);
+    return removed;
+  });
+}
+
+export {
+  registryPath,
+  registryLockPath,
+  normalizeProjectPath,
+  writeAtomically,
+  readRegistry,
+  ProjectNameCollisionError,
+  addProject,
+  getProject,
+  listProjects,
+  setStatus,
+  touchLastSeen,
+  removeProject
+};
+//# sourceMappingURL=chunk-WX55TLUT.js.map

package/dist/chunk-WX55TLUT.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/registry.ts"],"sourcesContent":["/**\n * Machine-level project registry (ADR-048).\n *\n * One file: `~/.neat/projects.json`. Per-user, machine-local. Not synced.\n * `registry.ts` is the only module that opens it. Everything else — `init`,\n * `daemon`, `cli` — calls into the helpers below.\n *\n * Two safety properties matter:\n *  1. Atomic writes. We tmp + fsync + rename so the daemon never sees a torn\n *     file when init races against it.\n *  2. Cross-process exclusion. We hold an exclusive lock on\n *     `~/.neat/projects.json.lock` for the read-modify-write window. Two\n *     concurrent `neat init` runs cannot both win and overwrite each other.\n *\n * The lock is a file we exclusively-create (`O_EXCL`), hold while we mutate,\n * and unlink on the way out. Crude but cross-platform; matches what\n * `proper-lockfile` does internally without pulling the dep in.\n */\n\nimport { promises as fs } from 'node:fs'\nimport os from 'node:os'\nimport path from 'node:path'\nimport {\n  RegistryFileSchema,\n  type RegistryEntry,\n  type RegistryFile,\n  type RegistryStatus,\n} from '@neat.is/types'\n\nconst LOCK_TIMEOUT_MS = 5_000\nconst LOCK_RETRY_MS = 50\n\n// Resolve `~/.neat/` per call so tests can override `HOME` / `NEAT_HOME`\n// before each run without module-load order mattering.\nfunction neatHome(): string {\n  const override = process.env.NEAT_HOME\n  if (override && override.length > 0) return path.resolve(override)\n  return path.join(os.homedir(), '.neat')\n}\n\nexport function registryPath(): string {\n  return path.join(neatHome(), 'projects.json')\n}\n\nexport function registryLockPath(): string {\n  return path.join(neatHome(), 'projects.json.lock')\n}\n\n/**\n * Path normalisation per ADR-048 #7. Two `init` calls from different relative\n * paths to the same dir must collapse to one entry. `path.resolve` handles\n * relative-to-cwd; we pass it through `fs.realpath` when the dir exists so\n * symlinked paths land on the same canonical entry too.\n */\nexport async function normalizeProjectPath(input: string): Promise<string> {\n  const resolved = path.resolve(input)\n  try {\n    return await fs.realpath(resolved)\n  } catch {\n    return resolved\n  }\n}\n\n/**\n * tmp + fsync + rename. The fsync on the data fd guarantees the bytes are on\n * disk before rename swaps the inode; rename itself is atomic on POSIX.\n *\n * Exported so the init flow and test harnesses can use the same helper.\n */\nexport async function writeAtomically(target: string, contents: string): Promise<void> {\n  await fs.mkdir(path.dirname(target), { recursive: true })\n  const tmp = `${target}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2, 8)}.tmp`\n  const fd = await fs.open(tmp, 'w')\n  try {\n    await fd.writeFile(contents, 'utf8')\n    await fd.sync()\n  } finally {\n    await fd.close()\n  }\n  await fs.rename(tmp, target)\n}\n\nasync function acquireLock(lockPath: string, timeoutMs: number = LOCK_TIMEOUT_MS): Promise<void> {\n  const deadline = Date.now() + timeoutMs\n  await fs.mkdir(path.dirname(lockPath), { recursive: true })\n  while (true) {\n    try {\n      const fd = await fs.open(lockPath, 'wx')\n      await fd.close()\n      return\n    } catch (err) {\n      const code = (err as NodeJS.ErrnoException).code\n      if (code !== 'EEXIST') throw err\n      if (Date.now() >= deadline) {\n        throw new Error(\n          `neat registry: timed out after ${timeoutMs}ms waiting for ${lockPath}. ` +\n            `Another neat process is holding the lock; if no such process exists, remove the file by hand.`,\n        )\n      }\n      await new Promise((r) => setTimeout(r, LOCK_RETRY_MS))\n    }\n  }\n}\n\nasync function releaseLock(lockPath: string): Promise<void> {\n  await fs.unlink(lockPath).catch(() => {})\n}\n\nasync function withLock<T>(fn: () => Promise<T>): Promise<T> {\n  const lock = registryLockPath()\n  await acquireLock(lock)\n  try {\n    return await fn()\n  } finally {\n    await releaseLock(lock)\n  }\n}\n\n/**\n * Read the registry from disk. Returns an empty registry if the file does\n * not exist yet — first run, never registered anything.\n *\n * Throws on parse / schema errors. The contract is single-source-of-truth;\n * a corrupt file is louder than a silent reset.\n */\nexport async function readRegistry(): Promise<RegistryFile> {\n  const file = registryPath()\n  let raw: string\n  try {\n    raw = await fs.readFile(file, 'utf8')\n  } catch (err) {\n    if ((err as NodeJS.ErrnoException).code === 'ENOENT') {\n      return { version: 1, projects: [] }\n    }\n    throw err\n  }\n  const parsed = JSON.parse(raw)\n  return RegistryFileSchema.parse(parsed)\n}\n\nasync function writeRegistry(reg: RegistryFile): Promise<void> {\n  // Re-parse before writing to surface schema drift introduced by callers\n  // mutating the in-memory object directly.\n  const validated = RegistryFileSchema.parse(reg)\n  await writeAtomically(registryPath(), JSON.stringify(validated, null, 2) + '\\n')\n}\n\nexport interface AddProjectOptions {\n  name: string\n  path: string\n  languages?: string[]\n  status?: RegistryStatus\n}\n\nexport class ProjectNameCollisionError extends Error {\n  readonly projectName: string\n  constructor(name: string) {\n    super(`neat registry: a project named \"${name}\" is already registered`)\n    this.name = 'ProjectNameCollisionError'\n    this.projectName = name\n  }\n}\n\n/**\n * Register a project, or update its `lastSeenAt` if the same path is already\n * registered under the same name (idempotent re-init).\n *\n * Hard error on name collision against a different path — ADR-046 #7. The\n * caller can recover by passing `--project <new-name>`.\n */\nexport async function addProject(opts: AddProjectOptions): Promise<RegistryEntry> {\n  const resolvedPath = await normalizeProjectPath(opts.path)\n  return withLock(async () => {\n    const reg = await readRegistry()\n    const byName = reg.projects.find((p) => p.name === opts.name)\n    const byPath = reg.projects.find((p) => p.path === resolvedPath)\n\n    if (byName && byName.path !== resolvedPath) {\n      throw new ProjectNameCollisionError(opts.name)\n    }\n\n    const now = new Date().toISOString()\n\n    if (byName && byName.path === resolvedPath) {\n      // Idempotent re-register: same name, same path. Refresh languages /\n      // status if the caller passed new ones.\n      byName.lastSeenAt = now\n      if (opts.languages) byName.languages = opts.languages\n      if (opts.status) byName.status = opts.status\n      await writeRegistry(reg)\n      return byName\n    }\n\n    if (byPath && byPath.name !== opts.name) {\n      // Same dir already registered under a different name. Treat as a\n      // collision so the user is forced to decide which name wins.\n      throw new ProjectNameCollisionError(byPath.name)\n    }\n\n    const entry: RegistryEntry = {\n      name: opts.name,\n      path: resolvedPath,\n      registeredAt: now,\n      languages: opts.languages ?? [],\n      status: opts.status ?? 'active',\n    }\n    reg.projects.push(entry)\n    await writeRegistry(reg)\n    return entry\n  })\n}\n\nexport async function getProject(name: string): Promise<RegistryEntry | undefined> {\n  const reg = await readRegistry()\n  return reg.projects.find((p) => p.name === name)\n}\n\nexport async function listProjects(): Promise<RegistryEntry[]> {\n  const reg = await readRegistry()\n  return reg.projects\n}\n\nexport async function setStatus(name: string, status: RegistryStatus): Promise<RegistryEntry> {\n  return withLock(async () => {\n    const reg = await readRegistry()\n    const entry = reg.projects.find((p) => p.name === name)\n    if (!entry) throw new Error(`neat registry: no project named \"${name}\"`)\n    entry.status = status\n    await writeRegistry(reg)\n    return entry\n  })\n}\n\nexport async function touchLastSeen(name: string, at: string = new Date().toISOString()): Promise<void> {\n  await withLock(async () => {\n    const reg = await readRegistry()\n    const entry = reg.projects.find((p) => p.name === name)\n    if (!entry) return\n    entry.lastSeenAt = at\n    await writeRegistry(reg)\n  })\n}\n\n/**\n * Remove the registry entry for `name`. Per ADR-048 #6: this only removes the\n * registry row. It does **not** touch `neat-out/`, `policy.json`, or any user\n * file in the project directory. SDK-install rollback is a separate flow\n * (`neat-rollback.patch`) that the caller opts in to.\n */\nexport async function removeProject(name: string): Promise<RegistryEntry | undefined> {\n  return withLock(async () => {\n    const reg = await readRegistry()\n    const idx = reg.projects.findIndex((p) => p.name === name)\n    if (idx < 0) return undefined\n    const [removed] = reg.projects.splice(idx, 1)\n    await writeRegistry(reg)\n    return removed\n  })\n}\n\n"],"mappings":"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","names":[]}

package/dist/chunk-XOOCA5T7.js

@@ -0,0 +1,290 @@
+// src/search.ts
+import { promises as fs } from "fs";
+import path from "path";
+import { createHash } from "crypto";
+var DEFAULT_LIMIT = 10;
+var NOMIC_DIM = 768;
+var MINI_LM_DIM = 384;
+function shouldEmbed(node) {
+  return node.type !== "FrontierNode";
+}
+function embedText(node) {
+  const parts = [node.id];
+  const name = node.name;
+  if (name) parts.push(name);
+  switch (node.type) {
+    case "ServiceNode": {
+      const lang = node.language;
+      if (lang) parts.push(`language=${lang}`);
+      break;
+    }
+    case "DatabaseNode": {
+      const eng = node.engine;
+      const ver = node.engineVersion;
+      if (eng) parts.push(`engine=${eng}`);
+      if (ver) parts.push(`engineVersion=${ver}`);
+      break;
+    }
+    case "InfraNode": {
+      const kind = node.kind;
+      if (kind) parts.push(`kind=${kind}`);
+      break;
+    }
+    case "ConfigNode": {
+      const filePath = node.path;
+      if (filePath) parts.push(`path=${filePath}`);
+      break;
+    }
+    default:
+      break;
+  }
+  return parts.join(" ");
+}
+function attrsHash(node) {
+  return createHash("sha1").update(embedText(node)).digest("hex").slice(0, 16);
+}
+function cosine(a, b) {
+  if (a.length !== b.length) return 0;
+  let dot = 0;
+  let na = 0;
+  let nb = 0;
+  for (let i = 0; i < a.length; i++) {
+    const ai = a[i] ?? 0;
+    const bi = b[i] ?? 0;
+    dot += ai * bi;
+    na += ai * ai;
+    nb += bi * bi;
+  }
+  if (na === 0 || nb === 0) return 0;
+  return dot / (Math.sqrt(na) * Math.sqrt(nb));
+}
+function ollamaHost() {
+  return process.env.OLLAMA_HOST ?? null;
+}
+async function ollamaReachable(host) {
+  try {
+    const res = await fetch(`${host.replace(/\/$/, "")}/api/tags`, {
+      signal: AbortSignal.timeout(500)
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+function makeOllamaEmbedder(host, model = "nomic-embed-text") {
+  const root = host.replace(/\/$/, "");
+  return {
+    provider: "ollama",
+    model,
+    dim: NOMIC_DIM,
+    async embed(texts) {
+      const out = [];
+      for (const text of texts) {
+        const res = await fetch(`${root}/api/embeddings`, {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({ model, prompt: text })
+        });
+        if (!res.ok) {
+          throw new Error(`ollama embeddings: ${res.status} ${res.statusText}`);
+        }
+        const data = await res.json();
+        out.push(Float32Array.from(data.embedding));
+      }
+      return out;
+    }
+  };
+}
+async function makeTransformersEmbedder() {
+  let pipelineFn = null;
+  try {
+    const specifier = "@xenova/transformers";
+    const mod = await import(specifier);
+    pipelineFn = mod.pipeline;
+  } catch {
+    return null;
+  }
+  if (!pipelineFn) return null;
+  const model = "Xenova/all-MiniLM-L6-v2";
+  const extractor = await pipelineFn("feature-extraction", model);
+  return {
+    provider: "transformers",
+    model,
+    dim: MINI_LM_DIM,
+    async embed(texts) {
+      const out = [];
+      for (const text of texts) {
+        const result = await extractor(text, { pooling: "mean", normalize: true });
+        out.push(Float32Array.from(result.data));
+      }
+      return out;
+    }
+  };
+}
+async function pickEmbedder() {
+  const host = ollamaHost();
+  if (host && await ollamaReachable(host)) {
+    return makeOllamaEmbedder(host);
+  }
+  return makeTransformersEmbedder();
+}
+async function readCache(cachePath) {
+  try {
+    const raw = await fs.readFile(cachePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== 1) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function writeCache(cachePath, cache) {
+  await fs.mkdir(path.dirname(cachePath), { recursive: true });
+  await fs.writeFile(cachePath, JSON.stringify(cache));
+}
+var VectorIndex = class {
+  constructor(embedder, cachePath) {
+    this.embedder = embedder;
+    this.cachePath = cachePath;
+    this.provider = embedder.provider;
+  }
+  embedder;
+  cachePath;
+  provider;
+  vectors = /* @__PURE__ */ new Map();
+  async search(query, limit = DEFAULT_LIMIT) {
+    const trimmed = query.trim();
+    if (!trimmed || this.vectors.size === 0) {
+      return { query: trimmed, provider: this.provider, matches: [] };
+    }
+    const embedded = await this.embedder.embed([trimmed]);
+    const qv = embedded[0];
+    if (!qv) {
+      return { query: trimmed, provider: this.provider, matches: [] };
+    }
+    const scored = [];
+    for (const { node, vector } of this.vectors.values()) {
+      const score = cosine(qv, vector);
+      scored.push({ node, score });
+    }
+    scored.sort((a, b) => b.score - a.score);
+    return { query: trimmed, provider: this.provider, matches: scored.slice(0, limit) };
+  }
+  async refresh(graph) {
+    const present = /* @__PURE__ */ new Set();
+    const toEmbed = [];
+    graph.forEachNode((id, attrs) => {
+      const node = attrs;
+      if (!shouldEmbed(node)) return;
+      present.add(id);
+      const hash = attrsHash(node);
+      const cached = this.vectors.get(id);
+      if (cached && cached.hash === hash) {
+        cached.node = node;
+        return;
+      }
+      toEmbed.push({ id, node, hash, text: embedText(node) });
+    });
+    for (const id of [...this.vectors.keys()]) {
+      if (!present.has(id)) this.vectors.delete(id);
+    }
+    if (toEmbed.length > 0) {
+      const vectors = await this.embedder.embed(toEmbed.map((e) => e.text));
+      toEmbed.forEach((entry, i) => {
+        const v = vectors[i];
+        if (!v) return;
+        this.vectors.set(entry.id, { node: entry.node, vector: v, hash: entry.hash });
+      });
+    }
+    if (this.cachePath) {
+      const entries = [];
+      for (const [id, { vector, hash }] of this.vectors) {
+        entries.push({ nodeId: id, attrsHash: hash, vector: Array.from(vector) });
+      }
+      await writeCache(this.cachePath, {
+        version: 1,
+        provider: this.embedder.provider,
+        model: this.embedder.model,
+        dim: this.embedder.dim,
+        entries
+      });
+    }
+  }
+  // Hydrate the in-memory map from a previously-written cache. Validates
+  // shape against the current embedder; mismatch → empty start.
+  loadFromCache(cache, graph) {
+    if (cache.provider !== this.embedder.provider || cache.model !== this.embedder.model || cache.dim !== this.embedder.dim) {
+      return;
+    }
+    const present = /* @__PURE__ */ new Map();
+    graph.forEachNode((id, attrs) => {
+      const node = attrs;
+      if (shouldEmbed(node)) present.set(id, node);
+    });
+    for (const entry of cache.entries) {
+      const node = present.get(entry.nodeId);
+      if (!node) continue;
+      if (attrsHash(node) !== entry.attrsHash) continue;
+      if (entry.vector.length !== this.embedder.dim) continue;
+      this.vectors.set(entry.nodeId, {
+        node,
+        hash: entry.attrsHash,
+        vector: Float32Array.from(entry.vector)
+      });
+    }
+  }
+};
+var SubstringIndex = class {
+  provider = "substring";
+  graph = null;
+  async search(query, limit = DEFAULT_LIMIT) {
+    const q = query.trim().toLowerCase();
+    const out = [];
+    if (!q || !this.graph) {
+      return { query: q, provider: "substring", matches: [] };
+    }
+    this.graph.forEachNode((id, attrs) => {
+      const node = attrs;
+      const name = node.name ?? "";
+      if (id.toLowerCase().includes(q) || name.toLowerCase().includes(q)) {
+        out.push({ node, score: 1 });
+      }
+    });
+    return { query: q, provider: "substring", matches: out.slice(0, limit) };
+  }
+  async refresh(graph) {
+    this.graph = graph;
+  }
+};
+async function buildSearchIndex(graph, options = {}) {
+  let embedder = null;
+  if (options.embedder) {
+    embedder = options.embedder;
+  } else if (options.forceProvider !== "substring") {
+    embedder = await pickEmbedder();
+    if (options.forceProvider === "ollama" && embedder?.provider !== "ollama") {
+      embedder = null;
+    }
+    if (options.forceProvider === "transformers" && embedder?.provider !== "transformers") {
+      embedder = null;
+    }
+  }
+  if (!embedder) {
+    const idx2 = new SubstringIndex();
+    await idx2.refresh(graph);
+    return idx2;
+  }
+  const cachePath = options.cachePath === void 0 ? null : options.cachePath;
+  const idx = new VectorIndex(embedder, cachePath);
+  if (cachePath) {
+    const cache = await readCache(cachePath);
+    if (cache) idx.loadFromCache(cache, graph);
+  }
+  await idx.refresh(graph);
+  return idx;
+}
+
+export {
+  buildSearchIndex
+};
+//# sourceMappingURL=chunk-XOOCA5T7.js.map

package/dist/chunk-XOOCA5T7.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/search.ts"],"sourcesContent":["// semantic_search — embedding-based node retrieval with a three-tier\n// fallback chain. The chain is settled in ADR-025; this file is the\n// implementation. Public API:\n//\n//   buildSearchIndex(graph, opts) → SearchIndex\n//   SearchIndex.search(query, limit) → { provider, matches }\n//   SearchIndex.refresh(graph)      → re-embeds new/changed nodes,\n//                                     drops vanished ones\n//\n// The `/search` route in api.ts holds a single SearchIndex, refreshing it\n// after any extraction. MCP's `semantic_search` tool reads the same shape.\n\nimport { promises as fs } from 'node:fs'\nimport path from 'node:path'\nimport { createHash } from 'node:crypto'\nimport type { GraphNode } from '@neat.is/types'\nimport type { NeatGraph } from './graph.js'\n\nexport interface ScoredNode {\n  node: GraphNode\n  score: number\n}\n\nexport interface SearchResponse {\n  query: string\n  provider: 'ollama' | 'transformers' | 'substring'\n  matches: ScoredNode[]\n}\n\nexport interface SearchIndex {\n  readonly provider: SearchResponse['provider']\n  search(query: string, limit?: number): Promise<SearchResponse>\n  refresh(graph: NeatGraph): Promise<void>\n}\n\ninterface Embedder {\n  provider: 'ollama' | 'transformers'\n  model: string\n  dim: number\n  embed(texts: string[]): Promise<Float32Array[]>\n}\n\nconst DEFAULT_LIMIT = 10\nconst NOMIC_DIM = 768\nconst MINI_LM_DIM = 384\n\n// FrontierNodes are noise by design (placeholders that should disappear).\n// Embedding them would just clutter results.\nfunction shouldEmbed(node: GraphNode): boolean {\n  return node.type !== 'FrontierNode'\n}\n\n// Deterministic per-node text. Stable keys let the cache hit across\n// extractions when nothing material changed.\nexport function embedText(node: GraphNode): string {\n  const parts: string[] = [node.id]\n  const name = (node as { name?: string }).name\n  if (name) parts.push(name)\n  switch (node.type) {\n    case 'ServiceNode': {\n      const lang = (node as { language?: string }).language\n      if (lang) parts.push(`language=${lang}`)\n      break\n    }\n    case 'DatabaseNode': {\n      const eng = (node as { engine?: string }).engine\n      const ver = (node as { engineVersion?: string }).engineVersion\n      if (eng) parts.push(`engine=${eng}`)\n      if (ver) parts.push(`engineVersion=${ver}`)\n      break\n    }\n    case 'InfraNode': {\n      const kind = (node as { kind?: string }).kind\n      if (kind) parts.push(`kind=${kind}`)\n      break\n    }\n    case 'ConfigNode': {\n      const filePath = (node as { path?: string }).path\n      if (filePath) parts.push(`path=${filePath}`)\n      break\n    }\n    default:\n      break\n  }\n  return parts.join(' ')\n}\n\nfunction attrsHash(node: GraphNode): string {\n  return createHash('sha1').update(embedText(node)).digest('hex').slice(0, 16)\n}\n\nexport function cosine(a: Float32Array, b: Float32Array): number {\n  if (a.length !== b.length) return 0\n  let dot = 0\n  let na = 0\n  let nb = 0\n  for (let i = 0; i < a.length; i++) {\n    const ai = a[i] ?? 0\n    const bi = b[i] ?? 0\n    dot += ai * bi\n    na += ai * ai\n    nb += bi * bi\n  }\n  if (na === 0 || nb === 0) return 0\n  return dot / (Math.sqrt(na) * Math.sqrt(nb))\n}\n\n// ---------------------------------------------------------------- Embedders\n\nfunction ollamaHost(): string | null {\n  return process.env.OLLAMA_HOST ?? null\n}\n\nasync function ollamaReachable(host: string): Promise<boolean> {\n  try {\n    const res = await fetch(`${host.replace(/\\/$/, '')}/api/tags`, {\n      signal: AbortSignal.timeout(500),\n    })\n    return res.ok\n  } catch {\n    return false\n  }\n}\n\nfunction makeOllamaEmbedder(host: string, model = 'nomic-embed-text'): Embedder {\n  const root = host.replace(/\\/$/, '')\n  return {\n    provider: 'ollama',\n    model,\n    dim: NOMIC_DIM,\n    async embed(texts: string[]): Promise<Float32Array[]> {\n      const out: Float32Array[] = []\n      // Ollama's /api/embeddings is one-text-per-request. ≤10K nodes × ~30ms\n      // each is fine for a one-shot index build; if it ever isn't, the API\n      // also accepts batched input on /api/embed (newer routes).\n      for (const text of texts) {\n        const res = await fetch(`${root}/api/embeddings`, {\n          method: 'POST',\n          headers: { 'content-type': 'application/json' },\n          body: JSON.stringify({ model, prompt: text }),\n        })\n        if (!res.ok) {\n          throw new Error(`ollama embeddings: ${res.status} ${res.statusText}`)\n        }\n        const data = (await res.json()) as { embedding: number[] }\n        out.push(Float32Array.from(data.embedding))\n      }\n      return out\n    },\n  }\n}\n\ninterface XenovaPipeline {\n  (text: string | string[], options?: { pooling?: string; normalize?: boolean }): Promise<{\n    data: Float32Array\n  }>\n}\n\nasync function makeTransformersEmbedder(): Promise<Embedder | null> {\n  let pipelineFn: ((task: string, model: string) => Promise<XenovaPipeline>) | null = null\n  try {\n    // Lazy require so server.ts boot doesn't pay the WASM init cost when\n    // Ollama is available. The package is heavy — only load it on demand.\n    // The package is optional so its types may not be installed in every\n    // environment. Use a dynamic specifier so tsc keeps the import dynamic\n    // and doesn't try to resolve types at build time.\n    const specifier = '@xenova/transformers'\n    const mod = (await import(specifier)) as unknown as {\n      pipeline: (task: string, model: string) => Promise<XenovaPipeline>\n    }\n    pipelineFn = mod.pipeline\n  } catch {\n    return null\n  }\n  if (!pipelineFn) return null\n  const model = 'Xenova/all-MiniLM-L6-v2'\n  const extractor = await pipelineFn('feature-extraction', model)\n  return {\n    provider: 'transformers',\n    model,\n    dim: MINI_LM_DIM,\n    async embed(texts: string[]): Promise<Float32Array[]> {\n      const out: Float32Array[] = []\n      for (const text of texts) {\n        // Mean-pooled, L2-normalized → cosine reduces to dot product but\n        // we keep the explicit cosine() for clarity.\n        const result = await extractor(text, { pooling: 'mean', normalize: true })\n        out.push(Float32Array.from(result.data))\n      }\n      return out\n    },\n  }\n}\n\n// Picks the highest-tier embedder available. Returns null when only\n// substring is available (caller decides what to build).\nexport async function pickEmbedder(): Promise<Embedder | null> {\n  const host = ollamaHost()\n  if (host && (await ollamaReachable(host))) {\n    return makeOllamaEmbedder(host)\n  }\n  return makeTransformersEmbedder()\n}\n\n// ------------------------------------------------------------------ Cache\n\ninterface CacheEntry {\n  nodeId: string\n  attrsHash: string\n  vector: number[]\n}\n\ninterface CacheFile {\n  version: 1\n  provider: 'ollama' | 'transformers'\n  model: string\n  dim: number\n  entries: CacheEntry[]\n}\n\nasync function readCache(cachePath: string): Promise<CacheFile | null> {\n  try {\n    const raw = await fs.readFile(cachePath, 'utf8')\n    const parsed = JSON.parse(raw) as CacheFile\n    if (parsed.version !== 1) return null\n    return parsed\n  } catch {\n    return null\n  }\n}\n\nasync function writeCache(cachePath: string, cache: CacheFile): Promise<void> {\n  await fs.mkdir(path.dirname(cachePath), { recursive: true })\n  await fs.writeFile(cachePath, JSON.stringify(cache))\n}\n\n// ----------------------------------------------------------------- Indexes\n\nclass VectorIndex implements SearchIndex {\n  readonly provider: 'ollama' | 'transformers'\n  private vectors = new Map<string, { node: GraphNode; vector: Float32Array; hash: string }>()\n\n  constructor(\n    private embedder: Embedder,\n    private cachePath: string | null,\n  ) {\n    this.provider = embedder.provider\n  }\n\n  async search(query: string, limit = DEFAULT_LIMIT): Promise<SearchResponse> {\n    const trimmed = query.trim()\n    if (!trimmed || this.vectors.size === 0) {\n      return { query: trimmed, provider: this.provider, matches: [] }\n    }\n    const embedded = await this.embedder.embed([trimmed])\n    const qv = embedded[0]\n    if (!qv) {\n      return { query: trimmed, provider: this.provider, matches: [] }\n    }\n    const scored: ScoredNode[] = []\n    for (const { node, vector } of this.vectors.values()) {\n      const score = cosine(qv, vector)\n      scored.push({ node, score })\n    }\n    scored.sort((a, b) => b.score - a.score)\n    return { query: trimmed, provider: this.provider, matches: scored.slice(0, limit) }\n  }\n\n  async refresh(graph: NeatGraph): Promise<void> {\n    const present = new Set<string>()\n    const toEmbed: { id: string; node: GraphNode; hash: string; text: string }[] = []\n\n    graph.forEachNode((id, attrs) => {\n      const node = attrs as GraphNode\n      if (!shouldEmbed(node)) return\n      present.add(id)\n      const hash = attrsHash(node)\n      const cached = this.vectors.get(id)\n      if (cached && cached.hash === hash) {\n        cached.node = node\n        return\n      }\n      toEmbed.push({ id, node, hash, text: embedText(node) })\n    })\n\n    // Drop vanished nodes\n    for (const id of [...this.vectors.keys()]) {\n      if (!present.has(id)) this.vectors.delete(id)\n    }\n\n    if (toEmbed.length > 0) {\n      const vectors = await this.embedder.embed(toEmbed.map((e) => e.text))\n      toEmbed.forEach((entry, i) => {\n        const v = vectors[i]\n        if (!v) return\n        this.vectors.set(entry.id, { node: entry.node, vector: v, hash: entry.hash })\n      })\n    }\n\n    if (this.cachePath) {\n      const entries: CacheEntry[] = []\n      for (const [id, { vector, hash }] of this.vectors) {\n        entries.push({ nodeId: id, attrsHash: hash, vector: Array.from(vector) })\n      }\n      await writeCache(this.cachePath, {\n        version: 1,\n        provider: this.embedder.provider,\n        model: this.embedder.model,\n        dim: this.embedder.dim,\n        entries,\n      })\n    }\n  }\n\n  // Hydrate the in-memory map from a previously-written cache. Validates\n  // shape against the current embedder; mismatch → empty start.\n  loadFromCache(cache: CacheFile, graph: NeatGraph): void {\n    if (\n      cache.provider !== this.embedder.provider ||\n      cache.model !== this.embedder.model ||\n      cache.dim !== this.embedder.dim\n    ) {\n      return\n    }\n    const present = new Map<string, GraphNode>()\n    graph.forEachNode((id, attrs) => {\n      const node = attrs as GraphNode\n      if (shouldEmbed(node)) present.set(id, node)\n    })\n    for (const entry of cache.entries) {\n      const node = present.get(entry.nodeId)\n      if (!node) continue\n      // Skip cache entries whose attrs no longer match — they'll be\n      // re-embedded by the next refresh().\n      if (attrsHash(node) !== entry.attrsHash) continue\n      if (entry.vector.length !== this.embedder.dim) continue\n      this.vectors.set(entry.nodeId, {\n        node,\n        hash: entry.attrsHash,\n        vector: Float32Array.from(entry.vector),\n      })\n    }\n  }\n}\n\nclass SubstringIndex implements SearchIndex {\n  readonly provider = 'substring' as const\n  private graph: NeatGraph | null = null\n\n  async search(query: string, limit = DEFAULT_LIMIT): Promise<SearchResponse> {\n    const q = query.trim().toLowerCase()\n    const out: ScoredNode[] = []\n    if (!q || !this.graph) {\n      return { query: q, provider: 'substring', matches: [] }\n    }\n    this.graph.forEachNode((id, attrs) => {\n      const node = attrs as GraphNode\n      const name = (node as { name?: string }).name ?? ''\n      if (id.toLowerCase().includes(q) || name.toLowerCase().includes(q)) {\n        out.push({ node, score: 1 })\n      }\n    })\n    return { query: q, provider: 'substring', matches: out.slice(0, limit) }\n  }\n\n  async refresh(graph: NeatGraph): Promise<void> {\n    this.graph = graph\n  }\n}\n\n// ------------------------------------------------------------ Public factory\n\nexport interface BuildSearchIndexOptions {\n  // Where to read/write the embedding cache. Falls back to in-memory only\n  // if not provided. Pass `null` to explicitly disable caching.\n  cachePath?: string | null\n  // Override the embedder selection. Useful for tests (substring-only mode\n  // skips the Ollama probe + the Transformers.js download).\n  forceProvider?: 'ollama' | 'transformers' | 'substring'\n  // Pre-built embedder (test injection). Wins over forceProvider.\n  embedder?: Embedder\n}\n\nexport async function buildSearchIndex(\n  graph: NeatGraph,\n  options: BuildSearchIndexOptions = {},\n): Promise<SearchIndex> {\n  let embedder: Embedder | null = null\n  if (options.embedder) {\n    embedder = options.embedder\n  } else if (options.forceProvider !== 'substring') {\n    embedder = await pickEmbedder()\n    if (options.forceProvider === 'ollama' && embedder?.provider !== 'ollama') {\n      embedder = null\n    }\n    if (options.forceProvider === 'transformers' && embedder?.provider !== 'transformers') {\n      embedder = null\n    }\n  }\n\n  if (!embedder) {\n    const idx = new SubstringIndex()\n    await idx.refresh(graph)\n    return idx\n  }\n\n  const cachePath = options.cachePath === undefined ? null : options.cachePath\n  const idx = new VectorIndex(embedder, cachePath)\n  if (cachePath) {\n    const cache = await readCache(cachePath)\n    if (cache) idx.loadFromCache(cache, graph)\n  }\n  await idx.refresh(graph)\n  return idx\n}\n"],"mappings":"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","names":["idx"]}