@yugenlab/vaayu 0.1.0

package/chunks/chunk-KC6NRZ7U.js

@@ -0,0 +1,198 @@
+// ../chitragupta/packages/core/dist/errors.js
+var ChitraguptaError = class extends Error {
+  code;
+  constructor(message, code, cause) {
+    super(message, { cause });
+    this.name = "ChitraguptaError";
+    this.code = code;
+  }
+};
+var SessionError = class extends ChitraguptaError {
+  constructor(message, cause) {
+    super(message, "SESSION_ERROR", cause);
+    this.name = "SessionError";
+  }
+};
+var MemoryError = class extends ChitraguptaError {
+  constructor(message, cause) {
+    super(message, "MEMORY_ERROR", cause);
+    this.name = "MemoryError";
+  }
+};
+
+// ../chitragupta/packages/core/dist/config.js
+import path from "path";
+function getChitraguptaHome() {
+  const override = process.env.CHITRAGUPTA_HOME?.trim();
+  if (override)
+    return override;
+  return path.join(process.env.HOME || process.env.USERPROFILE || "~", ".chitragupta");
+}
+
+// ../chitragupta/packages/core/dist/auth/rbac.js
+var PERMISSIONS = {
+  // Session
+  READ_SESSION: "read:session",
+  WRITE_SESSION: "write:session",
+  // Chat
+  READ_CHAT: "read:chat",
+  WRITE_CHAT: "write:chat",
+  // Jobs
+  READ_JOBS: "read:jobs",
+  WRITE_JOBS: "write:jobs",
+  // Agents
+  READ_AGENTS: "read:agents",
+  WRITE_AGENTS: "write:agents",
+  ADMIN_AGENTS: "admin:agents",
+  // Memory
+  READ_MEMORY: "read:memory",
+  WRITE_MEMORY: "write:memory",
+  DELETE_MEMORY: "delete:memory",
+  // Metrics
+  READ_METRICS: "read:metrics",
+  // Providers & Tools
+  READ_PROVIDERS: "read:providers",
+  READ_TOOLS: "read:tools",
+  // Admin
+  ADMIN_SYSTEM: "admin:system"
+};
+var WILDCARD_PERMISSION = "*";
+var ALL_PERMISSIONS = new Set(Object.values(PERMISSIONS));
+ALL_PERMISSIONS.add(WILDCARD_PERMISSION);
+var OPERATOR_ROLE = {
+  name: "operator",
+  description: "Read and write access to sessions, chat, jobs, agents, and memory.",
+  permissions: /* @__PURE__ */ new Set([
+    PERMISSIONS.READ_SESSION,
+    PERMISSIONS.WRITE_SESSION,
+    PERMISSIONS.READ_CHAT,
+    PERMISSIONS.WRITE_CHAT,
+    PERMISSIONS.READ_JOBS,
+    PERMISSIONS.WRITE_JOBS,
+    PERMISSIONS.READ_AGENTS,
+    PERMISSIONS.WRITE_AGENTS,
+    PERMISSIONS.READ_MEMORY,
+    PERMISSIONS.WRITE_MEMORY,
+    PERMISSIONS.DELETE_MEMORY,
+    PERMISSIONS.READ_METRICS,
+    PERMISSIONS.READ_PROVIDERS,
+    PERMISSIONS.READ_TOOLS
+  ])
+};
+var VIEWER_ROLE = {
+  name: "viewer",
+  description: "Read-only access to sessions, agents, memory, and metrics.",
+  permissions: /* @__PURE__ */ new Set([
+    PERMISSIONS.READ_SESSION,
+    PERMISSIONS.READ_CHAT,
+    PERMISSIONS.READ_JOBS,
+    PERMISSIONS.READ_AGENTS,
+    PERMISSIONS.READ_MEMORY,
+    PERMISSIONS.READ_METRICS,
+    PERMISSIONS.READ_PROVIDERS,
+    PERMISSIONS.READ_TOOLS
+  ])
+};
+var AGENT_ROLE = {
+  name: "agent",
+  description: "Limited API access for programmatic sub-agent use.",
+  permissions: /* @__PURE__ */ new Set([
+    PERMISSIONS.READ_SESSION,
+    PERMISSIONS.WRITE_CHAT,
+    PERMISSIONS.READ_AGENTS,
+    PERMISSIONS.READ_MEMORY,
+    PERMISSIONS.WRITE_MEMORY,
+    PERMISSIONS.READ_TOOLS
+  ])
+};
+var ROUTE_PERMISSIONS = /* @__PURE__ */ new Map([
+  // Public
+  ["GET /api/health", null],
+  // Sessions
+  ["GET /api/sessions", PERMISSIONS.READ_SESSION],
+  ["GET /api/sessions/:id", PERMISSIONS.READ_SESSION],
+  ["POST /api/sessions", PERMISSIONS.WRITE_SESSION],
+  // Chat
+  ["POST /api/chat", PERMISSIONS.WRITE_CHAT],
+  // Jobs
+  ["GET /api/jobs", PERMISSIONS.READ_JOBS],
+  ["GET /api/jobs/stats", PERMISSIONS.READ_JOBS],
+  ["GET /api/jobs/:id", PERMISSIONS.READ_JOBS],
+  ["POST /api/jobs", PERMISSIONS.WRITE_JOBS],
+  ["POST /api/jobs/:id/cancel", PERMISSIONS.WRITE_JOBS],
+  // Agents
+  ["GET /api/agents", PERMISSIONS.READ_AGENTS],
+  ["GET /api/agents/tree", PERMISSIONS.READ_AGENTS],
+  ["GET /api/agents/stats", PERMISSIONS.READ_AGENTS],
+  ["GET /api/agents/:id", PERMISSIONS.READ_AGENTS],
+  ["GET /api/agents/:id/tree", PERMISSIONS.READ_AGENTS],
+  ["POST /api/agents/:id/spawn", PERMISSIONS.WRITE_AGENTS],
+  ["POST /api/agents/:id/abort", PERMISSIONS.ADMIN_AGENTS],
+  ["POST /api/agents/:id/prompt", PERMISSIONS.WRITE_AGENTS],
+  ["GET /api/agent/status", PERMISSIONS.READ_AGENTS],
+  ["POST /api/agent/reset", PERMISSIONS.ADMIN_AGENTS],
+  // Memory
+  ["GET /api/memory/scopes", PERMISSIONS.READ_MEMORY],
+  ["GET /api/memory/:scope", PERMISSIONS.READ_MEMORY],
+  ["PUT /api/memory/:scope", PERMISSIONS.WRITE_MEMORY],
+  ["POST /api/memory/:scope", PERMISSIONS.WRITE_MEMORY],
+  ["POST /api/memory/search", PERMISSIONS.READ_MEMORY],
+  ["DELETE /api/memory/:scope", PERMISSIONS.DELETE_MEMORY],
+  // Providers & Tools
+  ["GET /api/providers", PERMISSIONS.READ_PROVIDERS],
+  ["GET /api/tools", PERMISSIONS.READ_TOOLS],
+  // Auth (public — these handle their own auth)
+  ["POST /api/auth/token", null],
+  ["POST /api/auth/refresh", null],
+  ["GET /api/auth/me", null]
+]);
+
+// ../chitragupta/packages/core/dist/auth/oauth.js
+var JWKS_CACHE_TTL_MS = 60 * 60 * 1e3;
+
+// ../chitragupta/packages/core/dist/observability/logger.js
+var LogLevel;
+(function(LogLevel2) {
+  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
+  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
+  LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
+  LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
+  LogLevel2[LogLevel2["FATAL"] = 4] = "FATAL";
+})(LogLevel || (LogLevel = {}));
+var LOG_LEVEL_NAMES = {
+  [LogLevel.DEBUG]: "DEBUG",
+  [LogLevel.INFO]: "INFO",
+  [LogLevel.WARN]: "WARN",
+  [LogLevel.ERROR]: "ERROR",
+  [LogLevel.FATAL]: "FATAL"
+};
+var LOG_LEVEL_PARSE = {
+  debug: LogLevel.DEBUG,
+  info: LogLevel.INFO,
+  warn: LogLevel.WARN,
+  error: LogLevel.ERROR,
+  fatal: LogLevel.FATAL
+};
+var LEVEL_COLORS = {
+  [LogLevel.DEBUG]: "\x1B[36m",
+  // cyan
+  [LogLevel.INFO]: "\x1B[32m",
+  // green
+  [LogLevel.WARN]: "\x1B[33m",
+  // yellow
+  [LogLevel.ERROR]: "\x1B[31m",
+  // red
+  [LogLevel.FATAL]: "\x1B[35;1m"
+  // bold magenta
+};
+
+// ../chitragupta/packages/core/dist/observability/tracing.js
+import { AsyncLocalStorage } from "node:async_hooks";
+var spanStorage = new AsyncLocalStorage();
+
+export {
+  SessionError,
+  MemoryError,
+  getChitraguptaHome
+};
+//# sourceMappingURL=chunk-KC6NRZ7U.js.map

package/chunks/chunk-KDRROLVN.js

@@ -0,0 +1,433 @@
+import {
+  searchSessions
+} from "./chunk-ITIVYGUG.js";
+
+// ../chitragupta/packages/smriti/src/hybrid-search.ts
+var PRAMANA_RELIABILITY = {
+  pratyaksha: 1,
+  anumana: 0.85,
+  shabda: 0.75,
+  upamana: 0.6,
+  arthapatti: 0.5,
+  anupalabdhi: 0.4
+};
+var DEFAULT_CONFIG = {
+  k: 60,
+  topK: 10,
+  enableBM25: true,
+  enableVector: true,
+  enableGraphRAG: true,
+  pramanaWeight: 0.1,
+  enablePramana: true,
+  minScore: 0
+};
+function gaussianRandom() {
+  const u1 = Math.random();
+  const u2 = Math.random();
+  return Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
+}
+function sampleGamma(shape) {
+  if (shape < 1) {
+    const g = sampleGamma(shape + 1);
+    return g * Math.pow(Math.random(), 1 / shape);
+  }
+  const d = shape - 1 / 3;
+  const c = 1 / Math.sqrt(9 * d);
+  for (; ; ) {
+    let z;
+    let v;
+    do {
+      z = gaussianRandom();
+      v = 1 + c * z;
+    } while (v <= 0);
+    v = v * v * v;
+    const u = Math.random();
+    const zSq = z * z;
+    if (u < 1 - 0.0331 * (zSq * zSq)) return d * v;
+    if (Math.log(u) < 0.5 * zSq + d * (1 - v + Math.log(v))) return d * v;
+  }
+}
+function sampleBeta(alpha, beta) {
+  const x = sampleGamma(alpha);
+  const y = sampleGamma(beta);
+  if (x + y === 0) return 0.5;
+  return x / (x + y);
+}
+var SIGNAL_INDEX = {
+  bm25: 0,
+  vector: 1,
+  graphrag: 2,
+  pramana: 3
+};
+var NUM_SIGNALS = 4;
+var HybridWeightLearner = class {
+  /** Success counts (α) for each of the 4 signals. */
+  _alphas;
+  /** Failure counts (β) for each of the 4 signals. */
+  _betas;
+  /** Total feedback events received. */
+  _totalFeedback;
+  /**
+   * @param priorAlpha - Initial α for all signals. Default: 1 (uniform prior).
+   * @param priorBeta - Initial β for all signals. Default: 1 (uniform prior).
+   */
+  constructor(priorAlpha = 1, priorBeta = 1) {
+    this._alphas = new Float64Array(NUM_SIGNALS);
+    this._betas = new Float64Array(NUM_SIGNALS);
+    this._totalFeedback = 0;
+    for (let i = 0; i < NUM_SIGNALS; i++) {
+      this._alphas[i] = priorAlpha;
+      this._betas[i] = priorBeta;
+    }
+  }
+  /**
+   * Sample a weight vector from the Beta posteriors.
+   *
+   * Each signal's weight is sampled from Beta(α_i, β_i), then the 4
+   * weights are normalized to sum to 1 (Dirichlet-like normalization).
+   *
+   * @returns Normalized weight vector { bm25, vector, graphrag, pramana }.
+   */
+  sample() {
+    const raw = new Float64Array(NUM_SIGNALS);
+    let sum = 0;
+    for (let i = 0; i < NUM_SIGNALS; i++) {
+      raw[i] = sampleBeta(this._alphas[i], this._betas[i]);
+      sum += raw[i];
+    }
+    if (sum < 1e-12) {
+      return { bm25: 0.25, vector: 0.25, graphrag: 0.25, pramana: 0.25 };
+    }
+    return {
+      bm25: raw[0] / sum,
+      vector: raw[1] / sum,
+      graphrag: raw[2] / sum,
+      pramana: raw[3] / sum
+    };
+  }
+  /**
+   * Update a signal's posterior after observing feedback.
+   *
+   * @param signal - Which signal to update.
+   * @param success - true = positive feedback (user found result useful),
+   *                  false = negative feedback (result was irrelevant).
+   */
+  update(signal, success) {
+    const idx = SIGNAL_INDEX[signal];
+    if (success) {
+      this._alphas[idx] += 1;
+    } else {
+      this._betas[idx] += 1;
+    }
+    this._totalFeedback += 1;
+  }
+  /**
+   * Get the posterior mean for each signal: α / (α + β).
+   * Useful for diagnostics and logging.
+   */
+  means() {
+    const m = (i) => this._alphas[i] / (this._alphas[i] + this._betas[i]);
+    return { bm25: m(0), vector: m(1), graphrag: m(2), pramana: m(3) };
+  }
+  /** Total number of feedback events recorded. */
+  get totalFeedback() {
+    return this._totalFeedback;
+  }
+  /**
+   * Serialize the learner state for persistence.
+   *
+   * @returns A plain object suitable for JSON serialization.
+   */
+  serialize() {
+    return {
+      alphas: Array.from(this._alphas),
+      betas: Array.from(this._betas),
+      totalFeedback: this._totalFeedback
+    };
+  }
+  /**
+   * Restore the learner state from a serialized object.
+   *
+   * @param data - Previously serialized state from `serialize()`.
+   */
+  restore(data) {
+    if (!data || !Array.isArray(data.alphas) || !Array.isArray(data.betas) || data.alphas.length !== NUM_SIGNALS || data.betas.length !== NUM_SIGNALS) {
+      return;
+    }
+    for (let i = 0; i < NUM_SIGNALS; i++) {
+      this._alphas[i] = data.alphas[i];
+      this._betas[i] = data.betas[i];
+    }
+    this._totalFeedback = data.totalFeedback ?? 0;
+  }
+};
+function shouldRetrieve(query) {
+  const lower = query.toLowerCase().trim();
+  const gapPatterns = [
+    /\bwhat did\b/,
+    /\bwhen did\b/,
+    /\bhow did\b/,
+    /\bwhy did\b/,
+    /\bdo you remember\b/,
+    /\bpreviously\b/,
+    /\blast time\b/,
+    /\bearlier\b/,
+    /\bbefore\b/,
+    /\brecall\b/,
+    /\bhistory\b/,
+    /\bwe discussed\b/,
+    /\bwe decided\b/,
+    /\bwe agreed\b/,
+    /\bwhat was\b/,
+    /\bwhat is the status\b/,
+    /\bfind\b.*\b(file|code|function|class|module)\b/,
+    /\bsearch\b/,
+    /\blook up\b/,
+    /\bshow me\b.*\bfrom\b/
+  ];
+  for (const pattern of gapPatterns) {
+    if (pattern.test(lower)) return true;
+  }
+  if (lower.endsWith("?") && lower.length > 20) return true;
+  if (/session[:\s]/i.test(lower)) return true;
+  if (/\bproject\b.*\b(memory|context|knowledge)\b/i.test(lower)) return true;
+  return false;
+}
+var HybridSearchEngine = class {
+  recallEngine;
+  graphEngine;
+  config;
+  weightLearner;
+  kalaChakra;
+  constructor(config, recallEngine, graphEngine, weightLearner) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.recallEngine = recallEngine ?? null;
+    this.graphEngine = graphEngine ?? null;
+    this.weightLearner = weightLearner ?? null;
+    this.kalaChakra = null;
+  }
+  /**
+   * Set or replace the RecallEngine instance.
+   */
+  setRecallEngine(engine) {
+    this.recallEngine = engine;
+  }
+  /**
+   * Set or replace the GraphRAGEngine instance.
+   */
+  setGraphEngine(engine) {
+    this.graphEngine = engine;
+  }
+  /**
+   * Set or replace the HybridWeightLearner instance.
+   */
+  setWeightLearner(learner) {
+    this.weightLearner = learner;
+  }
+  /**
+   * Get the current HybridWeightLearner, or null if not set.
+   */
+  getWeightLearner() {
+    return this.weightLearner;
+  }
+  /**
+   * Set or replace the KalaChakra temporal awareness engine.
+   * When set, search results with timestamps receive a temporal boost.
+   */
+  setKalaChakra(kala) {
+    this.kalaChakra = kala;
+  }
+  /**
+   * Get the current KalaChakra instance, or null if not set.
+   */
+  getKalaChakra() {
+    return this.kalaChakra;
+  }
+  /**
+   * Record feedback for a search result.
+   *
+   * Updates the Thompson Sampling weight learner based on which signals
+   * contributed to the result the user selected (success) or rejected (failure).
+   *
+   * @param result - The search result receiving feedback.
+   * @param success - true = user found it useful, false = irrelevant.
+   */
+  recordFeedback(result, success) {
+    if (!this.weightLearner) return;
+    for (const source of result.sources) {
+      this.weightLearner.update(source, success);
+    }
+    if (result.pramana) {
+      this.weightLearner.update("pramana", success);
+    }
+  }
+  /**
+   * Perform hybrid search across all enabled rankers.
+   *
+   * Each ranker produces its own ranking. Results are fused via RRF:
+   *   score(d) = Σ w_i / (k + rank_i(d))
+   *
+   * When a HybridWeightLearner is set, w_i are Thompson-sampled weights.
+   * Otherwise, all weights are 1.0 (standard RRF).
+   *
+   * When pramana is enabled, each result receives an additive epistemic boost:
+   *   finalScore += δ * pramanaReliability(d)
+   *
+   * @param query - The search query.
+   * @param configOverride - Optional per-query config overrides.
+   * @returns Fused results sorted by score descending.
+   */
+  async search(query, configOverride) {
+    const cfg = { ...this.config, ...configOverride };
+    const weights = this.weightLearner ? this.weightLearner.sample() : { bm25: 1, vector: 1, graphrag: 1, pramana: 1 };
+    const rankings = [];
+    const tasks = [];
+    if (cfg.enableBM25) {
+      tasks.push(
+        (async () => {
+          const bm25Results = searchSessions(query, cfg.project);
+          rankings.push({
+            source: "bm25",
+            weight: weights.bm25,
+            results: bm25Results.map((meta) => ({
+              id: meta.id,
+              title: meta.title,
+              content: `${meta.title} [${meta.tags.join(", ")}] agent:${meta.agent}`
+            }))
+          });
+        })()
+      );
+    }
+    if (cfg.enableVector && this.recallEngine) {
+      tasks.push(
+        (async () => {
+          try {
+            const vectorResults = await this.recallEngine.recall(query, {
+              topK: cfg.topK * 2
+              // Over-fetch for fusion
+            });
+            rankings.push({
+              source: "vector",
+              weight: weights.vector,
+              results: vectorResults.map((r) => ({
+                id: r.sessionId,
+                title: r.title,
+                content: r.matchedContent || r.summary
+              }))
+            });
+          } catch {
+          }
+        })()
+      );
+    }
+    if (cfg.enableGraphRAG && this.graphEngine) {
+      tasks.push(
+        (async () => {
+          try {
+            const graphResults = await this.graphEngine.search(query, void 0, cfg.topK * 2);
+            rankings.push({
+              source: "graphrag",
+              weight: weights.graphrag,
+              results: graphResults.map((node) => ({
+                id: node.id,
+                title: node.label,
+                content: node.content
+              }))
+            });
+          } catch {
+          }
+        })()
+      );
+    }
+    await Promise.all(tasks);
+    if (rankings.length === 0) return [];
+    const fusedScores = /* @__PURE__ */ new Map();
+    for (const ranking of rankings) {
+      for (let rank = 0; rank < ranking.results.length; rank++) {
+        const doc = ranking.results[rank];
+        const rrfContribution = ranking.weight / (cfg.k + rank);
+        const existing = fusedScores.get(doc.id);
+        if (existing) {
+          existing.score += rrfContribution;
+          existing.sources.add(ranking.source);
+          existing.ranks[ranking.source] = rank + 1;
+          if (doc.content.length > existing.content.length) {
+            existing.content = doc.content;
+          }
+        } else {
+          const sources = /* @__PURE__ */ new Set();
+          sources.add(ranking.source);
+          fusedScores.set(doc.id, {
+            id: doc.id,
+            title: doc.title,
+            content: doc.content,
+            score: rrfContribution,
+            sources,
+            ranks: { [ranking.source]: rank + 1 }
+          });
+        }
+      }
+    }
+    for (const entry of fusedScores.values()) {
+      if (entry.sources.size >= 3) {
+        entry.score *= 1.15;
+      } else if (entry.sources.size >= 2) {
+        entry.score *= 1.05;
+      }
+    }
+    const pramanaMap = /* @__PURE__ */ new Map();
+    if (cfg.enablePramana && this.graphEngine) {
+      const docIds = [...fusedScores.keys()];
+      const batchPramana = this.graphEngine.lookupPramanaBatch(docIds);
+      for (const [id, ptype] of batchPramana) {
+        pramanaMap.set(id, ptype);
+      }
+      const delta = cfg.pramanaWeight * weights.pramana;
+      for (const entry of fusedScores.values()) {
+        const ptype = pramanaMap.get(entry.id) ?? "shabda";
+        const reliability = PRAMANA_RELIABILITY[ptype];
+        entry.score += delta * reliability;
+      }
+    }
+    if (this.kalaChakra) {
+      for (const entry of fusedScores.values()) {
+        if (entry.timestamp !== void 0) {
+          entry.score = this.kalaChakra.boostScore(entry.score, entry.timestamp);
+        }
+      }
+    }
+    const sorted = [...fusedScores.values()].filter((r) => r.score >= cfg.minScore).sort((a, b) => b.score - a.score).slice(0, cfg.topK);
+    return sorted.map((r) => ({
+      id: r.id,
+      title: r.title,
+      content: r.content,
+      sources: [...r.sources],
+      score: r.score,
+      ranks: {
+        bm25: r.ranks.bm25,
+        vector: r.ranks.vector,
+        graphrag: r.ranks.graphrag
+      },
+      pramana: pramanaMap.get(r.id),
+      timestamp: r.timestamp
+    }));
+  }
+  /**
+   * Self-RAG gated search — only retrieves if the query signals a knowledge gap.
+   *
+   * @param query - The query to evaluate and optionally search.
+   * @returns Results if retrieval was triggered, empty array otherwise.
+   */
+  async gatedSearch(query, configOverride) {
+    if (!shouldRetrieve(query)) return [];
+    return this.search(query, configOverride);
+  }
+};
+
+export {
+  PRAMANA_RELIABILITY,
+  HybridWeightLearner,
+  shouldRetrieve,
+  HybridSearchEngine
+};
+//# sourceMappingURL=chunk-KDRROLVN.js.map