@krishivpb60/aether-ai-cli 1.0.0

package/test/config.test.js

@@ -0,0 +1,182 @@
+import os from "node:os";
+import { join } from "node:path";
+import { mkdir, rm } from "node:fs/promises";
+import { test, before, after, beforeEach, afterEach } from "node:test";
+import assert from "node:assert";
+
+// Redirect homedir before importing config.js to point to a temporary test folder
+const tempHome = join(process.cwd(), "temp-test-home");
+process.env.USERPROFILE = tempHome;
+process.env.HOME = tempHome;
+
+// Dynamically import config.js so it gets the redirected homedir
+const {
+  getConfigPath,
+  loadConfig,
+  saveConfig,
+  getConfigValue,
+  setConfigValue,
+  deleteConfigValue,
+  resetConfig,
+  listConfig,
+  getAIConfig,
+  configExists,
+  isValidConfigKey,
+  loadHistory,
+  saveHistory,
+  clearHistory,
+} = await import("../src/config.js");
+
+const { getAllConfigKeys } = await import("../src/ai/providers.js");
+
+test("Configuration Loading Suite", async (t) => {
+  let originalEnv = {};
+  const configKeys = getAllConfigKeys();
+
+  before(async () => {
+    await mkdir(tempHome, { recursive: true });
+    // Backup relevant env vars
+    for (const key of configKeys) {
+      if (key in process.env) {
+        originalEnv[key] = process.env[key];
+      }
+    }
+  });
+
+  after(async () => {
+    await rm(tempHome, { recursive: true, force: true });
+  });
+
+  beforeEach(async () => {
+    await resetConfig();
+    // Clear config env vars
+    for (const key of configKeys) {
+      delete process.env[key];
+    }
+    delete process.env.CUSTOM_TEST_API_KEY;
+  });
+
+  afterEach(async () => {
+    await resetConfig();
+    // Restore original env vars
+    for (const key of configKeys) {
+      if (key in originalEnv) {
+        process.env[key] = originalEnv[key];
+      } else {
+        delete process.env[key];
+      }
+    }
+  });
+
+  await t.test("getConfigPath should return path inside temporary home", () => {
+    const path = getConfigPath();
+    assert.ok(path.startsWith(tempHome));
+    assert.ok(path.endsWith(join(".aether", "config.json")));
+  });
+
+  await t.test("loadConfig should return empty object if file does not exist", async () => {
+    const config = await loadConfig();
+    assert.deepStrictEqual(config, {});
+  });
+
+  await t.test("saveConfig and loadConfig should save and load config file", async () => {
+    const testConfig = { GROQ_API_KEY: "test-groq-key", OPENAI_MODEL: "gpt-4" };
+    await saveConfig(testConfig);
+    assert.strictEqual(await configExists(), true);
+
+    const loaded = await loadConfig();
+    assert.deepStrictEqual(loaded, testConfig);
+  });
+
+  await t.test("getConfigValue and setConfigValue read and write specific keys", async () => {
+    await setConfigValue("TOGETHER_API_KEY", "together-val");
+    const val = await getConfigValue("TOGETHER_API_KEY");
+    assert.strictEqual(val, "together-val");
+
+    await deleteConfigValue("TOGETHER_API_KEY");
+    const deletedVal = await getConfigValue("TOGETHER_API_KEY");
+    assert.strictEqual(deletedVal, undefined);
+  });
+
+  await t.test("listConfig should mask sensitive keys", async () => {
+    await saveConfig({
+      GROQ_API_KEY: "supersecretgroqkey",
+      OPENAI_MODEL: "gpt-4o",
+      OTHER_PROP: "not-sensitive-but-short",
+      SHORT_SECRET: "123", // too short to mask (<= 8 chars)
+    });
+
+    const masked = await listConfig();
+    assert.strictEqual(masked.OPENAI_MODEL, "gpt-4o");
+    assert.strictEqual(masked.OTHER_PROP, "not-sensitive-but-short");
+    assert.strictEqual(masked.SHORT_SECRET, "123");
+    // GROQ_API_KEY contains "KEY", so it is sensitive. It has length 18 (> 8).
+    // It should be masked: first 6 chars + "•••" + last 3 chars
+    // "supers" + "•••" + "key" = "supers•••key"
+    assert.strictEqual(masked.GROQ_API_KEY, "supers•••key");
+  });
+
+  await t.test("getAIConfig Priority: config file overrides process.env", async () => {
+    // 1. Set environment variables
+    process.env.GROQ_API_KEY = "env-groq-key";
+    process.env.OPENAI_API_KEY = "env-openai-key";
+
+    // 2. Set config file value for GROQ_API_KEY (should override env)
+    // but leave OPENAI_API_KEY empty in config (should fall back to env)
+    await saveConfig({
+      GROQ_API_KEY: "file-groq-key",
+    });
+
+    const aiConfig = await getAIConfig();
+    assert.strictEqual(aiConfig.GROQ_API_KEY, "file-groq-key"); // overrides
+    assert.strictEqual(aiConfig.OPENAI_API_KEY, "env-openai-key"); // falls back
+  });
+
+  await t.test("getAIConfig supports fallback for any custom key ending with _API_KEY from process.env", async () => {
+    process.env.CUSTOM_TEST_API_KEY = "custom-env-key";
+    const aiConfig = await getAIConfig();
+    assert.strictEqual(aiConfig.CUSTOM_TEST_API_KEY, "custom-env-key");
+  });
+
+  await t.test("isValidConfigKey checks key formats and known keys", () => {
+    assert.strictEqual(isValidConfigKey("GROQ_API_KEY"), true);
+    assert.strictEqual(isValidConfigKey("CUSTOM_API_KEY"), true);
+    assert.strictEqual(isValidConfigKey("OPENAI_MODEL"), true);
+    assert.strictEqual(isValidConfigKey("GOOGLE_API_KEYS"), true);
+    assert.strictEqual(isValidConfigKey("THEME"), true);
+    assert.strictEqual(isValidConfigKey("CUSTOM_COMMANDS"), true);
+    assert.strictEqual(isValidConfigKey("INVALID_KEY_NAME"), false);
+  });
+
+  await t.test("loadHistory, saveHistory, and clearHistory write and delete log files", async () => {
+    // 1. Initial state: history should be empty
+    const initial = await loadHistory();
+    assert.deepStrictEqual(initial, []);
+
+    // 2. Save history
+    const testHistory = [
+      { role: "user", content: "ping" },
+      { role: "assistant", content: "pong" }
+    ];
+    await saveHistory(testHistory);
+    
+    // 3. Load back
+    const loaded = await loadHistory();
+    assert.deepStrictEqual(loaded, testHistory);
+
+    // 4. Clear history
+    await clearHistory();
+    const cleared = await loadHistory();
+    assert.deepStrictEqual(cleared, []);
+  });
+
+  await t.test("getAIConfig supports and loads CUSTOM_COMMANDS correctly", async () => {
+    const testCommands = { "/explain": "Explain this:", "/refactor": "Refactor this:" };
+    await saveConfig({
+      CUSTOM_COMMANDS: testCommands
+    });
+    
+    const config = await getAIConfig();
+    assert.deepStrictEqual(config.CUSTOM_COMMANDS, testCommands);
+  });
+});

package/test/fallback.test.js

@@ -0,0 +1,105 @@
+import { test } from "node:test";
+import assert from "node:assert";
+import {
+  detectMathExpression,
+  solveMath,
+  generateKryloReply,
+  runMainframeHack,
+} from "../src/ai/fallback.js";
+
+test("Offline Math Fallback & Krylo Suite", async (t) => {
+  await t.test("detectMathExpression identifies valid mathematical expressions", () => {
+    assert.strictEqual(detectMathExpression("2 + 2"), "2+2");
+    assert.strictEqual(detectMathExpression("10 * (5 - 3)"), "10*(5-3)");
+    assert.strictEqual(detectMathExpression("2 ^ 3"), "2^3");
+    assert.strictEqual(detectMathExpression("5 % 2"), "5%2");
+  });
+
+  await t.test("detectMathExpression rejects non-math and invalid expressions", () => {
+    assert.strictEqual(detectMathExpression("hello world"), null);
+    assert.strictEqual(detectMathExpression("2 + 2 = 4"), null);
+    assert.strictEqual(detectMathExpression("x + y"), null);
+    assert.strictEqual(detectMathExpression("123"), null); // No operators
+    assert.strictEqual(detectMathExpression("2 + a"), null);
+  });
+
+  await t.test("solveMath evaluates simple math expressions correctly", () => {
+    const result = solveMath("2+2");
+    assert.ok(result);
+    assert.strictEqual(result.type, "local-math");
+    assert.ok(result.text.includes("Expression: 2+2"));
+    assert.ok(result.text.includes("Result: 4"));
+  });
+
+  await t.test("solveMath converts ^ to ** correctly for exponentiation", () => {
+    const result = solveMath("2^3");
+    assert.ok(result);
+    assert.ok(result.text.includes("Result: 8"));
+  });
+
+  await t.test("solveMath handles floats and division", () => {
+    const result = solveMath("5/2");
+    assert.ok(result);
+    assert.ok(result.text.includes("Result: 2.5"));
+  });
+
+  await t.test("solveMath returns null on syntax error or unsafe code", () => {
+    assert.strictEqual(solveMath("2++2"), null);
+    assert.strictEqual(solveMath("2/0"), null); // Division by zero -> Infinity (isFinite checks false)
+    assert.strictEqual(solveMath(""), null);
+    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("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]"));
+  });
+
+  await t.test("detectMathExpression and solveMath support trig, logs, square root and constants", () => {
+    assert.strictEqual(detectMathExpression("sin(pi / 2)"), "sin(pi/2)");
+    assert.strictEqual(detectMathExpression("sqrt(9) + abs(-5)"), "sqrt(9)+abs(-5)");
+    
+    const resTrig = solveMath("sin(pi/2)");
+    assert.ok(resTrig);
+    assert.ok(resTrig.text.includes("Result: 1"));
+
+    const resComplex = solveMath("sqrt(9) + abs(-5)");
+    assert.ok(resComplex);
+    assert.ok(resComplex.text.includes("Result: 8"));
+  });
+
+  await t.test("runMainframeHack returns the game intro template", () => {
+    const gameIntro = runMainframeHack();
+    assert.strictEqual(gameIntro.type, "mainframe-game");
+    assert.ok(gameIntro.text.includes("Objective: Bypass security"));
+  });
+});

package/test/file-parser.test.js

@@ -0,0 +1,136 @@
+import { test, before, after } from "node:test";
+import assert from "node:assert";
+import { join } from "node:path";
+import { writeFile, mkdir, rm } from "node:fs/promises";
+import { parseFile, formatContext } from "../src/file-parser.js";
+
+const tempDir = join(process.cwd(), "temp-test-files");
+
+test("File Parser & Context Suite", async (t) => {
+  before(async () => {
+    await mkdir(tempDir, { recursive: true });
+  });
+
+  after(async () => {
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  await t.test("parseFile parses a standard .txt file successfully", async () => {
+    const filePath = join(tempDir, "test.txt");
+    const content = "Hello World Aether AI";
+    await writeFile(filePath, content, "utf-8");
+
+    const parsed = await parseFile(filePath);
+    assert.strictEqual(parsed.name, "test.txt");
+    assert.strictEqual(parsed.content, content);
+    assert.strictEqual(parsed.extension, ".txt");
+    assert.strictEqual(parsed.size, Buffer.byteLength(content));
+  });
+
+  await t.test("parseFile parses a code .js file successfully", async () => {
+    const filePath = join(tempDir, "test.js");
+    const content = "const x = 42;\nconsole.log(x);";
+    await writeFile(filePath, content, "utf-8");
+
+    const parsed = await parseFile(filePath);
+    assert.strictEqual(parsed.name, "test.js");
+    assert.strictEqual(parsed.content, content);
+    assert.strictEqual(parsed.extension, ".js");
+  });
+
+  await t.test("parseFile parses a .json file successfully", async () => {
+    const filePath = join(tempDir, "test.json");
+    const content = '{\n  "cyberpunk": "active"\n}';
+    await writeFile(filePath, content, "utf-8");
+
+    const parsed = await parseFile(filePath);
+    assert.strictEqual(parsed.name, "test.json");
+    assert.strictEqual(parsed.content, content.trim());
+    assert.strictEqual(parsed.extension, ".json");
+  });
+
+  await t.test("parseFile parses a .csv file successfully", async () => {
+    const filePath = join(tempDir, "test.csv");
+    const content = "id,name\n1,aether\n2,krylo";
+    await writeFile(filePath, content, "utf-8");
+
+    const parsed = await parseFile(filePath);
+    assert.strictEqual(parsed.name, "test.csv");
+    assert.strictEqual(parsed.content, content);
+    assert.strictEqual(parsed.extension, ".csv");
+  });
+
+  await t.test("parseFile truncates content exceeding 30,000 characters", async () => {
+    const filePath = join(tempDir, "large.txt");
+    const longContent = "A".repeat(35000);
+    await writeFile(filePath, longContent, "utf-8");
+
+    const parsed = await parseFile(filePath);
+    assert.strictEqual(parsed.name, "large.txt");
+    
+    const expectedPrefix = "A".repeat(30000);
+    const expectedTruncationSuffix = "\n\n[... truncated at 30,000 characters]";
+    assert.strictEqual(parsed.content, expectedPrefix + expectedTruncationSuffix);
+  });
+
+  await t.test("parseFile throws error on unsupported extension", async () => {
+    const filePath = join(tempDir, "test.xyz");
+    await writeFile(filePath, "some content", "utf-8");
+
+    await assert.rejects(
+      parseFile(filePath),
+      /Unsupported file type: "\.xyz"/
+    );
+  });
+
+  await t.test("parseFile throws error when file does not exist", async () => {
+    const nonExistentPath = join(tempDir, "does-not-exist.txt");
+    await assert.rejects(
+      parseFile(nonExistentPath),
+      /File not found:/
+    );
+  });
+
+  await t.test("parseFile throws error on directory path without supported extension", async () => {
+    await assert.rejects(
+      parseFile(tempDir),
+      /Unsupported file type:/
+    );
+  });
+
+  await t.test("parseFile throws error on directory path with supported extension", async () => {
+    const dirWithExt = join(tempDir, "test-dir.js");
+    await mkdir(dirWithExt, { recursive: true });
+    await assert.rejects(
+      parseFile(dirWithExt),
+      /Not a file:/
+    );
+  });
+
+  await t.test("formatContext returns formatted template string", () => {
+    const fileData = {
+      name: "test.txt",
+      content: "Hello from inside the file.",
+      size: 27,
+      extension: ".txt",
+    };
+
+    const formatted = formatContext(fileData);
+    const expectedLines = [
+      "[Context File: test.txt (27B, .txt)]",
+      "---",
+      "Hello from inside the file.",
+      "---",
+      "[End of test.txt]",
+    ];
+    assert.strictEqual(formatted, expectedLines.join("\n"));
+  });
+
+  await t.test("formatContext formats KB/MB file sizes correctly", () => {
+    const dataKb = { name: "kb.txt", content: "", size: 1536, extension: ".txt" };
+    assert.ok(formatContext(dataKb).includes("(1.5KB, .txt)"));
+
+    const dataMb = { name: "mb.txt", content: "", size: 1048576 * 2.5, extension: ".txt" };
+    assert.ok(formatContext(dataMb).includes("(2.5MB, .txt)"));
+  });
+});

package/test/router.test.js

@@ -0,0 +1,174 @@
+import { test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert";
+import { routePrompt } from "../src/ai/router.js";
+
+const originalFetch = globalThis.fetch;
+
+test("Universal AI Router Suite", async (t) => {
+  let fetchCalls = [];
+
+  beforeEach(() => {
+    fetchCalls = [];
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+  });
+
+  await t.test("routePrompt routes to local math solver when pure math expression", async () => {
+    globalThis.fetch = async () => {
+      throw new Error("Fetch should not be called for local math solver");
+    };
+
+    const result = await routePrompt("5 * 5", "You are a helpful assistant", {});
+    assert.strictEqual(result.provider, "local");
+    assert.strictEqual(result.node, 0);
+    assert.strictEqual(result.type, "local-math");
+    assert.ok(result.text.includes("Result: 25"));
+  });
+
+  await t.test("routePrompt routes to active providers in order of priority", async () => {
+    globalThis.fetch = async (url, options) => {
+      fetchCalls.push({ url, options });
+      if (url.includes("api.groq.com")) {
+        return {
+          ok: true,
+          json: async () => ({
+            choices: [{ message: { content: "Groq success response" } }],
+          }),
+        };
+      }
+      return { ok: false, status: 400 };
+    };
+
+    const config = {
+      GROQ_API_KEY: "groq-ok-key",
+      OPENAI_API_KEY: "openai-ok-key",
+    };
+
+    const result = await routePrompt("What is the capital of France?", "Sys prompt", config);
+    
+    assert.strictEqual(result.provider, "groq");
+    assert.strictEqual(result.text, "Groq success response");
+    assert.strictEqual(result.node, 1);
+
+    // Verify only Groq was called, OpenAI was skipped since Groq succeeded
+    assert.strictEqual(fetchCalls.length, 1);
+    assert.ok(fetchCalls[0].url.includes("api.groq.com"));
+  });
+
+  await t.test("routePrompt falls back to next provider if priority provider fails", async () => {
+    globalThis.fetch = async (url, options) => {
+      fetchCalls.push({ url, options });
+      if (url.includes("api.groq.com")) {
+        return {
+          ok: false,
+          status: 500,
+          statusText: "Internal Server Error",
+          text: async () => "Groq overloaded",
+        };
+      }
+      if (url.includes("api.openai.com")) {
+        return {
+          ok: true,
+          json: async () => ({
+            choices: [{ message: { content: "OpenAI success response" } }],
+          }),
+        };
+      }
+      return { ok: false, status: 400 };
+    };
+
+    const config = {
+      GROQ_API_KEY: "groq-fail-key",
+      OPENAI_API_KEY: "openai-ok-key",
+    };
+
+    const result = await routePrompt("Explain quantum computing", "Sys prompt", config);
+    
+    assert.strictEqual(result.provider, "openai");
+    assert.strictEqual(result.text, "OpenAI success response");
+    // Node index increments for failed providers, so OpenAI should be node 2
+    assert.strictEqual(result.node, 2);
+
+    // Verify both were called in order
+    assert.strictEqual(fetchCalls.length, 2);
+    assert.ok(fetchCalls[0].url.includes("api.groq.com"));
+    assert.ok(fetchCalls[1].url.includes("api.openai.com"));
+  });
+
+  await t.test("routePrompt handles Google extra key rotation and failover", async () => {
+    globalThis.fetch = async (url, options) => {
+      fetchCalls.push({ url, options });
+      if (url.includes("key=key-fail")) {
+        return {
+          ok: false,
+          status: 403,
+          statusText: "Forbidden",
+          text: async () => "Invalid Key",
+        };
+      }
+      if (url.includes("key=key-success")) {
+        return {
+          ok: true,
+          json: async () => ({
+            candidates: [{ content: { parts: [{ text: "Gemini success response" }] } }],
+          }),
+        };
+      }
+      return { ok: false, status: 400 };
+    };
+
+    const config = {
+      GOOGLE_API_KEYS: "key-fail, key-success",
+    };
+
+    const result = await routePrompt("Tell me a joke", "Sys prompt", config);
+    
+    assert.strictEqual(result.provider, "google");
+    assert.strictEqual(result.text, "Gemini success response");
+    assert.strictEqual(result.node, 2);
+
+    assert.strictEqual(fetchCalls.length, 2);
+    assert.ok(fetchCalls[0].url.includes("key=key-fail"));
+    assert.ok(fetchCalls[1].url.includes("key=key-success"));
+  });
+
+  await t.test("routePrompt falls back to Krylo companion 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.node, 0);
+    assert.strictEqual(result.type, "krylo-local");
+    assert.ok(result.text.includes("[LIVE DIAGNOSTIC READOUT]"));
+  });
+
+  await t.test("routePrompt falls back to Krylo companion when all providers fail", async () => {
+    globalThis.fetch = async (url, options) => {
+      fetchCalls.push({ url, options });
+      return {
+        ok: false,
+        status: 500,
+        statusText: "Service Unavailable",
+        text: async () => "Server Down",
+      };
+    };
+
+    const config = {
+      GROQ_API_KEY: "groq-bad",
+      OPENAI_API_KEY: "openai-bad",
+    };
+
+    const result = await routePrompt("Hello", "Sys prompt", config);
+    
+    assert.strictEqual(result.provider, "krylo-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"));
+  });
+});