@krishivpb60/aether-ai-cli 1.3.3 → 1.3.5

package/HIGHLIGHTS.md

@@ -1,3 +1,16 @@
+# Aether CLI v1.3.5 Highlights
+- **Visual Telemetry Dashboard HUD (`aether dashboard` / `aether telemetry`)**:
+  - Adds a local zero-dependency Web Server hosting a cyberpunk observability dashboard HUD.
+  - Displays real-time request latencies, query success rates, model token distributions, and active failover mesh topologies.
+  - Persistent storage preserves historical metrics across CLI executions in `~/.aether/telemetry.json`.
+  - Offline-compatible custom SVG chart engine allows telemetry visualization without an internet connection.
+
+# Aether CLI v1.3.4 Highlights
+- **AI-Powered Workspace Search & Code Indexer (`/search`)**:
+  - Adds `/search <query>` slash command to scan all workspace text files for keyword matches, showing line numbers and code snippets.
+  - Supports `/search --ai <query>` to run a semantic search using the active AI reasoning model.
+  - Automatically ignores binaries, files exceeding 250KB, and build/dependency/git directories.
+
 # Aether CLI v1.3.3 Highlights
 - **Codex & Claude Code Slash Commands**: Added 7 new advanced developer experience (DX) commands:
   - `/review`: Analyze staged/unstaged git changes and stream an AI-powered code review.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@krishivpb60/aether-ai-cli",
-  "version": "1.3.3",
+  "version": "1.3.5",
   "description": "Aether Core AI — A cyberpunk command-line AI assistant with multi-mode reasoning, 12-node failover mesh, file context injection, and offline fallbacks.",
   "main": "src/cli.js",
   "bin": {

package/src/ai/router.js

@@ -12,6 +12,7 @@ import {
   callCohere,
 } from "./universal.js";
 import { estimateTokens, recordTokenUsage } from "./tokens.js";
+import { recordLatency } from "./telemetry.js";
 
 /**
  * Routes a prompt through the universal AI failover mesh.
@@ -31,11 +32,14 @@ export async function routePrompt(prompt, systemPrompt, config, onToken, history
   // ── Node 0: Local Math Solver ───────────────────────────
   const mathExpr = detectMathExpression(prompt);
   if (mathExpr) {
+    const startTime = performance.now();
     const mathResult = solveMath(mathExpr);
     if (mathResult) {
+      const latencyMs = performance.now() - startTime;
       const pTokens = estimateTokens(systemPrompt + prompt);
       const cTokens = estimateTokens(mathResult.text);
       const usage = recordTokenUsage("local-math", pTokens, cTokens);
+      recordLatency("local", "math-solver", latencyMs, pTokens, cTokens, true);
       return { ...mathResult, provider: "local", node: 0, usage };
     }
   }
@@ -57,10 +61,13 @@ export async function routePrompt(prompt, systemPrompt, config, onToken, history
 
   // ── No providers configured → Krylo ────────────────────
   if (active.length === 0) {
+    const startTime = performance.now();
     const kryloReply = generateKryloReply(prompt);
+    const latencyMs = performance.now() - startTime;
     const pTokens = estimateTokens(systemPrompt + prompt);
     const cTokens = estimateTokens(kryloReply.text);
     const usage = recordTokenUsage("krylo-local", pTokens, cTokens);
+    recordLatency("krylo-fallback", "local", latencyMs, pTokens, cTokens, true);
     return { ...kryloReply, provider: "krylo-fallback", node: 0, usage };
   }
 
@@ -69,6 +76,7 @@ export async function routePrompt(prompt, systemPrompt, config, onToken, history
   let nodeIndex = 1;
 
   for (const { id, provider, apiKey } of active) {
+    const startTime = performance.now();
     try {
       const model = config[`${id.toUpperCase()}_MODEL`] || provider.defaultModel;
       let result;
@@ -103,22 +111,31 @@ export async function routePrompt(prompt, systemPrompt, config, onToken, history
           );
       }
 
+      const latencyMs = performance.now() - startTime;
       const pTokens = estimateTokens(systemPrompt + prompt + history.map(h => h.content).join(""));
       const cTokens = estimateTokens(result.text);
       const usage = recordTokenUsage(result.model, pTokens, cTokens);
 
+      recordLatency(provider.name, result.model, latencyMs, pTokens, cTokens, true);
+
       return { ...result, node: nodeIndex, usage };
     } catch (err) {
+      const latencyMs = performance.now() - startTime;
+      const pTokens = estimateTokens(systemPrompt + prompt + history.map(h => h.content).join(""));
+      recordLatency(provider.name, "unknown", latencyMs, pTokens, 0, false);
       errors.push(`[Node ${nodeIndex} ${provider.name}] ${err.message}`);
       nodeIndex++;
     }
   }
 
   // ── Final Fallback: Krylo Companion ─────────────────────
+  const startTimeKrylo = performance.now();
   const kryloReply = generateKryloReply(prompt);
+  const latencyMsKrylo = performance.now() - startTimeKrylo;
   const pTokens = estimateTokens(systemPrompt + prompt + history.map(h => h.content).join(""));
   const cTokens = estimateTokens(kryloReply.text);
   const usage = recordTokenUsage("krylo-local", pTokens, cTokens);
+  recordLatency("krylo-fallback", "local", latencyMsKrylo, pTokens, cTokens, true);
   return {
     ...kryloReply,
     provider: "krylo-fallback",

package/src/ai/search.js

@@ -0,0 +1,94 @@
+import { readdirSync, statSync, readFileSync } from "node:fs";
+import { join, sep, relative } from "node:path";
+
+const IGNORE_DIRS = new Set([
+  ".git",
+  "node_modules",
+  "build",
+  "dist",
+  ".agents",
+  "aether_ai_agent_cli.egg-info",
+  "aether_ai_cli.egg-info",
+  "temp-test-home",
+  "temp-test-home-updater",
+  "temp-test-home-search"
+]);
+
+const BINARY_EXTS = new Set([
+  ".png", ".jpg", ".jpeg", ".gif", ".ico", ".webp",
+  ".zip", ".tar", ".gz", ".rar", ".7z",
+  ".pdf", ".exe", ".dll", ".so", ".dylib", ".bin",
+  ".mp3", ".mp4", ".wav", ".avi", ".mov",
+  ".woff", ".woff2", ".ttf", ".eot"
+]);
+
+/**
+ * Recursively walks a directory and yields all text files.
+ * @param {string} dir - Directory to scan
+ * @param {string} rootDir - Root directory for ignore matching
+ * @returns {string[]} List of absolute paths
+ */
+export function crawlDirectory(dir, rootDir = dir) {
+  let files = [];
+  let entries = [];
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return files;
+  }
+
+  for (const entry of entries) {
+    if (IGNORE_DIRS.has(entry)) continue;
+    const fullPath = join(dir, entry);
+    try {
+      const stat = statSync(fullPath);
+      if (stat.isDirectory()) {
+        files = files.concat(crawlDirectory(fullPath, rootDir));
+      } else if (stat.isFile()) {
+        if (stat.size > 250 * 1024) continue; // Skip files larger than 250KB
+
+        const dotIdx = entry.lastIndexOf(".");
+        const ext = dotIdx !== -1 ? entry.slice(dotIdx).toLowerCase() : "";
+        if (BINARY_EXTS.has(ext)) continue;
+
+        files.push(fullPath);
+      }
+    } catch {
+      // Ignore stat failures
+    }
+  }
+  return files;
+}
+
+/**
+ * Searches all text files in the workspace for occurrences of query.
+ * @param {string} query - Query string
+ * @param {string} rootDir - The workspace root path
+ * @returns {Array<{ filePath: string, relativePath: string, lineNumber: number, lineContent: string }>}
+ */
+export function workspaceSearch(query, rootDir = process.cwd()) {
+  const files = crawlDirectory(rootDir, rootDir);
+  const results = [];
+  const lowerQuery = query.toLowerCase().trim();
+
+  for (const file of files) {
+    try {
+      const content = readFileSync(file, "utf8");
+      const lines = content.split(/\r?\n/);
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.toLowerCase().includes(lowerQuery)) {
+          results.push({
+            filePath: file,
+            relativePath: relative(rootDir, file),
+            lineNumber: i + 1,
+            lineContent: line.trim()
+          });
+        }
+      }
+    } catch {
+      // Ignore read failures
+    }
+  }
+  return results;
+}

package/src/ai/telemetry.js

@@ -0,0 +1,125 @@
+// ═══════════════════════════════════════════════════════════
+// AETHER AI CLI — Telemetry & Latency Logger
+// Logs request latencies, prompt speeds, and meshes provider logs.
+// ═══════════════════════════════════════════════════════════
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { getSessionTokenStats, getBreakdownByModel } from "./tokens.js";
+import { getActiveProviders, PROVIDERS } from "./providers.js";
+import { listSessions } from "../config.js";
+
+const CONFIG_DIR = join(homedir(), ".aether");
+const TELEMETRY_FILE = join(CONFIG_DIR, "telemetry.json");
+
+/**
+ * Loads telemetry logs from disk.
+ * @returns {Array}
+ */
+function loadTelemetryFromDisk() {
+  try {
+    if (existsSync(TELEMETRY_FILE)) {
+      const raw = readFileSync(TELEMETRY_FILE, "utf-8");
+      return JSON.parse(raw);
+    }
+  } catch {
+    // ignore
+  }
+  return [];
+}
+
+/**
+ * Saves telemetry logs to disk.
+ * @param {Array} logs
+ */
+function saveTelemetryToDisk(logs) {
+  try {
+    if (!existsSync(CONFIG_DIR)) {
+      mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    writeFileSync(TELEMETRY_FILE, JSON.stringify(logs, null, 2), "utf-8");
+  } catch {
+    // ignore
+  }
+}
+
+const latencyLogs = loadTelemetryFromDisk();
+
+/**
+ * Records telemetry metrics for an AI call.
+ * @param {string} provider - The provider name
+ * @param {string} model - The model name
+ * @param {number} latencyMs - The request latency in ms
+ * @param {number} promptTokens - Prompt token count
+ * @param {number} completionTokens - Completion token count
+ * @param {boolean} success - Whether the call succeeded
+ */
+export function recordLatency(provider, model, latencyMs, promptTokens, completionTokens, success) {
+  latencyLogs.push({
+    timestamp: new Date().toISOString(),
+    provider: provider || "unknown",
+    model: model || "unknown",
+    latencyMs: Math.round(latencyMs),
+    promptTokens: promptTokens || 0,
+    completionTokens: completionTokens || 0,
+    success: !!success,
+  });
+
+  // Limit to last 100 entries for historical visualization
+  if (latencyLogs.length > 100) {
+    latencyLogs.shift();
+  }
+
+  saveTelemetryToDisk(latencyLogs);
+}
+
+/**
+ * Returns raw latency records.
+ * @returns {Array}
+ */
+export function getLatencyLogs() {
+  return latencyLogs;
+}
+
+/**
+ * Clears all telemetry logs.
+ */
+export function clearTelemetryLogs() {
+  latencyLogs.length = 0;
+  try {
+    if (existsSync(TELEMETRY_FILE)) {
+      unlinkSync(TELEMETRY_FILE);
+    }
+  } catch {
+    // ignore
+  }
+}
+
+/**
+ * Gathers all metrics needed for the web dashboard visualization.
+ * @param {object} config - Aether configuration object
+ * @returns {object}
+ */
+export function getTelemetryData(config = {}) {
+  // Map active status for all providers in our registry
+  const mesh = Object.entries(PROVIDERS).map(([id, provider]) => {
+    const isConfigured = !!config[provider.key];
+    return {
+      id,
+      name: provider.name,
+      configured: isConfigured,
+      defaultModel: provider.defaultModel,
+      tier: provider.tier,
+      description: provider.description,
+    };
+  });
+
+  return {
+    tokenStats: getSessionTokenStats(),
+    modelBreakdown: getBreakdownByModel(),
+    latencyLogs: [...latencyLogs],
+    meshStructure: mesh,
+    sessions: listSessions(),
+  };
+}