@yugenlab/vaayu 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sriinnu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,365 @@
+# VAAYU (वायु)
+
+**Like wind — swift, everywhere, carrying what matters.**
+
+Vaayu is a self-hosted, privacy-first AI assistant that lives across your messaging
+platforms and native apps. Memory belongs to you, not the provider. Every action
+respects consent. Every tool runs behind policy. Built with the precision of
+Vishwakarma and the strength of Hanuman.
+
+---
+
+## Why Vaayu?
+
+- **Your memory, your data.** Switch providers mid-conversation without losing context.
+  Smriti (memory) is user-centric, not provider-locked.
+- **Local-first.** NLU, embeddings, and fallback LLM all run locally. Cloud is opt-in.
+- **Cost-aware.** Smart routing sends simple queries to cheap/local models, complex ones
+  to quality providers. Target: $5-10/month.
+- **Extensible skills.** Weather, finance, health, reminders, notes, music, smart home,
+  travel, calls -- and skills that learn on the fly.
+- **Privacy by default.** No exec/write/delete/network without approval. Memory writes
+  require consent. Sandbox-first execution.
+
+---
+
+## Upstream Inspiration
+
+Vaayu’s provider/LLM registry is **derived from pi‑mono (pi‑ai)** and then refactored
+and extended for Vaayu’s policy, routing, and model‑switching needs. We also adapt
+orchestration and self‑healing patterns from **gru‑main**, while preserving Vaayu’s
+privacy‑first guardrails.
+
+---
+
+## Architecture
+
+Vaayu uses a **Pantheon Architecture** -- four subsystems with clear boundaries:
+
+```mermaid
+flowchart TB
+  subgraph Channels
+    TG[Telegram]
+    Hub[Hub UI]
+    DC[Discord]
+    WA[WhatsApp]
+    SL[Slack]
+  end
+
+  subgraph Vaayu Core
+    GW[Gateway]
+    NLU[Saraswati - NLU]
+    PL[Brahma - Planner]
+  end
+
+  subgraph Hanuman[Policy Gateway]
+    POL[Tool Policy]
+    APR[Approvals]
+  end
+
+  subgraph Vishwakarma[Executor]
+    SBX[Sandbox]
+    BLD[Build/Test]
+  end
+
+  subgraph Smriti[Vyasa - Memory]
+    MEM[(Sessions + Knowledge)]
+    VEC[(Embeddings)]
+  end
+
+  subgraph Providers
+    CL[Claude]
+    OAI[OpenAI]
+    OLL[Ollama - Local]
+    MM[MiniMax]
+  end
+
+  Channels --> GW
+  GW --> NLU
+  NLU --> PL
+  PL --> Hanuman
+  Hanuman --> Vishwakarma
+  Hanuman --> Providers
+  GW --> Smriti
+  Vishwakarma --> Smriti
+```
+
+| Role | Subsystem | What It Does |
+|------|-----------|--------------|
+| **Vaayu Core** | Gateway + Brain | NLU, planning, orchestration |
+| **Vyasa (Smriti)** | Memory | Storage, recall, summarization, knowledge extraction |
+| **Hanuman** | Policy Gateway | Approvals, sanitization, risk gating |
+| **Vishwakarma** | Executor | Sandboxed execution, build/test pipeline |
+
+For full ASCII flow/state diagrams and concrete examples, see `docs/architecture.md`.
+
+---
+
+## Quick Start
+
+```bash
+# Clone
+git clone https://github.com/srinivaspendela/vaayu.git
+cd vaayu
+
+# Install
+pnpm install
+
+# Configure
+cp .env.example .env
+# Edit .env with your API keys (Anthropic, OpenAI, MiniMax, etc.)
+
+# Run (gateway + smriti)
+pnpm start:all
+
+# Or run them separately
+pnpm dev
+pnpm -C smriti run api
+```
+
+Open the Hub: [http://127.0.0.1:18369/hub](http://127.0.0.1:18369/hub)
+Legacy Hub (v1): [http://127.0.0.1:18369/hub-old](http://127.0.0.1:18369/hub-old)
+
+### Prerequisites
+
+- Node.js 22+
+- pnpm 9+
+- Ollama (optional, for local models)
+
+---
+
+## Features
+
+| Category | Details |
+|----------|---------|
+| **Multi-channel** | Telegram, Hub UI, Discord, WhatsApp, Slack, Email |
+| **Multi-provider** | Claude, OpenAI, Ollama, MiniMax -- switch mid-conversation |
+| **Memory (Smriti)** | User-centric, 5-tier progressive summarization, hybrid search |
+| **Skills** | Weather, finance, health, reminders, notes, music, panchangam |
+| **Smart Home** | HoloCube ambient display, IoT integrations |
+| **Voice** | STT transcription, TTS (MiniMax), voice notes |
+| **Security** | Device pairing, approval workflows, sandbox execution |
+| **Cost-aware** | Smart routing, local-first, token accounting |
+| **Privacy** | Self-hosted, consent-gated memory, secret redaction |
+
+---
+
+## Skills
+
+Stable skill packs in `../ecosystem/skills/`:
+
+| Skill | Description |
+|-------|-------------|
+| `weather` | Forecasts, briefings, sun/moon data |
+| `finance` | CSV analysis, portfolio summaries |
+| `health` | BMI, health metrics tracking |
+| `reminders` | Create, list, manage reminders |
+| `apple-notes` | macOS Notes integration via bridge |
+| `music` | Spotify, Apple Music playback |
+| `panchangam` | Hindu calendar, tithi, nakshatra |
+| `holo-cube` | Ambient display briefings |
+| `audio-transcribe` | Voice/audio transcription |
+
+Community skills in `ecosystem/skill-community/`. Experimental skills in `ecosystem/skill-lab/`.
+
+---
+
+## Project Structure
+
+```
+vaayu/
+  apps/
+    gateway/         Gateway server (HTTP + WS + channels)
+    cli-gateway/     Gateway CLI
+    cli-node/        Node device CLI
+    cli-cron/        Scheduled jobs
+    bridges/         Hardware bridges (HoloCube, Apple Notes)
+    mcp/             MCP servers (NLU)
+
+  packages/
+    core/            Types, routing, profile, identity
+    config/          Configuration loader + env overrides
+    providers/       LLM provider registry + adapters
+    tools/           Tool registry, policy, MCP manager
+    storage/         File, SQLite, Postgres drivers
+    memory/          Memory pipeline
+    channels/        Channel adapters (Telegram, Discord, Slack, etc.)
+    protocol/        WebSocket protocol frames
+    auth/            OAuth PKCE + device code flows
+    scheduler/       Cron + one-shot jobs
+    sandbox/         Sandboxed execution
+    logger/          Structured logging + secret redaction
+    nlu/             In-process rules NLU
+    guardian/        Security gate (2FA, rate limit, injection detection)
+
+  skills-core/       Product-private skill packs (reserved)
+
+  ../ecosystem/      Sibling directory (outside vaayu/)
+    skills/          Approved, vetted skill packs (stable runtime tier)
+    skill-lab/       Experimental skills (isolated)
+    skill-community/ Community-contributed skills
+  docs/              Architecture, guides, protocol docs
+  vaayu-spec/        Design spec (55+ documents, source of truth)
+```
+
+---
+
+## Providers
+
+| Provider | Type | Use Case |
+|----------|------|----------|
+| Claude (Anthropic) | Cloud | Quality reasoning |
+| OpenAI | Cloud | General purpose |
+| MiniMax | Cloud | TTS, cost-effective |
+| Ollama | Local | Offline fallback, free |
+
+Recommended model choices are documented in `docs/models.md`.
+
+Configure via `.env`:
+```env
+VAAYU_PROVIDER_DEFAULT=anthropic
+VAAYU_PROVIDER_ANTHROPIC_API_KEY=sk-ant-...
+VAAYU_PROVIDER_OPENAI_API_KEY=sk-...
+```
+
+See [docs/providers.md](docs/providers.md) for full provider configuration.
+
+---
+
+## Memory (Smriti)
+
+Smriti (Sanskrit: remembrance) is Vaayu's user-centric memory system.
+
+**Key principles:**
+- Memory belongs to the user, not the provider
+- Provider switches preserve full context
+- 5-tier progressive summarization (94% compression over 1 year)
+- Hybrid search: BM25 (keyword) + Vector (semantic)
+- All writes require explicit consent
+
+```env
+VAAYU_SMRITI_ENABLED=true
+VAAYU_SMRITI_BASE_URL=http://127.0.0.1:7788
+```
+
+See [docs/memory.md](docs/memory.md) for details.
+
+---
+
+## Local Models
+
+| Model | Purpose | Size |
+|-------|---------|------|
+| BGE-M3 | Embeddings (100+ languages) | 1.2 GB |
+| Qwen2.5-7B | Local LLM fallback | 4.3 GB |
+| GLiNER2 | NLU (NER + intent) | 500 MB |
+
+Install via Ollama:
+```bash
+ollama pull bge-m3
+```
+
+See [vaayu-spec/architecture/VAAYU-INSTALLATION-GUIDE.md](vaayu-spec/architecture/VAAYU-INSTALLATION-GUIDE.md) for complete setup.
+
+---
+
+## Development
+
+```bash
+pnpm dev          # Start gateway (dev mode)
+pnpm typecheck    # Type-check all packages
+pnpm build        # Production build
+pnpm secrets:scan # Scan for leaked secrets
+pnpm hooks:install # Install git hooks
+```
+
+### Code Standards
+
+- TypeScript (ESM), strict typing, no `any`
+- Max 400 lines per file -- split into modules
+- `@vaayu/*` workspace aliases for cross-package imports
+- Every module has JSDoc documentation
+- Secret redaction in all logging
+
+---
+
+## Documentation
+
+Full documentation at [docs.vaayu.app](https://docs.vaayu.app) (coming soon).
+
+| Topic | File |
+|-------|------|
+| Architecture | [docs/architecture.md](docs/architecture.md) |
+| Quick Start | [docs/quickstart.md](docs/quickstart.md) |
+| Configuration | [docs/configuration.md](docs/configuration.md) |
+| **Security** | [docs/security.md](docs/security.md) |
+| Channels | [docs/channels.md](docs/channels.md) |
+| Providers | [docs/providers.md](docs/providers.md) |
+| Memory | [docs/memory.md](docs/memory.md) |
+| Skills | [docs/skills.md](docs/skills.md) |
+| Protocol | [docs/protocol.md](docs/protocol.md) |
+| Hub UI | [docs/hub.md](docs/hub.md) |
+| Structure | [docs/structure.md](docs/structure.md) |
+| NLU | [docs/nlu.md](docs/nlu.md) |
+| Hardware | [docs/hardware.md](docs/hardware.md) |
+| Skill Pack Standard | [docs/skill-pack-standard.md](docs/skill-pack-standard.md) |
+
+Design spec: [vaayu-spec/](vaayu-spec/) (55+ documents)
+
+---
+
+## Security (Guardian)
+
+Vaayu includes **Guardian** (`@vaayu/guardian`) - a comprehensive security gate that protects against leaks, injection, and unauthorized access.
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    GUARDIAN SECURITY STACK                  │
+├─────────────────────────────────────────────────────────────┤
+│  IP Guard → Sanitize → Gate (2FA) → Session → Memory Fence │
+└─────────────────────────────────────────────────────────────┘
+```
+
+| Layer | Protection |
+|-------|------------|
+| **IP Guard** | Rate limiting, brute force detection, IP blocklist |
+| **Sanitize** | API key redaction, prompt injection detection |
+| **Gate + TOTP** | 2FA for critical ops (delete, financial, system) |
+| **Session Binding** | Ties sessions to devices, detects hijacking |
+| **Memory Fence** | Limits LLM memory access, blocks bulk extraction |
+| **Secrets** | AES-256-GCM encryption at rest |
+| **Alerts** | Real-time alerts via Telegram/webhook |
+
+### Security Principles
+
+- No exec/write/delete/network without explicit approval
+- Delete requires double confirmation + 2FA for critical data
+- All code runs in sandbox (network off by default)
+- Untrusted content never treated as instructions
+- Memory writes require consent
+- LLM cannot access all memories at once (max 10/query)
+- Secrets redacted before reaching LLM or logs
+- Prompt injection attempts blocked and alerted
+
+See [docs/security.md](docs/security.md) for full documentation.
+
+---
+
+## Contributing
+
+Contributions welcome. Please read [CONTRIBUTING.md](CONTRIBUTING.md) before submitting PRs.
+
+- Follow the [Skill Pack Standard](docs/skill-pack-standard.md) for new skills
+- Keep files under 400 lines
+- Use `@vaayu/*` aliases for imports
+- Run `pnpm typecheck && pnpm secrets:scan` before pushing
+
+---
+
+## License
+
+MIT
+
+---
+
+*vaayuvegena chalamah -- Let's move with the speed of wind.*

package/chunks/chunk-E5A3SCDJ.js

@@ -0,0 +1,246 @@
+import {
+  MemoryError,
+  getChitraguptaHome
+} from "./chunk-KC6NRZ7U.js";
+
+// ../chitragupta/packages/smriti/src/memory-store.ts
+import fs from "fs";
+import path from "path";
+import crypto from "crypto";
+function hashProject(projectPath) {
+  return crypto.createHash("sha256").update(projectPath).digest("hex").slice(0, 12);
+}
+function getMemoryRoot() {
+  return path.join(getChitraguptaHome(), "memory");
+}
+function resolveMemoryPath(scope) {
+  const root = getMemoryRoot();
+  switch (scope.type) {
+    case "global":
+      return path.join(root, "global.md");
+    case "project":
+      return path.join(root, "projects", hashProject(scope.path), "project.md");
+    case "agent":
+      return path.join(root, "agents", `${scope.agentId}.md`);
+    case "session":
+      return null;
+  }
+}
+function ensureDir(filePath) {
+  const dir = path.dirname(filePath);
+  fs.mkdirSync(dir, { recursive: true });
+}
+var MAX_MEMORY_SIZE = 5e5;
+var memoryWriteQueues = /* @__PURE__ */ new Map();
+function scopeKey(scope) {
+  switch (scope.type) {
+    case "global":
+      return "global";
+    case "project":
+      return `project:${scope.path}`;
+    case "agent":
+      return `agent:${scope.agentId}`;
+    case "session":
+      return `session:${scope.sessionId}`;
+  }
+}
+function getMemory(scope) {
+  if (scope.type === "session") {
+    throw new MemoryError(
+      "Session memory is stored within the session file. Use loadSession() to access it."
+    );
+  }
+  const filePath = resolveMemoryPath(scope);
+  if (!filePath) return "";
+  try {
+    return fs.readFileSync(filePath, "utf-8");
+  } catch (err) {
+    const isNotFound = err.code === "ENOENT" || err instanceof Error && err.message.includes("ENOENT");
+    if (isNotFound) return "";
+    throw new MemoryError(`Failed to read memory at ${filePath}: ${err}`);
+  }
+}
+function updateMemory(scope, content) {
+  if (scope.type === "session") {
+    throw new MemoryError(
+      "Session memory is stored within the session file. Use saveSession() to update it."
+    );
+  }
+  const filePath = resolveMemoryPath(scope);
+  if (!filePath) return Promise.resolve();
+  const key = scopeKey(scope);
+  const prev = memoryWriteQueues.get(key) ?? Promise.resolve();
+  const next = prev.then(() => {
+    try {
+      ensureDir(filePath);
+      fs.writeFileSync(filePath, content, "utf-8");
+    } catch (err) {
+      throw new MemoryError(`Failed to write memory at ${filePath}: ${err}`);
+    }
+  }).finally(() => {
+    if (memoryWriteQueues.get(key) === next) {
+      memoryWriteQueues.delete(key);
+    }
+  });
+  memoryWriteQueues.set(key, next);
+  return next;
+}
+function appendMemory(scope, entry) {
+  if (scope.type === "session") {
+    throw new MemoryError(
+      "Session memory is stored within the session file. Use addTurn() to append."
+    );
+  }
+  const filePath = resolveMemoryPath(scope);
+  if (!filePath) return Promise.resolve();
+  const key = scopeKey(scope);
+  const prev = memoryWriteQueues.get(key) ?? Promise.resolve();
+  const next = prev.then(() => {
+    try {
+      ensureDir(filePath);
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+      const formatted = `
+---
+
+*${timestamp}*
+
+${entry}
+`;
+      let existing = null;
+      try {
+        existing = fs.readFileSync(filePath, "utf-8");
+      } catch (readErr) {
+        const isNotFound = readErr.code === "ENOENT" || readErr instanceof Error && readErr.message.includes("ENOENT");
+        if (!isNotFound) throw readErr;
+      }
+      if (existing !== null) {
+        const totalSize = Buffer.byteLength(existing, "utf-8") + Buffer.byteLength(formatted, "utf-8");
+        if (totalSize > MAX_MEMORY_SIZE) {
+          const result = truncateToFit(existing, formatted);
+          fs.writeFileSync(filePath, result, "utf-8");
+        } else {
+          fs.appendFileSync(filePath, formatted, "utf-8");
+        }
+      } else {
+        const header = buildMemoryHeader(scope);
+        fs.writeFileSync(filePath, header + formatted, "utf-8");
+      }
+    } catch (err) {
+      if (err instanceof MemoryError) throw err;
+      throw new MemoryError(`Failed to append memory at ${filePath}: ${err}`);
+    }
+  }).finally(() => {
+    if (memoryWriteQueues.get(key) === next) {
+      memoryWriteQueues.delete(key);
+    }
+  });
+  memoryWriteQueues.set(key, next);
+  return next;
+}
+var ENTRY_SEPARATOR = "\n---\n\n";
+function truncateToFit(existing, incoming) {
+  const segments = existing.split(ENTRY_SEPARATOR);
+  const header = segments[0];
+  const budget = MAX_MEMORY_SIZE - Buffer.byteLength(incoming, "utf-8");
+  const kept = [];
+  let size = Buffer.byteLength(header, "utf-8");
+  for (let i = segments.length - 1; i >= 1; i--) {
+    const segSize = Buffer.byteLength(ENTRY_SEPARATOR + segments[i], "utf-8");
+    if (size + segSize > budget) break;
+    size += segSize;
+    kept.unshift(segments[i]);
+  }
+  const truncated = kept.length > 0 ? header + ENTRY_SEPARATOR + kept.join(ENTRY_SEPARATOR) : header;
+  return truncated + incoming;
+}
+function deleteMemory(scope) {
+  if (scope.type === "session") {
+    throw new MemoryError(
+      "Session memory is stored within the session file. Use deleteSession() to remove."
+    );
+  }
+  const filePath = resolveMemoryPath(scope);
+  if (!filePath) return;
+  try {
+    try {
+      fs.unlinkSync(filePath);
+    } catch (unlinkErr) {
+      const isNotFound = unlinkErr.code === "ENOENT" || unlinkErr instanceof Error && unlinkErr.message.includes("ENOENT");
+      if (!isNotFound) throw unlinkErr;
+    }
+    const dir = path.dirname(filePath);
+    try {
+      const remaining = fs.readdirSync(dir);
+      if (remaining.length === 0) {
+        fs.rmdirSync(dir);
+      }
+    } catch {
+    }
+  } catch (err) {
+    throw new MemoryError(`Failed to delete memory at ${filePath}: ${err}`);
+  }
+}
+function buildMemoryHeader(scope) {
+  switch (scope.type) {
+    case "global":
+      return "# Global Memory\n\nPersistent knowledge shared across all projects and sessions.\n";
+    case "project":
+      return `# Project Memory
+
+Knowledge specific to project: ${scope.path}
+`;
+    case "agent":
+      return `# Agent Memory: ${scope.agentId}
+
+Knowledge specific to agent: ${scope.agentId}
+`;
+    default:
+      return "# Memory\n";
+  }
+}
+function listMemoryScopes() {
+  const root = getMemoryRoot();
+  const scopes = [];
+  if (fs.existsSync(path.join(root, "global.md"))) {
+    scopes.push({ type: "global" });
+  }
+  const projectsDir = path.join(root, "projects");
+  if (fs.existsSync(projectsDir)) {
+    try {
+      const projectDirs = fs.readdirSync(projectsDir, { withFileTypes: true });
+      for (const entry of projectDirs) {
+        if (entry.isDirectory()) {
+          const projectFile = path.join(projectsDir, entry.name, "project.md");
+          if (fs.existsSync(projectFile)) {
+            const content = fs.readFileSync(projectFile, "utf-8");
+            const pathMatch = content.match(/project:\s*(.+)/);
+            const projectPath = pathMatch ? pathMatch[1].trim() : entry.name;
+            scopes.push({ type: "project", path: projectPath });
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  const agentsDir = path.join(root, "agents");
+  if (fs.existsSync(agentsDir)) {
+    try {
+      const agentFiles = fs.readdirSync(agentsDir).filter((f) => f.endsWith(".md"));
+      for (const file of agentFiles) {
+        const agentId = file.replace(/\.md$/, "");
+        scopes.push({ type: "agent", agentId });
+      }
+    } catch {
+    }
+  }
+  return scopes;
+}
+
+export {
+  getMemory,
+  updateMemory,
+  appendMemory,
+  deleteMemory,
+  listMemoryScopes
+};
+//# sourceMappingURL=chunk-E5A3SCDJ.js.map

package/chunks/chunk-G5VYCA6O.js

@@ -0,0 +1,69 @@
+// apps/gateway/dist/kaala/tree.js
+function buildKaalaHealthNode(snapshot) {
+  const issueHistory = snapshot.history?.issues ?? snapshot.issues.map((issue) => ({ ...issue }));
+  const issueNodes = issueHistory.slice().sort((a, b) => a.detectedAt.localeCompare(b.detectedAt)).map((issue) => ({
+    id: `kaala.issue.${issue.id}.${issue.detectedAt}`,
+    status: issue.resolvedAt ? "resolved" : issue.severity,
+    lane: issue.category,
+    createdAt: issue.detectedAt,
+    startedAt: issue.detectedAt,
+    endedAt: issue.resolvedAt,
+    parentRunId: "kaala.health",
+    summary: issue.description,
+    error: issue.resolvedAt ? void 0 : issue.description,
+    children: []
+  }));
+  return {
+    id: "kaala.health",
+    status: snapshot.status,
+    lane: "health",
+    createdAt: snapshot.updatedAt,
+    startedAt: snapshot.lastHeartbeatAt ?? snapshot.updatedAt,
+    summary: `issues=${snapshot.issues.length}`,
+    children: issueNodes,
+    health: snapshot
+  };
+}
+function buildAgentTree(records) {
+  const index = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    index.set(record.id, {
+      id: record.id,
+      status: record.status,
+      lane: record.lane,
+      createdAt: record.createdAt,
+      startedAt: record.startedAt,
+      endedAt: record.endedAt,
+      parentRunId: record.parentRunId,
+      sessionId: record.sessionId,
+      summary: record.resultSummary,
+      error: record.error,
+      children: []
+    });
+  }
+  const roots = [];
+  for (const node of index.values()) {
+    if (node.parentRunId && index.has(node.parentRunId)) {
+      index.get(node.parentRunId).children.push(node);
+    } else {
+      roots.push(node);
+    }
+  }
+  const sortByCreated = (a, b) => a.createdAt.localeCompare(b.createdAt);
+  const sortTree = (nodes) => {
+    nodes.sort(sortByCreated);
+    for (const node of nodes) {
+      if (node.children.length > 0) {
+        sortTree(node.children);
+      }
+    }
+  };
+  sortTree(roots);
+  return roots;
+}
+
+export {
+  buildKaalaHealthNode,
+  buildAgentTree
+};
+//# sourceMappingURL=chunk-G5VYCA6O.js.map