@yugenlab/vaayu 0.1.10 → 0.1.12

package/chunks/{chunk-MJ74G5RB.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,
-  require_lib,
   renderPairDisplay,
   renderPairStatus
 };
-//# sourceMappingURL=chunk-MJ74G5RB.js.map
+//# sourceMappingURL=chunk-R273KC7J.js.map

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

@@ -1,4 +1,4 @@
-// ../chitragupta/packages/smriti/src/graphrag-scoring.ts
+// ../chitragupta/packages/smriti/dist/graphrag-scoring.js
 var ALPHA = 0.6;
 var BETA = 0.25;
 var GAMMA = 0.15;
@@ -39,7 +39,8 @@ var STOP_WORDS = /* @__PURE__ */ new Set([
   "no"
 ]);
 function cosineSimilarity(a, b) {
-  if (a.length !== b.length) return 0;
+  if (a.length !== b.length)
+    return 0;
   let dotProduct = 0;
   let normA = 0;
   let normB = 0;
@@ -49,11 +50,12 @@ function cosineSimilarity(a, b) {
     normB += b[i] * b[i];
   }
   const denominator = Math.sqrt(normA) * Math.sqrt(normB);
-  if (denominator === 0) return 0;
+  if (denominator === 0)
+    return 0;
   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));
@@ -61,7 +63,8 @@ function tokenize(text) {
 function textMatchScore(query, docText) {
   const queryTokens = tokenize(query);
   const docTokens = tokenize(docText);
-  if (queryTokens.length === 0 || docTokens.length === 0) return 0;
+  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);
@@ -81,7 +84,7 @@ function textMatchScore(query, docText) {
   return Math.min(score, 1);
 }
 
-// ../chitragupta/packages/smriti/src/embedding-service.ts
+// ../chitragupta/packages/smriti/dist/embedding-service.js
 var FALLBACK_DIM = 384;
 var DEFAULT_MAX_CACHE = 5e3;
 var MAX_CACHE_CEILING = 2e4;
@@ -155,7 +158,8 @@ var EmbeddingService = class {
   async getEmbedding(text) {
     const cacheKey = fnv1aHash(text);
     const cached = this.cache.get(cacheKey);
-    if (cached) return cached;
+    if (cached)
+      return cached;
     let vector;
     if (this.provider) {
       if (this.providerAvailable === null) {
@@ -205,4 +209,4 @@ export {
   fallbackEmbedding,
   EmbeddingService
 };
-//# sourceMappingURL=chunk-JAWZ7ANC.js.map
+//# sourceMappingURL=chunk-RVKTGKFD.js.map