@imisbahk/hive 0.1.0

package/src/cli/commands/init.ts

@@ -0,0 +1,242 @@
+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";
+import ora from "ora";
+
+import { buildDefaultPersona } from "../../agent/agent.js";
+import { promptForModel, promptForProvider } from "../helpers/providerPrompts.js";
+import {
+  closeHiveDatabase,
+  getHiveHomeDir,
+  getPrimaryAgent,
+  openHiveDatabase,
+  setMetaValue,
+  upsertPrimaryAgent,
+} from "../../storage/db.js";
+import type { ProviderName } from "../../providers/base.js";
+
+interface InitAnswers {
+  name: string;
+  dob: string;
+  location: string;
+  profession: string;
+  aboutRaw: string;
+  provider: ProviderName;
+  model: string;
+  apiKey?: string;
+  agentName?: string;
+}
+
+interface InitCommandOptions {
+  force?: boolean;
+}
+
+const KEYCHAIN_SERVICE = "hive";
+
+export function registerInitCommand(program: Command): void {
+  program
+    .command("init")
+    .description("Birth your local Hive agent")
+    .option("--force", "overwrite ~/.hive/prompts when loading prompts")
+    .action(async (options: InitCommandOptions) => {
+      await runInitCommand(options);
+    });
+}
+
+export async function runInitCommand(options: InitCommandOptions = {}): Promise<void> {
+  const spinner = ora("Preparing init...").start();
+  const db = openHiveDatabase();
+
+  try {
+    if (!process.stdin.isTTY) {
+      throw new Error("`hive init` requires an interactive terminal.");
+    }
+
+    const existing = getPrimaryAgent(db);
+    spinner.stop();
+
+    if (existing) {
+      const { reinitialize } = (await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "reinitialize",
+          message: "Agent already exists. Reinitialize? (y/n)",
+          default: false,
+        },
+      ])) as { reinitialize: boolean };
+
+      if (!reinitialize) {
+        console.log(chalk.dim("Initialization cancelled."));
+        return;
+      }
+    }
+
+    const answers = await askInitQuestions();
+    spinner.start("Initializing...");
+
+    if (answers.provider !== "ollama" && answers.apiKey) {
+      await keytar.setPassword(KEYCHAIN_SERVICE, answers.provider, answers.apiKey);
+    }
+
+    const agent = upsertPrimaryAgent(db, {
+      name: answers.name,
+      provider: answers.provider,
+      model: answers.model,
+      persona: buildDefaultPersona(answers.name),
+      dob: answers.dob,
+      location: answers.location,
+      profession: answers.profession,
+      aboutRaw: answers.aboutRaw,
+      agentName: answers.agentName ?? null,
+    });
+
+    setMetaValue(db, "initialized_at", new Date().toISOString());
+    setMetaValue(db, "provider", agent.provider);
+    setMetaValue(db, "model", agent.model);
+    copyPromptsDirectory(options.force ?? false);
+
+    spinner.succeed("Initialization complete.");
+    console.log(chalk.green(`HIVE-ID: ${agent.id}`));
+    if (agent.agent_name) {
+      console.log(chalk.green(`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.");
+  } catch (error) {
+    if (spinner.isSpinning) {
+      spinner.fail("Hive initialization failed.");
+    }
+    throw error;
+  } finally {
+    closeHiveDatabase(db);
+  }
+}
+
+async function askInitQuestions(): Promise<InitAnswers> {
+  const { name } = (await inquirer.prompt([
+    {
+      type: "input",
+      name: "name",
+      message: "What's your name?",
+      validate: requiredField("Name is required."),
+    },
+  ])) as { name: string };
+
+  const { dob } = (await inquirer.prompt([
+    {
+      type: "input",
+      name: "dob",
+      message: "Date of birth? (DD/MM/YYYY)",
+      validate: (value: string) =>
+        /^\d{2}\/\d{2}\/\d{4}$/.test(value.trim()) || "Use DD/MM/YYYY format.",
+    },
+  ])) as { dob: string };
+
+  const { location } = (await inquirer.prompt([
+    {
+      type: "input",
+      name: "location",
+      message: "Where are you based?",
+      validate: requiredField("Location is required."),
+    },
+  ])) as { location: string };
+
+  const { profession } = (await inquirer.prompt([
+    {
+      type: "input",
+      name: "profession",
+      message: "What do you do?",
+      validate: requiredField("Profession is required."),
+    },
+  ])) as { profession: string };
+
+  const { aboutRaw } = (await inquirer.prompt([
+    {
+      type: "input",
+      name: "aboutRaw",
+      message:
+        "Tell me about yourself. Who you are, what you're building, what matters to you. No rules.",
+      validate: requiredField("About is required."),
+    },
+  ])) as { aboutRaw: string };
+
+  const provider = await promptForProvider();
+  const model = await promptForModel(provider);
+
+  let apiKey: string | undefined;
+  if (provider !== "ollama") {
+    const answer = (await inquirer.prompt([
+      {
+        type: "password",
+        name: "apiKey",
+        message: "Enter your API key:",
+        mask: "*",
+        validate: requiredField("API key is required."),
+      },
+    ])) as { apiKey: string };
+
+    apiKey = answer.apiKey.trim();
+  }
+
+  const { agentName } = (await inquirer.prompt([
+    {
+      type: "input",
+      name: "agentName",
+      message: "What do you want to call your agent? (optional)",
+    },
+  ])) as { agentName: string };
+
+  return {
+    name: name.trim(),
+    dob: dob.trim(),
+    location: location.trim(),
+    profession: profession.trim(),
+    aboutRaw,
+    provider,
+    model,
+    apiKey,
+    agentName: normalizeOptional(agentName),
+  };
+}
+
+function requiredField(message: string): (value: string) => true | string {
+  return (value: string) => {
+    if (value.trim().length > 0) {
+      return true;
+    }
+
+    return message;
+  };
+}
+
+function normalizeOptional(value: string): string | undefined {
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+}
+
+function copyPromptsDirectory(force: boolean): void {
+  const sourcePath = join(process.cwd(), "prompts");
+  const destinationPath = join(getHiveHomeDir(), "prompts");
+
+  if (!fs.existsSync(sourcePath)) {
+    console.warn(chalk.yellow("Warning: prompts/ folder not found. Skipping prompts load."));
+    return;
+  }
+
+  if (fs.existsSync(destinationPath)) {
+    if (!force) {
+      return;
+    }
+
+    fs.rmSync(destinationPath, { recursive: true, force: true });
+  }
+
+  fs.cpSync(sourcePath, destinationPath, { recursive: true });
+  console.log("Prompts loaded → ~/.hive/prompts/");
+}

package/src/cli/commands/nuke.ts

@@ -0,0 +1,60 @@
+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";
+
+const KEYCHAIN_SERVICE = "hive";
+const NUKE_CONFIRMATION = "nuke";
+
+export function registerNukeCommand(program: Command): void {
+  program
+    .command("nuke")
+    .description("Permanently delete your local Hive data and keys")
+    .action(async () => {
+      await runNukeCommand();
+    });
+}
+
+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.",
+    ),
+  );
+
+  const rl = createInterface({
+    input: stdin,
+    output: stdout,
+    terminal: true,
+  });
+
+  let confirmation = "";
+  try {
+    confirmation = (await rl.question('Are you sure? Type "nuke" to confirm: ')).trim();
+  } finally {
+    rl.close();
+  }
+
+  if (confirmation !== NUKE_CONFIRMATION) {
+    console.log(chalk.dim("Aborted."));
+    return;
+  }
+
+  fs.rmSync(getHiveHomeDir(), { recursive: true, force: true });
+
+  for (const providerName of SUPPORTED_PROVIDER_NAMES) {
+    try {
+      await keytar.deletePassword(KEYCHAIN_SERVICE, providerName);
+    } catch {
+      // Missing or inaccessible keychain entries are non-fatal for nuke.
+    }
+  }
+
+  console.log(chalk.green("The Hive has been nuked. Gone."));
+}

package/src/cli/commands/status.ts

@@ -0,0 +1,147 @@
+import * as fs from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+import chalk from "chalk";
+import { Command } from "commander";
+import keytar from "keytar";
+
+import {
+  closeHiveDatabase,
+  getHiveDatabasePath,
+  getHiveHomeDir,
+  getMetaValue,
+  getPrimaryAgent,
+  openHiveDatabase,
+} from "../../storage/db.js";
+
+const KEYCHAIN_SERVICE = "hive";
+const PROMPTS_DIRECTORY = "prompts";
+
+export function registerStatusCommand(program: Command): void {
+  program
+    .command("status")
+    .description("Show Hive setup status")
+    .action(async () => {
+      await runStatusCommand();
+    });
+}
+
+export async function runStatusCommand(): Promise<void> {
+  const db = openHiveDatabase();
+
+  try {
+    const agent = getPrimaryAgent(db);
+    if (!agent) {
+      console.log("Hive is not initialized. Run `hive init` to get started.");
+      return;
+    }
+
+    const provider = agent.provider;
+    const keyStatus = await getApiKeyStatus(provider);
+    const dbPath = getHiveDatabasePath();
+    const promptsPath = join(getHiveHomeDir(), PROMPTS_DIRECTORY);
+    const dbSizeBytes = getFileSize(dbPath);
+    const promptFiles = countFiles(promptsPath);
+    const initializedRaw = getMetaValue(db, "initialized_at") ?? agent.created_at;
+
+    console.log(chalk.whiteBright("🐝 The Hive — Status"));
+    console.log();
+    printStatusLine("Agent", agent.agent_name ?? "not set");
+    printStatusLine("Owner", agent.name);
+    printStatusLine("Provider", provider);
+    printStatusLine("Model", agent.model);
+    printStatusLine("API Key", keyStatus);
+    console.log();
+    printStatusLine(
+      "Database",
+      `${displayPath(dbPath)} (${formatBytes(dbSizeBytes)})`,
+    );
+    printStatusLine(
+      "Prompts",
+      `${ensureTrailingSlash(displayPath(promptsPath))} (${promptFiles} files)`,
+    );
+    console.log();
+    printStatusLine("Initialized", formatDate(initializedRaw));
+  } finally {
+    closeHiveDatabase(db);
+  }
+}
+
+async function getApiKeyStatus(providerName: string): Promise<string> {
+  let key: string | null = null;
+
+  try {
+    key = await keytar.getPassword(KEYCHAIN_SERVICE, providerName);
+  } catch {
+    key = null;
+  }
+
+  return key && key.trim().length > 0 ? "set ✓" : "not set ✗";
+}
+
+function printStatusLine(label: string, value: string): void {
+  const paddedLabel = `${label}:`.padEnd(10, " ");
+  console.log(`${chalk.dim(paddedLabel)} ${chalk.whiteBright(value)}`);
+}
+
+function getFileSize(path: string): number {
+  try {
+    return fs.statSync(path).size;
+  } catch {
+    return 0;
+  }
+}
+
+function countFiles(path: string): number {
+  try {
+    return fs
+      .readdirSync(path, { withFileTypes: true })
+      .filter((entry) => entry.isFile()).length;
+  } catch {
+    return 0;
+  }
+}
+
+function formatBytes(bytes: number): string {
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  let unitIndex = 0;
+  let value = bytes;
+
+  while (value >= 1024 && unitIndex < units.length - 1) {
+    value /= 1024;
+    unitIndex += 1;
+  }
+
+  if (unitIndex === 0) {
+    return `${value} ${units[unitIndex]}`;
+  }
+
+  return `${value.toFixed(1)} ${units[unitIndex]}`;
+}
+
+function formatDate(value: string): string {
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) {
+    return value;
+  }
+
+  return date.toISOString().slice(0, 10);
+}
+
+function displayPath(path: string): string {
+  const home = homedir();
+  if (path === home) {
+    return "~";
+  }
+
+  if (path.startsWith(`${home}/`)) {
+    return `~/${path.slice(home.length + 1)}`;
+  }
+
+  return path;
+}
+
+function ensureTrailingSlash(path: string): string {
+  return path.endsWith("/") ? path : `${path}/`;
+}

package/src/cli/helpers/providerPrompts.ts

@@ -0,0 +1,192 @@
+import inquirer from "inquirer";
+import fetch from "node-fetch";
+
+import { SUPPORTED_PROVIDER_NAMES, type ProviderName } from "../../providers/base.js";
+
+type HostedProviderName = Exclude<ProviderName, "ollama">;
+
+const OLLAMA_TAGS_URL = "http://localhost:11434/api/tags";
+
+const MODEL_CHOICES_BY_PROVIDER: Record<HostedProviderName, readonly string[]> = {
+  openai: ["gpt-4o", "gpt-4o-mini", "o1"],
+  anthropic: [
+    "claude-opus-4-6",
+    "claude-sonnet-4-6",
+    "claude-haiku-4-5-20251001",
+  ],
+  groq: ["llama-3.3-70b-versatile", "llama-3.1-8b-instant", "mixtral-8x7b-32768"],
+  mistral: ["mistral-large-latest", "mistral-small-latest", "codestral-latest"],
+  google: ["gemini-2.0-flash", "gemini-2.0-flash-lite", "gemini-2.0-pro-exp-02-05"],
+  openrouter: [
+    "openai/gpt-4o-mini",
+    "anthropic/claude-3.5-sonnet",
+    "google/gemini-2.0-flash-001",
+  ],
+  together: [
+    "meta-llama/Llama-3.3-70B-Instruct-Turbo",
+    "meta-llama/Llama-3.1-8B-Instruct-Turbo",
+    "Qwen/Qwen2.5-Coder-32B-Instruct",
+  ],
+};
+
+interface OllamaTagsResponse {
+  models?: Array<{
+    name?: string;
+    model?: string;
+  }>;
+}
+
+interface PromptForProviderOptions {
+  message?: string;
+  defaultProvider?: ProviderName;
+}
+
+interface PromptForModelOptions {
+  message?: string;
+  defaultModel?: string;
+}
+
+export async function promptForProvider(
+  options: PromptForProviderOptions = {},
+): Promise<ProviderName> {
+  const answer = (await inquirer.prompt([
+    {
+      type: "list",
+      name: "provider",
+      message: options.message ?? "Choose a provider",
+      choices: SUPPORTED_PROVIDER_NAMES.map((value) => ({
+        name: value,
+        value,
+      })),
+      default: options.defaultProvider,
+    },
+  ])) as { provider: ProviderName };
+
+  return answer.provider;
+}
+
+export async function promptForModel(
+  provider: ProviderName,
+  options: PromptForModelOptions = {},
+): Promise<string> {
+  const promptMessage = options.message ?? "Choose a model";
+
+  if (provider === "ollama") {
+    const ollamaModels = await fetchOllamaModels();
+
+    if (ollamaModels && ollamaModels.length > 0) {
+      const defaultSelection =
+        options.defaultModel && ollamaModels.includes(options.defaultModel)
+          ? [options.defaultModel]
+          : undefined;
+
+      const answer = (await inquirer.prompt([
+        {
+          type: "checkbox",
+          name: "model",
+          message: promptMessage,
+          choices: ollamaModels.map((value) => ({
+            name: value,
+            value,
+          })),
+          default: defaultSelection,
+          validate: (values: string[]) =>
+            values.length === 1 || "Select exactly one model.",
+        },
+      ])) as { model: string[] };
+
+      return answer.model[0];
+    }
+
+    const fallbackMessage =
+      ollamaModels === null
+        ? "Ollama not detected. Enter model name manually:"
+        : "No local Ollama models found. Enter model name manually:";
+
+    const answer = (await inquirer.prompt([
+      {
+        type: "input",
+        name: "model",
+        message: fallbackMessage,
+        validate: requiredField("Model is required."),
+      },
+    ])) as { model: string };
+
+    return answer.model.trim();
+  }
+
+  const modelChoices = MODEL_CHOICES_BY_PROVIDER[provider];
+  const defaultModel =
+    options.defaultModel && modelChoices.includes(options.defaultModel)
+      ? options.defaultModel
+      : undefined;
+
+  const answer = (await inquirer.prompt([
+    {
+      type: "list",
+      name: "model",
+      message: promptMessage,
+      choices: modelChoices.map((value) => ({
+        name: value,
+        value,
+      })),
+      default: defaultModel,
+    },
+  ])) as { model: string };
+
+  return answer.model;
+}
+
+async function fetchOllamaModels(): Promise<string[] | null> {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => {
+    controller.abort();
+  }, 1000);
+
+  try {
+    const response = await fetch(OLLAMA_TAGS_URL, {
+      signal: controller.signal,
+    });
+
+    if (!response.ok) {
+      return null;
+    }
+
+    const payload = (await response.json()) as OllamaTagsResponse;
+    if (!Array.isArray(payload.models)) {
+      return [];
+    }
+
+    return Array.from(
+      new Set(
+        payload.models
+          .map((entry) => {
+            if (typeof entry.name === "string" && entry.name.trim().length > 0) {
+              return entry.name.trim();
+            }
+
+            if (typeof entry.model === "string" && entry.model.trim().length > 0) {
+              return entry.model.trim();
+            }
+
+            return "";
+          })
+          .filter((value) => value.length > 0),
+      ),
+    );
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+function requiredField(message: string): (value: string) => true | string {
+  return (value: string) => {
+    if (value.trim().length > 0) {
+      return true;
+    }
+
+    return message;
+  };
+}

package/src/cli/index.ts

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+
+import "dotenv/config";
+
+import chalk from "chalk";
+import { Command } from "commander";
+
+import { registerChatCommand } 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";
+
+const program = new Command();
+
+program
+  .name("hive")
+  .description("Your agent. Always running. Always learning. Always working.")
+  .version("0.1.0");
+
+registerInitCommand(program);
+registerChatCommand(program);
+registerConfigCommand(program);
+registerStatusCommand(program);
+registerNukeCommand(program);
+
+program
+  .parseAsync(process.argv)
+  .catch((error: unknown) => {
+    if (error instanceof Error) {
+      console.error(chalk.red(error.message));
+      process.exitCode = 1;
+      return;
+    }
+
+    console.error(chalk.red(String(error)));
+    process.exitCode = 1;
+  });