@krishivpb60/aether-ai-cli 1.3.2 → 1.3.4

package/HIGHLIGHTS.md

@@ -1,3 +1,19 @@
+# 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.
+  - `/diagnose [cmd]`: Run tests/builds and automatically debug any errors.
+  - `/explain <file>`: Explains design flow and patterns in code.
+  - `/refactor <file>`: Rewrites a target file to optimize it.
+  - `/bug <file>`: Scans a file to detect logical edge case failures.
+  - `/doc <file>`: Automatically writes documentation, inline comments, or JSDoc.
+  - `/translate <file> <lang>`: AI-translates file code into another target language.
+
 # Aether CLI v1.3.2 Highlights
 - **Manual Updater `/update`**: Added a new slash command `/update` to manually check the registry and force-upgrade Aether CLI to the latest version immediately, bypassing the 24-hour cache throttle.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@krishivpb60/aether-ai-cli",
-  "version": "1.3.2",
+  "version": "1.3.4",
   "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,72 @@
+// ═══════════════════════════════════════════════════════════
+// AETHER AI CLI — Telemetry & Latency Logger
+// Logs request latencies, prompt speeds, and meshes provider logs.
+// ═══════════════════════════════════════════════════════════
+
+import { getSessionTokenStats, getBreakdownByModel } from "./tokens.js";
+import { getActiveProviders, PROVIDERS } from "./providers.js";
+import { listSessions } from "../config.js";
+
+const latencyLogs = [];
+
+/**
+ * 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 50 entries
+  if (latencyLogs.length > 50) {
+    latencyLogs.shift();
+  }
+}
+
+/**
+ * Returns raw latency records.
+ * @returns {Array}
+ */
+export function getLatencyLogs() {
+  return latencyLogs;
+}
+
+/**
+ * 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(),
+  };
+}

package/src/chat.js

@@ -47,6 +47,7 @@ import { runMainframeHack } from "./ai/fallback.js";
 import { AGENT_INSTRUCTIONS } from "./agent.js";
 import { checkForUpdates } from "./updater.js";
 import { getSessionTokenStats, getBreakdownByModel, resetSessionTokenStats } from "./ai/tokens.js";
+import { getGitDiff } from "./git.js";
 
 
 
@@ -136,7 +137,9 @@ export async function startChat(options = {}) {
       "/help", "/mode", "/modes", "/attach", "/files", "/clear",
       "/providers", "/export", "/status", "/copy", "/exit", "/quit",
       "/theme", "/themes", "/history-clear", "/game", "/abort", "/cmd", "/write",
-      "/commit", "/run", "/history", "/autopilot", "/tokens", "/update"
+      "/commit", "/run", "/history", "/autopilot", "/tokens", "/update",
+      "/review", "/diagnose", "/explain", "/refactor", "/bug", "/doc", "/translate",
+      "/search"
     ];
     const customCmds = aiConfig.CUSTOM_COMMANDS || {};
     const commands = [...builtIn, ...Object.keys(customCmds)];
@@ -424,7 +427,8 @@ export async function startChat(options = {}) {
         "/providers", "/export", "/status", "/copy", "/exit", "/quit",
         "/theme", "/themes", "/history-clear", "/game", "/abort", "/cmd",
         "/guess", "/write", "/commit", "/run", "/history", "/autopilot", "/tokens",
-        "/update"
+        "/update", "/review", "/diagnose", "/explain", "/refactor", "/bug", "/doc",
+        "/translate", "/search"
       ];
       
       const customCmds = aiConfig.CUSTOM_COMMANDS || {};
@@ -521,6 +525,26 @@ async function handleCommand(input, ctx) {
       console.log("");
       break;
 
+    case "/review":
+      await handleReviewCommand(ctx);
+      break;
+
+    case "/diagnose":
+      await handleDiagnoseCommand(args, ctx);
+      break;
+
+    case "/explain":
+    case "/refactor":
+    case "/bug":
+    case "/doc":
+    case "/translate":
+      await handleFileAICommand(cmd, args, ctx);
+      break;
+
+    case "/search":
+      await handleSearchCommand(args, ctx);
+      break;
+
     case "/theme":
       await handleThemeSwitch(args);
       break;
@@ -620,6 +644,14 @@ function showHelp(aiConfig) {
   console.log(keyValue("/write <filename>", "Extract last code block and save to file"));
   console.log(keyValue("/commit", "Generate conventional commit message and commit changes"));
   console.log(keyValue("/run <command>", "Execute a shell command interactively"));
+  console.log(keyValue("/review", "Run git diff and stream an AI code review"));
+  console.log(keyValue("/diagnose [cmd]", "Run build/tests and AI-debug any errors"));
+  console.log(keyValue("/explain <file>", "AI-explain the design and logic of a file"));
+  console.log(keyValue("/refactor <file>", "AI-refactor the code of a target file"));
+  console.log(keyValue("/bug <file>", "AI-audit a file to find potential logic bugs"));
+  console.log(keyValue("/doc <file>", "AI-generate documentation/docstrings for a file"));
+  console.log(keyValue("/translate <file> <lang>", "AI-translate code of a file to another language"));
+  console.log(keyValue("/search <query>", "Find matches in code files (use --ai for semantic search)"));
   console.log(keyValue("/exit", "End session"));
 
   if (aiConfig && aiConfig.CUSTOM_COMMANDS) {
@@ -1402,3 +1434,259 @@ async function handleTokensDisplay(ctx) {
   console.log("  " + colors.accent("Total Tokens:") + colors.text(`    Prompt: ${stats.prompt.toLocaleString()} | Completion: ${stats.completion.toLocaleString()} | Sum: `) + colors.brand.bold(stats.total.toLocaleString()));
   console.log(separator("━") + "\n");
 }
+
+/**
+ * Streams an AI query prompt and prints telemetry details at the end.
+ */
+async function executeAISpecialCommand(prompt, specialLabel, ctx) {
+  const systemPrompt = ctx.currentMode.systemPrompt + "\n" + AGENT_INSTRUCTIONS;
+  let hasStarted = false;
+  let responseText = "";
+  const queryStartTime = Date.now();
+  let firstTokenTime = 0;
+
+  const onToken = (token) => {
+    if (!hasStarted) {
+      hasStarted = true;
+      firstTokenTime = Date.now();
+      process.stdout.write("\n" + label.aether + " " + colors.accent(specialLabel) + "\n" + separator("─") + "\n\n");
+    }
+    process.stdout.write(colors.success(token));
+    responseText += token;
+  };
+
+  const result = await routePrompt(prompt, systemPrompt, ctx.aiConfig, onToken);
+  console.log("\n");
+
+  const elapsedSec = ((Date.now() - queryStartTime) / 1000).toFixed(1);
+  let speedText = "";
+  if (firstTokenTime > 0) {
+    const streamElapsed = (Date.now() - firstTokenTime) / 1000;
+    if (streamElapsed > 0.05) {
+      const estimatedTokens = Math.max(1, Math.round(responseText.length / 4));
+      const tps = (estimatedTokens / streamElapsed).toFixed(1);
+      speedText = ` • ${tps} tok/s`;
+    }
+  }
+
+  const showTokens = ctx.aiConfig.SHOW_TOKENS !== "false";
+  let tokensText = "";
+  if (showTokens && result.usage) {
+    const { promptTokens, completionTokens } = result.usage;
+    tokensText = ` • ${promptTokens.toLocaleString()} in / ${completionTokens.toLocaleString()} out tokens`;
+  }
+
+  console.log(separator("─"));
+  console.log(
+    "  " + colors.dim(`Node ${result.node} • ${result.provider}`) +
+    (result.model ? colors.dim(` • ${result.model}`) : "") +
+    colors.dim(` • ${elapsedSec}s${speedText}`) +
+    colors.dim(tokensText)
+  );
+  console.log("");
+}
+
+/**
+ * Handler for the /review command (git diff analysis).
+ */
+async function handleReviewCommand(ctx) {
+  console.log("\n" + label.system + " " + colors.muted("Running git diff to fetch repository changes..."));
+  try {
+    const { diff, isStaged } = await getGitDiff();
+    if (!diff) {
+      console.log(label.system + " " + colors.success("✓ No changes detected in the repository to review.\n"));
+      return;
+    }
+
+    const specialLabel = `Reviewing ${isStaged ? "staged" : "unstaged"} changes...`;
+    const prompt = `Review the following git diff. Identify potential bugs, logical issues, security concerns, performance problems, and recommend optimization or code cleanup. Keep it concise, practical, and highly technical:\n\n\`\`\`diff\n${diff}\n\`\`\``;
+
+    await executeAISpecialCommand(prompt, specialLabel, ctx);
+  } catch (err) {
+    console.log(label.system + " " + colors.danger(`Error: ${err.message}\n`));
+  }
+}
+
+/**
+ * Handler for the /diagnose command (build & test diagnostics execution).
+ */
+async function handleDiagnoseCommand(args, ctx) {
+  const defaultCmd = ctx.aiConfig.DIAGNOSE_CMD || "npm test";
+  const cmdToRun = args.join(" ").trim() || defaultCmd;
+
+  console.log("\n" + label.system + " " + colors.muted(`Running diagnostics command: "${cmdToRun}"...`));
+  
+  const spinner = createSpinner("Executing diagnostics").start();
+  try {
+    const { exec } = await import("node:child_process");
+    const { promisify } = await import("node:util");
+    const execAsync = promisify(exec);
+    await execAsync(cmdToRun);
+    spinner.succeed("Diagnostics complete!");
+    console.log("\n" + label.system + " " + colors.success("✓ Diagnostics clean! Build and tests passed successfully.\n"));
+  } catch (err) {
+    spinner.fail("Diagnostics failed!");
+    
+    const output = (err.stdout || "") + "\n" + (err.stderr || "");
+    console.log("\n" + label.system + " " + colors.warning(`Diagnostics returned exit code ${err.code}.`));
+    console.log(colors.muted("Analyzing compiler/test output logs...\n"));
+
+    const prompt = `The diagnostics command "${cmdToRun}" failed with exit code ${err.code}. Analyze the following stdout and stderr logs to determine the root cause, identify the files/lines causing the failure, and provide a step-by-step resolution and debugging plan:\n\n\`\`\`\n${output.slice(0, 15000)}\n\`\`\``;
+
+    await executeAISpecialCommand(prompt, "Analyzing diagnostics logs...", ctx);
+  }
+}
+
+/**
+ * Handler for file analysis commands: /explain, /refactor, /bug, /doc, /translate.
+ */
+async function handleFileAICommand(cmdName, args, ctx) {
+  const filePath = args[0];
+  if (!filePath) {
+    console.log("\n" + label.system + " " + colors.warning(`Usage: ${cmdName} <file_path>\n`));
+    return;
+  }
+
+  // Resolve path
+  const resolvedPath = resolve(process.cwd(), filePath);
+  
+  // Verify path is inside the workspace
+  const { isInsideWorkspace } = await import("./agent.js");
+  if (!isInsideWorkspace(resolvedPath)) {
+    console.log("\n" + label.system + " " + colors.danger("Error: Path is outside the current workspace sandbox.\n"));
+    return;
+  }
+
+  if (!existsSync(resolvedPath)) {
+    console.log("\n" + label.system + " " + colors.danger(`Error: File does not exist at "${filePath}"\n`));
+    return;
+  }
+
+  const stat = statSync(resolvedPath);
+  if (stat.isDirectory()) {
+    console.log("\n" + label.system + " " + colors.danger(`Error: "${filePath}" is a directory. File path required.\n`));
+    return;
+  }
+
+  if (stat.size > 150 * 1024) { // 150KB limit
+    console.log("\n" + label.system + " " + colors.warning(`Warning: File "${filePath}" is too large (${Math.round(stat.size / 1024)}KB). Limits are 150KB to protect context limit.\n`));
+    return;
+  }
+
+  // Read file content
+  let content;
+  try {
+    const { parseFile } = await import("./file-parser.js");
+    const parsed = await parseFile(resolvedPath);
+    content = parsed.content;
+  } catch (err) {
+    console.log("\n" + label.system + " " + colors.danger(`Error parsing file: ${err.message}\n`));
+    return;
+  }
+
+  let prompt = "";
+  let labelText = "";
+
+  switch (cmdName.toLowerCase()) {
+    case "/explain":
+      labelText = `Explaining ${filePath}...`;
+      prompt = `Explain the architecture, design patterns, logic flow, and purpose of the following code. Be clear, technical, and structured:\n\n\`\`\`\n${content}\n\`\`\``;
+      break;
+    case "/refactor":
+      labelText = `Refactoring ${filePath}...`;
+      prompt = `Suggest refactoring improvements for the following code. Focus on clean code design principles, optimization, readability, reducing complexity, and fixing potential logic bugs. Return both the refactored code block and explanations:\n\n\`\`\`\n${content}\n\`\`\``;
+      break;
+    case "/bug":
+      labelText = `Auditing bugs in ${filePath}...`;
+      prompt = `Perform a thorough static analysis and code review of the following code. Identify potential logical bugs, race conditions, edge case failures, performance bottlenecks, and security hazards. Suggest fixes:\n\n\`\`\`\n${content}\n\`\`\``;
+      break;
+    case "/doc":
+      labelText = `Generating documentation for ${filePath}...`;
+      prompt = `Generate comprehensive API documentation, JSDoc/docstrings, and comments for the following code. Ensure code parameters, return values, and types are documented:\n\n\`\`\`\n${content}\n\`\`\``;
+      break;
+    case "/translate":
+      const targetLang = args[1];
+      if (!targetLang) {
+        console.log("\n" + label.system + " " + colors.warning(`Usage: /translate <file_path> <target_language>\n`));
+        return;
+      }
+      labelText = `Translating ${filePath} to ${targetLang}...`;
+      prompt = `Translate the following code into ${targetLang}. Return a clean, syntactically correct, and beautifully structured code block of the translated code:\n\n\`\`\`\n${content}\n\`\`\``;
+      break;
+  }
+
+  try {
+    await executeAISpecialCommand(prompt, labelText, ctx);
+  } catch (err) {
+    console.log("\n" + label.system + " " + colors.danger(`Error: ${err.message}\n`));
+  }
+}
+
+/**
+ * Handler for the /search command (workspace file crawler and AI semantic finder).
+ */
+async function handleSearchCommand(args, ctx) {
+  const isAi = args[0] === "--ai";
+  const queryArgs = isAi ? args.slice(1) : args;
+  const query = queryArgs.join(" ").trim();
+
+  if (!query) {
+    console.log("\n" + label.system + " " + colors.warning("Usage: /search [--ai] <query_string>\n"));
+    return;
+  }
+
+  const { workspaceSearch, crawlDirectory } = await import("./search.js");
+
+  if (isAi) {
+    console.log("\n" + label.system + " " + colors.muted("Scanning workspace project tree for semantic search..."));
+    const files = crawlDirectory(process.cwd());
+    const { relative } = await import("node:path");
+    const relativePaths = files.map((f) => relative(process.cwd(), f).replace(/\\/g, "/"));
+    
+    // Construct semantic prompt
+    const prompt = `Here is the directory structure / file listing of the current workspace:\n\n${relativePaths.slice(0, 100).join("\n")}\n\nBased on this file listing, identify and explain where the following logic or system is implemented, listing the relevant files: ${query}`;
+    
+    await executeAISpecialCommand(prompt, `Semantic search: "${query}"`, ctx);
+    return;
+  }
+
+  console.log("\n" + label.system + " " + colors.muted(`Searching workspace for "${query}"...`));
+  const results = workspaceSearch(query);
+
+  if (results.length === 0) {
+    console.log("\n" + label.system + " " + colors.warning(`✓ No matches found for "${query}" in workspace.\n`));
+    return;
+  }
+
+  console.log("\n" + separator("━"));
+  console.log(colors.accent.bold(`  ★  WORKSPACE SEARCH RESULTS FOR "${query.toUpperCase()}"  ★`));
+  console.log(separator("─"));
+
+  // Print header
+  console.log(
+    colors.brand("  " + "File Path".padEnd(45) + "Line".padStart(6) + "   " + "Preview")
+  );
+  console.log(colors.dim("  " + "─".repeat(80)));
+
+  // Display matches (limit to top 50 to prevent terminal overflow)
+  const displayLimit = 50;
+  const visibleResults = results.slice(0, displayLimit);
+
+  for (const match of visibleResults) {
+    const truncatedPath = match.relativePath.length > 43 ? "..." + match.relativePath.slice(-40) : match.relativePath;
+    const truncatedLine = match.lineContent.length > 50 ? match.lineContent.slice(0, 47) + "..." : match.lineContent;
+    console.log(
+      "  " + colors.text(truncatedPath.padEnd(45)) +
+      colors.brand(match.lineNumber.toString().padStart(6)) +
+      "   " + colors.muted(truncatedLine)
+    );
+  }
+
+  console.log(separator("─"));
+  if (results.length > displayLimit) {
+    console.log("  " + colors.warning(`⚠ Showing first ${displayLimit} of ${results.length} total matches.`));
+  } else {
+    console.log("  " + colors.success(`✓ Found ${results.length} matches across the workspace.`));
+  }
+  console.log(separator("━") + "\n");
+}

package/src/config.js

@@ -176,7 +176,7 @@ export function isValidConfigKey(key) {
   const allowedSpecialKeys = [
     "THEME", "CUSTOM_COMMANDS", "AUTOPILOT", 
     "AUTO_UPDATE", "SHOW_HIGHLIGHTS", "LAST_UPDATE_CHECK", "LAST_NOTIFIED_VERSION",
-    "SHOW_TOKENS"
+    "SHOW_TOKENS", "DIAGNOSE_CMD"
   ];
   if (upper.endsWith("_API_KEY") || upper.endsWith("_API_KEYS") || upper.endsWith("_MODEL") || allowedSpecialKeys.includes(upper)) {
     return true;

package/test/dx.test.js

@@ -0,0 +1,10 @@
+import { test } from "node:test";
+import assert from "node:assert";
+import { isValidConfigKey } from "../src/config.js";
+
+test("Developer Experience (DX) Commands Suite", async (t) => {
+  await t.test("isValidConfigKey whitelists DIAGNOSE_CMD correctly", () => {
+    assert.strictEqual(isValidConfigKey("DIAGNOSE_CMD"), true);
+    assert.strictEqual(isValidConfigKey("diagnose_cmd"), true);
+  });
+});

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');");
+  });
+});