@krishivpb60/aether-ai-cli 1.1.9 → 1.3.1

package/src/updater.js

@@ -0,0 +1,186 @@
+// ═══════════════════════════════════════════════════════════
+// AETHER AI CLI — Automated Update & Highlights Engine
+// Checks NPM registry, updates packages, and renders release details.
+// ═══════════════════════════════════════════════════════════
+
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import { getConfigValue, setConfigValue } from "./config.js";
+import { colors, label, separator } from "./ui/theme.js";
+import { createSpinner } from "./ui/spinner.js";
+
+const execAsync = promisify(exec);
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const pkg = JSON.parse(readFileSync(join(__dirname, "../package.json"), "utf8"));
+
+/**
+ * Returns true if version 'latest' is newer than version 'current'.
+ * Supports standard semver format x.y.z.
+ * @param {string} latest
+ * @param {string} current
+ * @returns {boolean}
+ */
+export function isNewerVersion(latest, current) {
+  const l = latest.split(".").map((num) => parseInt(num, 10) || 0);
+  const c = current.split(".").map((num) => parseInt(num, 10) || 0);
+  for (let i = 0; i < 3; i++) {
+    if (l[i] > c[i]) return true;
+    if (l[i] < c[i]) return false;
+  }
+  return false;
+}
+
+/**
+ * Fetches and displays release highlights from the remote repository.
+ * @param {string} version
+ */
+export async function showReleaseHighlights(version) {
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 2000);
+
+    const res = await fetch("https://raw.githubusercontent.com/Krylo-60/aether-ai-cli/main/HIGHLIGHTS.md", {
+      signal: controller.signal,
+    });
+    clearTimeout(timeoutId);
+
+    if (!res.ok) return;
+    const text = await res.text();
+
+    console.log("\n" + separator("━"));
+    console.log(colors.accent.bold(`  ★  AETHER AI CLI v${version} RELEASE HIGHLIGHTS  ★`));
+    console.log(separator("─"));
+
+    const lines = text.split("\n");
+    let inReleaseHeader = false;
+    let printedAny = false;
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("#")) {
+        // Matches the version header like "# Aether CLI v1.1.9 Highlights" or similar
+        if (trimmed.toLowerCase().includes(`v${version}`)) {
+          inReleaseHeader = true;
+        } else {
+          inReleaseHeader = false;
+        }
+        continue;
+      }
+
+      if (inReleaseHeader && trimmed) {
+        if (trimmed.startsWith("-") || trimmed.startsWith("*")) {
+          console.log(colors.brand("  " + trimmed));
+          printedAny = true;
+        } else {
+          console.log(colors.text("  " + trimmed));
+          printedAny = true;
+        }
+      }
+    }
+
+    if (!printedAny) {
+      // Fallback if no specific version section was found in HIGHLIGHTS.md
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("#")) continue;
+        if (trimmed.startsWith("-") || trimmed.startsWith("*")) {
+          console.log(colors.brand("  " + trimmed));
+        } else if (trimmed) {
+          console.log(colors.text("  " + trimmed));
+        }
+      }
+    }
+
+    console.log(separator("━") + "\n");
+  } catch {
+    // Fail silently (offline or repo down)
+  }
+}
+
+/**
+ * Checks for updates and runs the automatic updater if configured.
+ */
+export async function checkForUpdates() {
+  const autoUpdate = (await getConfigValue("AUTO_UPDATE")) !== "false";
+  const showHighlights = (await getConfigValue("SHOW_HIGHLIGHTS")) !== "false";
+  const lastCheck = parseInt(await getConfigValue("LAST_UPDATE_CHECK") || "0", 10);
+  const now = Date.now();
+  const currentVersion = pkg.version;
+
+  // Run update check at most once every 24 hours (86,400,000 ms)
+  const checkInterval = 24 * 60 * 60 * 1000;
+  if (now - lastCheck < checkInterval) {
+    // Show highlights if we just updated and haven't shown highlights for this version
+    const lastNotified = await getConfigValue("LAST_NOTIFIED_VERSION") || "";
+    if (showHighlights && lastNotified !== currentVersion) {
+      await showReleaseHighlights(currentVersion);
+      await setConfigValue("LAST_NOTIFIED_VERSION", currentVersion);
+    }
+    return;
+  }
+
+  // Update check timestamp immediately
+  await setConfigValue("LAST_UPDATE_CHECK", now.toString());
+
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 2000);
+
+    const res = await fetch("https://registry.npmjs.org/@krishivpb60/aether-ai-cli/latest", {
+      signal: controller.signal,
+    });
+    clearTimeout(timeoutId);
+
+    if (!res.ok) return;
+    const data = await res.json();
+    const latestVersion = data.version;
+
+    if (isNewerVersion(latestVersion, currentVersion)) {
+      if (autoUpdate) {
+        console.log("\n" + label.system + " " + colors.brand(`⚡ New version detected! Auto-updating from v${currentVersion} to v${latestVersion}...`));
+
+        const isPip = process.env.AETHER_PACKAGER === "pip";
+        const updateCmd = isPip
+          ? "pip install --upgrade aether-ai-agent-cli"
+          : "npm install -g @krishivpb60/aether-ai-cli";
+
+        try {
+          const spinner = createSpinner("Installing update").start();
+          await execAsync(updateCmd);
+          spinner.succeed("Update complete!");
+
+          console.log(label.system + " " + colors.success(`✓ Successfully updated to v${latestVersion}.`));
+
+          if (showHighlights) {
+            await showReleaseHighlights(latestVersion);
+          }
+          await setConfigValue("LAST_NOTIFIED_VERSION", latestVersion);
+        } catch (err) {
+          console.log(label.system + " " + colors.warning(`⚠ Auto-update failed: ${err.message}`));
+          console.log(label.system + " " + colors.muted(`Please run manually: ${updateCmd}`));
+        }
+      } else {
+        console.log("\n" + label.system + " " + colors.warning(`⚡ A new version (v${latestVersion}) is available!`));
+        const isPip = process.env.AETHER_PACKAGER === "pip";
+        const updateCmd = isPip
+          ? "pip install -U aether-ai-agent-cli"
+          : "npm install -g @krishivpb60/aether-ai-cli";
+        console.log(label.system + " " + colors.muted(`To update, run: ${updateCmd}`));
+      }
+    } else {
+      // Already on latest version, check if we need to show highlights
+      const lastNotified = await getConfigValue("LAST_NOTIFIED_VERSION") || "";
+      if (showHighlights && lastNotified !== currentVersion) {
+        await showReleaseHighlights(currentVersion);
+        await setConfigValue("LAST_NOTIFIED_VERSION", currentVersion);
+      }
+    }
+  } catch {
+    // Fail silently (offline or registry down)
+  }
+}

package/test/tokens.test.js

@@ -0,0 +1,89 @@
+import { test } from "node:test";
+import assert from "node:assert";
+import {
+  estimateTokens,
+  getSessionTokenStats,
+  resetSessionTokenStats,
+  recordTokenUsage,
+  getBreakdownByModel
+} from "../src/ai/tokens.js";
+
+test("Token Estimation & Usage Telemetry Suite", async (t) => {
+  await t.test("estimateTokens uses standard character heuristics", () => {
+    assert.strictEqual(estimateTokens(""), 0);
+    assert.strictEqual(estimateTokens(null), 0);
+    // 8 characters should be 2 tokens (8 / 4)
+    assert.strictEqual(estimateTokens("12345678"), 2);
+    // 9 characters should be 3 tokens (Math.ceil(9 / 4))
+    assert.strictEqual(estimateTokens("123456789"), 3);
+  });
+
+  await t.test("recordTokenUsage updates session stats and breakdowns", () => {
+    resetSessionTokenStats();
+
+    // 1. Initial State
+    let stats = getSessionTokenStats();
+    assert.strictEqual(stats.prompt, 0);
+    assert.strictEqual(stats.completion, 0);
+    assert.strictEqual(stats.total, 0);
+    assert.strictEqual(stats.exchanges, 0);
+
+    // 2. Record first usage
+    const result1 = recordTokenUsage("gpt-4o", 100, 50);
+    assert.deepStrictEqual(result1, { promptTokens: 100, completionTokens: 50, totalTokens: 150 });
+
+    stats = getSessionTokenStats();
+    assert.strictEqual(stats.prompt, 100);
+    assert.strictEqual(stats.completion, 50);
+    assert.strictEqual(stats.total, 150);
+    assert.strictEqual(stats.exchanges, 1);
+
+    let breakdown = getBreakdownByModel();
+    assert.ok(breakdown["gpt-4o"]);
+    assert.strictEqual(breakdown["gpt-4o"].prompt, 100);
+    assert.strictEqual(breakdown["gpt-4o"].completion, 50);
+    assert.strictEqual(breakdown["gpt-4o"].total, 150);
+    assert.strictEqual(breakdown["gpt-4o"].exchanges, 1);
+
+    // 3. Record second usage for same model
+    recordTokenUsage("gpt-4o", 200, 100);
+    stats = getSessionTokenStats();
+    assert.strictEqual(stats.prompt, 300);
+    assert.strictEqual(stats.completion, 150);
+    assert.strictEqual(stats.total, 450);
+    assert.strictEqual(stats.exchanges, 2);
+
+    breakdown = getBreakdownByModel();
+    assert.strictEqual(breakdown["gpt-4o"].prompt, 300);
+    assert.strictEqual(breakdown["gpt-4o"].completion, 150);
+    assert.strictEqual(breakdown["gpt-4o"].total, 450);
+    assert.strictEqual(breakdown["gpt-4o"].exchanges, 2);
+
+    // 4. Record usage for another model
+    recordTokenUsage("gemini-2.5-flash", 50, 25);
+    stats = getSessionTokenStats();
+    assert.strictEqual(stats.prompt, 350);
+    assert.strictEqual(stats.completion, 175);
+    assert.strictEqual(stats.total, 525);
+    assert.strictEqual(stats.exchanges, 3);
+
+    breakdown = getBreakdownByModel();
+    assert.ok(breakdown["gemini-2.5-flash"]);
+    assert.strictEqual(breakdown["gemini-2.5-flash"].prompt, 50);
+    assert.strictEqual(breakdown["gemini-2.5-flash"].completion, 25);
+    assert.strictEqual(breakdown["gemini-2.5-flash"].total, 75);
+    assert.strictEqual(breakdown["gemini-2.5-flash"].exchanges, 1);
+  });
+
+  await t.test("resetSessionTokenStats clears stats and breakdowns", () => {
+    resetSessionTokenStats();
+    const stats = getSessionTokenStats();
+    assert.strictEqual(stats.prompt, 0);
+    assert.strictEqual(stats.completion, 0);
+    assert.strictEqual(stats.total, 0);
+    assert.strictEqual(stats.exchanges, 0);
+
+    const breakdown = getBreakdownByModel();
+    assert.strictEqual(Object.keys(breakdown).length, 0);
+  });
+});

package/test/updater.test.js

@@ -0,0 +1,90 @@
+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";
+import { readFileSync } from "node:fs";
+
+const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+
+// Redirect homedir before importing config and updater to point to a temporary test folder
+const tempHome = join(process.cwd(), "temp-test-home-updater");
+process.env.USERPROFILE = tempHome;
+process.env.HOME = tempHome;
+
+const { resetConfig, setConfigValue, getConfigValue } = await import("../src/config.js");
+const { isNewerVersion, checkForUpdates, showReleaseHighlights } = await import("../src/updater.js");
+
+const originalFetch = globalThis.fetch;
+
+test("Auto-Updater & Highlights Suite", async (t) => {
+  let fetchCalls = [];
+
+  before(async () => {
+    await mkdir(tempHome, { recursive: true });
+  });
+
+  after(async () => {
+    await rm(tempHome, { recursive: true, force: true });
+  });
+
+  beforeEach(async () => {
+    fetchCalls = [];
+    await resetConfig();
+  });
+
+  afterEach(async () => {
+    globalThis.fetch = originalFetch;
+    await resetConfig();
+  });
+
+  await t.test("isNewerVersion compares semver versions correctly", () => {
+    assert.strictEqual(isNewerVersion("1.1.9", "1.1.8"), true);
+    assert.strictEqual(isNewerVersion("1.2.0", "1.1.9"), true);
+    assert.strictEqual(isNewerVersion("2.0.0", "1.9.9"), true);
+    assert.strictEqual(isNewerVersion("1.1.9", "1.1.9"), false);
+    assert.strictEqual(isNewerVersion("1.1.8", "1.1.9"), false);
+    assert.strictEqual(isNewerVersion("1.0.0", "2.0.0"), false);
+  });
+
+  await t.test("checkForUpdates respects 24h throttling", async () => {
+    const now = Date.now();
+    // Set last check to 1 hour ago
+    await setConfigValue("LAST_UPDATE_CHECK", (now - 60 * 60 * 1000).toString());
+    // Set last notified version to current version so highlights are not triggered
+    await setConfigValue("LAST_NOTIFIED_VERSION", pkg.version);
+
+    let fetchCalled = false;
+    globalThis.fetch = async () => {
+      fetchCalled = true;
+      return { ok: false };
+    };
+
+    await checkForUpdates();
+    // Should NOT call fetch because it hasn't been 24 hours
+    assert.strictEqual(fetchCalled, false);
+  });
+
+  await t.test("checkForUpdates triggers check if 24h passed", async () => {
+    const now = Date.now();
+    // Set last check to 25 hours ago
+    await setConfigValue("LAST_UPDATE_CHECK", (now - 25 * 60 * 60 * 1000).toString());
+
+    let fetchCalled = false;
+    globalThis.fetch = async (url) => {
+      fetchCalled = true;
+      assert.ok(url.includes("registry.npmjs.org"));
+      return {
+        ok: true,
+        json: async () => ({ version: "1.1.9" })
+      };
+    };
+
+    await checkForUpdates();
+    assert.strictEqual(fetchCalled, true);
+    
+    // Check that LAST_UPDATE_CHECK was updated to a recent timestamp
+    const updatedCheck = parseInt(await getConfigValue("LAST_UPDATE_CHECK") || "0", 10);
+    assert.ok(updatedCheck > now - 10000);
+  });
+});

package/test/ux.test.js

@@ -128,23 +128,27 @@ test("Cyberpunk UX and Streaming Suite", async (t) => {
     setTheme("cyberpunk");
   });
 
-  await t.test("Reasoning modes should be loaded correctly including codex and cloude-code", () => {
+  await t.test("Reasoning modes should be loaded correctly including codex and cloude-code redirection", () => {
     const synthesis = getModeByName("synthesis");
     assert.strictEqual(synthesis.name, "synthesis");
 
+    const titan = getModeByName("titan");
+    assert.strictEqual(titan.name, "titan");
+    assert.ok(titan.systemPrompt.includes("fuses the absolute best capabilities of OpenAI Codex"));
+    assert.ok(titan.systemPrompt.includes("Claude Code"));
+
+    // Deprecated codex and cloude-code modes should redirect to titan
     const codex = getModeByName("codex");
-    assert.strictEqual(codex.name, "codex");
-    assert.ok(codex.systemPrompt.includes("OpenAI Codex mode"));
+    assert.strictEqual(codex.name, "titan");
 
     const cloudeCode = getModeByName("cloude-code");
-    assert.strictEqual(cloudeCode.name, "cloude-code");
-    assert.ok(cloudeCode.systemPrompt.includes("Claude Code mode"));
+    assert.strictEqual(cloudeCode.name, "titan");
 
     const claudeCode = getModeByName("claude-code");
-    assert.strictEqual(claudeCode.name, "cloude-code");
+    assert.strictEqual(claudeCode.name, "titan");
 
     const caseCheck = getModeByName("  CoDeX  ");
-    assert.strictEqual(caseCheck.name, "codex");
+    assert.strictEqual(caseCheck.name, "titan");
 
     const unknown = getModeByName("nonexistent-mode");
     assert.strictEqual(unknown, null);