@yugenlab/vaayu 0.1.0

package/chunks/chunk-ITIVYGUG.js

@@ -0,0 +1,347 @@
+import {
+  getMemory,
+  listMemoryScopes
+} from "./chunk-E5A3SCDJ.js";
+import {
+  listSessions,
+  loadSession
+} from "./chunk-L7JICQBW.js";
+import {
+  DatabaseManager,
+  initAgentSchema
+} from "./chunk-U6OLJ36B.js";
+
+// ../chitragupta/packages/smriti/src/search.ts
+var _dbInitialized = false;
+function getAgentDb() {
+  const dbm = DatabaseManager.instance();
+  if (!_dbInitialized) {
+    try {
+      initAgentSchema(dbm);
+      _dbInitialized = true;
+    } catch (err) {
+      process.stderr.write(`[chitragupta] search DB schema init failed: ${err instanceof Error ? err.message : err}
+`);
+      throw err;
+    }
+  }
+  return dbm.get("agent");
+}
+function _resetSearchDbInit() {
+  _dbInitialized = false;
+}
+function sanitizeFts5Query(query) {
+  const cleaned = query.replace(/[*^"(){}:]/g, "").replace(/\b(NOT|AND|OR|NEAR)\b/gi, "").trim();
+  if (!cleaned) return "";
+  const terms = cleaned.split(/\s+/).filter((t) => t.length >= 2).map((t) => `"${t}"`).join(" ");
+  return terms;
+}
+function recencyBoost(epochMs) {
+  const ageMs = Date.now() - epochMs;
+  const ageHours = ageMs / (1e3 * 60 * 60);
+  if (ageHours < 1) return 1.5 - 0.2 * (ageHours / 1);
+  if (ageHours < 24) return 1.3 - 0.2 * ((ageHours - 1) / 23);
+  if (ageHours < 168) return 1.1 - 0.1 * ((ageHours - 24) / 144);
+  return 1;
+}
+function recencyBoostIso(isoDate) {
+  return recencyBoost(new Date(isoDate).getTime());
+}
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "the",
+  "and",
+  "or",
+  "but",
+  "in",
+  "on",
+  "at",
+  "to",
+  "for",
+  "of",
+  "with",
+  "by",
+  "from",
+  "is",
+  "it",
+  "its",
+  "this",
+  "that",
+  "was",
+  "are",
+  "be",
+  "been",
+  "being",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "could",
+  "should",
+  "may",
+  "might",
+  "shall",
+  "can",
+  "not",
+  "no",
+  "nor",
+  "so",
+  "if",
+  "then",
+  "than",
+  "too",
+  "very",
+  "just",
+  "about",
+  "above",
+  "after",
+  "again",
+  "all",
+  "also",
+  "am",
+  "any",
+  "as",
+  "because",
+  "before",
+  "between",
+  "both",
+  "each",
+  "few",
+  "get",
+  "got",
+  "he",
+  "her",
+  "here",
+  "him",
+  "his",
+  "how",
+  "i",
+  "into",
+  "me",
+  "more",
+  "most",
+  "my",
+  "now",
+  "only",
+  "other",
+  "our",
+  "out",
+  "over",
+  "own",
+  "s",
+  "same",
+  "she",
+  "some",
+  "still",
+  "such",
+  "t",
+  "their",
+  "them",
+  "there",
+  "these",
+  "they",
+  "those",
+  "through",
+  "under",
+  "up",
+  "us",
+  "we",
+  "what",
+  "when",
+  "where",
+  "which",
+  "while",
+  "who",
+  "whom",
+  "why",
+  "you",
+  "your"
+]);
+var BM25_K1 = 1.2;
+var BM25_B = 0.75;
+function tokenize(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((t) => t.length >= 2 && !STOP_WORDS.has(t));
+}
+var BM25Corpus = class {
+  documents = [];
+  df = /* @__PURE__ */ new Map();
+  avgDl = 0;
+  addDocument(payload, text) {
+    const tokens = tokenize(text);
+    const tf = /* @__PURE__ */ new Map();
+    for (const token of tokens) {
+      tf.set(token, (tf.get(token) ?? 0) + 1);
+    }
+    this.documents.push({ payload, tf, length: tokens.length });
+    for (const term of tf.keys()) {
+      this.df.set(term, (this.df.get(term) ?? 0) + 1);
+    }
+  }
+  finalize() {
+    if (this.documents.length === 0) {
+      this.avgDl = 0;
+      return;
+    }
+    const totalLength = this.documents.reduce((sum, doc) => sum + doc.length, 0);
+    this.avgDl = totalLength / this.documents.length;
+  }
+  idf(term) {
+    const N = this.documents.length;
+    const df = this.df.get(term) ?? 0;
+    return Math.log((N - df + 0.5) / (df + 0.5) + 1);
+  }
+  scoreDocument(doc, queryTerms) {
+    let score = 0;
+    for (const term of queryTerms) {
+      const tf = doc.tf.get(term) ?? 0;
+      if (tf === 0) continue;
+      const idf = this.idf(term);
+      const numerator = tf * (BM25_K1 + 1);
+      const denominator = tf + BM25_K1 * (1 - BM25_B + BM25_B * (doc.length / (this.avgDl || 1)));
+      score += idf * (numerator / denominator);
+    }
+    return score;
+  }
+  query(queryText) {
+    const queryTerms = tokenize(queryText);
+    if (queryTerms.length === 0) return [];
+    const results = [];
+    for (const doc of this.documents) {
+      const score = this.scoreDocument(doc, queryTerms);
+      if (score > 0) results.push({ payload: doc.payload, score });
+    }
+    results.sort((a, b) => b.score - a.score);
+    return results;
+  }
+};
+function searchSessions(query, project) {
+  if (!query || query.trim().length === 0) return [];
+  try {
+    return searchSessionsFts5(query, project);
+  } catch (err) {
+    process.stderr.write(`[chitragupta] FTS5 search failed, falling back to BM25: ${err instanceof Error ? err.message : err}
+`);
+    return searchSessionsBm25(query, project);
+  }
+}
+function searchSessionsFts5(query, project) {
+  const ftsQuery = sanitizeFts5Query(query);
+  if (!ftsQuery) return [];
+  const db = getAgentDb();
+  const sql = project ? `SELECT t.session_id, t.turn_number, t.content, f.rank,
+				s.title, s.project, s.created_at, s.updated_at,
+				s.agent, s.model, s.cost, s.tokens, s.tags, s.parent_id, s.branch
+			FROM turns_fts f
+			JOIN turns t ON t.id = f.rowid
+			JOIN sessions s ON s.id = t.session_id
+			WHERE turns_fts MATCH ? AND s.project = ?
+			ORDER BY f.rank
+			LIMIT 200` : `SELECT t.session_id, t.turn_number, t.content, f.rank,
+				s.title, s.project, s.created_at, s.updated_at,
+				s.agent, s.model, s.cost, s.tokens, s.tags, s.parent_id, s.branch
+			FROM turns_fts f
+			JOIN turns t ON t.id = f.rowid
+			JOIN sessions s ON s.id = t.session_id
+			WHERE turns_fts MATCH ?
+			ORDER BY f.rank
+			LIMIT 200`;
+  const rows = project ? db.prepare(sql).all(ftsQuery, project) : db.prepare(sql).all(ftsQuery);
+  const sessionBest = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const bm25Score = -row.rank;
+    const boost = recencyBoost(row.updated_at);
+    const finalScore = bm25Score * boost;
+    const existing = sessionBest.get(row.session_id);
+    if (!existing || finalScore > existing.score) {
+      sessionBest.set(row.session_id, { row, score: finalScore });
+    }
+  }
+  const sorted = [...sessionBest.values()].sort((a, b) => b.score - a.score);
+  return sorted.map(({ row }) => ({
+    id: row.session_id,
+    title: row.title,
+    created: new Date(row.created_at).toISOString(),
+    updated: new Date(row.updated_at).toISOString(),
+    agent: row.agent ?? "chitragupta",
+    model: row.model ?? "unknown",
+    project: row.project,
+    parent: row.parent_id ?? null,
+    branch: row.branch ?? null,
+    tags: (() => {
+      try {
+        return JSON.parse(row.tags ?? "[]");
+      } catch {
+        return [];
+      }
+    })(),
+    totalCost: row.cost ?? 0,
+    totalTokens: row.tokens ?? 0
+  }));
+}
+function searchSessionsBm25(query, project) {
+  const allMetas = listSessions(project);
+  const corpus = new BM25Corpus();
+  for (const meta of allMetas) {
+    const parts = [];
+    parts.push(meta.title, meta.title, meta.title);
+    const tagsText = meta.tags.join(" ");
+    parts.push(tagsText, tagsText);
+    parts.push(meta.agent);
+    try {
+      const session = loadSession(meta.id, meta.project);
+      for (const turn of session.turns) {
+        parts.push(turn.content);
+        if (turn.toolCalls) {
+          for (const tc of turn.toolCalls) {
+            parts.push(tc.name, tc.input, tc.result);
+          }
+        }
+      }
+    } catch {
+    }
+    corpus.addDocument(meta, parts.join(" "));
+  }
+  corpus.finalize();
+  const results = corpus.query(query);
+  const boosted = results.map((r) => ({
+    meta: r.payload,
+    score: r.score * recencyBoostIso(r.payload.updated)
+  }));
+  boosted.sort((a, b) => b.score - a.score);
+  return boosted.map((s) => s.meta);
+}
+function searchMemory(query) {
+  if (!query || query.trim().length === 0) return [];
+  const scopes = listMemoryScopes();
+  const corpus = new BM25Corpus();
+  for (const scope of scopes) {
+    try {
+      const content = getMemory(scope);
+      if (!content) continue;
+      corpus.addDocument({ scope, content }, content);
+    } catch {
+    }
+  }
+  corpus.finalize();
+  const results = corpus.query(query);
+  if (results.length === 0) return [];
+  const maxScore = results[0].score;
+  return results.map((r) => ({
+    scope: r.payload.scope,
+    content: r.payload.content,
+    relevance: maxScore > 0 ? r.score / maxScore : 0
+  }));
+}
+
+export {
+  _resetSearchDbInit,
+  sanitizeFts5Query,
+  searchSessions,
+  searchMemory
+};
+//# sourceMappingURL=chunk-ITIVYGUG.js.map

package/chunks/chunk-JAWZ7ANC.js

@@ -0,0 +1,208 @@
+// ../chitragupta/packages/smriti/src/graphrag-scoring.ts
+var ALPHA = 0.6;
+var BETA = 0.25;
+var GAMMA = 0.15;
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "the",
+  "and",
+  "or",
+  "but",
+  "in",
+  "on",
+  "at",
+  "to",
+  "for",
+  "of",
+  "with",
+  "by",
+  "from",
+  "is",
+  "it",
+  "this",
+  "that",
+  "was",
+  "are",
+  "be",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "could",
+  "should",
+  "not",
+  "no"
+]);
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) return 0;
+  let dotProduct = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dotProduct += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+  if (denominator === 0) return 0;
+  return dotProduct / denominator;
+}
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function tokenize(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((t) => t.length >= 2 && !STOP_WORDS.has(t));
+}
+function textMatchScore(query, docText) {
+  const queryTokens = tokenize(query);
+  const docTokens = tokenize(docText);
+  if (queryTokens.length === 0 || docTokens.length === 0) return 0;
+  const docTf = /* @__PURE__ */ new Map();
+  for (const token of docTokens) {
+    docTf.set(token, (docTf.get(token) ?? 0) + 1);
+  }
+  let score = 0;
+  let matchedTerms = 0;
+  for (const qTerm of queryTokens) {
+    const tf = docTf.get(qTerm) ?? 0;
+    if (tf > 0) {
+      score += 1 + Math.log(1 + tf);
+      matchedTerms++;
+    }
+  }
+  const coverage = matchedTerms / queryTokens.length;
+  score *= 0.5 + 0.5 * coverage;
+  score /= queryTokens.length;
+  return Math.min(score, 1);
+}
+
+// ../chitragupta/packages/smriti/src/embedding-service.ts
+var FALLBACK_DIM = 384;
+var DEFAULT_MAX_CACHE = 5e3;
+var MAX_CACHE_CEILING = 2e4;
+function fnv1aHash(text) {
+  let h1 = 2166136261;
+  let h2 = 16777619;
+  for (let i = 0; i < text.length; i++) {
+    const c = text.charCodeAt(i);
+    h1 = Math.imul(h1 ^ c, 16777619);
+    h2 = Math.imul(h2 ^ c >> 8, 16777619);
+  }
+  return (h1 >>> 0).toString(16).padStart(8, "0") + (h2 >>> 0).toString(16).padStart(8, "0");
+}
+function fallbackEmbedding(text) {
+  const vector = new Array(FALLBACK_DIM).fill(0);
+  const lower = text.toLowerCase();
+  for (let i = 0; i < lower.length; i++) {
+    const code = lower.charCodeAt(i);
+    const idx = (code * 7 + i * 13) % FALLBACK_DIM;
+    vector[idx] += 1;
+  }
+  const magnitude = Math.sqrt(vector.reduce((sum, v) => sum + v * v, 0));
+  if (magnitude > 0) {
+    for (let i = 0; i < FALLBACK_DIM; i++) {
+      vector[i] /= magnitude;
+    }
+  }
+  return vector;
+}
+var LRUCache = class {
+  map = /* @__PURE__ */ new Map();
+  maxSize;
+  constructor(maxSize) {
+    this.maxSize = maxSize;
+  }
+  get(key) {
+    const value = this.map.get(key);
+    if (value !== void 0) {
+      this.map.delete(key);
+      this.map.set(key, value);
+    }
+    return value;
+  }
+  set(key, value) {
+    if (this.map.has(key)) {
+      this.map.delete(key);
+    } else if (this.map.size >= this.maxSize) {
+      const oldest = this.map.keys().next().value;
+      if (oldest !== void 0) {
+        this.map.delete(oldest);
+      }
+    }
+    this.map.set(key, value);
+  }
+  get size() {
+    return this.map.size;
+  }
+  clear() {
+    this.map.clear();
+  }
+};
+var EmbeddingService = class {
+  provider;
+  cache;
+  providerAvailable = null;
+  constructor(provider, maxCacheSize) {
+    this.provider = provider;
+    const bounded = Math.min(maxCacheSize ?? DEFAULT_MAX_CACHE, MAX_CACHE_CEILING);
+    this.cache = new LRUCache(bounded);
+  }
+  async getEmbedding(text) {
+    const cacheKey = fnv1aHash(text);
+    const cached = this.cache.get(cacheKey);
+    if (cached) return cached;
+    let vector;
+    if (this.provider) {
+      if (this.providerAvailable === null) {
+        try {
+          this.providerAvailable = await this.provider.isConfigured();
+        } catch {
+          this.providerAvailable = false;
+        }
+      }
+      if (this.providerAvailable) {
+        try {
+          const result = await this.provider.embed(text);
+          vector = result.embedding;
+        } catch {
+          this.providerAvailable = false;
+          vector = fallbackEmbedding(text);
+        }
+      } else {
+        vector = fallbackEmbedding(text);
+      }
+    } else {
+      vector = fallbackEmbedding(text);
+    }
+    this.cache.set(cacheKey, vector);
+    return vector;
+  }
+  resetAvailability() {
+    this.providerAvailable = null;
+  }
+  clearCache() {
+    this.cache.clear();
+  }
+  /** Current number of cached embeddings. */
+  get cacheSize() {
+    return this.cache.size;
+  }
+};
+
+export {
+  ALPHA,
+  BETA,
+  GAMMA,
+  STOP_WORDS,
+  cosineSimilarity,
+  estimateTokens,
+  textMatchScore,
+  fallbackEmbedding,
+  EmbeddingService
+};
+//# sourceMappingURL=chunk-JAWZ7ANC.js.map