@yugenlab/vaayu 0.1.11 → 0.1.12

package/chunks/{agentic-tool-loop-O3NUV7KG.js → agentic-tool-loop-NQESOBLC.js}

@@ -1,4 +1,4 @@
-import "./chunk-IGKYKEKT.js";
+import "./chunk-NAQKA54E.js";
 
 // apps/gateway/dist/agent/agentic-tool-loop.js
 async function runAgenticToolLoop(params) {
@@ -144,4 +144,4 @@ async function runAgenticToolLoop(params) {
 export {
   runAgenticToolLoop
 };
-//# sourceMappingURL=agentic-tool-loop-O3NUV7KG.js.map
+//# sourceMappingURL=agentic-tool-loop-NQESOBLC.js.map

package/chunks/akasha-5C5Q6NMP.js

@@ -0,0 +1,12 @@
+import {
+  AkashaField,
+  jaccardSimilarity,
+  tokenize
+} from "./chunk-5E3ZS5SW.js";
+import "./chunk-NAQKA54E.js";
+export {
+  AkashaField,
+  jaccardSimilarity,
+  tokenize
+};
+//# sourceMappingURL=akasha-5C5Q6NMP.js.map

package/chunks/{chunk-7XV5ISV7.js → chunk-26K6DS6N.js}

@@ -7,7 +7,7 @@ var DEPTH_BOOST = {
 async function hierarchicalTemporalSearch(query, options) {
   const limit = options?.limit ?? 10;
   const results = [];
-  const { searchConsolidationSummaries } = await import("./consolidation-indexer-VIWOP6VO.js");
+  const { searchConsolidationSummaries } = await import("./consolidation-indexer-KPXORCJ4.js");
   const yearlyHits = await searchConsolidationSummaries(query, "yearly", {
     limit: 3,
     project: options?.project
@@ -122,4 +122,4 @@ function deduplicateAndSort(results, limit) {
 export {
   hierarchicalTemporalSearch
 };
-//# sourceMappingURL=chunk-7XV5ISV7.js.map
+//# sourceMappingURL=chunk-26K6DS6N.js.map

package/chunks/chunk-5E3ZS5SW.js

@@ -0,0 +1,529 @@
+// ../chitragupta/packages/smriti/dist/akasha-integration.js
+var CREATE_TABLE_SQL = `
+	CREATE TABLE IF NOT EXISTS akasha_traces (
+		id TEXT PRIMARY KEY,
+		agent_id TEXT NOT NULL,
+		trace_type TEXT NOT NULL,
+		topic TEXT NOT NULL,
+		content TEXT NOT NULL,
+		strength REAL NOT NULL,
+		reinforcements INTEGER NOT NULL DEFAULT 0,
+		metadata TEXT,
+		created_at INTEGER NOT NULL,
+		last_reinforced_at INTEGER NOT NULL
+	);
+	CREATE INDEX IF NOT EXISTS idx_akasha_topic ON akasha_traces(topic);
+	CREATE INDEX IF NOT EXISTS idx_akasha_strength ON akasha_traces(strength DESC);
+`;
+var UPSERT_SQL = `
+	INSERT OR REPLACE INTO akasha_traces
+		(id, agent_id, trace_type, topic, content, strength,
+		 reinforcements, metadata, created_at, last_reinforced_at)
+	VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+`;
+var ENSURE_TABLE_SQL = `
+	CREATE TABLE IF NOT EXISTS akasha_traces (
+		id TEXT PRIMARY KEY,
+		agent_id TEXT NOT NULL,
+		trace_type TEXT NOT NULL,
+		topic TEXT NOT NULL,
+		content TEXT NOT NULL,
+		strength REAL NOT NULL,
+		reinforcements INTEGER NOT NULL DEFAULT 0,
+		metadata TEXT,
+		created_at INTEGER NOT NULL,
+		last_reinforced_at INTEGER NOT NULL
+	);
+`;
+function safeParseJson(raw) {
+  if (!raw)
+    return {};
+  try {
+    const parsed = JSON.parse(raw);
+    return typeof parsed === "object" && parsed !== null ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function persistTraces(traces, db) {
+  db.exec(CREATE_TABLE_SQL);
+  const upsert = db.prepare(UPSERT_SQL);
+  for (const trace of traces.values()) {
+    upsert.run(trace.id, trace.agentId, trace.traceType, trace.topic, trace.content, trace.strength, trace.reinforcements, JSON.stringify(trace.metadata), trace.createdAt, trace.lastReinforcedAt);
+  }
+}
+function restoreTraces(db, config) {
+  db.exec(ENSURE_TABLE_SQL);
+  const rows = db.prepare("SELECT * FROM akasha_traces").all();
+  const traces = /* @__PURE__ */ new Map();
+  const reinforcedBy = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    if (row.strength < config.minStrength)
+      continue;
+    const trace = {
+      id: row.id,
+      agentId: row.agent_id,
+      traceType: row.trace_type,
+      topic: row.topic,
+      content: row.content,
+      strength: row.strength,
+      reinforcements: row.reinforcements,
+      metadata: safeParseJson(row.metadata),
+      createdAt: row.created_at,
+      lastReinforcedAt: row.last_reinforced_at
+    };
+    traces.set(trace.id, trace);
+    reinforcedBy.set(trace.id, /* @__PURE__ */ new Set([trace.agentId]));
+  }
+  return { traces, reinforcedBy };
+}
+function tracesToGraphNodes(traces, minStrength) {
+  const nodes = [];
+  for (const trace of traces.values()) {
+    if (trace.strength < minStrength)
+      continue;
+    nodes.push({
+      id: trace.id,
+      label: `[${trace.traceType}] ${trace.topic}`,
+      content: trace.content,
+      type: "akasha",
+      weight: trace.strength
+    });
+  }
+  return nodes;
+}
+function boostResultsWithTraces(traces, config, results, query) {
+  const queryTokens = new Set(tokenize(query));
+  const matchingTraces = [];
+  if (queryTokens.size > 0) {
+    for (const trace of traces.values()) {
+      if (trace.strength < config.minStrength)
+        continue;
+      const traceTokens = /* @__PURE__ */ new Set([
+        ...tokenize(trace.topic),
+        ...tokenize(trace.content)
+      ]);
+      const sim = jaccardSimilarity(queryTokens, traceTokens);
+      if (sim > 0) {
+        matchingTraces.push({ trace, similarity: sim });
+      }
+    }
+    matchingTraces.sort((a, b) => b.similarity - a.similarity);
+  }
+  return results.map((result) => {
+    let traceBoost = 0;
+    if (queryTokens.size > 0 && matchingTraces.length > 0) {
+      const resultTokens = result.content ? new Set(tokenize(result.content)) : /* @__PURE__ */ new Set();
+      let bestBoost = 0;
+      for (const { trace, similarity } of matchingTraces) {
+        if (result.id === trace.id) {
+          bestBoost = Math.max(bestBoost, trace.strength);
+          break;
+        }
+        if (resultTokens.size > 0) {
+          const traceTokens = /* @__PURE__ */ new Set([
+            ...tokenize(trace.topic),
+            ...tokenize(trace.content)
+          ]);
+          const resultSim = jaccardSimilarity(resultTokens, traceTokens);
+          if (resultSim > 0.1) {
+            bestBoost = Math.max(bestBoost, similarity * trace.strength);
+          }
+        } else {
+          bestBoost = Math.max(bestBoost, similarity * trace.strength);
+        }
+      }
+      traceBoost = bestBoost * config.traceBoostFactor;
+    }
+    return {
+      ...result,
+      score: result.score * (1 + traceBoost),
+      traceBoost
+    };
+  });
+}
+
+// ../chitragupta/packages/smriti/dist/akasha.js
+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",
+  "not",
+  "no",
+  "so",
+  "if",
+  "then",
+  "than",
+  "too",
+  "very",
+  "can",
+  "just",
+  "about",
+  "into",
+  "over",
+  "after"
+]);
+var FNV_OFFSET = 2166136261;
+var FNV_PRIME = 16777619;
+function fnv1a(input) {
+  let hash = FNV_OFFSET;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = Math.imul(hash, FNV_PRIME) >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+function tokenize(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((t) => t.length >= 2 && !STOP_WORDS.has(t));
+}
+function jaccardSimilarity(a, b) {
+  if (a.size === 0 && b.size === 0)
+    return 1;
+  let intersection = 0;
+  for (const token of a) {
+    if (b.has(token))
+      intersection++;
+  }
+  const union = a.size + b.size - intersection;
+  return union === 0 ? 0 : intersection / union;
+}
+var DAY_MS = 864e5;
+var DEFAULT_CONFIG = {
+  decayHalfLife: 7 * DAY_MS,
+  minStrength: 0.01,
+  maxTraces: 5e3,
+  reinforcementBoost: 0.15,
+  initialStrength: 0.5,
+  topKRetrieval: 10,
+  traceBoostFactor: 0.3,
+  diminishingAlpha: 0.3,
+  frequencyDecayBeta: 0.5
+};
+var HARD_CEILINGS = { maxTraces: 5e4, minDecayHalfLife: 36e5, maxContentSize: 1e4 };
+var AkashaField = class {
+  config;
+  traces = /* @__PURE__ */ new Map();
+  /** Tracks which agents reinforced which traces (prevents self/duplicate). */
+  reinforcedBy = /* @__PURE__ */ new Map();
+  onEvent;
+  constructor(config) {
+    this.config = {
+      ...DEFAULT_CONFIG,
+      ...config,
+      maxTraces: Math.min(config?.maxTraces ?? DEFAULT_CONFIG.maxTraces, HARD_CEILINGS.maxTraces),
+      decayHalfLife: Math.max(config?.decayHalfLife ?? DEFAULT_CONFIG.decayHalfLife, HARD_CEILINGS.minDecayHalfLife)
+    };
+  }
+  /** Set a callback for trace lifecycle events. */
+  setOnEvent(handler) {
+    this.onEvent = handler;
+  }
+  // ─── Leaving Traces ─────────────────────────────────────────────────
+  /**
+   * Agent leaves a stigmergic trace after solving or discovering something.
+   *
+   * @param agentId  - Which agent is leaving this trace.
+   * @param type     - The category of knowledge.
+   * @param topic    - What the trace is about (used for matching).
+   * @param content  - The actual knowledge or solution.
+   * @param metadata - Optional metadata for the trace.
+   * @returns The created StigmergicTrace.
+   */
+  leave(agentId, type, topic, content, metadata) {
+    const truncatedContent = content.length > HARD_CEILINGS.maxContentSize ? content.slice(0, HARD_CEILINGS.maxContentSize) : content;
+    const id = `aks-${fnv1a(agentId + ":" + type + ":" + topic + ":" + truncatedContent)}`;
+    const now = Date.now();
+    const trace = {
+      id,
+      agentId,
+      traceType: type,
+      topic,
+      content: truncatedContent,
+      strength: this.config.initialStrength,
+      reinforcements: 0,
+      metadata: metadata ?? {},
+      createdAt: now,
+      lastReinforcedAt: now
+    };
+    this.traces.set(id, trace);
+    this.reinforcedBy.set(id, /* @__PURE__ */ new Set([agentId]));
+    if (this.traces.size > this.config.maxTraces)
+      this.evictWeakest();
+    this.onEvent?.({ type: "trace:created", traceId: id, topic });
+    return trace;
+  }
+  /**
+   * Reinforce an existing trace -- another agent found it useful.
+   *
+   * @param traceId - The trace to reinforce.
+   * @param agentId - The agent reinforcing it.
+   * @returns The updated trace, or null if not found / already reinforced.
+   */
+  reinforce(traceId, agentId) {
+    const trace = this.traces.get(traceId);
+    if (!trace)
+      return null;
+    const agents = this.reinforcedBy.get(traceId);
+    if (agents?.has(agentId))
+      return null;
+    const alpha = this.config.diminishingAlpha;
+    const effectiveBoost = this.config.reinforcementBoost / (1 + alpha * trace.reinforcements);
+    trace.strength = Math.min(1, trace.strength + effectiveBoost);
+    trace.reinforcements++;
+    trace.lastReinforcedAt = Date.now();
+    if (!agents) {
+      this.reinforcedBy.set(traceId, /* @__PURE__ */ new Set([agentId]));
+    } else {
+      agents.add(agentId);
+    }
+    this.onEvent?.({ type: "trace:reinforced", traceId, topic: trace.topic });
+    return trace;
+  }
+  // ─── Following Traces ────────────────────────────────────────────────
+  /**
+   * Find relevant traces by Jaccard similarity on topic/content tokens.
+   *
+   * @param topic - The query to match against trace topics and content.
+   * @param opts  - Optional filters: type, minStrength, limit.
+   * @returns Matching traces sorted by relevance score.
+   */
+  query(topic, opts) {
+    const queryTokens = new Set(tokenize(topic));
+    if (queryTokens.size === 0)
+      return [];
+    const minStr = opts?.minStrength ?? this.config.minStrength;
+    const limit = opts?.limit ?? this.config.topKRetrieval;
+    const scored = [];
+    for (const trace of this.traces.values()) {
+      if (trace.strength < minStr)
+        continue;
+      if (opts?.type && trace.traceType !== opts.type)
+        continue;
+      const traceTokens = /* @__PURE__ */ new Set([...tokenize(trace.topic), ...tokenize(trace.content)]);
+      const similarity = jaccardSimilarity(queryTokens, traceTokens);
+      if (similarity <= 0)
+        continue;
+      scored.push({ trace, score: similarity * trace.strength });
+    }
+    scored.sort((a, b) => b.score - a.score);
+    return scored.slice(0, limit).map((s) => s.trace);
+  }
+  /**
+   * Get the strongest traces overall -- the "highways" of collective knowledge.
+   *
+   * @param limit - Maximum number of traces to return.
+   * @returns Traces sorted by strength descending.
+   */
+  strongest(limit) {
+    const all = [...this.traces.values()];
+    all.sort((a, b) => b.strength - a.strength);
+    return all.slice(0, limit ?? this.config.topKRetrieval);
+  }
+  /**
+   * Get traces left by a specific agent.
+   *
+   * @param agentId - The agent whose traces to retrieve.
+   * @param limit   - Maximum results.
+   * @returns Traces by the agent, sorted by creation time descending.
+   */
+  byAgent(agentId, limit) {
+    const results = [];
+    for (const trace of this.traces.values()) {
+      if (trace.agentId === agentId)
+        results.push(trace);
+    }
+    results.sort((a, b) => b.createdAt - a.createdAt);
+    return results.slice(0, limit ?? this.config.topKRetrieval);
+  }
+  // ─── Decay & Maintenance ─────────────────────────────────────────────
+  /**
+   * Apply temporal decay to all traces. Traces that fall below `minStrength`
+   * after decay are pruned automatically.
+   *
+   * @returns Counts of decayed and pruned traces.
+   */
+  decay() {
+    const now = Date.now();
+    const baseHalfLife = this.config.decayHalfLife;
+    const beta = this.config.frequencyDecayBeta;
+    let decayed = 0;
+    const toPrune = [];
+    for (const [id, trace] of this.traces) {
+      const elapsed = now - trace.lastReinforcedAt;
+      if (elapsed <= 0)
+        continue;
+      const effectiveHalfLife = baseHalfLife * (1 + beta * Math.log(1 + trace.reinforcements));
+      const factor = Math.exp(-Math.LN2 * elapsed / effectiveHalfLife);
+      const newStrength = trace.strength * factor;
+      if (Math.abs(newStrength - trace.strength) > 1e-10) {
+        trace.strength = newStrength;
+        decayed++;
+      }
+      if (trace.strength < this.config.minStrength)
+        toPrune.push(id);
+    }
+    for (const id of toPrune) {
+      this.traces.delete(id);
+      this.reinforcedBy.delete(id);
+    }
+    return { decayed, pruned: toPrune.length };
+  }
+  /**
+   * Remove traces below the minStrength threshold.
+   *
+   * @returns The number of traces pruned.
+   */
+  prune() {
+    const toPrune = [];
+    for (const [id, trace] of this.traces) {
+      if (trace.strength < this.config.minStrength)
+        toPrune.push(id);
+    }
+    for (const id of toPrune) {
+      this.traces.delete(id);
+      this.reinforcedBy.delete(id);
+    }
+    return toPrune.length;
+  }
+  // ─── Persistence (delegated to akasha-integration) ───────────────────
+  /**
+   * Persist all traces to a SQLite database.
+   *
+   * @param db - A duck-typed database handle with prepare/exec methods.
+   */
+  persist(db) {
+    persistTraces(this.traces, db);
+  }
+  /**
+   * Restore traces from a SQLite database.
+   *
+   * @param db - A duck-typed database handle with prepare/exec methods.
+   */
+  restore(db) {
+    const result = restoreTraces(db, this.config);
+    this.traces.clear();
+    this.reinforcedBy.clear();
+    for (const [k, v] of result.traces)
+      this.traces.set(k, v);
+    for (const [k, v] of result.reinforcedBy)
+      this.reinforcedBy.set(k, v);
+  }
+  // ─── GraphRAG (delegated to akasha-integration) ──────────────────────
+  /**
+   * Register traces as graph nodes suitable for GraphRAG retrieval.
+   *
+   * @returns An array of graph-compatible node objects.
+   */
+  toGraphNodes() {
+    return tracesToGraphNodes(this.traces, this.config.minStrength);
+  }
+  /**
+   * Boost graph search results that have matching stigmergic traces.
+   *
+   * @param results - The original search results with id and score.
+   * @param query   - The search query used for topic matching.
+   * @returns Results with boosted scores and traceBoost metadata.
+   */
+  boostResults(results, query) {
+    return boostResultsWithTraces(this.traces, this.config, results, query);
+  }
+  // ─── Stats ───────────────────────────────────────────────────────────
+  /**
+   * Return statistics about the current state of the Akasha field.
+   *
+   * @returns Total/active counts, per-type breakdown, average strength,
+   *          strongest topic, and total reinforcements.
+   */
+  stats() {
+    const byType = {
+      solution: 0,
+      warning: 0,
+      shortcut: 0,
+      pattern: 0,
+      correction: 0,
+      preference: 0
+    };
+    let totalStrength = 0;
+    let activeCount = 0;
+    let totalReinforcements = 0;
+    let strongestTrace = null;
+    for (const trace of this.traces.values()) {
+      byType[trace.traceType]++;
+      totalStrength += trace.strength;
+      totalReinforcements += trace.reinforcements;
+      if (trace.strength >= this.config.minStrength)
+        activeCount++;
+      if (!strongestTrace || trace.strength > strongestTrace.strength) {
+        strongestTrace = trace;
+      }
+    }
+    return {
+      totalTraces: this.traces.size,
+      activeTraces: activeCount,
+      byType,
+      avgStrength: this.traces.size > 0 ? totalStrength / this.traces.size : 0,
+      strongestTopic: strongestTrace?.topic ?? null,
+      totalReinforcements
+    };
+  }
+  // ─── Internal Helpers ────────────────────────────────────────────────
+  /** Evict the weakest trace. Ties broken by oldest createdAt. */
+  evictWeakest() {
+    let weakestId = null;
+    let weakestStrength = Infinity;
+    let weakestCreatedAt = Infinity;
+    for (const [id, trace] of this.traces) {
+      if (trace.strength < weakestStrength || trace.strength === weakestStrength && trace.createdAt < weakestCreatedAt) {
+        weakestId = id;
+        weakestStrength = trace.strength;
+        weakestCreatedAt = trace.createdAt;
+      }
+    }
+    if (!weakestId && this.traces.size > 0) {
+      weakestId = this.traces.keys().next().value;
+    }
+    if (weakestId) {
+      this.traces.delete(weakestId);
+      this.reinforcedBy.delete(weakestId);
+    }
+  }
+};
+
+export {
+  tokenize,
+  jaccardSimilarity,
+  AkashaField
+};
+//# sourceMappingURL=chunk-5E3ZS5SW.js.map