@krishivpb60/aether-ai-cli 1.3.3 → 1.3.5

package/test/autopilot-debug.test.js

@@ -0,0 +1,91 @@
+import { test, before, after } from "node:test";
+import assert from "node:assert";
+import { join } from "node:path";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+
+const tempHome = join(process.cwd(), "temp-test-home-autopilot");
+process.env.USERPROFILE = tempHome;
+process.env.HOME = tempHome;
+process.env.NODE_ENV = "test";
+
+const originalFetch = globalThis.fetch;
+const { handleAutopilotDebug } = await import("../src/chat.js");
+
+test("Autopilot Self-Correcting Debug Suite", async (t) => {
+  before(() => {
+    mkdirSync(tempHome, { recursive: true });
+  });
+
+  after(() => {
+    rmSync(tempHome, { recursive: true, force: true });
+    globalThis.fetch = originalFetch;
+  });
+
+  await t.test("handleAutopilotDebug stops immediately if test command passes", async () => {
+    const ctx = {
+      aiConfig: { DIAGNOSE_CMD: "node -e \"process.exit(0)\"" },
+      rl: { pause: () => {}, resume: () => {} },
+      history: [],
+      currentMode: { name: "titan" }
+    };
+    
+    let logged = [];
+    const origLog = console.log;
+    console.log = (m) => logged.push(m);
+    
+    try {
+      await handleAutopilotDebug("node -e \"process.exit(0)\"", ctx);
+      
+      const hasSuccess = logged.some(l => l && l.includes("passed successfully"));
+      assert.ok(hasSuccess);
+    } finally {
+      console.log = origLog;
+    }
+  });
+
+  await t.test("handleAutopilotDebug enters loop, applies write fix, and passes", async () => {
+    // We will run a command that checks for the existence of a file we write.
+    // If the file exists, it passes; if not, it fails.
+    const checkFile = join(tempHome, "fix.txt");
+    const testCmd = `node -e "const fs = require('fs'); if (fs.existsSync('${checkFile.replace(/\\/g, '\\\\')}')) { process.exit(0); } else { process.exit(1); }"`;
+
+    // Mock fetch to simulate AI response writing the file
+    globalThis.fetch = async (url, options) => {
+      // Simulate writing fix.txt using write block
+      return {
+        ok: true,
+        json: async () => ({
+          choices: [{
+            message: {
+              content: `Let me fix this by writing the missing file.\n[WRITE_FILE: ${checkFile}]\nfixed content\n[END_WRITE]`
+            }
+          }]
+        })
+      };
+    };
+
+    const ctx = {
+      aiConfig: {
+        GROQ_API_KEY: "mock-key",
+        AUTOPILOT: "machine"
+      },
+      rl: { pause: () => {}, resume: () => {} },
+      history: [],
+      currentMode: { name: "titan" }
+    };
+
+    let logged = [];
+    const origLog = console.log;
+    console.log = (m) => logged.push(m);
+
+    try {
+      await handleAutopilotDebug(testCmd, ctx);
+      
+      // The test command should succeed on the second attempt
+      const hasCorrectedSuccess = logged.some(l => l && l.includes("Diagnostics passed successfully"));
+      assert.ok(hasCorrectedSuccess);
+    } finally {
+      console.log = origLog;
+    }
+  });
+});

package/test/git-tui.test.js

@@ -0,0 +1,94 @@
+import { test, before, after } from "node:test";
+import assert from "node:assert";
+import { tmpdir } from "node:os";
+
+// Stub only setRawMode globally for handleGitTUI to prevent crashes in non-TTY environments
+const origSetRawMode = process.stdin.setRawMode;
+process.stdin.setRawMode = () => {};
+
+const originalCwd = process.cwd();
+const nonGitDir = tmpdir();
+
+// We import handleGitTUI
+const { handleGitTUI } = await import("../src/chat.js");
+
+test("Git TUI Suite", async (t) => {
+  after(() => {
+    // Restore Cwd and stdin setRawMode stub
+    process.chdir(originalCwd);
+    process.stdin.setRawMode = origSetRawMode;
+    if (typeof process.stdin.unref === "function") {
+      process.stdin.unref();
+    }
+  });
+
+  await t.test("handleGitTUI fails gracefully outside git repository", async () => {
+    let logged = [];
+    const origLog = console.log;
+    console.log = (m) => logged.push(m);
+
+    // Force git commands to fail by pointing GIT_DIR to a non-existent directory
+    const oldGitDir = process.env.GIT_DIR;
+    process.env.GIT_DIR = "C:\\non_existent_directory_xxx";
+
+    try {
+      await handleGitTUI({});
+      const hasErrorMsg = logged.some(l => l && l.includes("Not a git repository"));
+      assert.ok(hasErrorMsg);
+    } catch (err) {
+      console.error("SUBTEST 1 ERROR:", err);
+      throw err;
+    } finally {
+      console.log = origLog;
+      if (oldGitDir === undefined) {
+        delete process.env.GIT_DIR;
+      } else {
+        process.env.GIT_DIR = oldGitDir;
+      }
+    }
+  });
+
+  await t.test("handleGitTUI renders commit graph and parsed files status correctly", async () => {
+    let logged = [];
+    const origLog = console.log;
+    console.log = (m) => logged.push(m);
+
+    const origWrite = process.stdout.write;
+    let written = [];
+    process.stdout.write = (chunk) => {
+      written.push(chunk);
+      return true;
+    };
+
+    const ctx = {
+      rl: { pause: () => {}, resume: () => {} }
+    };
+
+    try {
+      const initialCount = process.stdin.listeners("data").length;
+      const p = handleGitTUI(ctx);
+
+      // Poll until handleGitTUI registers its data listener on stdin (increases listener count)
+      while (process.stdin.listeners("data").length <= initialCount) {
+        await new Promise(resolve => setTimeout(resolve, 10));
+      }
+
+      // Trigger ESC/Q keypress on stdin to quit the TUI loop immediately
+      process.stdin.emit("data", "q");
+
+      await p;
+
+      const fullOutput = written.join("");
+      assert.ok(fullOutput.includes("🌿 AETHER INTERACTIVE GIT TUI"));
+      assert.ok(fullOutput.includes("Commit Graph & History:"));
+      assert.ok(fullOutput.includes("Modified Files:"));
+      assert.ok(fullOutput.includes("Hotkeys:"));
+    } catch (err) {
+      console.error("SUBTEST 2 ERROR:", err);
+      throw err;
+    } finally {
+      console.log = origLog;
+      process.stdout.write = origWrite;
+    }
+  });
+});

package/test/search.test.js

@@ -0,0 +1,52 @@
+import { test, before, after } from "node:test";
+import assert from "node:assert";
+import { mkdir, writeFile, rm } from "node:fs/promises";
+import { join, relative } from "node:path";
+import { workspaceSearch, crawlDirectory } from "../src/ai/search.js";
+
+const testDir = join(process.cwd(), "temp-test-home-search");
+
+test("Workspace Search Engine Suite", async (t) => {
+  before(async () => {
+    await mkdir(testDir, { recursive: true });
+    // Write test files
+    await writeFile(join(testDir, "file1.txt"), "hello world\nthis is a search test\nbye");
+    await writeFile(join(testDir, "file2.js"), "function test() {\n  console.log('hello search');\n}");
+    await writeFile(join(testDir, "file3.png"), "binary data matches nothing");
+    
+    const subDir = join(testDir, "subdir");
+    await mkdir(subDir, { recursive: true });
+    await writeFile(join(subDir, "file4.txt"), "nested matches here under search term");
+  });
+
+  after(async () => {
+    await rm(testDir, { recursive: true, force: true });
+  });
+
+  await t.test("crawlDirectory finds all text files and excludes binaries/ignored folders", () => {
+    const files = crawlDirectory(testDir, testDir);
+    const relativePaths = files.map((f) => relative(testDir, f).replace(/\\/g, "/"));
+    
+    assert.ok(relativePaths.includes("file1.txt"));
+    assert.ok(relativePaths.includes("file2.js"));
+    assert.ok(relativePaths.includes("subdir/file4.txt"));
+    // Should exclude png
+    assert.strictEqual(relativePaths.includes("file3.png"), false);
+  });
+
+  await t.test("workspaceSearch returns matching files, lines, and content", () => {
+    const results = workspaceSearch("search", testDir);
+    // Should match in file1.txt, file2.js, and subdir/file4.txt
+    assert.strictEqual(results.length, 3);
+    
+    const file1Match = results.find((r) => r.relativePath.replace(/\\/g, "/") === "file1.txt");
+    assert.ok(file1Match);
+    assert.strictEqual(file1Match.lineNumber, 2);
+    assert.strictEqual(file1Match.lineContent, "this is a search test");
+
+    const jsMatch = results.find((r) => r.relativePath.replace(/\\/g, "/") === "file2.js");
+    assert.ok(jsMatch);
+    assert.strictEqual(jsMatch.lineNumber, 2);
+    assert.strictEqual(jsMatch.lineContent, "console.log('hello search');");
+  });
+});

package/test/telemetry.test.js

@@ -0,0 +1,104 @@
+import { test, before, after } from "node:test";
+import assert from "node:assert";
+import { join } from "node:path";
+import { mkdir, rm } from "node:fs/promises";
+
+// Redirect homedir for testing
+const tempHome = join(process.cwd(), "temp-test-home-telemetry");
+process.env.USERPROFILE = tempHome;
+process.env.HOME = tempHome;
+process.env.NODE_ENV = "test";
+
+const { recordLatency, getLatencyLogs, clearTelemetryLogs, getTelemetryData } = await import("../src/ai/telemetry.js");
+const { startTelemetryServer } = await import("../src/telemetry-server.js");
+
+test("Visual Telemetry and Dashboard Suite", async (t) => {
+  before(async () => {
+    await mkdir(tempHome, { recursive: true });
+  });
+
+  after(async () => {
+    await rm(tempHome, { recursive: true, force: true });
+  });
+
+  await t.test("recordLatency saves metrics to memory and disk, getLatencyLogs returns them", () => {
+    clearTelemetryLogs();
+    
+    assert.strictEqual(getLatencyLogs().length, 0);
+
+    recordLatency("openai", "gpt-4o", 150, 20, 15, true);
+    recordLatency("google", "gemini-1.5", 300, 30, 25, false);
+
+    const logs = getLatencyLogs();
+    assert.strictEqual(logs.length, 2);
+    
+    assert.strictEqual(logs[0].provider, "openai");
+    assert.strictEqual(logs[0].model, "gpt-4o");
+    assert.strictEqual(logs[0].latencyMs, 150);
+    assert.strictEqual(logs[0].promptTokens, 20);
+    assert.strictEqual(logs[0].completionTokens, 15);
+    assert.strictEqual(logs[0].success, true);
+
+    assert.strictEqual(logs[1].provider, "google");
+    assert.strictEqual(logs[1].success, false);
+  });
+
+  await t.test("clearTelemetryLogs clears all saved logs", () => {
+    assert.ok(getLatencyLogs().length > 0);
+    clearTelemetryLogs();
+    assert.strictEqual(getLatencyLogs().length, 0);
+  });
+
+  await t.test("getTelemetryData returns structured data for visual HUD", () => {
+    clearTelemetryLogs();
+    recordLatency("groq", "llama-3", 100, 10, 5, true);
+    
+    const data = getTelemetryData({ GROQ_API_KEY: "fake-key" });
+    
+    assert.ok(data.tokenStats);
+    assert.ok(data.modelBreakdown);
+    assert.strictEqual(data.latencyLogs.length, 1);
+    assert.strictEqual(data.latencyLogs[0].provider, "groq");
+
+    // Mesh structure verification
+    assert.ok(Array.isArray(data.meshStructure));
+    const groqItem = data.meshStructure.find(m => m.id === "groq");
+    assert.ok(groqItem);
+    assert.strictEqual(groqItem.configured, true);
+  });
+
+  await t.test("startTelemetryServer serves HTTP endpoints correctly", async () => {
+    const { server, port } = await startTelemetryServer(5500);
+    const baseUrl = `http://localhost:${port}`;
+
+    try {
+      // 1. Fetch dashboard HTML
+      const htmlRes = await fetch(`${baseUrl}/`);
+      assert.strictEqual(htmlRes.status, 200);
+      const htmlText = await htmlRes.text();
+      assert.ok(htmlText.includes("Telemetry HUD"));
+
+      // 2. Fetch telemetry JSON API
+      const apiRes = await fetch(`${baseUrl}/api/telemetry`);
+      assert.strictEqual(apiRes.status, 200);
+      const apiData = await apiRes.json();
+      assert.ok(apiData.latencyLogs);
+      assert.ok(apiData.meshStructure);
+
+      // 3. POST clear logs API
+      const clearRes = await fetch(`${baseUrl}/api/clear`, { method: "POST" });
+      assert.strictEqual(clearRes.status, 200);
+      const clearData = await clearRes.json();
+      assert.strictEqual(clearData.success, true);
+      assert.strictEqual(getLatencyLogs().length, 0);
+
+      // 4. POST shutdown server API
+      const shutdownRes = await fetch(`${baseUrl}/api/shutdown`, { method: "POST" });
+      assert.strictEqual(shutdownRes.status, 200);
+      const shutdownData = await shutdownRes.json();
+      assert.strictEqual(shutdownData.success, true);
+    } finally {
+      server.close();
+    }
+  });
+});