@titan-design/brain 0.3.0 → 0.5.0

package/dist/chunk-BDNH2E2O.js

@@ -0,0 +1,112 @@
+// src/adapters/local-embedder.ts
+import { pipeline } from "@huggingface/transformers";
+var LocalEmbedder = class {
+  model = "bge-small-en-v1.5";
+  dimensions = 384;
+  extractor = null;
+  async embed(texts) {
+    if (!this.extractor) {
+      this.extractor = await pipeline("feature-extraction", "Xenova/bge-small-en-v1.5", {
+        dtype: "q8"
+      });
+    }
+    const output = await this.extractor(texts, {
+      pooling: "mean",
+      normalize: true
+    });
+    return output.tolist();
+  }
+};
+
+// src/adapters/ollama-embedder.ts
+import { Ollama } from "ollama";
+var OllamaEmbedder = class {
+  model = "nomic-embed-text";
+  dimensions = 768;
+  client;
+  constructor(url) {
+    this.client = url ? new Ollama({ host: url }) : new Ollama();
+  }
+  async embed(texts) {
+    const prefixed = texts.map((t) => `search_document: ${t}`);
+    try {
+      const response = await this.client.embed({
+        model: this.model,
+        input: prefixed
+      });
+      return response.embeddings;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Ollama embedding failed: ${message}. Is Ollama running?`);
+    }
+  }
+};
+
+// src/adapters/remote-embedder.ts
+var RemoteEmbedder = class {
+  constructor(url) {
+    this.url = url;
+  }
+  model = "nomic-embed-text";
+  dimensions = 768;
+  async embed(texts) {
+    const prefixed = texts.map((t) => `search_document: ${t}`);
+    const baseUrl = this.url.replace(/\/+$/, "");
+    let response;
+    try {
+      response = await fetch(`${baseUrl}/api/embed`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ model: this.model, input: prefixed }),
+        signal: AbortSignal.timeout(3e4)
+      });
+    } catch (err) {
+      if (err instanceof DOMException && err.name === "TimeoutError") {
+        throw new Error(`Remote embedding timed out after 30s (${baseUrl})`);
+      }
+      throw err;
+    }
+    if (!response.ok) {
+      throw new Error(`Remote embedding failed: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data.embeddings;
+  }
+};
+
+// src/adapters/index.ts
+function getEmbedderInfo(backend) {
+  switch (backend) {
+    case "local":
+      return { model: "bge-small-en-v1.5", dimensions: 384 };
+    case "ollama":
+      return { model: "nomic-embed-text", dimensions: 768 };
+    case "remote":
+      return { model: "nomic-embed-text", dimensions: 768 };
+    default:
+      throw new Error(`Unknown embedder backend: ${backend}`);
+  }
+}
+function createEmbedder(config) {
+  switch (config.embedder) {
+    case "local":
+      return new LocalEmbedder();
+    case "ollama":
+      return new OllamaEmbedder(config.ollamaUrl);
+    case "remote":
+      if (!config.ollamaUrl) {
+        throw new Error("ollamaUrl is required when using the remote embedder");
+      }
+      return new RemoteEmbedder(config.ollamaUrl);
+    default:
+      throw new Error(`Unknown embedder backend: ${config.embedder}`);
+  }
+}
+
+export {
+  LocalEmbedder,
+  OllamaEmbedder,
+  RemoteEmbedder,
+  getEmbedderInfo,
+  createEmbedder
+};

package/dist/chunk-PO3GJPIC.js

@@ -0,0 +1,66 @@
+// src/services/file-scanner.ts
+import { createHash } from "crypto";
+import { readFile, stat, readdir } from "fs/promises";
+import { join, extname } from "path";
+var INDEXABLE_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".csv", ".txt"]);
+function hashContent(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+async function scanForChanges(rootDir, knownFiles) {
+  const result = {
+    new: [],
+    modified: [],
+    deleted: [],
+    unchanged: 0
+  };
+  const entries = await readdir(rootDir, { recursive: true });
+  const files = entries.filter((e) => {
+    const ext = extname(e).toLowerCase();
+    return INDEXABLE_EXTENSIONS.has(ext) && !e.includes("node_modules") && !e.includes(".git");
+  }).map((e) => join(rootDir, e));
+  const seen = /* @__PURE__ */ new Set();
+  for (const filePath of files) {
+    seen.add(filePath);
+    const fileStat = await stat(filePath);
+    const mtime = fileStat.mtimeMs;
+    const known = knownFiles.get(filePath);
+    if (!known) {
+      const content2 = await readFile(filePath, "utf-8");
+      const hash2 = hashContent(content2);
+      result.new.push({ path: filePath, hash: hash2, mtime });
+      continue;
+    }
+    if (mtime === known.mtime) {
+      result.unchanged++;
+      continue;
+    }
+    const content = await readFile(filePath, "utf-8");
+    const hash = hashContent(content);
+    if (hash === known.hash) {
+      result.unchanged++;
+    } else {
+      result.modified.push({ path: filePath, hash, mtime });
+    }
+  }
+  for (const [path] of knownFiles) {
+    if (!seen.has(path)) {
+      result.deleted.push(path);
+    }
+  }
+  return result;
+}
+async function listUnsupportedFiles(rootDir) {
+  const entries = await readdir(rootDir, { recursive: true });
+  return entries.filter((e) => {
+    if (e.includes("node_modules") || e.includes(".git")) return false;
+    const ext = extname(e).toLowerCase();
+    return ext !== "" && !INDEXABLE_EXTENSIONS.has(ext);
+  }).map((e) => ({ path: join(rootDir, e), ext: extname(e).toLowerCase() }));
+}
+
+export {
+  INDEXABLE_EXTENSIONS,
+  hashContent,
+  scanForChanges,
+  listUnsupportedFiles
+};