@imisbahk/hive 0.1.0 → 0.1.2

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);
@@ -82,7 +105,7 @@ async function getApiKeyStatus(providerName: string): Promise<string> {
 
 function printStatusLine(label: string, value: string): void {
   const paddedLabel = `${label}:`.padEnd(10, " ");
-  console.log(`${chalk.dim(paddedLabel)} ${chalk.whiteBright(value)}`);
+  console.log(`${chalk.dim(paddedLabel)} ${value}`);
 }
 
 function getFileSize(path: string): number {

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/theme.ts

@@ -0,0 +1,88 @@
+import chalk, { type ChalkInstance } from "chalk";
+
+import {
+  closeHiveDatabase,
+  getMetaValue,
+  openHiveDatabase,
+} from "../storage/db.js";
+
+export const DEFAULT_THEME_NAME = "amber";
+export const DEFAULT_THEME_HEX = "#FFA500";
+
+export const BUILT_IN_THEMES = {
+  amber: "#FFA500",
+  cyan: "#00BCD4",
+  rose: "#FF4081",
+  slate: "#90A4AE",
+  green: "#00E676",
+} as const;
+
+export const HEX_COLOR_PATTERN = /^#[0-9A-Fa-f]{6}$/;
+
+export type BuiltInThemeName = keyof typeof BUILT_IN_THEMES;
+export type ThemeName = BuiltInThemeName | "custom";
+
+export interface HiveTheme {
+  name: ThemeName;
+  hex: string;
+  accent: ChalkInstance;
+}
+
+export function applyTheme(hex: string): ChalkInstance {
+  const normalizedHex = normalizeHex(hex);
+  return chalk.hex(normalizedHex);
+}
+
+export function getTheme(): HiveTheme {
+  let db: ReturnType<typeof openHiveDatabase> | null = null;
+
+  try {
+    db = openHiveDatabase();
+    const storedName = getMetaValue(db, "theme");
+    const storedHex = getMetaValue(db, "theme_hex");
+    return resolveTheme(storedName, storedHex);
+  } catch {
+    return makeTheme(DEFAULT_THEME_NAME, DEFAULT_THEME_HEX);
+  } finally {
+    if (db) {
+      closeHiveDatabase(db);
+    }
+  }
+}
+
+export function isValidHexColor(value: string): boolean {
+  return HEX_COLOR_PATTERN.test(value);
+}
+
+function resolveTheme(storedName: string | null, storedHex: string | null): HiveTheme {
+  if (isBuiltInTheme(storedName)) {
+    return makeTheme(storedName, BUILT_IN_THEMES[storedName]);
+  }
+
+  if (storedName === "custom" && storedHex && isValidHexColor(storedHex)) {
+    return makeTheme("custom", storedHex);
+  }
+
+  return makeTheme(DEFAULT_THEME_NAME, DEFAULT_THEME_HEX);
+}
+
+function makeTheme(name: ThemeName, hex: string): HiveTheme {
+  const normalizedHex = normalizeHex(hex);
+  return {
+    name,
+    hex: normalizedHex,
+    accent: applyTheme(normalizedHex),
+  };
+}
+
+function normalizeHex(value: string): string {
+  if (!isValidHexColor(value)) {
+    return DEFAULT_THEME_HEX;
+  }
+
+  return value.toUpperCase();
+}
+
+function isBuiltInTheme(value: string | null): value is BuiltInThemeName {
+  return value !== null && value in BUILT_IN_THEMES;
+}

package/src/cli/ui.ts

@@ -0,0 +1,127 @@
+import { readFileSync } from "node:fs";
+import process from "node:process";
+
+import chalk from "chalk";
+
+import { getTheme } from "./theme.js";
+
+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));
+  const accent = getTheme().accent;
+
+  for (const line of WORDMARK_LINES) {
+    console.log(accent.bold(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(accent(centerText(commandCentreTitle, terminalWidth)));
+  console.log(accent(centerText(separator, terminalWidth)));
+}
+
+export function renderSuccess(message: string): void {
+  const accent = getTheme().accent;
+  console.log(`${accent("✓")} ${message}`);
+}
+
+export function renderError(message: string): void {
+  console.error(chalk.red(message));
+}
+
+export function renderStep(message: string): void {
+  const accent = getTheme().accent;
+  console.log(`${accent("›")} ${message}`);
+}
+
+export function renderInfo(message: string): void {
+  console.log(chalk.dim(message));
+}
+
+export function renderSeparator(text?: string): void {
+  const accent = getTheme().accent;
+
+  if (text) {
+    console.log(accent(text));
+    return;
+  }
+
+  console.log(accent("─".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);
+}

package/src/providers/base.ts

@@ -12,11 +12,38 @@ export const SUPPORTED_PROVIDER_NAMES = [
 ] as const;
 
 export type ProviderName = (typeof SUPPORTED_PROVIDER_NAMES)[number];
-export type ProviderMessageRole = "system" | "user" | "assistant";
+export type ProviderMessageRole = "system" | "user" | "assistant" | "tool";
+
+export interface ProviderToolDefinition {
+  type: "function";
+  function: {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+  };
+}
+
+export interface ProviderToolCallPayload {
+  id: string;
+  type: "function";
+  function: {
+    name: string;
+    arguments: string;
+  };
+}
+
+export interface ProviderToolCall {
+  id: string;
+  name: string;
+  arguments: string;
+}
 
 export interface ProviderMessage {
   role: ProviderMessageRole;
   content: string;
+  name?: string;
+  tool_call_id?: string;
+  tool_calls?: ProviderToolCallPayload[];
 }
 
 export interface StreamChatRequest {
@@ -26,10 +53,20 @@ export interface StreamChatRequest {
   maxTokens?: number;
 }
 
+export interface CompleteChatRequest extends StreamChatRequest {
+  tools?: ProviderToolDefinition[];
+}
+
+export interface CompleteChatResponse {
+  content: string;
+  toolCalls: ProviderToolCall[];
+}
+
 export interface Provider {
   readonly name: ProviderName;
   readonly defaultModel: string;
   streamChat(request: StreamChatRequest): AsyncGenerator<string>;
+  completeChat?(request: CompleteChatRequest): Promise<CompleteChatResponse>;
 }
 
 export class ProviderConfigurationError extends Error {
@@ -58,6 +95,10 @@ export interface OpenAICompatibleStreamInput {
   extraBody?: Record<string, unknown>;
 }
 
+export interface OpenAICompatibleCompleteInput extends OpenAICompatibleStreamInput {
+  tools?: ProviderToolDefinition[];
+}
+
 export function normalizeProviderName(raw?: string): ProviderName {
   if (!raw) {
     return "openai";
@@ -146,6 +187,71 @@ export async function* streamOpenAICompatibleChat(
   }
 }
 
+export async function completeOpenAICompatibleChat(
+  input: OpenAICompatibleCompleteInput,
+): Promise<CompleteChatResponse> {
+  const endpoint = `${input.baseUrl.replace(/\/$/, "")}/chat/completions`;
+
+  const headers: Record<string, string> = {
+    "content-type": "application/json",
+    ...(input.extraHeaders ?? {}),
+  };
+
+  if (input.apiKey) {
+    headers.authorization = `Bearer ${input.apiKey}`;
+  }
+
+  const body: Record<string, unknown> = {
+    model: input.model,
+    messages: input.messages,
+    stream: false,
+    ...(input.extraBody ?? {}),
+  };
+
+  if (input.temperature !== undefined) {
+    body.temperature = input.temperature;
+  }
+
+  if (input.maxTokens !== undefined) {
+    body.max_tokens = input.maxTokens;
+  }
+
+  if (input.tools && input.tools.length > 0) {
+    body.tools = input.tools;
+    body.tool_choice = "auto";
+  }
+
+  const response = await fetch(endpoint, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body),
+  });
+
+  await ensureOk(response, `${input.provider} request failed`);
+
+  const payload = (await response.json()) as Record<string, unknown>;
+  const errorMessage = pickErrorMessage(payload);
+  if (errorMessage) {
+    throw new ProviderRequestError(`${input.provider} error: ${errorMessage}`);
+  }
+
+  const maybeChoices = payload.choices;
+  if (!Array.isArray(maybeChoices) || maybeChoices.length === 0) {
+    throw new ProviderRequestError(`${input.provider} response did not include choices.`);
+  }
+
+  const firstChoice = maybeChoices[0] as Record<string, unknown>;
+  const message = firstChoice.message as Record<string, unknown> | undefined;
+
+  const content = pickMessageContent(message);
+  const toolCalls = pickToolCalls(message);
+
+  return {
+    content,
+    toolCalls,
+  };
+}
+
 export async function* iterateSseData(response: Response): AsyncGenerator<string> {
   if (!response.body) {
     return;
@@ -220,6 +326,75 @@ function pickErrorMessage(payload: Record<string, unknown>): string | null {
   return null;
 }
 
+function pickMessageContent(message: Record<string, unknown> | undefined): string {
+  if (!message) {
+    return "";
+  }
+
+  const rawContent = message.content;
+  if (typeof rawContent === "string") {
+    return rawContent;
+  }
+
+  if (Array.isArray(rawContent)) {
+    return rawContent
+      .map((part) => {
+        if (typeof part === "string") {
+          return part;
+        }
+
+        if (part && typeof part === "object") {
+          const asRecord = part as Record<string, unknown>;
+          if (typeof asRecord.text === "string") {
+            return asRecord.text;
+          }
+        }
+
+        return "";
+      })
+      .join("");
+  }
+
+  return "";
+}
+
+function pickToolCalls(message: Record<string, unknown> | undefined): ProviderToolCall[] {
+  if (!message) {
+    return [];
+  }
+
+  const rawToolCalls = message.tool_calls;
+  if (!Array.isArray(rawToolCalls)) {
+    return [];
+  }
+
+  const calls: ProviderToolCall[] = [];
+  for (const toolCall of rawToolCalls) {
+    if (!toolCall || typeof toolCall !== "object") {
+      continue;
+    }
+
+    const callRecord = toolCall as Record<string, unknown>;
+    const callId = typeof callRecord.id === "string" ? callRecord.id : "";
+    const callFunction = callRecord.function as Record<string, unknown> | undefined;
+    const callName = typeof callFunction?.name === "string" ? callFunction.name : "";
+    const callArguments =
+      typeof callFunction?.arguments === "string" ? callFunction.arguments : "{}";
+
+    if (callId.length === 0 || callName.length === 0) {
+      continue;
+    }
+
+    calls.push({
+      id: callId,
+      name: callName,
+      arguments: callArguments,
+    });
+  }
+
+  return calls;
+}
+
 async function ensureOk(response: Response, fallbackMessage: string): Promise<void> {
   if (response.ok) {
     return;

package/src/providers/openai-compatible.ts

@@ -1,4 +1,7 @@
 import {
+  completeOpenAICompatibleChat,
+  type CompleteChatRequest,
+  type CompleteChatResponse,
   ProviderConfigurationError,
   type Provider,
   type ProviderName,
@@ -55,4 +58,25 @@ export class OpenAICompatibleProvider implements Provider {
       extraBody: this.extraBody,
     });
   }
+
+  async completeChat(request: CompleteChatRequest): Promise<CompleteChatResponse> {
+    if (!this.allowMissingApiKey && !this.apiKey) {
+      throw new ProviderConfigurationError(
+        `Provider \"${this.name}\" is missing an API key.`,
+      );
+    }
+
+    return completeOpenAICompatibleChat({
+      provider: this.name,
+      baseUrl: this.baseUrl,
+      apiKey: this.apiKey,
+      model: request.model ?? this.defaultModel,
+      messages: request.messages,
+      temperature: request.temperature,
+      maxTokens: request.maxTokens,
+      tools: request.tools,
+      extraHeaders: this.extraHeaders,
+      extraBody: this.extraBody,
+    });
+  }
 }