@imisbahk/hive 0.1.0 → 0.1.1

package/src/cli/commands/config.ts

@@ -1,6 +1,5 @@
 import process from "node:process";
 
-import chalk from "chalk";
 import { Command } from "commander";
 import inquirer from "inquirer";
 import keytar from "keytar";
@@ -9,6 +8,13 @@ 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 {
   closeHiveDatabase,
   getPrimaryAgent,
@@ -20,6 +26,14 @@ import {
 
 const KEYCHAIN_SERVICE = "hive";
 
+interface ConfigShowRenderOptions {
+  showHeader?: boolean;
+}
+
+interface ConfigInteractiveRenderOptions {
+  showHeader?: boolean;
+}
+
 export function registerConfigCommand(program: Command): void {
   const configCommand = program
     .command("config")
@@ -52,9 +66,24 @@ export function registerConfigCommand(program: Command): void {
     .action(async () => {
       await runConfigShowCommand();
     });
+
+  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 +93,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 +139,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 +152,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 +171,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 +191,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 +204,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 +223,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 +246,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 +259,33 @@ export async function runConfigKeyCommand(): Promise<void> {
 }
 
 export async function runConfigShowCommand(): Promise<void> {
+  await runConfigShowCommandWithOptions();
+}
+
+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);
   }
@@ -235,8 +298,8 @@ 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}`);
 }
 
 async function getKeyStatus(provider: ProviderName): Promise<"set" | "not set"> {

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

package/src/cli/commands/status.ts

@@ -5,6 +5,12 @@ import { join } from "node:path";
 import chalk from "chalk";
 import { Command } from "commander";
 import keytar from "keytar";
+import {
+  renderHiveHeader,
+  renderInfo,
+  renderSeparator,
+  renderStep,
+} from "../ui.js";
 
 import {
   closeHiveDatabase,
@@ -18,6 +24,10 @@ import {
 const KEYCHAIN_SERVICE = "hive";
 const PROMPTS_DIRECTORY = "prompts";
 
+interface StatusCommandRenderOptions {
+  showHeader?: boolean;
+}
+
 export function registerStatusCommand(program: Command): void {
   program
     .command("status")
@@ -28,12 +38,23 @@ export function registerStatusCommand(program: Command): void {
 }
 
 export async function runStatusCommand(): Promise<void> {
+  await runStatusCommandWithOptions();
+}
+
+export async function runStatusCommandWithOptions(
+  options: StatusCommandRenderOptions = {},
+): Promise<void> {
+  const showHeader = options.showHeader ?? true;
+  if (showHeader) {
+    renderHiveHeader("Status");
+  }
+
   const db = openHiveDatabase();
 
   try {
     const agent = getPrimaryAgent(db);
     if (!agent) {
-      console.log("Hive is not initialized. Run `hive init` to get started.");
+      renderInfo("Hive is not initialized. Run `hive init` to get started.");
       return;
     }
 
@@ -45,14 +66,16 @@ export async function runStatusCommand(): Promise<void> {
     const promptFiles = countFiles(promptsPath);
     const initializedRaw = getMetaValue(db, "initialized_at") ?? agent.created_at;
 
-    console.log(chalk.whiteBright("🐝 The Hive — Status"));
-    console.log();
+    if (showHeader) {
+      renderStep("Status");
+    }
+    renderSeparator();
     printStatusLine("Agent", agent.agent_name ?? "not set");
     printStatusLine("Owner", agent.name);
     printStatusLine("Provider", provider);
     printStatusLine("Model", agent.model);
     printStatusLine("API Key", keyStatus);
-    console.log();
+    renderSeparator();
     printStatusLine(
       "Database",
       `${displayPath(dbPath)} (${formatBytes(dbSizeBytes)})`,
@@ -61,7 +84,7 @@ export async function runStatusCommand(): Promise<void> {
       "Prompts",
       `${ensureTrailingSlash(displayPath(promptsPath))} (${promptFiles} files)`,
     );
-    console.log();
+    renderSeparator();
     printStatusLine("Initialized", formatDate(initializedRaw));
   } finally {
     closeHiveDatabase(db);

package/src/cli/index.ts

@@ -2,21 +2,21 @@
 
 import "dotenv/config";
 
-import chalk from "chalk";
 import { Command } from "commander";
 
-import { registerChatCommand } from "./commands/chat.js";
+import { registerChatCommand, runChatCommand } from "./commands/chat.js";
 import { registerConfigCommand } from "./commands/config.js";
 import { registerInitCommand } from "./commands/init.js";
 import { registerNukeCommand } from "./commands/nuke.js";
 import { registerStatusCommand } from "./commands/status.js";
+import { renderError, renderHiveHeader } from "./ui.js";
 
 const program = new Command();
 
 program
   .name("hive")
   .description("Your agent. Always running. Always learning. Always working.")
-  .version("0.1.0");
+  .version("0.1.1");
 
 registerInitCommand(program);
 registerChatCommand(program);
@@ -24,15 +24,43 @@ registerConfigCommand(program);
 registerStatusCommand(program);
 registerNukeCommand(program);
 
-program
-  .parseAsync(process.argv)
-  .catch((error: unknown) => {
+const argv = process.argv.slice(2);
+
+void main();
+
+async function main(): Promise<void> {
+  try {
+    if (argv.length === 0) {
+      await runChatCommand({}, { entrypoint: "default" });
+      return;
+    }
+
+    if (shouldRenderHelpHeader(argv)) {
+      renderHiveHeader(resolveHelpTitle(argv));
+    }
+
+    await program.parseAsync(process.argv);
+  } catch (error) {
     if (error instanceof Error) {
-      console.error(chalk.red(error.message));
+      renderError(error.message);
       process.exitCode = 1;
       return;
     }
 
-    console.error(chalk.red(String(error)));
+    renderError(String(error));
     process.exitCode = 1;
-  });
+  }
+}
+
+function shouldRenderHelpHeader(args: string[]): boolean {
+  return args[0] === "help" || args.includes("-h") || args.includes("--help");
+}
+
+function resolveHelpTitle(args: string[]): string {
+  if (args[0] === "help") {
+    return args[1] ?? "Help";
+  }
+
+  const commandName = args.find((arg) => !arg.startsWith("-"));
+  return commandName ?? "Help";
+}

package/src/cli/ui.ts

@@ -0,0 +1,120 @@
+import { readFileSync } from "node:fs";
+import process from "node:process";
+
+import chalk from "chalk";
+
+const WORDMARK_LINES = [
+  "  ██╗  ██╗██╗██╗   ██╗███████╗",
+  "  ██║  ██║██║██║   ██║██╔════╝",
+  "  ███████║██║██║   ██║█████╗  ",
+  "  ██╔══██║██║╚██╗ ██╔╝██╔══╝  ",
+  "  ██║  ██║██║ ╚████╔╝ ███████╗",
+  "  ╚═╝  ╚═╝╚═╝  ╚═══╝  ╚══════╝",
+] as const;
+
+const COMMAND_CENTRE_LABEL = "COMMAND CENTRE";
+const MAX_SEPARATOR_WIDTH = 72;
+const MIN_SEPARATOR_WIDTH = 24;
+
+let cachedVersion: string | null = null;
+
+export function renderHiveHeader(pageTitle?: string): void {
+  const terminalWidth = getTerminalWidth();
+  const separator = "─".repeat(getSeparatorWidth(terminalWidth));
+
+  for (const line of WORDMARK_LINES) {
+    console.log(chalk.bold.whiteBright(centerText(line, terminalWidth)));
+  }
+
+  console.log("");
+  console.log(chalk.dim(centerText(`v${getCliVersion()}`, terminalWidth)));
+
+  const normalizedTitle = normalizePageTitle(pageTitle);
+  const commandCentreTitle = normalizedTitle
+    ? `${COMMAND_CENTRE_LABEL} · ${normalizedTitle}`
+    : COMMAND_CENTRE_LABEL;
+
+  console.log(chalk.whiteBright(centerText(commandCentreTitle, terminalWidth)));
+  console.log(chalk.dim(centerText(separator, terminalWidth)));
+}
+
+export function renderSuccess(message: string): void {
+  console.log(chalk.green(message));
+}
+
+export function renderError(message: string): void {
+  console.error(chalk.red(message));
+}
+
+export function renderStep(message: string): void {
+  console.log(chalk.whiteBright(message));
+}
+
+export function renderInfo(message: string): void {
+  console.log(chalk.dim(message));
+}
+
+export function renderSeparator(text?: string): void {
+  if (text) {
+    console.log(chalk.dim(text));
+    return;
+  }
+
+  console.log(chalk.dim("─".repeat(getSeparatorWidth(getTerminalWidth()))));
+}
+
+function getCliVersion(): string {
+  if (cachedVersion) {
+    return cachedVersion;
+  }
+
+  try {
+    const raw = readFileSync(new URL("../../package.json", import.meta.url), "utf8");
+    const parsed = JSON.parse(raw) as { version?: unknown };
+    if (typeof parsed.version === "string" && parsed.version.trim().length > 0) {
+      cachedVersion = parsed.version.trim();
+      return cachedVersion;
+    }
+  } catch {
+    // Fall through to default when package metadata cannot be read.
+  }
+
+  cachedVersion = "0.0.0";
+  return cachedVersion;
+}
+
+function normalizePageTitle(pageTitle?: string): string {
+  const trimmed = pageTitle?.trim() ?? "";
+  if (trimmed.length === 0) {
+    return "";
+  }
+
+  return trimmed.toUpperCase();
+}
+
+function getTerminalWidth(): number {
+  if (!process.stdout.isTTY) {
+    return 80;
+  }
+
+  const columns = process.stdout.columns;
+  if (typeof columns !== "number" || columns < 20) {
+    return 80;
+  }
+
+  return columns;
+}
+
+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}`;
+}
+
+function getSeparatorWidth(terminalWidth: number): number {
+  const usableWidth = Math.max(MIN_SEPARATOR_WIDTH, terminalWidth - 8);
+  return Math.min(MAX_SEPARATOR_WIDTH, usableWidth);
+}