@backbencher/brain 0.0.0-stage → 0.1.0

package/dist/chunk-7AN7U5IZ.js

@@ -0,0 +1,371 @@
+import {
+  create
+} from "./chunk-BQ3OVQ3P.js";
+
+// src/brain/semantic/local-embed.ts
+var log = create({ service: "local-embed" });
+var WORD_DIM = 50;
+var LOCAL_VECTOR_DIMENSION = WORD_DIM;
+var BASE_WORDS = [
+  "function",
+  "class",
+  "return",
+  "import",
+  "export",
+  "const",
+  "let",
+  "var",
+  "async",
+  "await",
+  "if",
+  "else",
+  "for",
+  "while",
+  "switch",
+  "case",
+  "break",
+  "continue",
+  "try",
+  "catch",
+  "throw",
+  "new",
+  "this",
+  "super",
+  "extends",
+  "implements",
+  "interface",
+  "type",
+  "enum",
+  "public",
+  "private",
+  "protected",
+  "static",
+  "abstract",
+  "final",
+  "override",
+  "string",
+  "number",
+  "boolean",
+  "array",
+  "object",
+  "null",
+  "undefined",
+  "void",
+  "true",
+  "false",
+  "map",
+  "filter",
+  "reduce",
+  "find",
+  "sort",
+  "push",
+  "pop",
+  "slice",
+  "promise",
+  "callback",
+  "event",
+  "handler",
+  "listener",
+  "dispatch",
+  "subscribe",
+  "module",
+  "package",
+  "dependency",
+  "require",
+  "default",
+  "data",
+  "user",
+  "get",
+  "set",
+  "create",
+  "update",
+  "delete",
+  "fetch",
+  "load",
+  "save",
+  "list",
+  "item",
+  "result",
+  "error",
+  "success",
+  "fail",
+  "check",
+  "validate",
+  "parse",
+  "convert",
+  "format",
+  "render",
+  "display",
+  "show",
+  "hide",
+  "open",
+  "close",
+  "start",
+  "stop",
+  "init",
+  "setup",
+  "config",
+  "option",
+  "param",
+  "value",
+  "key",
+  "id",
+  "name",
+  "path",
+  "file",
+  "dir",
+  "read",
+  "write",
+  "send",
+  "receive",
+  "request",
+  "response",
+  "query",
+  "select",
+  "insert",
+  "table",
+  "column",
+  "row",
+  "index",
+  "join",
+  "api",
+  "http",
+  "url",
+  "server",
+  "client",
+  "host",
+  "port",
+  "connect",
+  "socket",
+  "auth",
+  "token",
+  "login",
+  "logout",
+  "session",
+  "cookie",
+  "password",
+  "hash",
+  "test",
+  "mock",
+  "stub",
+  "assert",
+  "expect",
+  "should",
+  "describe",
+  "before",
+  "after",
+  "build",
+  "deploy",
+  "release",
+  "version",
+  "tag",
+  "branch",
+  "commit",
+  "merge",
+  "payment",
+  "checkout",
+  "order",
+  "cart",
+  "product",
+  "price",
+  "customer",
+  "invoice",
+  "subscription",
+  "refund",
+  "transaction",
+  "balance",
+  "charge",
+  "billing",
+  "notification",
+  "message",
+  "email",
+  "template",
+  "report",
+  "dashboard",
+  "widget",
+  "component",
+  "screen",
+  "page",
+  "view",
+  "layout",
+  "style",
+  "theme",
+  "color",
+  "cache",
+  "store",
+  "database",
+  "repository",
+  "service",
+  "controller",
+  "model",
+  "middleware",
+  "route",
+  "router",
+  "endpoint",
+  "schema",
+  "migration",
+  "seed",
+  "state",
+  "context",
+  "provider",
+  "hook",
+  "effect",
+  "reducer",
+  "action"
+];
+var _wordMap = null;
+var _wordVecs = null;
+var tableCache = /* @__PURE__ */ new WeakMap();
+var baseTable = null;
+function hashWord(w) {
+  let h = 24301;
+  for (let i = 0; i < w.length; i++) {
+    h = Math.imul(h ^ w.charCodeAt(i), 1540483477);
+    h = Math.imul(h ^ h >>> 15, 1540483477);
+  }
+  return h >>> 0;
+}
+function seedPRNG(seed) {
+  let s = seed | 0;
+  return () => {
+    s = s + 1831565813 | 0;
+    let t = Math.imul(s ^ s >>> 15, 1 | s);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function buildVectors(words) {
+  const unique = [...new Set(words.map((w) => w.toLowerCase().slice(0, 30)).filter((w) => w.length >= 2))];
+  const map = /* @__PURE__ */ Object.create(null);
+  const vecs = new Float32Array(unique.length * WORD_DIM);
+  for (let i = 0; i < unique.length; i++) {
+    map[unique[i]] = i;
+    vecs.set(wordVector(unique[i]), i * WORD_DIM);
+  }
+  _wordMap = map;
+  _wordVecs = vecs;
+}
+function publish(table) {
+  if (!table) return null;
+  _wordMap = table.map;
+  _wordVecs = table.vecs;
+  return table;
+}
+function wordVector(word) {
+  const v = new Float32Array(WORD_DIM);
+  const rng = seedPRNG(hashWord(word) | 0);
+  for (let d = 0; d < WORD_DIM; d++) v[d] = rng() * 2 - 1;
+  let norm = 0;
+  for (let d = 0; d < WORD_DIM; d++) norm += v[d] * v[d];
+  norm = Math.sqrt(norm);
+  if (norm > 0) for (let d = 0; d < WORD_DIM; d++) v[d] /= norm;
+  return v;
+}
+function tokenizeForEmbedding(text) {
+  const out = [];
+  for (const raw of String(text).split(/[^A-Za-z0-9]+/)) {
+    if (!raw) continue;
+    for (const part of raw.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").split(" ")) {
+      const word = part.toLowerCase();
+      if (word.length >= 2 && word.length <= 30 && !/^\d+$/.test(word)) out.push(word);
+    }
+  }
+  return out;
+}
+var PROJECT_VOCAB_MAX = 16;
+var projectVocabCache = /* @__PURE__ */ new Map();
+function projectVocabulary(rawDb, projectId) {
+  const cached = projectVocabCache.get(projectId);
+  if (cached) {
+    projectVocabCache.delete(projectId);
+    projectVocabCache.set(projectId, cached);
+    return cached;
+  }
+  const words = new Set(BASE_WORDS);
+  try {
+    const symbols = rawDb.prepare("SELECT DISTINCT name FROM brain_symbol WHERE project_id = ? LIMIT 80000").all(projectId);
+    const freq = {};
+    for (const s of symbols) {
+      if (!s.name) continue;
+      for (const w of tokenizeForEmbedding(String(s.name))) freq[w] = (freq[w] || 0) + 1;
+    }
+    const top = Object.entries(freq).sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, 5e3);
+    for (const [w] of top) words.add(w);
+  } catch (e) {
+    log.debug("project vocabulary failed, using base", { e: e?.message });
+    return null;
+  }
+  const map = /* @__PURE__ */ Object.create(null);
+  for (const w of words) map[w.toLowerCase().slice(0, 30)] = 0;
+  if (projectVocabCache.size >= PROJECT_VOCAB_MAX) {
+    const oldest = projectVocabCache.keys().next().value;
+    if (oldest !== void 0) projectVocabCache.delete(oldest);
+  }
+  projectVocabCache.set(projectId, map);
+  return map;
+}
+function getVectors(vocabulary) {
+  if (vocabulary) {
+    const cached = tableCache.get(vocabulary);
+    if (cached) return publish(cached);
+    buildVectors(Object.keys(vocabulary));
+    const table2 = _wordMap && _wordVecs ? { map: _wordMap, vecs: _wordVecs } : null;
+    if (table2) tableCache.set(vocabulary, table2);
+    return table2;
+  }
+  if (baseTable) return publish(baseTable);
+  if (_wordMap && _wordVecs) return { map: _wordMap, vecs: _wordVecs };
+  buildVectors(BASE_WORDS);
+  const table = _wordMap && _wordVecs ? { map: _wordMap, vecs: _wordVecs } : null;
+  baseTable = table;
+  return table;
+}
+function embedLocal(texts, vocabulary) {
+  const wv = getVectors(vocabulary);
+  if (!wv) return [];
+  const results = [];
+  for (const text of texts) {
+    const vec = new Array(WORD_DIM).fill(0);
+    const words = tokenizeForEmbedding(text);
+    let count = 0;
+    for (const w of words) {
+      const idx = wv.map[w];
+      if (idx !== void 0) {
+        const base = idx * WORD_DIM;
+        for (let d = 0; d < WORD_DIM; d++) vec[d] += wv.vecs[base + d];
+        count++;
+      } else {
+        for (let i = 0; i < w.length - 3; i++) {
+          const sub = w.slice(i, i + 4);
+          const si = wv.map[sub];
+          if (si !== void 0) {
+            const b = si * WORD_DIM;
+            for (let d = 0; d < WORD_DIM; d++) vec[d] += wv.vecs[b + d] * 0.25;
+            count++;
+          }
+        }
+      }
+    }
+    if (count === 0) {
+      results.push(new Array(WORD_DIM).fill(0));
+      continue;
+    }
+    let norm = 0;
+    for (let d = 0; d < WORD_DIM; d++) norm += vec[d] * vec[d];
+    norm = Math.sqrt(norm);
+    if (norm > 0) for (let d = 0; d < WORD_DIM; d++) vec[d] /= norm;
+    results.push(vec);
+  }
+  return results;
+}
+async function initLocalModel() {
+  return getVectors() !== null;
+}
+
+export {
+  LOCAL_VECTOR_DIMENSION,
+  tokenizeForEmbedding,
+  projectVocabulary,
+  embedLocal,
+  initLocalModel
+};