@yugenlab/vaayu 0.1.11 → 0.1.12

package/chunks/{chunk-LJUEMPLG.js → chunk-M2RLX5LU.js}

@@ -6,16 +6,19 @@ import {
   STOP_WORDS,
   cosineSimilarity,
   textMatchScore
-} from "./chunk-A3HOZBC5.js";
+} from "./chunk-RVKTGKFD.js";
 import {
-  initGraphSchema
-} from "./chunk-V2ZIKDN4.js";
+  initGraphSchema,
+  init_schema
+} from "./chunk-VEZ2DI2M.js";
 import {
-  DatabaseManager
-} from "./chunk-67DXWEKG.js";
+  DatabaseManager,
+  init_database
+} from "./chunk-H46F2Y6R.js";
 import {
-  getChitraguptaHome
-} from "./chunk-2OBLQJYJ.js";
+  getChitraguptaHome,
+  init_dist
+} from "./chunk-KVQH4LE7.js";
 
 // ../chitragupta/packages/smriti/dist/graphrag-pagerank.js
 var PAGERANK_DAMPING = 0.85;
@@ -1492,6 +1495,9 @@ function findBridgeNodes(graph, result, minCommunities = 2) {
 }
 
 // ../chitragupta/packages/smriti/dist/graphrag-persistence.js
+init_dist();
+init_database();
+init_schema();
 import fs from "fs";
 import path from "path";
 function getGraphDir() {
@@ -1827,7 +1833,9 @@ var GraphRAGEngine = class {
     if (isAvailable) {
       try {
         baseEntities = await llmExtractEntities(text, this.config.endpoint, this.config.generationModel);
-      } catch {
+      } catch (err) {
+        process.stderr.write(`[smriti:graphrag] LLM entity extraction failed, falling back to keywords: ${err instanceof Error ? err.message : String(err)}
+`);
         baseEntities = keywordExtractEntities(text);
       }
     } else {
@@ -1860,7 +1868,9 @@ var GraphRAGEngine = class {
           seen.add(normalized);
         }
       }
-    } catch {
+    } catch (err) {
+      process.stderr.write(`[smriti:graphrag] NER extraction failed: ${err instanceof Error ? err.message : String(err)}
+`);
     }
     return baseEntities;
   }
@@ -2019,7 +2029,9 @@ var GraphRAGEngine = class {
         saveToSqlite(db, this.graph, this.pageRankScores, this.embeddingCache);
         return;
       }
-    } catch {
+    } catch (err) {
+      process.stderr.write(`[smriti:graphrag] SQLite save failed, falling back to JSON: ${err instanceof Error ? err.message : String(err)}
+`);
     }
     saveToJson(this.graph, this.pageRankScores, this.embeddingCache);
   }
@@ -2040,13 +2052,17 @@ var GraphRAGEngine = class {
           if (this.graph.nodes.length > 0) {
             try {
               migrateInMemoryToSqlite(db, this.graph, this.pageRankScores);
-            } catch {
+            } catch (err) {
+              process.stderr.write(`[smriti:graphrag] in-memory to SQLite migration failed: ${err instanceof Error ? err.message : String(err)}
+`);
             }
           }
         }
         loaded = true;
       }
-    } catch {
+    } catch (err) {
+      process.stderr.write(`[smriti:graphrag] SQLite load failed: ${err instanceof Error ? err.message : String(err)}
+`);
     }
     if (!loaded) {
       const jsonData = loadFromJson();
@@ -2073,7 +2089,9 @@ var GraphRAGEngine = class {
       const db = this.getGraphDbHandle();
       if (db)
         db.exec("DELETE FROM pagerank; DELETE FROM edges; DELETE FROM nodes;");
-    } catch {
+    } catch (err) {
+      process.stderr.write(`[smriti:graphrag] clear DB failed: ${err instanceof Error ? err.message : String(err)}
+`);
     }
     this.saveToDisk();
   }
@@ -2116,4 +2134,4 @@ export {
   migrateGraphJson,
   GraphRAGEngine
 };
-//# sourceMappingURL=chunk-LJUEMPLG.js.map
+//# sourceMappingURL=chunk-M2RLX5LU.js.map

package/chunks/{chunk-IGKYKEKT.js → chunk-NAQKA54E.js}

@@ -10,6 +10,9 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __commonJS = (cb, mod) => function __require2() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
@@ -33,11 +36,14 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 export {
   __require,
+  __esm,
   __commonJS,
   __export,
-  __toESM
+  __toESM,
+  __toCommonJS
 };
-//# sourceMappingURL=chunk-IGKYKEKT.js.map
+//# sourceMappingURL=chunk-NAQKA54E.js.map

package/chunks/{chunk-F6RNEGFX.js → chunk-PZ4AQ22L.js}

@@ -2,13 +2,15 @@ import {
   EmbeddingService,
   cosineSimilarity,
   fallbackEmbedding
-} from "./chunk-A3HOZBC5.js";
+} from "./chunk-RVKTGKFD.js";
 import {
   SessionError,
-  getChitraguptaHome
-} from "./chunk-2OBLQJYJ.js";
+  getChitraguptaHome,
+  init_dist
+} from "./chunk-KVQH4LE7.js";
 
 // ../chitragupta/packages/smriti/dist/day-consolidation.js
+init_dist();
 import fs2 from "fs";
 import path2 from "path";
 
@@ -558,6 +560,8 @@ var FactExtractor = class {
    * Uses pattern matching first, then vector similarity for misses.
    */
   async extract(text) {
+    if (!shouldAnalyzeForFacts(text))
+      return [];
     await this.ensureInitialized();
     const facts = [];
     if (text.length < 5 || text.length > 5e3)
@@ -580,7 +584,7 @@ var FactExtractor = class {
         }
       }
     }
-    if (this.config.useVectors && facts.length === 0) {
+    if (this.config.useVectors && facts.length === 0 && shouldUseVectorFallback(text)) {
       const inputEmbedding = fallbackEmbedding(text.toLowerCase().slice(0, 200));
       let bestScore = 0;
       let bestTemplate = null;
@@ -623,20 +627,22 @@ var FactExtractor = class {
     const facts = await this.extract(text);
     if (facts.length === 0)
       return [];
-    const { appendMemory, getMemory } = await import("./memory-store-LEERUQGL.js");
+    const { appendMemory, getMemory } = await import("./memory-store-4GCBR2DZ.js");
     const globalScope = scope ?? { type: "global" };
     const existingMemory = getMemory(globalScope).toLowerCase();
+    const projectMemory = projectScope && projectScope.type !== "session" ? getMemory(projectScope).toLowerCase() : "";
     for (const fact of facts) {
       const dedupeKey = `${fact.category}:${fact.fact.toLowerCase().slice(0, 50)}`;
       if (this.recentFacts.has(dedupeKey))
         continue;
-      if (existingMemory.includes(fact.fact.toLowerCase().slice(0, 30)))
+      const memoryNeedle = fact.fact.toLowerCase().slice(0, 40);
+      if (existingMemory.includes(memoryNeedle) || projectMemory.includes(memoryNeedle))
         continue;
       const entry = `[${fact.category}] ${fact.fact}`;
       if (fact.category === "preference" && projectScope) {
-        await appendMemory(projectScope, entry);
+        await appendMemory(projectScope, entry, { dedupe: true });
       } else {
-        await appendMemory(globalScope, entry);
+        await appendMemory(globalScope, entry, { dedupe: true });
       }
       this.recentFacts.add(dedupeKey);
     }
@@ -652,10 +658,43 @@ var FactExtractor = class {
     }
   }
 };
+var MIN_WORDS = {
+  identity: 1,
+  location: 1,
+  work: 1,
+  preference: 1,
+  relationship: 1,
+  instruction: 3,
+  personal: 1
+};
+var MIN_LENGTH = {
+  identity: 2,
+  location: 2,
+  work: 2,
+  preference: 3,
+  relationship: 2,
+  instruction: 10,
+  personal: 2
+};
+var NOISE_PATTERNS = [
+  /^(?:this|that|it|the|a|an|some|any|all)$/i,
+  /^(?:circular deps?|deps?|fix|bug|error|issue|test|build|run|check)$/i,
+  /^(?:file|folder|dir|path|module|package|import|export)$/i,
+  /^[a-z]$/i
+];
 function normalizeFact(category, raw) {
   const cleaned = raw.replace(/[.!?,;:]+$/, "").trim();
-  if (cleaned.length < 2)
+  if (cleaned.length < MIN_LENGTH[category])
+    return null;
+  const wordCount = cleaned.split(/\s+/).filter((w) => w.length > 0).length;
+  if (wordCount < MIN_WORDS[category])
     return null;
+  if (wordCount <= 2) {
+    for (const noise of NOISE_PATTERNS) {
+      if (noise.test(cleaned))
+        return null;
+    }
+  }
   switch (category) {
     case "identity":
       return `Name: ${capitalize(cleaned)}`;
@@ -678,6 +717,32 @@ function normalizeFact(category, raw) {
 function capitalize(s) {
   return s.charAt(0).toUpperCase() + s.slice(1);
 }
+function shouldAnalyzeForFacts(text) {
+  const trimmed = text.trim();
+  if (trimmed.length < 8 || trimmed.length > 5e3)
+    return false;
+  const lower = trimmed.toLowerCase();
+  if (/^\/[a-z0-9_-]+/i.test(lower))
+    return false;
+  if (/^(hi|hii|hello|hey|yo|thanks|thank you|ok|okay|cool|fine|namaste|namaskaram)\b/.test(lower) && trimmed.length < 64) {
+    return false;
+  }
+  const hasMemorySignal = /\b(remember|don't forget|note this|save this|from now on|always|call me|my name is|i am|i'm|i live|i work|i prefer|we use|our stack)\b/i.test(lower);
+  const hasFirstPerson = /\b(i|i'm|i am|my|we|our)\b/i.test(lower);
+  const hasPatternCue = /\b(based in|living in|located in|never use|don't use|avoid|keep in mind|note that|remember that)\b/i.test(lower);
+  const isQuestion = /\?\s*$/.test(lower);
+  if (isQuestion && !hasMemorySignal)
+    return false;
+  return hasMemorySignal || hasFirstPerson || hasPatternCue;
+}
+function shouldUseVectorFallback(text) {
+  const lower = text.toLowerCase();
+  if (!shouldAnalyzeForFacts(text))
+    return false;
+  if (/^\s*(which|what|when|where|why|how)\b/.test(lower) && /\?\s*$/.test(lower))
+    return false;
+  return true;
+}
 var _instance = null;
 function getFactExtractor(config) {
   if (!_instance) {
@@ -873,7 +938,7 @@ function isDayConsolidated(date) {
   return fs.existsSync(getDayFilePath(date));
 }
 async function getUnconsolidatedDates(limit) {
-  const { listSessionDates } = await import("./session-store-O3TS7DUY.js");
+  const { listSessionDates } = await import("./session-store-3EDQZEDS.js");
   const sessionDates = listSessionDates();
   const unconsolidated = [];
   for (const date of sessionDates) {
@@ -916,7 +981,7 @@ async function consolidateDay(date, options) {
   if (options?.loadSessions) {
     sessions = await options.loadSessions(date);
   } else {
-    const { listSessionsByDate, listTurnsWithTimestamps, loadSession } = await import("./session-store-O3TS7DUY.js");
+    const { listSessionsByDate, listTurnsWithTimestamps, loadSession } = await import("./session-store-3EDQZEDS.js");
     const metas = listSessionsByDate(date);
     sessions = metas.map((meta) => {
       try {
@@ -992,7 +1057,7 @@ async function consolidateDay(date, options) {
   fs2.mkdirSync(dir, { recursive: true });
   fs2.writeFileSync(dayPath, markdown, "utf-8");
   try {
-    const { indexConsolidationSummary } = await import("./consolidation-indexer-VIWOP6VO.js");
+    const { indexConsolidationSummary } = await import("./consolidation-indexer-KPXORCJ4.js");
     await indexConsolidationSummary("daily", date, markdown);
   } catch {
   }
@@ -1074,4 +1139,4 @@ export {
   getDayFilePath,
   consolidateDay
 };
-//# sourceMappingURL=chunk-F6RNEGFX.js.map
+//# sourceMappingURL=chunk-PZ4AQ22L.js.map

package/chunks/{chunk-G2QREGXK.js → chunk-R273KC7J.js}

@@ -2,7 +2,7 @@ import {
   __commonJS,
   __require,
   __toESM
-} from "./chunk-IGKYKEKT.js";
+} from "./chunk-NAQKA54E.js";
 
 // ../node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/can-promise.js
 var require_can_promise = __commonJS({
@@ -5802,15 +5802,288 @@ var TwitterAdapter = class {
   }
 };
 
+// packages/channels/src/tring.ts
+import { execSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+var TRING_PLATFORM_ALIASES = {
+  whispr: "signal"
+};
+var normalizeTringPlatform = (value) => {
+  const normalized = value.trim().toLowerCase();
+  if (normalized in TRING_PLATFORM_ALIASES) return TRING_PLATFORM_ALIASES[normalized];
+  if (normalized === "whatsapp" || normalized === "telegram" || normalized === "signal") {
+    return normalized;
+  }
+  return void 0;
+};
+var TringAdapter = class _TringAdapter {
+  id = "tring";
+  options;
+  onMessage;
+  timer;
+  isPolling = false;
+  unsupportedPollPlatforms = /* @__PURE__ */ new Set();
+  /** Per-platform cursor token returned by Tring message list/poll. */
+  lastCursor = /* @__PURE__ */ new Map();
+  /** Per-platform fallback lower bound in unix seconds when cursor is unavailable. */
+  lastSince = /* @__PURE__ */ new Map();
+  /** Recent message identities for local de-duplication when daemon lacks `since`. */
+  recentMessageKeys = /* @__PURE__ */ new Map();
+  constructor(options, onMessage) {
+    const normalizedPlatforms = options.platforms.map((platform) => normalizeTringPlatform(platform)).filter((platform) => Boolean(platform)).filter((platform, index, list) => list.indexOf(platform) === index);
+    this.options = {
+      ...options,
+      platforms: normalizedPlatforms
+    };
+    this.onMessage = onMessage;
+  }
+  /** Start the adapter: verify daemon health, optionally spawn it, begin polling. */
+  async start() {
+    if (this.timer) return;
+    const healthy = await this.health();
+    if (!healthy && this.options.autoStartDaemon) {
+      const bin = this.options.tringBin ?? _TringAdapter.detectTringBin();
+      if (bin) {
+        try {
+          execSync(`${bin} daemon start`, { stdio: "ignore", timeout: 5e3 });
+        } catch {
+        }
+      }
+    }
+    this.timer = setInterval(() => {
+      void this.pollOnce();
+    }, this.options.pollIntervalMs);
+  }
+  /** Stop polling. Does NOT kill the daemon. */
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = void 0;
+    }
+  }
+  /**
+   * Send a text message through the Tring daemon.
+   * @param platform Target platform (whatsapp, telegram, signal).
+   * @param chatId Destination chat identifier.
+   * @param text Message body.
+   */
+  async sendMessage(platform, chatId, text) {
+    const canonical = normalizeTringPlatform(platform);
+    if (!canonical) {
+      throw new Error(`unsupported tring platform: ${platform}`);
+    }
+    await this.rpc("message.send", { platform: canonical, chat_id: chatId, text });
+  }
+  /** Check daemon health. Returns `true` if the daemon is reachable and healthy. */
+  async health() {
+    try {
+      const res = await this.rpc("platform.health", {});
+      return res?.ok === true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Auto-detect the tring CLI binary on the local system.
+   * Searches common install paths.
+   */
+  static detectTringBin() {
+    const paths = [
+      "tring",
+      `${process.env["HOME"] ?? ""}/.local/bin/tring`,
+      "/usr/local/bin/tring"
+    ];
+    for (const p of paths) {
+      try {
+        execSync(`which ${p}`, { stdio: "ignore" });
+        return p;
+      } catch {
+      }
+    }
+    return void 0;
+  }
+  // ── Private ──────────────────────────────────────────────────────────
+  /** Poll all configured platforms once for new messages. */
+  async pollOnce() {
+    if (this.isPolling) return;
+    this.isPolling = true;
+    try {
+      for (const platform of this.options.platforms) {
+        const params = {
+          platform,
+          direction: "incoming"
+        };
+        const cursor = this.lastCursor.get(platform);
+        const since = this.lastSince.get(platform);
+        if (cursor) {
+          params["cursor"] = cursor;
+        } else if (since && since > 0) {
+          params["since"] = since;
+        }
+        let res;
+        if (this.unsupportedPollPlatforms.has(platform)) {
+          res = await this.rpc("message.list", params);
+        } else {
+          const pollRes = await this.rpc("message.poll", params);
+          if (pollRes.ok) {
+            res = pollRes;
+          } else if (this.shouldFallbackToList(pollRes.error)) {
+            this.unsupportedPollPlatforms.add(platform);
+            res = await this.rpc("message.list", params);
+          } else {
+            res = pollRes;
+          }
+        }
+        const { messages, cursor: nextCursor } = this.extractMessages(res?.data);
+        if (nextCursor) this.lastCursor.set(platform, nextCursor);
+        this.pruneRecentMessageKeys();
+        let maxSeenSince = since ?? 0;
+        for (const raw of messages) {
+          if (this.isDuplicate(platform, raw)) continue;
+          if (this.options.allowedChats?.length) {
+            if (!this.options.allowedChats.includes(raw.chat_id)) continue;
+          }
+          const normalized = this.normalize(platform, raw);
+          if (normalized) {
+            await this.onMessage(normalized);
+          }
+          const ts = this.toUnixSeconds(raw.timestamp);
+          if (ts > maxSeenSince) maxSeenSince = ts;
+        }
+        if (maxSeenSince > 0) this.lastSince.set(platform, maxSeenSince);
+      }
+    } finally {
+      this.isPolling = false;
+    }
+  }
+  /** Normalize a Tring raw message into a NormalizedMessage. */
+  normalize(platform, raw) {
+    const normalizedPlatform = normalizeTringPlatform(raw.platform ?? platform);
+    if (!normalizedPlatform) return null;
+    const body = raw.body_text ?? raw.body;
+    if (!body) return null;
+    const userId = raw.user_id ?? raw.sender_id ?? raw.chat_id;
+    const channel = normalizedPlatform;
+    return {
+      channel,
+      chatId: raw.chat_id,
+      userId,
+      chatType: raw.chat_type ?? "dm",
+      threadId: raw.thread_id,
+      text: body,
+      time: this.toIsoTimestamp(raw.timestamp),
+      raw
+    };
+  }
+  /** Extract messages/cursor from both legacy (`data: []`) and current payloads. */
+  extractMessages(data) {
+    if (Array.isArray(data)) return { messages: data };
+    if (!data) return { messages: [] };
+    return {
+      messages: Array.isArray(data.messages) ? data.messages : [],
+      cursor: typeof data.cursor === "string" && data.cursor.length > 0 ? data.cursor : void 0
+    };
+  }
+  /** Convert epoch seconds/milliseconds into ISO timestamp. */
+  toIsoTimestamp(value) {
+    const millis = value > 1e10 ? value : value * 1e3;
+    return new Date(millis).toISOString();
+  }
+  /** Convert epoch seconds/milliseconds to unix seconds. */
+  toUnixSeconds(value) {
+    return value > 1e10 ? Math.floor(value / 1e3) : value;
+  }
+  /** Prune dedupe cache to avoid unbounded growth. */
+  pruneRecentMessageKeys() {
+    const cutoff = Date.now() - 10 * 6e4;
+    for (const [key, seenAt] of this.recentMessageKeys.entries()) {
+      if (seenAt < cutoff) this.recentMessageKeys.delete(key);
+    }
+  }
+  /** Return true when this inbound record was already observed in recent polls. */
+  isDuplicate(platform, raw) {
+    const identity = raw.platform_message_id || raw.id || `${raw.chat_id}:${raw.sender_id ?? raw.user_id ?? ""}:${raw.timestamp}:${raw.body ?? ""}`;
+    const key = `${platform}:${identity}`;
+    const now = Date.now();
+    if (this.recentMessageKeys.has(key)) return true;
+    this.recentMessageKeys.set(key, now);
+    return false;
+  }
+  shouldFallbackToList(error) {
+    if (!error) return false;
+    const code = this.extractErrorCode(error);
+    if (!code) return false;
+    return code.includes("PLATFORM_FEATURE_UNSUPPORTED") || code.includes("METHOD_NOT_FOUND") || code.includes("INVALID_ARGUMENT") || code.includes("NOT_FOUND");
+  }
+  extractErrorCode(error) {
+    if (typeof error === "string") return error;
+    return error.code;
+  }
+  /**
+   * Inline JSON-RPC client. Posts a command to the Tring daemon.
+   * Retries once on connection failure after a 1 second delay.
+   */
+  async rpc(command, params) {
+    const url = `${this.options.daemonUrl}/rpc`;
+    const body = JSON.stringify({
+      request_id: randomUUID(),
+      command,
+      params
+    });
+    const headers = { "content-type": "application/json" };
+    const attempt = async () => {
+      const res = await fetch(url, { method: "POST", headers, body });
+      const contentType = res.headers.get("content-type")?.toLowerCase() ?? "";
+      const payloadText = await res.text();
+      const preview = payloadText.length > 512 ? `${payloadText.slice(0, 512)}...` : payloadText;
+      if (!res.ok) {
+        return {
+          ok: false,
+          error: `http_${res.status}_${res.statusText}: ${preview}`
+        };
+      }
+      if (!contentType.includes("application/json")) {
+        return {
+          ok: false,
+          error: `non_json_response_${contentType || "unknown"}: ${preview}`
+        };
+      }
+      try {
+        return JSON.parse(payloadText);
+      } catch (parseError) {
+        return {
+          ok: false,
+          error: `json_parse_failed_${parseError instanceof Error ? parseError.message : String(parseError)}: ${preview}`
+        };
+      }
+    };
+    try {
+      return await attempt();
+    } catch (firstError) {
+      await new Promise((resolve) => setTimeout(resolve, 1e3));
+      try {
+        return await attempt();
+      } catch (retryError) {
+        console.warn("[vaayu] tring rpc failed", {
+          command,
+          message: retryError instanceof Error ? retryError.message : String(retryError)
+        });
+        return { ok: false, error: "connection_failed" };
+      }
+    }
+  }
+};
+
 export {
   require_lib,
   TelegramAdapter,
   WhatsAppAdapter,
   IMessageAdapter,
   TwitterAdapter,
+  TringAdapter,
   generateMantra,
   validateMantra,
   renderPairDisplay,
   renderPairStatus
 };
-//# sourceMappingURL=chunk-G2QREGXK.js.map
+//# sourceMappingURL=chunk-R273KC7J.js.map

package/chunks/{chunk-A3HOZBC5.js → chunk-RVKTGKFD.js}

@@ -55,7 +55,7 @@ function cosineSimilarity(a, b) {
   return dotProduct / denominator;
 }
 function estimateTokens(text) {
-  return Math.ceil(text.length / 4);
+  return Math.ceil(text.length / 3.7);
 }
 function tokenize(text) {
   return text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((t) => t.length >= 2 && !STOP_WORDS.has(t));
@@ -209,4 +209,4 @@ export {
   fallbackEmbedding,
   EmbeddingService
 };
-//# sourceMappingURL=chunk-A3HOZBC5.js.map
+//# sourceMappingURL=chunk-RVKTGKFD.js.map