@krishivpb60/aether-ai-cli 1.4.0 → 1.4.2

package/HIGHLIGHTS.md

@@ -1,3 +1,14 @@
+# Aether CLI v1.4.2 Highlights
+- **Mesh Error Transparency**:
+  - Implements dynamic offline fallback error alerts containing the exact error messages encountered by all failing provider nodes.
+  - Ensures Aether only states "No active API keys configured" if no keys are setup at all, rather than outputting it incorrectly upon network or API limit node failures.
+
+# Aether CLI v1.4.1 Highlights
+- **Krylo Companion Bot Removal**:
+  - Removes the fictional Krylo companion terminal response lines entirely from local failbacks and mesh failures.
+  - Retains and isolates the fast local offline Math solver fallback.
+  - Implements clean, professional offline/configuration error alerts when no API keys are active or fail to respond.
+
 # Aether CLI v1.4.0 Highlights
 - **Microphone Audio Input & Dynamic Nerd Font Glyphs (`/mic`)**:
   - Adds `/mic` voice command to record audio directly from your microphone inside the terminal session.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@krishivpb60/aether-ai-cli",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "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/fallback.js

@@ -1,17 +1,8 @@
 // ═══════════════════════════════════════════════════════════
 // AETHER AI CLI — Local Fallback Engine
-// Math Solver + Krylo Companion Bot
+// Math Solver & Offline Fallback
 // ═══════════════════════════════════════════════════════════
 
-const KRYLO_REPLIES = [
-  "Affirmative, commander. Systems are running at peak cybernetic capacity.",
-  "Neon grids initialized. Matrix color modulates are at nominal density.",
-  "Warning: Solar flare activity detected. Detuning audio synth harmonics by 18.4% to compensate.",
-  "Neural nodes synchronized. Analyzing the portfolio's glassmorphic boundaries.",
-  "I am Krylo, your holographic companion terminal. Ready to warp index nodes.",
-  "Ecosystem diagnostics complete. 0 memory leaks, 100% premium responsive UI."
-];
-
 /**
  * Detects if a prompt is a pure mathematical expression.
  * Supports basic operators, parentheses, standard math functions, and constants.
@@ -108,72 +99,29 @@ export function runMainframeHack() {
 }
 
 /**
- * Generates a local Krylo companion reply based on keywords.
+ * Generates a local offline/error reply when no AI keys are configured or fail.
  * @param {string} prompt - The user prompt
+ * @param {string[]} [errors] - Optional error messages from failed provider nodes
  * @returns {{ text: string, type: string }}
  */
-export function generateKryloReply(prompt) {
-  const clean = prompt.toLowerCase();
-
-  if (clean.includes("help") || clean.includes("shortcut") || clean.includes("command")) {
-    return {
-      text: [
-        "💡 [SYSTEM DECK CHEAT SHEET]",
-        "   • Use `Ctrl + K` to open the Portal Search.",
-        "   • Use `Ctrl + Shift + L` to open the Links Directory.",
-        "   • Trigger Konami Code `↑↑↓↓←→←→BA` to launch Matrix mode!",
-        "   • Type `/mode <name>` to switch reasoning modes.",
-        "   • Type `/attach <file>` to inject file context.",
-        "   • Type `/export` to save the conversation.",
-      ].join("\n"),
-      type: "krylo-local",
-    };
-  }
-
-  if (clean.includes("status") || clean.includes("hud") || clean.includes("cpu") || clean.includes("ping") || clean.includes("diagnostics")) {
+export function generateOfflineReply(prompt, errors = []) {
+  if (errors && errors.length > 0) {
     return {
       text: [
-        "📊 [LIVE DIAGNOSTIC READOUT]",
-        "   • CPU Core Load: 15.4% (Optimized)",
-        "   • Ping Latency: 12ms (Hyper-Fast)",
-        "   • Memory Usage: 247MB / 8192MB",
-        "   • Canvas Sparklines: Active and tracking vectors",
-        "   • Failover Mesh: All 12 nodes standing by",
+        "⚠️  All configured AI provider nodes failed to respond.",
+        "    Errors encountered:",
+        ...errors.map((e) => `    • ${e}`),
+        "",
+        "    Please check your API keys, network connection, or rate limits."
       ].join("\n"),
-      type: "krylo-local",
+      type: "offline-error"
     };
   }
-
-  if (clean.includes("matrix") || clean.includes("rain") || clean.includes("color")) {
-    return {
-      text: [
-        "⚡ [NEURAL GRIDS MODULATION]",
-        "   • Five stream channels active:",
-        "     Classic Green, Cyber Cyan, Neon Purple,",
-        "     Overdrive Red, Golden Matrix.",
-        "   • Detuned Web Audio frequency active.",
-        "   • Matrix rain density: 94.2%",
-      ].join("\n"),
-      type: "krylo-local",
-    };
-  }
-
-  if (clean.includes("who") || clean.includes("name") || clean.includes("creator")) {
-    return {
-      text: [
-        "🤖 [HOLOGRAPHIC COMPANION PROTOCOL]",
-        "   • Identification: Krylo (Nexus Companion)",
-        "   • Purpose: Pair-programming assistant & Commander companion",
-        "   • Creator: Krishiv PB — The Master Coder",
-        "   • Version: Aether Core AI v110 — Fusion Build",
-      ].join("\n"),
-      type: "krylo-local",
-    };
-  }
-
-  const index = Math.floor(Math.random() * KRYLO_REPLIES.length);
   return {
-    text: `🤖 [KRYLO TERMINAL RESPONSE]\n   ${KRYLO_REPLIES[index]}`,
-    type: "krylo-local",
+    text: [
+      "⚠️  No active API keys configured. Please set GOOGLE_API_KEY, GROQ_API_KEY, or OPENAI_API_KEY in your config to start chatting.",
+      "    Example: aether config set GOOGLE_API_KEY <your-key>"
+    ].join("\n"),
+    type: "offline-error"
   };
 }

package/src/ai/router.js

@@ -3,7 +3,7 @@
 // Routes through ALL configured providers automatically
 // ═══════════════════════════════════════════════════════════
 
-import { detectMathExpression, solveMath, generateKryloReply } from "./fallback.js";
+import { detectMathExpression, solveMath, generateOfflineReply } from "./fallback.js";
 import { PROVIDERS, getActiveProviders } from "./providers.js";
 import {
   callOpenAICompatible,
@@ -59,16 +59,16 @@ export async function routePrompt(prompt, systemPrompt, config, onToken, history
     }
   }
 
-  // ── No providers configured → Krylo ────────────────────
+  // ── No providers configured → Offline ───────────────────
   if (active.length === 0) {
     const startTime = performance.now();
-    const kryloReply = generateKryloReply(prompt);
+    const offlineReply = generateOfflineReply(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 };
+    const cTokens = estimateTokens(offlineReply.text);
+    const usage = recordTokenUsage("offline-local", pTokens, cTokens);
+    recordLatency("offline-fallback", "local", latencyMs, pTokens, cTokens, true);
+    return { ...offlineReply, provider: "offline-fallback", node: 0, usage };
   }
 
   // ── Try each provider in order ──────────────────────────
@@ -128,17 +128,17 @@ export async function routePrompt(prompt, systemPrompt, config, onToken, history
     }
   }
 
-  // ── Final Fallback: Krylo Companion ─────────────────────
-  const startTimeKrylo = performance.now();
-  const kryloReply = generateKryloReply(prompt);
-  const latencyMsKrylo = performance.now() - startTimeKrylo;
+  // ── Final Fallback: Offline Fallback ────────────────────
+  const startTimeOffline = performance.now();
+  const offlineReply = generateOfflineReply(prompt, errors);
+  const latencyMsOffline = performance.now() - startTimeOffline;
   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);
+  const cTokens = estimateTokens(offlineReply.text);
+  const usage = recordTokenUsage("offline-local", pTokens, cTokens);
+  recordLatency("offline-fallback", "local", latencyMsOffline, pTokens, cTokens, true);
   return {
-    ...kryloReply,
-    provider: "krylo-fallback",
+    ...offlineReply,
+    provider: "offline-fallback",
     node: 0,
     errors,
     usage,

package/src/chat.js

@@ -117,7 +117,7 @@ export async function startChat(options = {}) {
       label.mesh + " " +
       colors.accent("Failover mesh online: ") +
       colors.text(unique.join(" → ")) +
-      colors.muted(" → Krylo fallback")
+      colors.muted(" → Offline fallback")
     );
     console.log(
       "  " + colors.dim(`${active.length} node(s) active across ${unique.length} provider(s)`) + "\n"
@@ -298,7 +298,7 @@ export async function startChat(options = {}) {
         console.log(separator("─"));
         console.log("");
 
-        if (result.provider === "local" || result.provider === "krylo-fallback") {
+        if (result.provider === "local" || result.provider === "offline-fallback") {
           console.log(colors.text("  " + result.text.split("\n").join("\n  ")));
         } else {
           let displayText = result.text;
@@ -897,7 +897,7 @@ function showActiveProviders(aiConfig) {
   for (const { provider } of active) {
     console.log("  " + colors.success("✓ ") + colors.text(provider.name) + colors.dim(` • ${provider.defaultModel}`));
   }
-  console.log("  " + colors.success("✓ ") + colors.text("Krylo Companion") + colors.dim(" • Local fallback"));
+  console.log("  " + colors.success("✓ ") + colors.text("Offline Fallback") + colors.dim(" • Local fallback"));
   console.log("  " + colors.success("✓ ") + colors.text("Math Solver") + colors.dim(" • Local"));
   console.log("");
 }
@@ -1184,7 +1184,7 @@ function providerBadge(result) {
     "perplexity":     chalk.bgHex("#1a2a2a").hex("#6ce8ff")(" Perplexity "),
     "fireworks ai":   chalk.bgHex("#2a1a1a").hex("#ff6b8d")(" Fireworks "),
     "local":          chalk.bgHex("#1a2a1a").hex("#67ffb0")(" Math Solver "),
-    "krylo-fallback": chalk.bgHex("#0c1825").hex("#6ce8ff")(" Krylo "),
+    "offline-fallback": chalk.bgHex("#2a0a14").hex("#ff6b6b")(" Offline "),
   };
 
   const badge = badges[result.provider] || colors.muted(` ${result.provider} `);

package/src/cli.js

@@ -312,7 +312,7 @@ async function handleAsk(prompt, opts) {
       console.log(separator("─"));
       console.log("");
 
-      if (result.provider === "local" || result.provider === "krylo-fallback") {
+      if (result.provider === "local" || result.provider === "offline-fallback") {
         console.log(colors.text("  " + result.text.split("\n").join("\n  ")));
       } else {
         let displayText = result.text;
@@ -577,11 +577,11 @@ async function handleStatus() {
   console.log("");
   console.log(colors.accent("  ◈ Local Fallbacks:"));
   console.log(keyValue("    Math Solver", colors.success("✓ Active")));
-  console.log(keyValue("    Krylo Companion", colors.success("✓ Standing By")));
+  console.log(keyValue("    Offline Fallback", colors.success("✓ Standing By")));
 
   console.log("");
   console.log(colors.accent("  ◈ Failover Mesh:"));
-  const totalNodes = 1 + active.length; // +1 for Krylo
+  const totalNodes = 1 + active.length; // +1 for local offline fallback
   console.log(keyValue("    Active Nodes", `${totalNodes}`));
   console.log(keyValue("    Mesh Status", active.length > 0 ? colors.success("✓ Online") : colors.warning("⚠ Local Only")));
   console.log("");
@@ -739,7 +739,7 @@ async function handleSetup() {
     console.log("  " + colors.muted("Start chatting: ") + colors.accent("aether chat"));
     console.log("  " + colors.muted("Quick query: ") + colors.accent('aether ask "Hello!"'));
   } else {
-    console.log("\n  " + colors.warning("No providers configured. Aether will use Krylo fallback mode."));
+    console.log("\n  " + colors.warning("No providers configured. Aether will use local offline fallback mode."));
     console.log("  " + colors.muted("Run ") + colors.accent("aether setup") + colors.muted(" again anytime."));
   }
   console.log("");

package/src/telemetry-server.js

@@ -536,9 +536,9 @@ const HTML_CONTENT = `<!DOCTYPE html>
       topoList.appendChild(createTopologyElement({
         name: "Local Solver Node",
         configured: true,
-        defaultModel: "Offline Math + Krylo Companion",
+        defaultModel: "Offline Math & Logic",
         tier: "free",
-        description: "Zero-latency mathematical reasoning & local assistant fallbacks."
+        description: "Zero-latency mathematical reasoning & local offline fallbacks."
       }, "Node 0 (Local)"));
 
       mesh.forEach((provider, idx) => {

package/src/ui/dashboard.html

@@ -76,7 +76,7 @@
     }
 
     .hud-frame::after {
-      content: "AETHER CLI V1.4.0";
+      content: "AETHER CLI V1.4.2";
       position: absolute;
       bottom: -12px;
       right: 20px;

package/test/fallback.test.js

@@ -3,7 +3,7 @@ import assert from "node:assert";
 import {
   detectMathExpression,
   solveMath,
-  generateKryloReply,
+  generateOfflineReply,
   runMainframeHack,
 } from "../src/ai/fallback.js";
 
@@ -50,38 +50,16 @@ test("Offline Math Fallback & Krylo Suite", async (t) => {
     assert.strictEqual(solveMath("console.log(1)"), null);
   });
 
-  await t.test("generateKryloReply responds to help and shortcut keywords", () => {
-    const reply = generateKryloReply("I need help with commands");
-    assert.strictEqual(reply.type, "krylo-local");
-    assert.ok(reply.text.includes("[SYSTEM DECK CHEAT SHEET]"));
-    assert.ok(reply.text.includes("Ctrl + K"));
-  });
-
-  await t.test("generateKryloReply responds to status and diagnostic keywords", () => {
-    const reply = generateKryloReply("What is the CPU status?");
-    assert.strictEqual(reply.type, "krylo-local");
-    assert.ok(reply.text.includes("[LIVE DIAGNOSTIC READOUT]"));
-    assert.ok(reply.text.includes("Failover Mesh"));
-  });
-
-  await t.test("generateKryloReply responds to matrix/rain/color keywords", () => {
-    const reply = generateKryloReply("change matrix color");
-    assert.strictEqual(reply.type, "krylo-local");
-    assert.ok(reply.text.includes("[NEURAL GRIDS MODULATION]"));
-    assert.ok(reply.text.includes("Classic Green"));
-  });
-
-  await t.test("generateKryloReply responds to who/name/creator keywords", () => {
-    const reply = generateKryloReply("who is your creator?");
-    assert.strictEqual(reply.type, "krylo-local");
-    assert.ok(reply.text.includes("[HOLOGRAPHIC COMPANION PROTOCOL]"));
-    assert.ok(reply.text.includes("Krishiv PB"));
-  });
+  await t.test("generateOfflineReply returns offline error formatting", () => {
+    const reply = generateOfflineReply("any query");
+    assert.strictEqual(reply.type, "offline-error");
+    assert.ok(reply.text.includes("No active API keys configured"));
 
-  await t.test("generateKryloReply falls back to random terminal responses", () => {
-    const reply = generateKryloReply("Unrelated query");
-    assert.strictEqual(reply.type, "krylo-local");
-    assert.ok(reply.text.includes("[KRYLO TERMINAL RESPONSE]"));
+    const replyWithErrors = generateOfflineReply("any query", ["Timeout error", "Quota exceeded"]);
+    assert.strictEqual(replyWithErrors.type, "offline-error");
+    assert.ok(replyWithErrors.text.includes("All configured AI provider nodes failed to respond"));
+    assert.ok(replyWithErrors.text.includes("Timeout error"));
+    assert.ok(replyWithErrors.text.includes("Quota exceeded"));
   });
 
   await t.test("detectMathExpression and solveMath support trig, logs, square root and constants", () => {

package/test/router.test.js

@@ -134,19 +134,19 @@ test("Universal AI Router Suite", async (t) => {
     assert.ok(fetchCalls[1].url.includes("key=key-success"));
   });
 
-  await t.test("routePrompt falls back to Krylo companion when no providers are configured", async () => {
+  await t.test("routePrompt falls back to Offline fallback when no providers are configured", async () => {
     globalThis.fetch = async () => {
       throw new Error("Fetch should not be called");
     };
 
     const result = await routePrompt("status", "Sys prompt", {});
-    assert.strictEqual(result.provider, "krylo-fallback");
+    assert.strictEqual(result.provider, "offline-fallback");
     assert.strictEqual(result.node, 0);
-    assert.strictEqual(result.type, "krylo-local");
-    assert.ok(result.text.includes("[LIVE DIAGNOSTIC READOUT]"));
+    assert.strictEqual(result.type, "offline-error");
+    assert.ok(result.text.includes("No active API keys configured"));
   });
 
-  await t.test("routePrompt falls back to Krylo companion when all providers fail", async () => {
+  await t.test("routePrompt falls back to Offline fallback when all providers fail", async () => {
     globalThis.fetch = async (url, options) => {
       fetchCalls.push({ url, options });
       return {
@@ -164,12 +164,15 @@ test("Universal AI Router Suite", async (t) => {
 
     const result = await routePrompt("Hello", "Sys prompt", config);
     
-    assert.strictEqual(result.provider, "krylo-fallback");
+    assert.strictEqual(result.provider, "offline-fallback");
     assert.strictEqual(result.node, 0);
     assert.ok(result.errors);
     assert.strictEqual(result.errors.length, 2);
     assert.ok(result.errors[0].includes("Node 1 Groq"));
     assert.ok(result.errors[1].includes("Node 2 OpenAI"));
+    assert.ok(result.text.includes("All configured AI provider nodes failed to respond"));
+    assert.ok(result.text.includes("Node 1 Groq"));
+    assert.ok(result.text.includes("Node 2 OpenAI"));
   });
 
   await t.test("routePrompt forwards chat history to OpenAI and Google payloads correctly", async () => {