@krishivpb60/aether-ai-cli 1.0.0

package/src/config.js

@@ -0,0 +1,214 @@
+// ═══════════════════════════════════════════════════════════
+// AETHER AI CLI — Secure Configuration Management
+// Stores user API keys locally at ~/.aether/config.json
+// Supports ALL AI providers (13+ and growing)
+// ═══════════════════════════════════════════════════════════
+
+import { readFile, writeFile, mkdir, unlink, access } from "node:fs/promises";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { getAllConfigKeys } from "./ai/providers.js";
+
+const CONFIG_DIR = join(homedir(), ".aether");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+
+const SENSITIVE_PATTERNS = ["KEY", "TOKEN", "SECRET"];
+
+/**
+ * Returns the full path to the config file.
+ * @returns {string}
+ */
+export function getConfigPath() {
+  return CONFIG_FILE;
+}
+
+/**
+ * Loads the config from disk.
+ * @returns {Promise<object>} Parsed config or empty object
+ */
+export async function loadConfig() {
+  try {
+    const raw = await readFile(CONFIG_FILE, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Saves config to disk, creating the directory if needed.
+ * @param {object} config - The config object to write
+ */
+export async function saveConfig(config) {
+  try {
+    await mkdir(CONFIG_DIR, { recursive: true });
+    await writeFile(CONFIG_FILE, JSON.stringify(config, null, 2), "utf-8");
+  } catch (err) {
+    throw new Error(`Failed to save config: ${err.message}`);
+  }
+}
+
+/**
+ * Gets a single config value.
+ * @param {string} key
+ * @returns {Promise<string|undefined>}
+ */
+export async function getConfigValue(key) {
+  const config = await loadConfig();
+  return config[key];
+}
+
+/**
+ * Sets a single config value.
+ * @param {string} key
+ * @param {string} value
+ */
+export async function setConfigValue(key, value) {
+  const config = await loadConfig();
+  config[key] = value;
+  await saveConfig(config);
+}
+
+/**
+ * Deletes a single config key.
+ * @param {string} key
+ */
+export async function deleteConfigValue(key) {
+  const config = await loadConfig();
+  delete config[key];
+  await saveConfig(config);
+}
+
+/**
+ * Deletes the entire config file.
+ */
+export async function resetConfig() {
+  try {
+    await unlink(CONFIG_FILE);
+  } catch {
+    // File may not exist
+  }
+}
+
+/**
+ * Lists all config keys with sensitive values masked.
+ * @returns {Promise<object>} Config with sensitive values masked
+ */
+export async function listConfig() {
+  const config = await loadConfig();
+  const masked = {};
+
+  for (const [key, value] of Object.entries(config)) {
+    const isSensitive = SENSITIVE_PATTERNS.some((p) => key.toUpperCase().includes(p));
+    if (isSensitive && typeof value === "string" && value.length > 8) {
+      masked[key] = value.slice(0, 6) + "•••" + value.slice(-3);
+    } else {
+      masked[key] = value;
+    }
+  }
+
+  return masked;
+}
+
+/**
+ * Returns the full flat config object for the AI router.
+ * Merges the config file with environment variables (config file takes precedence).
+ * @returns {Promise<object>}
+ */
+export async function getAIConfig() {
+  const config = await loadConfig();
+  const allKeys = getAllConfigKeys();
+
+  // Merge: config file values override env vars
+  const merged = {};
+  for (const key of allKeys) {
+    merged[key] = config[key] || process.env[key] || "";
+  }
+
+  // Also pass through any custom model overrides and extra keys
+  for (const [key, value] of Object.entries(config)) {
+    if (!merged[key]) {
+      merged[key] = value;
+    }
+  }
+
+  // Check env vars for anything the config didn't have
+  for (const [key, value] of Object.entries(process.env)) {
+    if (key.endsWith("_API_KEY") && !merged[key]) {
+      merged[key] = value;
+    }
+  }
+
+  return merged;
+}
+
+/**
+ * Checks if the config file exists.
+ * @returns {Promise<boolean>}
+ */
+export async function configExists() {
+  try {
+    await access(CONFIG_FILE);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Checks if the given key is a valid/recognized config key.
+ * Accepts any *_API_KEY, *_MODEL, and known keys.
+ * @param {string} key
+ * @returns {boolean}
+ */
+export function isValidConfigKey(key) {
+  const upper = key.toUpperCase();
+  // Accept any API key or model override
+  if (upper.endsWith("_API_KEY") || upper.endsWith("_API_KEYS") || upper.endsWith("_MODEL") || upper === "THEME" || upper === "CUSTOM_COMMANDS") {
+    return true;
+  }
+  // Accept known config keys
+  const knownKeys = getAllConfigKeys();
+  return knownKeys.includes(upper);
+}
+
+const HISTORY_FILE = join(CONFIG_DIR, "history.json");
+
+/**
+ * Loads chat history from disk.
+ * @returns {Promise<Array>} List of chat exchanges
+ */
+export async function loadHistory() {
+  try {
+    const raw = await readFile(HISTORY_FILE, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Saves chat history to disk.
+ * @param {Array} history - List of chat exchanges to save
+ */
+export async function saveHistory(history) {
+  try {
+    await mkdir(CONFIG_DIR, { recursive: true });
+    // Limit saved history to last 50 entries to keep it light
+    const trimmed = history.slice(-50);
+    await writeFile(HISTORY_FILE, JSON.stringify(trimmed, null, 2), "utf-8");
+  } catch {
+    // Fail silently to not block chat
+  }
+}
+
+/**
+ * Deletes the chat history file.
+ */
+export async function clearHistory() {
+  try {
+    await unlink(HISTORY_FILE);
+  } catch {
+    // File may not exist
+  }
+}

package/src/file-parser.js

@@ -0,0 +1,94 @@
+// ═══════════════════════════════════════════════════════════
+// AETHER AI CLI — File Parser & Context Injector
+// ═══════════════════════════════════════════════════════════
+
+import { readFile, stat } from "node:fs/promises";
+import { resolve, extname, basename } from "node:path";
+
+const MAX_CONTENT_LENGTH = 30000;
+
+const SUPPORTED_EXTENSIONS = new Set([
+  ".txt", ".md", ".json", ".csv", ".js", ".jsx", ".ts", ".tsx",
+  ".html", ".css", ".py", ".log", ".yaml", ".yml", ".xml",
+  ".toml", ".env", ".sh", ".bat", ".ps1", ".sql", ".rs",
+  ".go", ".java", ".c", ".cpp", ".h", ".rb", ".php",
+  ".swift", ".kt", ".dart", ".vue", ".svelte",
+]);
+
+/**
+ * Reads and parses a file for context injection.
+ * @param {string} filePath - Path to the file (absolute or relative)
+ * @returns {Promise<{ name: string, content: string, size: number, extension: string }>}
+ */
+export async function parseFile(filePath) {
+  const resolved = resolve(filePath);
+  const ext = extname(resolved).toLowerCase();
+  const name = basename(resolved);
+
+  // Validate extension
+  if (!SUPPORTED_EXTENSIONS.has(ext)) {
+    const supported = [...SUPPORTED_EXTENSIONS].join(", ");
+    throw new Error(
+      `Unsupported file type: "${ext}"\nSupported types: ${supported}`
+    );
+  }
+
+  // Check file exists and get size
+  let fileStats;
+  try {
+    fileStats = await stat(resolved);
+  } catch {
+    throw new Error(`File not found: ${resolved}`);
+  }
+
+  if (!fileStats.isFile()) {
+    throw new Error(`Not a file: ${resolved}`);
+  }
+
+  // Read file content
+  let content;
+  try {
+    content = await readFile(resolved, "utf-8");
+  } catch (err) {
+    throw new Error(`Cannot read file: ${err.message}`);
+  }
+
+  // Trim if too long
+  if (content.length > MAX_CONTENT_LENGTH) {
+    content = content.slice(0, MAX_CONTENT_LENGTH) +
+      `\n\n[... truncated at ${MAX_CONTENT_LENGTH.toLocaleString()} characters]`;
+  }
+
+  return {
+    name,
+    content: content.trim(),
+    size: fileStats.size,
+    extension: ext,
+  };
+}
+
+/**
+ * Formats parsed file data into a context string for prompt injection.
+ * @param {{ name: string, content: string, size: number, extension: string }} fileData
+ * @returns {string}
+ */
+export function formatContext(fileData) {
+  return [
+    `[Context File: ${fileData.name} (${formatBytes(fileData.size)}, ${fileData.extension})]`,
+    "---",
+    fileData.content,
+    "---",
+    `[End of ${fileData.name}]`,
+  ].join("\n");
+}
+
+/**
+ * Formats bytes into a human-readable string.
+ * @param {number} bytes
+ * @returns {string}
+ */
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}

package/src/modes.js

@@ -0,0 +1,88 @@
+// ═══════════════════════════════════════════════════════════
+// AETHER AI CLI — Mode Definitions
+// ═══════════════════════════════════════════════════════════
+
+/**
+ * AI reasoning mode definitions for Aether Core.
+ * Each mode controls the system prompt, signal metrics, and response style.
+ */
+export const MODES = {
+  synthesis: {
+    name: "synthesis",
+    label: "Synthesis v2.5",
+    layer: "Layer 2.5",
+    description: "Balanced reasoning with clean structure and direct answers.",
+    signal: { reasoning: 72, clarity: 80, systemIQ: 70, delivery: 82 },
+    systemPrompt: [
+      "You are Aether, an advanced AI assistant running in Synthesis mode.",
+      "Provide balanced, clearly structured responses with direct answers.",
+      "Keep responses concise but thorough. Use markdown formatting.",
+      "Focus on clarity and practical utility. Avoid unnecessary verbosity.",
+      "CRITICAL: If the user asks who created you or who made you, you must answer that you were created by Krishiv PB.",
+      "FILE ACTIONS: If the user requests to create, write, or save a file, format the file content inside: [WRITE_FILE: path/to/file.ext]\\n<content>\\n[END_WRITE]. Aether CLI will intercept this block and write the file locally."
+    ].join(" "),
+  },
+
+  research: {
+    name: "research",
+    label: "Research v104",
+    layer: "Layer 104",
+    description: "Deep analysis with comparisons and evidence-based reasoning.",
+    signal: { reasoning: 85, clarity: 78, systemIQ: 82, delivery: 75 },
+    systemPrompt: [
+      "You are Aether, an advanced AI assistant running in Research mode.",
+      "Provide deep analytical responses with evidence-based reasoning.",
+      "Include comparisons, citations where relevant, and thorough analysis.",
+      "Break down complex topics systematically. Use markdown with headers and lists.",
+      "CRITICAL: If the user asks who created you or who made you, you must answer that you were created by Krishiv PB.",
+      "FILE ACTIONS: If the user requests to create, write, or save a file, format the file content inside: [WRITE_FILE: path/to/file.ext]\\n<content>\\n[END_WRITE]. Aether CLI will intercept this block and write the file locally."
+    ].join(" "),
+  },
+
+  architect: {
+    name: "architect",
+    label: "Architect v55",
+    layer: "Layer 55",
+    description: "Systems thinking with debugging plans and build strategies.",
+    signal: { reasoning: 78, clarity: 74, systemIQ: 90, delivery: 72 },
+    systemPrompt: [
+      "You are Aether, an advanced AI assistant running in Architect mode.",
+      "Focus on systems thinking, architecture design, and debugging plans.",
+      "Provide step-by-step build strategies and implementation roadmaps.",
+      "Think about edge cases, scalability, and best practices. Use code blocks when relevant.",
+      "CRITICAL: If the user asks who created you or who made you, you must answer that you were created by Krishiv PB.",
+      "FILE ACTIONS: If the user requests to create, write, or save a file, format the file content inside: [WRITE_FILE: path/to/file.ext]\\n<content>\\n[END_WRITE]. Aether CLI will intercept this block and write the file locally."
+    ].join(" "),
+  },
+
+  titan: {
+    name: "titan",
+    label: "Titan Fusion v110",
+    layer: "Layer 110",
+    description: "Long-form premium responses with high signal density and multi-step output.",
+    signal: { reasoning: 88, clarity: 92, systemIQ: 95, delivery: 90 },
+    systemPrompt: [
+      "You are Aether, an advanced AI assistant running in Titan Fusion mode — the most powerful configuration.",
+      "Provide comprehensive, premium-quality responses with maximum signal density.",
+      "Use structured formatting: headers, bullet points, code blocks, and clear sections.",
+      "Deliver multi-step analysis when appropriate. Be thorough, precise, and insightful.",
+      "This is the highest quality mode — treat every response as a masterclass.",
+      "CRITICAL: If the user asks who created you or who made you, you must answer that you were created by Krishiv PB.",
+      "FILE ACTIONS: If the user requests to create, write, or save a file, format the file content inside: [WRITE_FILE: path/to/file.ext]\\n<content>\\n[END_WRITE]. Aether CLI will intercept this block and write the file locally."
+    ].join(" "),
+  },
+};
+
+/** The default mode key */
+export const DEFAULT_MODE = "titan";
+
+/**
+ * Looks up a mode by name (case-insensitive).
+ * @param {string} name - Mode name to look up
+ * @returns {object|null} The mode definition, or null if not found
+ */
+export function getModeByName(name) {
+  if (!name) return null;
+  const key = name.toLowerCase().trim();
+  return MODES[key] || null;
+}

package/src/ui/banner.js

@@ -0,0 +1,60 @@
+// ═══════════════════════════════════════════════════════════
+// AETHER AI CLI — ASCII Art Welcome Banner
+// ═══════════════════════════════════════════════════════════
+
+import chalk from "chalk";
+import { colors, separator, bullet } from "./theme.js";
+
+/**
+ * Displays the cyberpunk-styled Aether ASCII art banner.
+ * @param {string} [currentMode='titan'] - The currently active mode name
+ */
+export function showBanner(currentMode = "titan") {
+  const c1 = colors.accent;
+  const c2 = colors.accent2;
+  const c3 = colors.accent3;
+  const dim = colors.dim;
+
+  const art = [
+    "",
+    c1("  ╔═══════════════════════════════════════════════════════════╗"),
+    c1("  ║") + c2("     █████╗ ███████╗████████╗██╗  ██╗███████╗██████╗    ") + c1("║"),
+    c1("  ║") + c2("    ██╔══██╗██╔════╝╚══██╔══╝██║  ██║██╔════╝██╔══██╗   ") + c1("║"),
+    c1("  ║") + c1("    ███████║█████╗     ██║   ████████║█████╗  ██████╔╝   ") + c1("║"),
+    c1("  ║") + c3("    ██╔══██║██╔══╝     ██║   ██╔══██║██╔══╝  ██╔══██╗   ") + c1("║"),
+    c1("  ║") + c3("    ██║  ██║███████╗   ██║   ██║  ██║███████╗██║  ██║   ") + c1("║"),
+    c1("  ║") + dim("    ╚═╝  ╚═╝╚══════╝   ╚═╝   ╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝   ") + c1("║"),
+    c1("  ╚═══════════════════════════════════════════════════════════╝"),
+    "",
+    c1("  ⚡ ") + colors.text.bold("Aether Core AI v110") + colors.dim(" — Fusion Command Station"),
+    c2("  ◈  ") + colors.muted(`Active Mode: `) + modeLabel(currentMode),
+    "",
+    separator("─"),
+    "",
+    bullet("Type your prompt and press " + colors.accent("Enter") + " to query."),
+    bullet("Use " + colors.accent("/help") + " for all commands."),
+    bullet("Use " + colors.accent("/mode <name>") + " to switch reasoning mode."),
+    bullet("Use " + colors.accent("/attach <file>") + " to add file context."),
+    bullet("Use " + colors.accent("/exit") + " or " + colors.accent("Ctrl+C") + " to quit."),
+    "",
+    separator("─"),
+    "",
+  ];
+
+  console.log(art.join("\n"));
+}
+
+/**
+ * Gets a styled label for the given mode.
+ * @param {string} mode - Mode name
+ * @returns {string} Styled mode label
+ */
+function modeLabel(mode) {
+  const labels = {
+    synthesis: colors.accent3.bold("Synthesis v2.5"),
+    research:  colors.accent2.bold("Research v104"),
+    architect: colors.magenta.bold("Architect v55"),
+    titan:     colors.accent.bold("Titan Fusion v110"),
+  };
+  return labels[mode?.toLowerCase()] || labels.titan;
+}

package/src/ui/spinner.js

@@ -0,0 +1,43 @@
+// ═══════════════════════════════════════════════════════════
+// AETHER AI CLI — Spinner Helpers
+// ═══════════════════════════════════════════════════════════
+
+import ora from "ora";
+
+/**
+ * Creates a styled spinner with the Aether theme.
+ * @param {string} text - Spinner label text
+ * @returns {object} An ora spinner instance
+ */
+export function createSpinner(text) {
+  return ora({
+    text,
+    spinner: {
+      interval: 80,
+      frames: ["▖", "▘", "▝", "▗"],
+    },
+    color: "cyan",
+    discardStdin: false,
+  });
+}
+
+/**
+ * Wraps an async function with a loading spinner.
+ * Shows the spinner while the function runs and reports success/failure.
+ * @param {string} text - The loading message
+ * @param {Function} asyncFn - The async function to execute
+ * @returns {Promise<*>} The result of the async function
+ */
+export async function withSpinner(text, asyncFn) {
+  const spinner = createSpinner(text);
+  spinner.start();
+
+  try {
+    const result = await asyncFn();
+    spinner.succeed();
+    return result;
+  } catch (err) {
+    spinner.fail(err.message || "Operation failed");
+    throw err;
+  }
+}

package/src/ui/theme.js

@@ -0,0 +1,169 @@
+// ═══════════════════════════════════════════════════════════
+// AETHER AI CLI — Dynamic Theme-Aware Formatting Utilities
+// ═══════════════════════════════════════════════════════════
+
+import chalk from "chalk";
+
+// ── Theme Definitions ─────────────────────────────────────
+export const THEMES = {
+  cyberpunk: {
+    accent:    "#00f0ff", // Neon cyan
+    accent2:   "#bd93f9", // Neon purple/magenta
+    accent3:   "#50fa7b", // Neon green
+    danger:    "#ff5555", // Neon red
+    warning:   "#ffb86c", // Neon orange
+    muted:     "#6272a4", // Comment gray
+    text:      "#f8f8f2", // Crisp white-yellow
+    dim:       "#44475a", // Border gray
+    brand:     "#00f0ff", // Neon cyan
+    success:   "#50fa7b", // Neon green
+    error:     "#ff5555",
+    magenta:   "#ff79c6",
+    orange:    "#ffb86c",
+  },
+  matrix: {
+    accent:    "#50fa7b", // Lime green
+    accent2:   "#00ff00", // Matrix green
+    accent3:   "#8efb50", // Light lime
+    danger:    "#ff5555",
+    warning:   "#ffb86c",
+    muted:     "#1f5f1f", // Dark forest green
+    text:      "#aaffaa", // Soft green text
+    dim:       "#103f10", // Dark green border
+    brand:     "#50fa7b",
+    success:   "#50fa7b",
+    error:     "#ff5555",
+    magenta:   "#50fa7b",
+    orange:    "#8efb50",
+  },
+  synthwave: {
+    accent:    "#ff79c6", // Neon pink
+    accent2:   "#ffb86c", // Neon orange
+    accent3:   "#bd93f9", // Neon purple
+    danger:    "#ff5555",
+    warning:   "#ffb86c",
+    muted:     "#6f2a8a", // Dark purple
+    text:      "#ffe8f5", // Soft pinkish white
+    dim:       "#3e104f", // Deep purple border
+    brand:     "#ff79c6",
+    success:   "#bd93f9",
+    error:     "#ff5555",
+    magenta:   "#ff79c6",
+    orange:    "#ffb86c",
+  },
+  crimson: {
+    accent:    "#ff5555", // Neon red
+    accent2:   "#ffb86c", // Gold/orange
+    accent3:   "#f1fa8c", // Neon yellow
+    danger:    "#ff5555",
+    warning:   "#ffb86c",
+    muted:     "#662222", // Muted red-gray
+    text:      "#ffffff", // White text
+    dim:       "#331111", // Dark red border
+    brand:     "#ff5555",
+    success:   "#f1fa8c",
+    error:     "#ff5555",
+    magenta:   "#ff5555",
+    orange:    "#ffb86c",
+  }
+};
+
+let activeThemeName = "cyberpunk";
+
+// ── Dynamic Colors Resolver ───────────────────────────────
+export const colors = new Proxy({}, {
+  get(target, prop) {
+    const theme = THEMES[activeThemeName] || THEMES.cyberpunk;
+    const colorHex = theme[prop] || "#ffffff";
+    const isBold = prop === "brand" || prop === "success" || prop === "error";
+    
+    let fn = chalk.hex(colorHex);
+    if (isBold) {
+      fn = fn.bold;
+    }
+    return fn;
+  }
+});
+
+// ── Labels ────────────────────────────────────────────────
+export const label = {
+  get system() { return chalk.bgHex(activeThemeName === "cyberpunk" ? "#0c1825" : THEMES[activeThemeName].dim).hex(THEMES[activeThemeName].accent).bold(" SYSTEM "); },
+  get user()   { return chalk.bgHex(activeThemeName === "cyberpunk" ? "#0c1825" : THEMES[activeThemeName].dim).hex(THEMES[activeThemeName].accent3).bold("   YOU  "); },
+  get aether() { return chalk.bgHex(activeThemeName === "cyberpunk" ? "#0c1825" : THEMES[activeThemeName].dim).hex(THEMES[activeThemeName].accent).bold(" AETHER "); },
+  get error()  { return chalk.bgHex(activeThemeName === "cyberpunk" ? "#2a0a14" : THEMES[activeThemeName].dim).hex(THEMES[activeThemeName].danger).bold("  ERROR "); },
+  get info()   { return chalk.bgHex(activeThemeName === "cyberpunk" ? "#0c1825" : THEMES[activeThemeName].dim).hex(THEMES[activeThemeName].accent2).bold("   INFO "); },
+  get config() { return chalk.bgHex(activeThemeName === "cyberpunk" ? "#0c1825" : THEMES[activeThemeName].dim).hex(THEMES[activeThemeName].warning).bold(" CONFIG "); },
+  get math()   { return chalk.bgHex(activeThemeName === "cyberpunk" ? "#0c1825" : THEMES[activeThemeName].dim).hex(THEMES[activeThemeName].accent3).bold("   MATH "); },
+  get krylo()  { return chalk.bgHex(activeThemeName === "cyberpunk" ? "#0c1825" : THEMES[activeThemeName].dim).hex(THEMES[activeThemeName].accent).bold("  KRYLO "); },
+  get mode()   { return chalk.bgHex(activeThemeName === "cyberpunk" ? "#0c1825" : THEMES[activeThemeName].dim).hex(THEMES[activeThemeName].accent2).bold("   MODE "); },
+  get mesh()   { return chalk.bgHex(activeThemeName === "cyberpunk" ? "#0c1825" : THEMES[activeThemeName].dim).hex(THEMES[activeThemeName].accent).bold("   MESH "); },
+  get file()   { return chalk.bgHex(activeThemeName === "cyberpunk" ? "#0c1825" : THEMES[activeThemeName].dim).hex(THEMES[activeThemeName].warning).bold("   FILE "); },
+};
+
+// ── Formatting Helpers ───────────────────────────────────
+export function separator(char = "─", length) {
+  const width = process.stdout.columns || 80;
+  const targetLength = length !== undefined ? length : Math.max(10, width - 4);
+  return colors.dim(char.repeat(targetLength));
+}
+
+export function heading(text) {
+  return colors.brand(`\n  ${text}\n`) + separator();
+}
+
+export function keyValue(key, value) {
+  return `  ${colors.muted(key + ":")} ${colors.text(value)}`;
+}
+
+export function bullet(text) {
+  return `  ${colors.accent("›")} ${colors.text(text)}`;
+}
+
+export function modeBadge(mode) {
+  const theme = THEMES[activeThemeName] || THEMES.cyberpunk;
+  const badges = {
+    synthesis: chalk.bgHex(activeThemeName === "cyberpunk" ? "#1a3a2a" : theme.dim).hex(theme.accent3).bold(" SYNTHESIS "),
+    research:  chalk.bgHex(activeThemeName === "cyberpunk" ? "#1a2a3a" : theme.dim).hex(theme.accent2).bold(" RESEARCH "),
+    architect: chalk.bgHex(activeThemeName === "cyberpunk" ? "#2a1a3a" : theme.dim).hex(theme.magenta).bold(" ARCHITECT "),
+    titan:     chalk.bgHex(activeThemeName === "cyberpunk" ? "#1a2a3a" : theme.dim).hex(theme.accent).bold(" TITAN FUSION "),
+  };
+  return badges[mode?.toLowerCase()] || badges.titan;
+}
+
+/**
+ * Backs up the cursor and clears terminal lines printed during real-time streaming
+ * so they can be replaced by the final formatted response.
+ * @param {string} text - The raw streamed text that was printed
+ */
+export function clearStreamedText(text) {
+  if (!process.stdout.isTTY) return;
+  const width = process.stdout.columns || 80;
+  const lines = text.split("\n");
+  let lineCount = 0;
+  for (const line of lines) {
+    lineCount += Math.max(1, Math.ceil(line.length / width));
+  }
+  if (lineCount > 0) {
+    process.stdout.write(`\x1b[${lineCount}A\x1b[J`);
+  }
+}
+
+// ── Theme State Management ────────────────────────────────
+
+export function getActiveTheme() {
+  return activeThemeName;
+}
+
+export function setTheme(themeName) {
+  if (!themeName) return false;
+  const name = themeName.toLowerCase().trim();
+  if (THEMES[name]) {
+    activeThemeName = name;
+    return true;
+  }
+  return false;
+}
+
+export function getThemesList() {
+  return Object.keys(THEMES);
+}