@yugenlab/vaayu 0.1.0

package/chunks/chunk-HAPVUJ6A.js

@@ -0,0 +1,238 @@
+import {
+  blobToVector,
+  vectorToBlob
+} from "./chunk-JZU37VQ5.js";
+import {
+  EmbeddingService,
+  cosineSimilarity,
+  fallbackEmbedding
+} from "./chunk-JAWZ7ANC.js";
+import {
+  DatabaseManager,
+  initVectorsSchema
+} from "./chunk-U6OLJ36B.js";
+
+// ../chitragupta/packages/smriti/src/consolidation-indexer.ts
+var _embeddingService = null;
+function getEmbeddingService() {
+  if (!_embeddingService) {
+    _embeddingService = new EmbeddingService();
+  }
+  return _embeddingService;
+}
+var _vectorsDbInit = false;
+function getVectorsDb() {
+  const dbm = DatabaseManager.instance();
+  if (!_vectorsDbInit) {
+    initVectorsSchema(dbm);
+    _vectorsDbInit = true;
+  }
+  return dbm.get("vectors");
+}
+function _resetConsolidationIndexer() {
+  _vectorsDbInit = false;
+  _embeddingService = null;
+}
+function buildEmbeddingId(level, period, project) {
+  const suffix = project ? `-${fnvHash4(project)}` : "";
+  return `${level}_summary:${period}${suffix}`;
+}
+function fnvHash4(s) {
+  let h = 2166136261;
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = h * 16777619 >>> 0;
+  }
+  return (h >>> 0).toString(16).slice(0, 4);
+}
+function extractSummaryText(markdown, level) {
+  const lines = markdown.split("\n");
+  const parts = [];
+  if (level === "daily") {
+    for (const line of lines) {
+      const trimmed = line.trim();
+      const stripped = trimmed.replace(/^-\s*/, "");
+      if (trimmed.startsWith("# ") || trimmed.startsWith("## ")) {
+        parts.push(trimmed.replace(/^#+\s*/, ""));
+      } else if (stripped.startsWith("**Fact**:") || stripped.startsWith("**Decision**:") || stripped.startsWith("**Pref**:") || stripped.startsWith("**Error**:") || stripped.startsWith("**Topic**:") || stripped.startsWith("**Q**:")) {
+        parts.push(stripped.replace(/\*\*/g, ""));
+      } else if (trimmed.startsWith("- [") && trimmed.includes("]")) {
+        parts.push(stripped);
+      } else if (trimmed.startsWith("**Topics**:")) {
+        parts.push(trimmed.replace(/\*\*/g, ""));
+      } else if (trimmed.startsWith(">") && !trimmed.includes("sessions |")) {
+        parts.push(trimmed.replace(/^>\s*/, ""));
+      }
+    }
+  } else if (level === "monthly") {
+    let inRecommendations = false;
+    let inVasanas = false;
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("# ")) {
+        parts.push(trimmed.replace(/^#+\s*/, ""));
+      } else if (trimmed.startsWith("- **Sessions**:") || trimmed.startsWith("- **Turns**:") || trimmed.startsWith("- **Estimated Cost**:")) {
+        parts.push(trimmed.replace(/^-\s*/, "").replace(/\*\*/g, ""));
+      }
+      if (trimmed === "## Recommendations") inRecommendations = true;
+      else if (trimmed.startsWith("## ") && inRecommendations) inRecommendations = false;
+      if (inRecommendations && trimmed.startsWith("- ")) {
+        parts.push(trimmed.replace(/^-\s*/, ""));
+      }
+      if (trimmed === "## Vasanas Crystallized") inVasanas = true;
+      else if (trimmed.startsWith("## ") && trimmed !== "## Vasanas Crystallized") inVasanas = false;
+      if (inVasanas && trimmed.startsWith("|") && !trimmed.startsWith("|--") && !trimmed.startsWith("| Tendency")) {
+        const cells = trimmed.split("|").filter(Boolean).map((c) => c.trim());
+        if (cells[0]) parts.push(`Vasana: ${cells[0]}`);
+      }
+    }
+  } else {
+    let inTrends = false;
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("# ") || trimmed.startsWith("## Annual Summary")) {
+        parts.push(trimmed.replace(/^#+\s*/, ""));
+      } else if (trimmed.startsWith("- **Sessions**:") || trimmed.startsWith("- **Vasanas Crystallized**:")) {
+        parts.push(trimmed.replace(/^-\s*/, "").replace(/\*\*/g, ""));
+      }
+      if (trimmed === "## Trends") inTrends = true;
+      else if (trimmed.startsWith("## ") && trimmed !== "## Trends") inTrends = false;
+      if (inTrends && trimmed.startsWith("- ")) {
+        parts.push(trimmed.replace(/^-\s*/, ""));
+      }
+    }
+  }
+  return parts.join(" ").slice(0, 2e3);
+}
+async function indexConsolidationSummary(level, period, markdown, project) {
+  const summaryText = extractSummaryText(markdown, level);
+  if (!summaryText || summaryText.length < 10) return;
+  let embedding;
+  try {
+    const svc = getEmbeddingService();
+    embedding = await svc.getEmbedding(summaryText);
+  } catch {
+    embedding = fallbackEmbedding(summaryText);
+  }
+  const id = buildEmbeddingId(level, period, project);
+  const sourceType = `${level}_summary`;
+  const sourceId = project ? `${period}-${fnvHash4(project)}` : period;
+  try {
+    const db = getVectorsDb();
+    db.prepare(`
+			INSERT OR REPLACE INTO embeddings (id, vector, text, source_type, source_id, dimensions, metadata, created_at)
+			VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+		`).run(
+      id,
+      vectorToBlob(embedding),
+      summaryText.slice(0, 5e3),
+      sourceType,
+      sourceId,
+      embedding.length,
+      JSON.stringify({ level, period, project: project ?? null }),
+      Date.now()
+    );
+  } catch {
+  }
+}
+async function searchConsolidationSummaries(query, level, options) {
+  const limit = options?.limit ?? 5;
+  let queryEmbedding;
+  try {
+    const svc = getEmbeddingService();
+    queryEmbedding = await svc.getEmbedding(query);
+  } catch {
+    queryEmbedding = fallbackEmbedding(query);
+  }
+  const sourceType = `${level}_summary`;
+  try {
+    const db = getVectorsDb();
+    const rows = db.prepare(
+      `SELECT id, vector, text, source_type, source_id, metadata
+			 FROM embeddings WHERE source_type = ?`
+    ).all(sourceType);
+    const scored = [];
+    for (const row of rows) {
+      let meta = {};
+      try {
+        meta = JSON.parse(row.metadata ?? "{}");
+      } catch {
+      }
+      if (options?.project && meta.project && meta.project !== options.project) continue;
+      const vector = blobToVector(row.vector);
+      const score = cosineSimilarity(queryEmbedding, vector);
+      if (score > 0.1) {
+        scored.push({
+          period: meta.period ?? row.source_id,
+          score,
+          snippet: row.text.slice(0, 300),
+          project: meta.project ?? void 0
+        });
+      }
+    }
+    scored.sort((a, b) => b.score - a.score);
+    return scored.slice(0, limit);
+  } catch {
+    return [];
+  }
+}
+async function backfillConsolidationIndices() {
+  const counts = { daily: 0, monthly: 0, yearly: 0 };
+  try {
+    const db = getVectorsDb();
+    const existing = new Set(
+      db.prepare("SELECT id FROM embeddings WHERE source_type IN ('daily_summary', 'monthly_summary', 'yearly_summary')").all().map((r) => r.id)
+    );
+    try {
+      const { listDayFiles, readDayFile } = await import("./day-consolidation-NKO63HZQ.js");
+      const dayFiles = listDayFiles();
+      for (const date of dayFiles) {
+        const id = buildEmbeddingId("daily", date);
+        if (existing.has(id)) continue;
+        const content = readDayFile(date);
+        if (content && content.length > 20) {
+          await indexConsolidationSummary("daily", date, content);
+          counts.daily++;
+        }
+      }
+    } catch {
+    }
+    try {
+      const { PeriodicConsolidation } = await import("./periodic-consolidation-BPKOZDGB.js");
+      const { listSessionProjects } = await import("./session-store-XKPGKXUS.js");
+      const projectEntries = listSessionProjects();
+      for (const entry of projectEntries) {
+        const project = entry.project;
+        const pc = new PeriodicConsolidation({ project });
+        const reports = pc.listReports();
+        for (const report of reports) {
+          const level = report.type === "monthly" ? "monthly" : "yearly";
+          const id = buildEmbeddingId(level, report.period, project);
+          if (existing.has(id)) continue;
+          try {
+            const fs = await import("node:fs");
+            const content = fs.readFileSync(report.path, "utf-8");
+            if (content && content.length > 20) {
+              await indexConsolidationSummary(level, report.period, content, project);
+              if (level === "monthly") counts.monthly++;
+              else counts.yearly++;
+            }
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+  } catch {
+  }
+  return counts;
+}
+
+export {
+  _resetConsolidationIndexer,
+  extractSummaryText,
+  indexConsolidationSummary,
+  searchConsolidationSummaries,
+  backfillConsolidationIndices
+};
+//# sourceMappingURL=chunk-HAPVUJ6A.js.map

package/chunks/chunk-IEKAYVA3.js

@@ -0,0 +1,137 @@
+// packages/sandbox/src/index.ts
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+async function runProcess(params) {
+  const start = Date.now();
+  return await new Promise((resolve) => {
+    const child = spawn(params.command, params.args, {
+      cwd: params.cwd,
+      env: params.env,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    const timeout = params.timeoutMs && params.timeoutMs > 0 ? setTimeout(() => {
+      child.kill("SIGKILL");
+      resolve({
+        code: null,
+        stdout,
+        stderr: `${stderr}
+[sandbox timeout]`.trim(),
+        durationMs: Date.now() - start
+      });
+    }, params.timeoutMs) : null;
+    child.stdout.on("data", (chunk) => stdout += chunk.toString());
+    child.stderr.on("data", (chunk) => stderr += chunk.toString());
+    child.on("error", (error) => {
+      if (timeout) clearTimeout(timeout);
+      resolve({
+        code: 1,
+        stdout,
+        stderr: `${stderr}
+${error instanceof Error ? error.message : String(error)}`.trim(),
+        durationMs: Date.now() - start
+      });
+    });
+    child.on("close", (code) => {
+      if (timeout) clearTimeout(timeout);
+      resolve({
+        code: typeof code === "number" ? code : null,
+        stdout,
+        stderr,
+        durationMs: Date.now() - start
+      });
+    });
+  });
+}
+function buildMinimalEnv(overrides) {
+  const base = {};
+  if (process.env.PATH) base.PATH = process.env.PATH;
+  if (process.env.LANG) base.LANG = process.env.LANG;
+  if (process.env.TMPDIR) base.TMPDIR = process.env.TMPDIR;
+  return { ...base, ...overrides ?? {} };
+}
+function inferDockerImage(request) {
+  if (request.image) return request.image;
+  const cmd = request.command.toLowerCase();
+  if (cmd.includes("python")) return "python:3.11-slim";
+  if (cmd.includes("node") || cmd.includes("npm") || cmd.includes("pnpm")) {
+    return "node:22-bookworm-slim";
+  }
+  return "ubuntu:24.04";
+}
+var LocalSandboxRunner = class {
+  name = "local";
+  async run(request) {
+    return await runProcess({
+      command: request.command,
+      args: request.args ?? [],
+      cwd: request.cwd,
+      env: buildMinimalEnv(request.env),
+      timeoutMs: request.timeoutMs
+    });
+  }
+};
+var DockerSandboxRunner = class {
+  name = "docker";
+  async run(request) {
+    const image = inferDockerImage(request);
+    const cwd = request.cwd ? path.resolve(request.cwd) : process.cwd();
+    const workdir = request.workdir ?? "/workspace";
+    const args = [
+      "run",
+      "--rm",
+      "--init",
+      "--read-only",
+      "--tmpfs",
+      "/tmp",
+      "--tmpfs",
+      "/var/tmp",
+      "--workdir",
+      workdir
+    ];
+    const networkMode = request.network ?? "none";
+    if (networkMode === "none") {
+      args.push("--network", "none");
+    }
+    if (typeof request.cpuLimit === "number" && Number.isFinite(request.cpuLimit)) {
+      args.push("--cpus", String(request.cpuLimit));
+    }
+    if (typeof request.memoryMb === "number" && Number.isFinite(request.memoryMb)) {
+      args.push("--memory", `${Math.floor(request.memoryMb)}m`);
+    }
+    if (fs.existsSync(cwd)) {
+      args.push("-v", `${cwd}:${workdir}:ro`);
+    }
+    const env = buildMinimalEnv(request.env);
+    for (const [key, value] of Object.entries(env)) {
+      if (!key) continue;
+      args.push("-e", `${key}=${value}`);
+    }
+    args.push("--user", "65534:65534");
+    args.push(image);
+    args.push(request.command);
+    args.push(...request.args ?? []);
+    return await runProcess({
+      command: "docker",
+      args,
+      cwd: void 0,
+      env: buildMinimalEnv(),
+      timeoutMs: request.timeoutMs ?? 12e4
+    });
+  }
+};
+function createSandboxRunner(driver) {
+  if (driver === "docker") {
+    return new DockerSandboxRunner();
+  }
+  return new LocalSandboxRunner();
+}
+
+export {
+  LocalSandboxRunner,
+  DockerSandboxRunner,
+  createSandboxRunner
+};
+//# sourceMappingURL=chunk-IEKAYVA3.js.map

package/chunks/chunk-IGKYKEKT.js

@@ -0,0 +1,43 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __require,
+  __commonJS,
+  __export,
+  __toESM
+};
+//# sourceMappingURL=chunk-IGKYKEKT.js.map