@imisbahk/hive 0.1.0

package/src/storage/db.ts

@@ -0,0 +1,476 @@
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+import { mkdirSync } from "node:fs";
+
+import Database from "better-sqlite3";
+import { v4 as uuidv4 } from "uuid";
+
+import {
+  CURRENT_SCHEMA_VERSION,
+  MIGRATIONS,
+  type AgentRecord,
+  type ConversationRecord,
+  type MessageRecord,
+  type MessageRole,
+  type MetaRecord,
+} from "./schema.js";
+
+export type HiveDatabase = Database.Database;
+export type {
+  AgentRecord,
+  ConversationRecord,
+  MessageRecord,
+  MessageRole,
+  MetaRecord,
+} from "./schema.js";
+
+export interface UpsertAgentInput {
+  name: string;
+  provider: string;
+  model: string;
+  persona: string;
+  dob?: string | null;
+  location?: string | null;
+  profession?: string | null;
+  aboutRaw?: string | null;
+  agentName?: string | null;
+}
+
+export interface CreateConversationInput {
+  agentId: string;
+  title?: string | null;
+}
+
+export interface AppendMessageInput {
+  conversationId: string;
+  role: MessageRole;
+  content: string;
+}
+
+export interface UpdatePrimaryAgentProviderModelInput {
+  provider: string;
+  model: string;
+}
+
+export const HIVE_DIRECTORY_NAME = ".hive";
+export const HIVE_DB_FILENAME = "hive.db";
+
+const AGENT_PROFILE_COLUMNS = [
+  { name: "dob", definition: "TEXT" },
+  { name: "location", definition: "TEXT" },
+  { name: "profession", definition: "TEXT" },
+  { name: "about_raw", definition: "TEXT" },
+  { name: "agent_name", definition: "TEXT" },
+] as const;
+
+export function getHiveHomeDir(): string {
+  return process.env.HIVE_HOME ?? join(homedir(), HIVE_DIRECTORY_NAME);
+}
+
+export function getHiveDatabasePath(): string {
+  return join(getHiveHomeDir(), HIVE_DB_FILENAME);
+}
+
+export function openHiveDatabase(databasePath = getHiveDatabasePath()): HiveDatabase {
+  mkdirSync(dirname(databasePath), { recursive: true });
+
+  const db = new Database(databasePath);
+  configureDatabase(db);
+  runMigrations(db);
+  setMetaValue(db, "schema_version", String(CURRENT_SCHEMA_VERSION));
+
+  return db;
+}
+
+export function closeHiveDatabase(db: HiveDatabase): void {
+  db.close();
+}
+
+function configureDatabase(db: HiveDatabase): void {
+  db.pragma("foreign_keys = ON");
+  db.pragma("journal_mode = WAL");
+  db.pragma("synchronous = NORMAL");
+}
+
+function ensureMigrationTable(db: HiveDatabase): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS schema_migrations (
+      version INTEGER PRIMARY KEY,
+      name TEXT NOT NULL,
+      applied_at TEXT NOT NULL
+    );
+  `);
+}
+
+export function runMigrations(db: HiveDatabase): void {
+  ensureMigrationTable(db);
+
+  const appliedRows = db
+    .prepare("SELECT version FROM schema_migrations")
+    .all() as Array<{ version: number }>;
+  const appliedVersions = new Set(appliedRows.map((row) => row.version));
+
+  for (const migration of MIGRATIONS) {
+    if (appliedVersions.has(migration.version)) {
+      continue;
+    }
+
+    const applyMigration = db.transaction(() => {
+      if (migration.name === "v2_agents_profile_columns") {
+        ensureAgentProfileColumns(db);
+      } else {
+        db.exec(migration.sql);
+      }
+
+      db.prepare(
+        `
+        INSERT INTO schema_migrations (version, name, applied_at)
+        VALUES (?, ?, ?)
+      `,
+      ).run(migration.version, migration.name, nowIso());
+    });
+
+    applyMigration();
+  }
+}
+
+function ensureAgentProfileColumns(db: HiveDatabase): void {
+  const tableInfo = db.prepare("PRAGMA table_info(agents)").all() as Array<{
+    name: string;
+  }>;
+  const existingColumns = new Set(tableInfo.map((column) => column.name));
+
+  for (const column of AGENT_PROFILE_COLUMNS) {
+    if (existingColumns.has(column.name)) {
+      continue;
+    }
+
+    db.exec(`ALTER TABLE agents ADD COLUMN ${column.name} ${column.definition}`);
+  }
+}
+
+function nowIso(): string {
+  return new Date().toISOString();
+}
+
+export function getMetaValue(db: HiveDatabase, key: string): string | null {
+  const row = db
+    .prepare("SELECT key, value, updated_at FROM meta WHERE key = ?")
+    .get(key) as MetaRecord | undefined;
+
+  return row?.value ?? null;
+}
+
+export function setMetaValue(db: HiveDatabase, key: string, value: string): void {
+  db.prepare(
+    `
+    INSERT INTO meta (key, value, updated_at)
+    VALUES (?, ?, ?)
+    ON CONFLICT(key) DO UPDATE SET
+      value = excluded.value,
+      updated_at = excluded.updated_at
+  `,
+  ).run(key, value, nowIso());
+}
+
+export function isHiveInitialized(db: HiveDatabase): boolean {
+  const row = db
+    .prepare("SELECT COUNT(1) as count FROM agents")
+    .get() as { count: number };
+
+  return row.count > 0;
+}
+
+export function getPrimaryAgent(db: HiveDatabase): AgentRecord | null {
+  const row = db
+    .prepare(
+      `
+      SELECT
+        id,
+        name,
+        provider,
+        model,
+        persona,
+        dob,
+        location,
+        profession,
+        about_raw,
+        agent_name,
+        created_at,
+        updated_at
+      FROM agents
+      ORDER BY datetime(created_at) ASC
+      LIMIT 1
+    `,
+    )
+    .get() as AgentRecord | undefined;
+
+  return row ?? null;
+}
+
+export function upsertPrimaryAgent(
+  db: HiveDatabase,
+  input: UpsertAgentInput,
+): AgentRecord {
+  const existing = getPrimaryAgent(db);
+  const timestamp = nowIso();
+
+  if (existing) {
+    db.prepare(
+      `
+      UPDATE agents
+      SET
+        name = ?,
+        provider = ?,
+        model = ?,
+        persona = ?,
+        dob = ?,
+        location = ?,
+        profession = ?,
+        about_raw = ?,
+        agent_name = ?,
+        updated_at = ?
+      WHERE id = ?
+    `,
+    ).run(
+      input.name,
+      input.provider,
+      input.model,
+      input.persona,
+      input.dob ?? null,
+      input.location ?? null,
+      input.profession ?? null,
+      input.aboutRaw ?? null,
+      input.agentName ?? null,
+      timestamp,
+      existing.id,
+    );
+
+    return {
+      ...existing,
+      name: input.name,
+      provider: input.provider,
+      model: input.model,
+      persona: input.persona,
+      dob: input.dob ?? null,
+      location: input.location ?? null,
+      profession: input.profession ?? null,
+      about_raw: input.aboutRaw ?? null,
+      agent_name: input.agentName ?? null,
+      updated_at: timestamp,
+    };
+  }
+
+  const id = uuidv4();
+  db.prepare(
+    `
+    INSERT INTO agents (
+      id,
+      name,
+      provider,
+      model,
+      persona,
+      dob,
+      location,
+      profession,
+      about_raw,
+      agent_name,
+      created_at,
+      updated_at
+    )
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `,
+  ).run(
+    id,
+    input.name,
+    input.provider,
+    input.model,
+    input.persona,
+    input.dob ?? null,
+    input.location ?? null,
+    input.profession ?? null,
+    input.aboutRaw ?? null,
+    input.agentName ?? null,
+    timestamp,
+    timestamp,
+  );
+
+  return {
+    id,
+    name: input.name,
+    provider: input.provider,
+    model: input.model,
+    persona: input.persona,
+    dob: input.dob ?? null,
+    location: input.location ?? null,
+    profession: input.profession ?? null,
+    about_raw: input.aboutRaw ?? null,
+    agent_name: input.agentName ?? null,
+    created_at: timestamp,
+    updated_at: timestamp,
+  };
+}
+
+export function updatePrimaryAgentProviderAndModel(
+  db: HiveDatabase,
+  input: UpdatePrimaryAgentProviderModelInput,
+): AgentRecord {
+  const existing = getPrimaryAgent(db);
+  if (!existing) {
+    throw new Error("Hive is not initialized. Run `hive init` first.");
+  }
+
+  return updatePrimaryAgentConfiguration(db, existing, input.provider, input.model);
+}
+
+export function updatePrimaryAgentModel(
+  db: HiveDatabase,
+  model: string,
+): AgentRecord {
+  const existing = getPrimaryAgent(db);
+  if (!existing) {
+    throw new Error("Hive is not initialized. Run `hive init` first.");
+  }
+
+  return updatePrimaryAgentConfiguration(db, existing, existing.provider, model);
+}
+
+function updatePrimaryAgentConfiguration(
+  db: HiveDatabase,
+  existing: AgentRecord,
+  provider: string,
+  model: string,
+): AgentRecord {
+  const timestamp = nowIso();
+
+  db.prepare(
+    `
+      UPDATE agents
+      SET provider = ?, model = ?, updated_at = ?
+      WHERE id = ?
+    `,
+  ).run(provider, model, timestamp, existing.id);
+
+  return {
+    ...existing,
+    provider,
+    model,
+    updated_at: timestamp,
+  };
+}
+
+export function createConversation(
+  db: HiveDatabase,
+  input: CreateConversationInput,
+): ConversationRecord {
+  const id = uuidv4();
+  const timestamp = nowIso();
+
+  db.prepare(
+    `
+    INSERT INTO conversations (id, agent_id, title, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?)
+  `,
+  ).run(id, input.agentId, input.title ?? null, timestamp, timestamp);
+
+  return {
+    id,
+    agent_id: input.agentId,
+    title: input.title ?? null,
+    created_at: timestamp,
+    updated_at: timestamp,
+  };
+}
+
+export function getConversationById(
+  db: HiveDatabase,
+  conversationId: string,
+): ConversationRecord | null {
+  const row = db
+    .prepare(
+      `
+      SELECT id, agent_id, title, created_at, updated_at
+      FROM conversations
+      WHERE id = ?
+    `,
+    )
+    .get(conversationId) as ConversationRecord | undefined;
+
+  return row ?? null;
+}
+
+export function getLatestConversationForAgent(
+  db: HiveDatabase,
+  agentId: string,
+): ConversationRecord | null {
+  const row = db
+    .prepare(
+      `
+      SELECT id, agent_id, title, created_at, updated_at
+      FROM conversations
+      WHERE agent_id = ?
+      ORDER BY datetime(updated_at) DESC
+      LIMIT 1
+    `,
+    )
+    .get(agentId) as ConversationRecord | undefined;
+
+  return row ?? null;
+}
+
+export function appendMessage(
+  db: HiveDatabase,
+  input: AppendMessageInput,
+): MessageRecord {
+  const id = uuidv4();
+  const timestamp = nowIso();
+
+  const writeMessage = db.transaction(() => {
+    db.prepare(
+      `
+      INSERT INTO messages (id, conversation_id, role, content, created_at)
+      VALUES (?, ?, ?, ?, ?)
+    `,
+    ).run(id, input.conversationId, input.role, input.content, timestamp);
+
+    db.prepare(
+      `
+      UPDATE conversations
+      SET updated_at = ?
+      WHERE id = ?
+    `,
+    ).run(timestamp, input.conversationId);
+  });
+
+  writeMessage();
+
+  return {
+    id,
+    conversation_id: input.conversationId,
+    role: input.role,
+    content: input.content,
+    created_at: timestamp,
+  };
+}
+
+export function listMessages(
+  db: HiveDatabase,
+  conversationId: string,
+  limit = 100,
+): MessageRecord[] {
+  return db
+    .prepare(
+      `
+      SELECT id, conversation_id, role, content, created_at
+      FROM (
+        SELECT id, conversation_id, role, content, created_at
+        FROM messages
+        WHERE conversation_id = ?
+        ORDER BY datetime(created_at) DESC
+        LIMIT ?
+      )
+      ORDER BY datetime(created_at) ASC
+    `,
+    )
+    .all(conversationId, limit) as MessageRecord[];
+}

package/src/storage/schema.ts

@@ -0,0 +1,116 @@
+export const MESSAGE_ROLES = ["system", "user", "assistant"] as const;
+
+export type MessageRole = (typeof MESSAGE_ROLES)[number];
+
+export interface SchemaMigration {
+  version: number;
+  name: string;
+  sql: string;
+}
+
+export const CURRENT_SCHEMA_VERSION = 2;
+
+const initialSchemaSql = `
+CREATE TABLE IF NOT EXISTS schema_migrations (
+  version INTEGER PRIMARY KEY,
+  name TEXT NOT NULL,
+  applied_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS meta (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS agents (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  provider TEXT NOT NULL,
+  model TEXT NOT NULL,
+  persona TEXT NOT NULL,
+  dob TEXT,
+  location TEXT,
+  profession TEXT,
+  about_raw TEXT,
+  agent_name TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS conversations (
+  id TEXT PRIMARY KEY,
+  agent_id TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,
+  title TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS messages (
+  id TEXT PRIMARY KEY,
+  conversation_id TEXT NOT NULL REFERENCES conversations(id) ON DELETE CASCADE,
+  role TEXT NOT NULL CHECK (role IN ('system', 'user', 'assistant')),
+  content TEXT NOT NULL,
+  created_at TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_conversations_agent_id ON conversations(agent_id);
+CREATE INDEX IF NOT EXISTS idx_messages_conversation_id ON messages(conversation_id);
+CREATE INDEX IF NOT EXISTS idx_messages_created_at ON messages(created_at);
+`;
+
+export const MIGRATIONS: readonly SchemaMigration[] = [
+  {
+    version: 1,
+    name: "v1_initial_schema",
+    sql: initialSchemaSql,
+  },
+  {
+    version: 2,
+    name: "v2_agents_profile_columns",
+    sql: `
+ALTER TABLE agents ADD COLUMN dob TEXT;
+ALTER TABLE agents ADD COLUMN location TEXT;
+ALTER TABLE agents ADD COLUMN profession TEXT;
+ALTER TABLE agents ADD COLUMN about_raw TEXT;
+ALTER TABLE agents ADD COLUMN agent_name TEXT;
+`,
+  },
+];
+
+export interface MetaRecord {
+  key: string;
+  value: string;
+  updated_at: string;
+}
+
+export interface AgentRecord {
+  id: string;
+  name: string;
+  provider: string;
+  model: string;
+  persona: string;
+  dob: string | null;
+  location: string | null;
+  profession: string | null;
+  about_raw: string | null;
+  agent_name: string | null;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface ConversationRecord {
+  id: string;
+  agent_id: string;
+  title: string | null;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface MessageRecord {
+  id: string;
+  conversation_id: string;
+  role: MessageRole;
+  content: string;
+  created_at: string;
+}

package/tsconfig.json

@@ -0,0 +1,51 @@
+{
+    "compilerOptions": {
+        "target": "ES2022",
+        "module": "ES2022",
+        "moduleResolution": "bundler",
+        "lib": [
+            "ES2022"
+        ],
+        "outDir": "./dist",
+        "rootDir": "./src",
+        "strict": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true,
+        "resolveJsonModule": true,
+        "declaration": true,
+        "declarationMap": true,
+        "sourceMap": true,
+        "experimentalDecorators": true,
+        "emitDecoratorMetadata": true,
+        "allowSyntheticDefaultImports": true,
+        "paths": {
+            "@agent/*": [
+                "./src/agent/*"
+            ],
+            "@providers/*": [
+                "./src/providers/*"
+            ],
+            "@storage/*": [
+                "./src/storage/*"
+            ],
+            "@utils/*": [
+                "./src/utils/*"
+            ],
+            "@integrations/*": [
+                "./src/integrations/*"
+            ],
+            "@mesh/*": [
+                "./src/mesh/*"
+            ]
+        }
+    },
+    "include": [
+        "src/**/*"
+    ],
+    "exclude": [
+        "node_modules",
+        "dist",
+        "**/*.test.ts"
+    ]
+}