@imisbahk/hive 0.1.0

package/src/agent/agent.ts

@@ -0,0 +1,155 @@
+import type {
+  AgentRecord,
+  ConversationRecord,
+  HiveDatabase,
+} from "../storage/db.js";
+import {
+  appendMessage,
+  createConversation,
+  getConversationById,
+  getPrimaryAgent,
+  listMessages,
+} from "../storage/db.js";
+import type { Provider, StreamChatRequest } from "../providers/base.js";
+import { createProvider } from "../providers/index.js";
+
+export interface AgentChatOptions {
+  conversationId?: string;
+  title?: string;
+  model?: string;
+  temperature?: number;
+  maxTokens?: number;
+}
+
+export type AgentStreamEvent =
+  | {
+      type: "token";
+      conversationId: string;
+      token: string;
+    }
+  | {
+      type: "done";
+      conversationId: string;
+      assistantMessageId: string;
+    };
+
+export class HiveAgent {
+  private readonly historyLimit = 80;
+
+  constructor(
+    private readonly db: HiveDatabase,
+    private readonly provider: Provider,
+    private readonly agent: AgentRecord,
+  ) {}
+
+  static async load(db: HiveDatabase, provider?: Provider): Promise<HiveAgent> {
+    const agent = getPrimaryAgent(db);
+    if (!agent) {
+      throw new Error("Hive is not initialized. Run `hive init` first.");
+    }
+
+    const resolvedProvider = provider ?? (await createProvider(agent.provider));
+    return new HiveAgent(db, resolvedProvider, agent);
+  }
+
+  getProfile(): AgentRecord {
+    return this.agent;
+  }
+
+  startConversation(title?: string): ConversationRecord {
+    return createConversation(this.db, {
+      agentId: this.agent.id,
+      title,
+    });
+  }
+
+  async *chat(
+    userMessage: string,
+    options: AgentChatOptions = {},
+  ): AsyncGenerator<AgentStreamEvent> {
+    const trimmed = userMessage.trim();
+    if (trimmed.length === 0) {
+      throw new Error("Cannot send an empty message.");
+    }
+
+    const conversation = this.resolveConversation(options.conversationId, options.title);
+
+    appendMessage(this.db, {
+      conversationId: conversation.id,
+      role: "user",
+      content: trimmed,
+    });
+
+    const history = listMessages(this.db, conversation.id, this.historyLimit);
+    const providerRequest: StreamChatRequest = {
+      model: options.model ?? this.agent.model,
+      temperature: options.temperature,
+      maxTokens: options.maxTokens,
+      messages: [
+        {
+          role: "system",
+          content: this.agent.persona,
+        },
+        ...history.map((message) => ({
+          role: message.role,
+          content: message.content,
+        })),
+      ],
+    };
+
+    let assistantText = "";
+    for await (const token of this.provider.streamChat(providerRequest)) {
+      assistantText += token;
+      yield {
+        type: "token",
+        conversationId: conversation.id,
+        token,
+      };
+    }
+
+    const savedMessage = appendMessage(this.db, {
+      conversationId: conversation.id,
+      role: "assistant",
+      content: assistantText,
+    });
+
+    yield {
+      type: "done",
+      conversationId: conversation.id,
+      assistantMessageId: savedMessage.id,
+    };
+  }
+
+  private resolveConversation(
+    conversationId?: string,
+    title?: string,
+  ): ConversationRecord {
+    if (!conversationId) {
+      return createConversation(this.db, {
+        agentId: this.agent.id,
+        title,
+      });
+    }
+
+    const existingConversation = getConversationById(this.db, conversationId);
+    if (!existingConversation) {
+      throw new Error(`Conversation \"${conversationId}\" was not found.`);
+    }
+
+    if (existingConversation.agent_id !== this.agent.id) {
+      throw new Error("Conversation does not belong to the initialized Hive agent.");
+    }
+
+    return existingConversation;
+  }
+}
+
+export function buildDefaultPersona(ownerName: string): string {
+  return [
+    "You are The Hive: a local-first personal AI agent.",
+    `You are assisting ${ownerName}.`,
+    "Be direct, useful, and execution-focused.",
+    "Prefer concrete actions over abstract advice.",
+    "If context is missing, ask one concise clarifying question.",
+  ].join("\n");
+}

package/src/agent/index.ts

@@ -0,0 +1,2 @@
+export { HiveAgent, buildDefaultPersona } from "./agent.js";
+export type { AgentChatOptions, AgentStreamEvent } from "./agent.js";

package/src/cli/commands/chat.ts

@@ -0,0 +1,169 @@
+import { stdin, stdout } from "node:process";
+import { createInterface } from "node:readline/promises";
+
+import chalk from "chalk";
+import { Command } from "commander";
+
+import { HiveAgent } from "../../agent/agent.js";
+import {
+  closeHiveDatabase,
+  getPrimaryAgent,
+  openHiveDatabase,
+} from "../../storage/db.js";
+import { createProvider } from "../../providers/index.js";
+
+interface ChatCommandOptions {
+  message?: string;
+  conversation?: string;
+  model?: string;
+  title?: string;
+  temperature?: string;
+}
+
+interface RunChatOptions {
+  model?: string;
+  title?: string;
+  temperature?: number;
+}
+
+export function registerChatCommand(program: Command): void {
+  program
+    .command("chat")
+    .description("Talk to your Hive agent")
+    .option("-m, --message <text>", "send a single message and exit")
+    .option("-c, --conversation <id>", "continue an existing conversation")
+    .option("--model <model>", "override model for this session")
+    .option("--title <title>", "title for a newly created conversation")
+    .option("-t, --temperature <value>", "sampling temperature")
+    .action(async (options: ChatCommandOptions) => {
+      await runChatCommand(options);
+    });
+}
+
+export async function runChatCommand(options: ChatCommandOptions): Promise<void> {
+  const temperature = parseTemperature(options.temperature);
+  const db = openHiveDatabase();
+
+  try {
+    const profile = getPrimaryAgent(db);
+    if (!profile) {
+      console.error(chalk.red("Hive is not initialized. Run `hive init` first."));
+      return;
+    }
+
+    const provider = await createProvider(profile.provider);
+    const agent = new HiveAgent(db, provider, profile);
+
+    let conversationId = options.conversation;
+    const runOptions: RunChatOptions = {
+      model: options.model,
+      title: options.title,
+      temperature,
+    };
+
+    if (options.message) {
+      conversationId = await streamReply(
+        agent,
+        options.message,
+        conversationId,
+        runOptions,
+      );
+      console.log(chalk.dim(`conversation: ${conversationId}`));
+      return;
+    }
+
+    const rl = createInterface({
+      input: stdin,
+      output: stdout,
+      terminal: true,
+    });
+
+    console.log(chalk.dim("Type /exit to quit, /new to start a fresh conversation."));
+
+    try {
+      while (true) {
+        const prompt = (await rl.question(chalk.cyan("you> "))).trim();
+
+        if (prompt.length === 0) {
+          continue;
+        }
+
+        if (prompt === "/exit" || prompt === "/quit") {
+          break;
+        }
+
+        if (prompt === "/new") {
+          conversationId = undefined;
+          console.log(chalk.dim("Started a new conversation context."));
+          continue;
+        }
+
+        try {
+          conversationId = await streamReply(agent, prompt, conversationId, runOptions);
+        } catch (error) {
+          process.stdout.write("\n");
+          console.error(formatError(error));
+        }
+      }
+    } finally {
+      rl.close();
+    }
+  } finally {
+    closeHiveDatabase(db);
+  }
+}
+
+async function streamReply(
+  agent: HiveAgent,
+  prompt: string,
+  conversationId: string | undefined,
+  options: RunChatOptions,
+): Promise<string> {
+  process.stdout.write(chalk.green("hive> "));
+
+  let activeConversationId = conversationId;
+
+  for await (const event of agent.chat(prompt, {
+    conversationId: activeConversationId,
+    model: options.model,
+    temperature: options.temperature,
+    title: options.title,
+  })) {
+    if (event.type === "token") {
+      process.stdout.write(event.token);
+      activeConversationId = event.conversationId;
+      continue;
+    }
+
+    activeConversationId = event.conversationId;
+  }
+
+  process.stdout.write("\n");
+
+  if (!activeConversationId) {
+    throw new Error("Conversation state was not returned by the agent.");
+  }
+
+  return activeConversationId;
+}
+
+function parseTemperature(raw?: string): number | undefined {
+  if (raw === undefined) {
+    return undefined;
+  }
+
+  const parsed = Number.parseFloat(raw);
+  if (Number.isNaN(parsed) || parsed < 0 || parsed > 2) {
+    throw new Error("Temperature must be a number between 0 and 2.");
+  }
+
+  return parsed;
+}
+
+function formatError(error: unknown): string {
+  if (error instanceof Error) {
+    return chalk.red(error.message);
+  }
+
+  return chalk.red(String(error));
+}

package/src/cli/commands/config.ts

@@ -0,0 +1,282 @@
+import process from "node:process";
+
+import chalk from "chalk";
+import { Command } from "commander";
+import inquirer from "inquirer";
+import keytar from "keytar";
+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 {
+  closeHiveDatabase,
+  getPrimaryAgent,
+  openHiveDatabase,
+  setMetaValue,
+  updatePrimaryAgentModel,
+  updatePrimaryAgentProviderAndModel,
+} from "../../storage/db.js";
+
+const KEYCHAIN_SERVICE = "hive";
+
+export function registerConfigCommand(program: Command): void {
+  const configCommand = program
+    .command("config")
+    .description("Update provider, model, or API keys without re-running init");
+
+  configCommand
+    .command("provider")
+    .description("Change provider, model, and API key")
+    .action(async () => {
+      await runConfigProviderCommand();
+    });
+
+  configCommand
+    .command("model")
+    .description("Change model for the current provider")
+    .action(async () => {
+      await runConfigModelCommand();
+    });
+
+  configCommand
+    .command("key")
+    .description("Update API key for the current provider")
+    .action(async () => {
+      await runConfigKeyCommand();
+    });
+
+  configCommand
+    .command("show")
+    .description("Show current provider, model, and key status")
+    .action(async () => {
+      await runConfigShowCommand();
+    });
+}
+
+export async function runConfigProviderCommand(): Promise<void> {
+  const spinner = ora("Loading configuration...").start();
+  const db = openHiveDatabase();
+
+  try {
+    ensureInteractiveTerminal("`hive config provider` requires an interactive terminal.");
+
+    const agent = getPrimaryAgent(db);
+    if (!agent) {
+      spinner.stop();
+      console.error(chalk.red("Hive is not initialized. Run `hive init` first."));
+      return;
+    }
+
+    const currentProvider = normalizeProviderName(agent.provider);
+    const currentModel = agent.model;
+
+    spinner.stop();
+    printCurrentProviderAndModel(currentProvider, currentModel);
+
+    const provider = await promptForProvider({
+      defaultProvider: currentProvider,
+    });
+    const model = await promptForModel(provider, {
+      defaultModel: provider === currentProvider ? currentModel : undefined,
+    });
+
+    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();
+    }
+
+    spinner.start("Saving configuration...");
+
+    const updatedAgent = updatePrimaryAgentProviderAndModel(db, {
+      provider,
+      model,
+    });
+    setMetaValue(db, "provider", updatedAgent.provider);
+    setMetaValue(db, "model", updatedAgent.model);
+
+    if (provider !== "ollama" && apiKey) {
+      await keytar.setPassword(KEYCHAIN_SERVICE, provider, apiKey);
+    }
+
+    spinner.succeed("Configuration saved.");
+    console.log("Provider updated. Run `hive chat` to use it.");
+  } catch (error) {
+    if (spinner.isSpinning) {
+      spinner.fail("Failed to update provider configuration.");
+    }
+    throw error;
+  } finally {
+    closeHiveDatabase(db);
+  }
+}
+
+export async function runConfigModelCommand(): Promise<void> {
+  const spinner = ora("Loading configuration...").start();
+  const db = openHiveDatabase();
+
+  try {
+    ensureInteractiveTerminal("`hive config model` requires an interactive terminal.");
+
+    const agent = getPrimaryAgent(db);
+    if (!agent) {
+      spinner.stop();
+      console.error(chalk.red("Hive is not initialized. Run `hive init` first."));
+      return;
+    }
+
+    const provider = normalizeProviderName(agent.provider);
+    const currentModel = agent.model;
+
+    spinner.stop();
+    printCurrentProviderAndModel(provider, currentModel);
+
+    const model = await promptForModel(provider, {
+      defaultModel: currentModel,
+    });
+
+    spinner.start("Saving model...");
+
+    const updatedAgent = updatePrimaryAgentModel(db, model);
+    setMetaValue(db, "model", updatedAgent.model);
+
+    spinner.succeed("Configuration saved.");
+    console.log("Model updated. Run `hive chat` to use it.");
+  } catch (error) {
+    if (spinner.isSpinning) {
+      spinner.fail("Failed to update model configuration.");
+    }
+    throw error;
+  } finally {
+    closeHiveDatabase(db);
+  }
+}
+
+export async function runConfigKeyCommand(): Promise<void> {
+  const spinner = ora("Loading configuration...").start();
+  const db = openHiveDatabase();
+
+  try {
+    ensureInteractiveTerminal("`hive config key` requires an interactive terminal.");
+
+    const agent = getPrimaryAgent(db);
+    if (!agent) {
+      spinner.stop();
+      console.error(chalk.red("Hive is not initialized. Run `hive init` first."));
+      return;
+    }
+
+    const provider = normalizeProviderName(agent.provider);
+
+    spinner.stop();
+    console.log(chalk.dim(`Current provider: ${provider}`));
+
+    const answer = (await inquirer.prompt([
+      {
+        type: "password",
+        name: "apiKey",
+        message: "Enter your API key:",
+        mask: "*",
+        validate: requiredField("API key is required."),
+      },
+    ])) as { apiKey: string };
+
+    spinner.start("Saving key...");
+    await keytar.setPassword(KEYCHAIN_SERVICE, provider, answer.apiKey.trim());
+
+    spinner.succeed("Configuration saved.");
+    console.log("API key updated. Run `hive chat` to use it.");
+  } catch (error) {
+    if (spinner.isSpinning) {
+      spinner.fail("Failed to update API key.");
+    }
+    throw error;
+  } finally {
+    closeHiveDatabase(db);
+  }
+}
+
+export async function runConfigShowCommand(): Promise<void> {
+  const db = openHiveDatabase();
+
+  try {
+    const agent = getPrimaryAgent(db);
+    if (!agent) {
+      console.error(chalk.red("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}`);
+  } finally {
+    closeHiveDatabase(db);
+  }
+}
+
+function ensureInteractiveTerminal(errorMessage: string): void {
+  if (!process.stdin.isTTY) {
+    throw new Error(errorMessage);
+  }
+}
+
+function printCurrentProviderAndModel(provider: ProviderName, model: string): void {
+  console.log(chalk.dim(`Current provider: ${provider}`));
+  console.log(chalk.dim(`Current model: ${model}`));
+}
+
+async function getKeyStatus(provider: ProviderName): Promise<"set" | "not set"> {
+  const apiKey = await resolveProviderApiKey(provider, apiKeyEnvVar(provider));
+  return apiKey ? "set" : "not set";
+}
+
+function apiKeyEnvVar(provider: ProviderName): string {
+  switch (provider) {
+    case "openai":
+      return "OPENAI_API_KEY";
+    case "anthropic":
+      return "ANTHROPIC_API_KEY";
+    case "ollama":
+      return "OLLAMA_API_KEY";
+    case "groq":
+      return "GROQ_API_KEY";
+    case "mistral":
+      return "MISTRAL_API_KEY";
+    case "google":
+      return "GOOGLE_API_KEY";
+    case "openrouter":
+      return "OPENROUTER_API_KEY";
+    case "together":
+      return "TOGETHER_API_KEY";
+    default:
+      return assertNever(provider);
+  }
+}
+
+function requiredField(message: string): (value: string) => true | string {
+  return (value: string) => {
+    if (value.trim().length > 0) {
+      return true;
+    }
+
+    return message;
+  };
+}
+
+function assertNever(value: never): never {
+  throw new Error(`Unsupported provider: ${String(value)}`);
+}