@imisbahk/hive 0.1.0 → 0.1.2

package/src/cli/commands/config.ts

@@ -1,6 +1,6 @@
 import process from "node:process";
+import * as readline from "node:readline";
 
-import chalk from "chalk";
 import { Command } from "commander";
 import inquirer from "inquirer";
 import keytar from "keytar";
@@ -9,6 +9,21 @@ import ora from "ora";
 import { resolveProviderApiKey } from "../../providers/api-key.js";
 import { normalizeProviderName, type ProviderName } from "../../providers/base.js";
 import { promptForModel, promptForProvider } from "../helpers/providerPrompts.js";
+import {
+  renderError,
+  renderHiveHeader,
+  renderInfo,
+  renderStep,
+  renderSuccess,
+} from "../ui.js";
+import {
+  BUILT_IN_THEMES,
+  DEFAULT_THEME_HEX,
+  applyTheme,
+  getTheme,
+  isValidHexColor,
+  type ThemeName,
+} from "../theme.js";
 import {
   closeHiveDatabase,
   getPrimaryAgent,
@@ -19,11 +34,40 @@ import {
 } from "../../storage/db.js";
 
 const KEYCHAIN_SERVICE = "hive";
+const THEME_LABEL_WIDTH = 8;
+const ENTER_ALT_SCREEN = "\u001B[?1049h";
+const EXIT_ALT_SCREEN = "\u001B[?1049l";
+const CLEAR_SCREEN = "\u001B[H\u001B[2J";
+const THEME_SELECTOR_TITLE = "COMMAND CENTRE · CONFIG · THEME";
+const THEME_SELECTOR_MAX_SEPARATOR_WIDTH = 72;
+const THEME_SELECTOR_MIN_SEPARATOR_WIDTH = 24;
+const THEME_WORDMARK_LINES = [
+  "  ██╗  ██╗██╗██╗   ██╗███████╗",
+  "  ██║  ██║██║██║   ██║██╔════╝",
+  "  ███████║██║██║   ██║█████╗  ",
+  "  ██╔══██║██║╚██╗ ██╔╝██╔══╝  ",
+  "  ██║  ██║██║ ╚████╔╝ ███████╗",
+  "  ╚═╝  ╚═╝╚═╝  ╚═══╝  ╚══════╝",
+] as const;
+
+interface ConfigShowRenderOptions {
+  showHeader?: boolean;
+}
+
+interface ConfigInteractiveRenderOptions {
+  showHeader?: boolean;
+}
+
+interface ThemeOption {
+  name: ThemeName;
+  hex: string;
+  description?: string;
+}
 
 export function registerConfigCommand(program: Command): void {
   const configCommand = program
     .command("config")
-    .description("Update provider, model, or API keys without re-running init");
+    .description("Update provider, model, theme, or API keys without re-running init");
 
   configCommand
     .command("provider")
@@ -52,9 +96,31 @@ export function registerConfigCommand(program: Command): void {
     .action(async () => {
       await runConfigShowCommand();
     });
+
+  configCommand
+    .command("theme")
+    .description("Change CLI accent theme")
+    .action(async () => {
+      await runConfigThemeCommand();
+    });
+
+  configCommand.action(() => {
+    renderHiveHeader("Config");
+    configCommand.outputHelp();
+  });
 }
 
 export async function runConfigProviderCommand(): Promise<void> {
+  await runConfigProviderCommandWithOptions();
+}
+
+export async function runConfigProviderCommandWithOptions(
+  options: ConfigInteractiveRenderOptions = {},
+): Promise<void> {
+  const showHeader = options.showHeader ?? true;
+  if (showHeader) {
+    renderHiveHeader("Config · Provider");
+  }
   const spinner = ora("Loading configuration...").start();
   const db = openHiveDatabase();
 
@@ -64,7 +130,7 @@ export async function runConfigProviderCommand(): Promise<void> {
     const agent = getPrimaryAgent(db);
     if (!agent) {
       spinner.stop();
-      console.error(chalk.red("Hive is not initialized. Run `hive init` first."));
+      renderError("Hive is not initialized. Run `hive init` first.");
       return;
     }
 
@@ -110,7 +176,8 @@ export async function runConfigProviderCommand(): Promise<void> {
     }
 
     spinner.succeed("Configuration saved.");
-    console.log("Provider updated. Run `hive chat` to use it.");
+    renderSuccess("Provider updated.");
+    renderStep("Run `hive` to use it.");
   } catch (error) {
     if (spinner.isSpinning) {
       spinner.fail("Failed to update provider configuration.");
@@ -122,6 +189,16 @@ export async function runConfigProviderCommand(): Promise<void> {
 }
 
 export async function runConfigModelCommand(): Promise<void> {
+  await runConfigModelCommandWithOptions();
+}
+
+export async function runConfigModelCommandWithOptions(
+  options: ConfigInteractiveRenderOptions = {},
+): Promise<void> {
+  const showHeader = options.showHeader ?? true;
+  if (showHeader) {
+    renderHiveHeader("Config · Model");
+  }
   const spinner = ora("Loading configuration...").start();
   const db = openHiveDatabase();
 
@@ -131,7 +208,7 @@ export async function runConfigModelCommand(): Promise<void> {
     const agent = getPrimaryAgent(db);
     if (!agent) {
       spinner.stop();
-      console.error(chalk.red("Hive is not initialized. Run `hive init` first."));
+      renderError("Hive is not initialized. Run `hive init` first.");
       return;
     }
 
@@ -151,7 +228,8 @@ export async function runConfigModelCommand(): Promise<void> {
     setMetaValue(db, "model", updatedAgent.model);
 
     spinner.succeed("Configuration saved.");
-    console.log("Model updated. Run `hive chat` to use it.");
+    renderSuccess("Model updated.");
+    renderStep("Run `hive` to use it.");
   } catch (error) {
     if (spinner.isSpinning) {
       spinner.fail("Failed to update model configuration.");
@@ -163,6 +241,16 @@ export async function runConfigModelCommand(): Promise<void> {
 }
 
 export async function runConfigKeyCommand(): Promise<void> {
+  await runConfigKeyCommandWithOptions();
+}
+
+export async function runConfigKeyCommandWithOptions(
+  options: ConfigInteractiveRenderOptions = {},
+): Promise<void> {
+  const showHeader = options.showHeader ?? true;
+  if (showHeader) {
+    renderHiveHeader("Config · Key");
+  }
   const spinner = ora("Loading configuration...").start();
   const db = openHiveDatabase();
 
@@ -172,14 +260,14 @@ export async function runConfigKeyCommand(): Promise<void> {
     const agent = getPrimaryAgent(db);
     if (!agent) {
       spinner.stop();
-      console.error(chalk.red("Hive is not initialized. Run `hive init` first."));
+      renderError("Hive is not initialized. Run `hive init` first.");
       return;
     }
 
     const provider = normalizeProviderName(agent.provider);
 
     spinner.stop();
-    console.log(chalk.dim(`Current provider: ${provider}`));
+    renderInfo(`Current provider: ${provider}`);
 
     const answer = (await inquirer.prompt([
       {
@@ -195,7 +283,8 @@ export async function runConfigKeyCommand(): Promise<void> {
     await keytar.setPassword(KEYCHAIN_SERVICE, provider, answer.apiKey.trim());
 
     spinner.succeed("Configuration saved.");
-    console.log("API key updated. Run `hive chat` to use it.");
+    renderSuccess("API key updated.");
+    renderStep("Run `hive` to use it.");
   } catch (error) {
     if (spinner.isSpinning) {
       spinner.fail("Failed to update API key.");
@@ -207,22 +296,90 @@ export async function runConfigKeyCommand(): Promise<void> {
 }
 
 export async function runConfigShowCommand(): Promise<void> {
+  await runConfigShowCommandWithOptions();
+}
+
+export async function runConfigThemeCommand(): Promise<void> {
+  await runConfigThemeCommandWithOptions();
+}
+
+export async function runConfigShowCommandWithOptions(
+  options: ConfigShowRenderOptions = {},
+): Promise<void> {
+  const showHeader = options.showHeader ?? true;
+  if (showHeader) {
+    renderHiveHeader("Config · Show");
+  }
+
   const db = openHiveDatabase();
 
   try {
     const agent = getPrimaryAgent(db);
     if (!agent) {
-      console.error(chalk.red("Hive is not initialized. Run `hive init` first."));
+      renderError("Hive is not initialized. Run `hive init` first.");
       return;
     }
 
     const provider = normalizeProviderName(agent.provider);
     const keyStatus = await getKeyStatus(provider);
 
-    console.log(`Provider: ${provider}`);
-    console.log(`Model: ${agent.model}`);
-    console.log(`Agent name: ${agent.agent_name ?? "not set"}`);
-    console.log(`API key: ${keyStatus}`);
+    renderStep(`Provider: ${provider}`);
+    renderStep(`Model: ${agent.model}`);
+    renderStep(`Agent name: ${agent.agent_name ?? "not set"}`);
+    renderStep(`API key: ${keyStatus}`);
+  } finally {
+    closeHiveDatabase(db);
+  }
+}
+
+export async function runConfigThemeCommandWithOptions(
+  options: ConfigInteractiveRenderOptions = {},
+): Promise<void> {
+  const showHeader = options.showHeader ?? true;
+  if (showHeader) {
+    renderHiveHeader("Config · Theme");
+  }
+
+  const spinner = ora("Loading themes...").start();
+  const db = openHiveDatabase();
+
+  try {
+    ensureInteractiveTerminal("`hive config theme` requires an interactive terminal.");
+
+    const currentTheme = getTheme();
+    const themeOptions = buildThemeOptions(currentTheme.hex, currentTheme.name);
+
+    spinner.stop();
+
+    const theme = await selectThemeOption(themeOptions, currentTheme.name);
+
+    let themeHex = resolveThemeHex(theme, currentTheme.hex);
+
+    if (theme === "custom") {
+      const answer = (await inquirer.prompt([
+        {
+          type: "input",
+          name: "hex",
+          message: "Enter hex color: #",
+          default: currentTheme.name === "custom" ? currentTheme.hex : undefined,
+          validate: validateHexColor,
+        },
+      ])) as { hex: string };
+
+      themeHex = normalizeHexColor(answer.hex);
+    }
+
+    spinner.start("Saving theme...");
+    setMetaValue(db, "theme", theme);
+    setMetaValue(db, "theme_hex", themeHex);
+    spinner.succeed("Theme saved.");
+
+    console.log(applyTheme(themeHex)("✓ Theme set. The Hive is now yours."));
+  } catch (error) {
+    if (spinner.isSpinning) {
+      spinner.fail("Failed to update theme.");
+    }
+    throw error;
   } finally {
     closeHiveDatabase(db);
   }
@@ -235,8 +392,171 @@ function ensureInteractiveTerminal(errorMessage: string): void {
 }
 
 function printCurrentProviderAndModel(provider: ProviderName, model: string): void {
-  console.log(chalk.dim(`Current provider: ${provider}`));
-  console.log(chalk.dim(`Current model: ${model}`));
+  renderInfo(`Current provider: ${provider}`);
+  renderInfo(`Current model: ${model}`);
+}
+
+function formatThemeChoice(name: string, hex: string, description?: string): string {
+  const dot = applyTheme(hex)("●");
+  const paddedName = name.padEnd(THEME_LABEL_WIDTH, " ");
+  const descriptionSuffix = description ? ` (${description})` : "";
+  return `${dot} ${paddedName} ${hex}${descriptionSuffix}`;
+}
+
+function buildThemeOptions(currentHex: string, currentTheme: ThemeName): ThemeOption[] {
+  const customHex = currentTheme === "custom" ? currentHex : DEFAULT_THEME_HEX;
+  return [
+    {
+      name: "amber",
+      hex: BUILT_IN_THEMES.amber,
+      description: "default — beehive",
+    },
+    { name: "cyan", hex: BUILT_IN_THEMES.cyan },
+    { name: "rose", hex: BUILT_IN_THEMES.rose },
+    { name: "slate", hex: BUILT_IN_THEMES.slate },
+    { name: "green", hex: BUILT_IN_THEMES.green },
+    { name: "custom", hex: customHex, description: "user provided hex" },
+  ];
+}
+
+function resolveThemeHex(theme: ThemeName, currentHex: string): string {
+  if (theme === "custom") {
+    return currentHex;
+  }
+
+  return BUILT_IN_THEMES[theme];
+}
+
+async function selectThemeOption(
+  themeOptions: ThemeOption[],
+  currentTheme: ThemeName,
+): Promise<ThemeName> {
+  const input = process.stdin;
+  const output = process.stdout;
+  readline.emitKeypressEvents(input);
+
+  const defaultIndex = themeOptions.findIndex((option) => option.name === currentTheme);
+  let selectedIndex = defaultIndex >= 0 ? defaultIndex : 0;
+  const wasRaw = input.isRaw ?? false;
+
+  if (!wasRaw) {
+    input.setRawMode(true);
+  }
+  input.resume();
+  output.write(ENTER_ALT_SCREEN);
+
+  return new Promise<ThemeName>((resolve, reject) => {
+    const cleanup = () => {
+      input.off("keypress", onKeypress);
+      if (!wasRaw) {
+        input.setRawMode(false);
+      }
+      output.write(EXIT_ALT_SCREEN);
+    };
+
+    const render = () => {
+      const selectedOption = themeOptions[selectedIndex] ?? themeOptions[0];
+      const accent = applyTheme(selectedOption?.hex ?? DEFAULT_THEME_HEX);
+      const terminalWidth = getThemeSelectorTerminalWidth(output.columns);
+      const headerLines = renderThemeSelectorHeader(accent, terminalWidth);
+      const lines = [
+        ...headerLines,
+        "",
+        "Select a theme (live preview):",
+        "",
+        ...themeOptions.map((option, index) => {
+          const marker = index === selectedIndex ? accent("›") : " ";
+          return `${marker} ${formatThemeChoice(option.name, option.hex, option.description)}`;
+        }),
+        "",
+        accent("Preview"),
+        `${accent("✓")} Theme set. The Hive is now yours.`,
+        `${accent("›")} Step indicator`,
+        `${accent("you›")} prompt  ${accent("hive›")} agent`,
+        accent("────────────────────────────────────────"),
+        "",
+        "Enter to apply, Esc to cancel",
+      ];
+
+      output.write(`${CLEAR_SCREEN}${lines.join("\n")}`);
+    };
+
+    const onKeypress = (keyText: string, key: readline.Key) => {
+      if ((key.ctrl && key.name === "c") || key.name === "escape") {
+        cleanup();
+        reject(new Error("Theme selection cancelled."));
+        return;
+      }
+
+      if (key.name === "up") {
+        selectedIndex =
+          selectedIndex > 0 ? selectedIndex - 1 : themeOptions.length - 1;
+        render();
+        return;
+      }
+
+      if (key.name === "down") {
+        selectedIndex =
+          selectedIndex < themeOptions.length - 1 ? selectedIndex + 1 : 0;
+        render();
+        return;
+      }
+
+      if (key.name === "return" || key.name === "enter") {
+        const selectedOption = themeOptions[selectedIndex];
+        cleanup();
+        resolve(selectedOption?.name ?? "amber");
+        return;
+      }
+
+      const digit = Number.parseInt(keyText, 10);
+      if (!Number.isNaN(digit) && digit >= 1 && digit <= themeOptions.length) {
+        selectedIndex = digit - 1;
+        render();
+      }
+    };
+
+    input.on("keypress", onKeypress);
+    render();
+  });
+}
+
+function renderThemeSelectorHeader(
+  accent: ReturnType<typeof applyTheme>,
+  terminalWidth: number,
+): string[] {
+  const separator = "─".repeat(getThemeSelectorSeparatorWidth(terminalWidth));
+  const centredWordmark = THEME_WORDMARK_LINES.map((line) =>
+    accent.bold(centerText(line, terminalWidth)),
+  );
+
+  return [
+    ...centredWordmark,
+    accent(centerText(THEME_SELECTOR_TITLE, terminalWidth)),
+    accent(centerText(separator, terminalWidth)),
+  ];
+}
+
+function getThemeSelectorTerminalWidth(columns: number | undefined): number {
+  if (typeof columns !== "number" || columns < 20) {
+    return 80;
+  }
+
+  return columns;
+}
+
+function getThemeSelectorSeparatorWidth(terminalWidth: number): number {
+  const usableWidth = Math.max(THEME_SELECTOR_MIN_SEPARATOR_WIDTH, terminalWidth - 8);
+  return Math.min(THEME_SELECTOR_MAX_SEPARATOR_WIDTH, usableWidth);
+}
+
+function centerText(value: string, totalWidth: number): string {
+  if (value.length >= totalWidth) {
+    return value;
+  }
+
+  const leftPadding = Math.floor((totalWidth - value.length) / 2);
+  return `${" ".repeat(leftPadding)}${value}`;
 }
 
 async function getKeyStatus(provider: ProviderName): Promise<"set" | "not set"> {
@@ -277,6 +597,14 @@ function requiredField(message: string): (value: string) => true | string {
   };
 }
 
+function validateHexColor(value: string): true | string {
+  return isValidHexColor(value.trim()) || "Use #RRGGBB format.";
+}
+
+function normalizeHexColor(value: string): string {
+  return value.trim().toUpperCase();
+}
+
 function assertNever(value: never): never {
   throw new Error(`Unsupported provider: ${String(value)}`);
 }

package/src/cli/commands/init.ts

@@ -2,7 +2,6 @@ import process from "node:process";
 import * as fs from "node:fs";
 import { join } from "node:path";
 
-import chalk from "chalk";
 import { Command } from "commander";
 import inquirer from "inquirer";
 import keytar from "keytar";
@@ -10,6 +9,12 @@ import ora from "ora";
 
 import { buildDefaultPersona } from "../../agent/agent.js";
 import { promptForModel, promptForProvider } from "../helpers/providerPrompts.js";
+import {
+  renderHiveHeader,
+  renderInfo,
+  renderStep,
+  renderSuccess,
+} from "../ui.js";
 import {
   closeHiveDatabase,
   getHiveHomeDir,
@@ -49,6 +54,7 @@ export function registerInitCommand(program: Command): void {
 }
 
 export async function runInitCommand(options: InitCommandOptions = {}): Promise<void> {
+  renderHiveHeader("Init");
   const spinner = ora("Preparing init...").start();
   const db = openHiveDatabase();
 
@@ -71,7 +77,7 @@ export async function runInitCommand(options: InitCommandOptions = {}): Promise<
       ])) as { reinitialize: boolean };
 
       if (!reinitialize) {
-        console.log(chalk.dim("Initialization cancelled."));
+        renderInfo("Initialization cancelled.");
         return;
       }
     }
@@ -101,13 +107,13 @@ export async function runInitCommand(options: InitCommandOptions = {}): Promise<
     copyPromptsDirectory(options.force ?? false);
 
     spinner.succeed("Initialization complete.");
-    console.log(chalk.green(`HIVE-ID: ${agent.id}`));
+    renderSuccess(`HIVE-ID: ${agent.id}`);
     if (agent.agent_name) {
-      console.log(chalk.green(`Agent name: ${agent.agent_name}`));
+      renderSuccess(`Agent name: ${agent.agent_name}`);
     }
-    console.log(chalk.green(`Provider: ${agent.provider}`));
-    console.log(chalk.green(`Model: ${agent.model}`));
-    console.log("Run `hive chat` to start talking.");
+    renderSuccess(`Provider: ${agent.provider}`);
+    renderSuccess(`Model: ${agent.model}`);
+    renderStep("Run `hive` to start talking.");
   } catch (error) {
     if (spinner.isSpinning) {
       spinner.fail("Hive initialization failed.");
@@ -225,18 +231,58 @@ function copyPromptsDirectory(force: boolean): void {
   const destinationPath = join(getHiveHomeDir(), "prompts");
 
   if (!fs.existsSync(sourcePath)) {
-    console.warn(chalk.yellow("Warning: prompts/ folder not found. Skipping prompts load."));
+    renderInfo("Warning: prompts/ folder not found. Skipping prompts load.");
+    return;
+  }
+
+  if (force && fs.existsSync(destinationPath)) {
+    fs.rmSync(destinationPath, { recursive: true, force: true });
+  }
+
+  fs.mkdirSync(destinationPath, { recursive: true });
+  const copiedFiles = syncPromptFiles(sourcePath, destinationPath, force);
+
+  if (copiedFiles === 0) {
+    renderStep("Prompts already up to date -> ~/.hive/prompts/");
     return;
   }
 
-  if (fs.existsSync(destinationPath)) {
-    if (!force) {
-      return;
+  renderStep(`Prompts loaded -> ~/.hive/prompts/ (${copiedFiles} files)`);
+}
+
+function syncPromptFiles(
+  sourceDirectory: string,
+  destinationDirectory: string,
+  overwriteExisting: boolean,
+): number {
+  let copiedCount = 0;
+  const entries = fs.readdirSync(sourceDirectory, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const sourceEntryPath = join(sourceDirectory, entry.name);
+    const destinationEntryPath = join(destinationDirectory, entry.name);
+
+    if (entry.isDirectory()) {
+      fs.mkdirSync(destinationEntryPath, { recursive: true });
+      copiedCount += syncPromptFiles(
+        sourceEntryPath,
+        destinationEntryPath,
+        overwriteExisting,
+      );
+      continue;
     }
 
-    fs.rmSync(destinationPath, { recursive: true, force: true });
+    if (!entry.isFile()) {
+      continue;
+    }
+
+    if (!overwriteExisting && fs.existsSync(destinationEntryPath)) {
+      continue;
+    }
+
+    fs.copyFileSync(sourceEntryPath, destinationEntryPath);
+    copiedCount += 1;
   }
 
-  fs.cpSync(sourcePath, destinationPath, { recursive: true });
-  console.log("Prompts loaded → ~/.hive/prompts/");
+  return copiedCount;
 }

package/src/cli/commands/nuke.ts

@@ -2,12 +2,17 @@ import * as fs from "node:fs";
 import { stdin, stdout } from "node:process";
 import { createInterface } from "node:readline/promises";
 
-import chalk from "chalk";
 import { Command } from "commander";
 import keytar from "keytar";
 
 import { SUPPORTED_PROVIDER_NAMES } from "../../providers/base.js";
 import { getHiveHomeDir } from "../../storage/db.js";
+import {
+  renderError,
+  renderHiveHeader,
+  renderInfo,
+  renderSuccess,
+} from "../ui.js";
 
 const KEYCHAIN_SERVICE = "hive";
 const NUKE_CONFIRMATION = "nuke";
@@ -22,10 +27,9 @@ export function registerNukeCommand(program: Command): void {
 }
 
 export async function runNukeCommand(): Promise<void> {
-  console.log(
-    chalk.red(
-      "This will permanently delete your agent, all memory, all conversations, and all keys. This cannot be undone.",
-    ),
+  renderHiveHeader("Nuke");
+  renderError(
+    "This will permanently delete your agent, all memory, all conversations, and all keys. This cannot be undone.",
   );
 
   const rl = createInterface({
@@ -42,7 +46,7 @@ export async function runNukeCommand(): Promise<void> {
   }
 
   if (confirmation !== NUKE_CONFIRMATION) {
-    console.log(chalk.dim("Aborted."));
+    renderInfo("Aborted.");
     return;
   }
 
@@ -56,5 +60,5 @@ export async function runNukeCommand(): Promise<void> {
     }
   }
 
-  console.log(chalk.green("The Hive has been nuked. Gone."));
+  renderSuccess("The Hive has been nuked. Gone.");
 }