@johpaz/hive-core 1.0.6 → 1.0.7

package/src/gateway/session.ts

@@ -5,6 +5,7 @@ export interface SessionId {
   channel: string;
   kind: "main" | "dm" | "group";
   identifier: string;
+  userId?: string;
 }
 
 export function parseSessionId(sessionId: string): SessionId | null {
@@ -38,7 +39,7 @@ export function parseSessionId(sessionId: string): SessionId | null {
       return null;
     }
     
-    return { agentId: agentId!, channel, kind, identifier };
+    return { agentId: agentId!, channel, kind, identifier, userId: identifier };
   }
 
   return null;

package/src/gateway/slash-commands.ts

@@ -4,7 +4,7 @@ import { laneQueue } from "./lane-queue.ts";
 import { logger } from "../utils/logger.ts";
 
 export interface InboundMessage {
-  type: "message" | "command" | "ping";
+  type: "message" | "command" | "ping" | "join";
   sessionId: string;
   content?: string;
   command?: string;
@@ -13,11 +13,12 @@ export interface InboundMessage {
 }
 
 export interface OutboundMessage {
-  type: "message" | "stream" | "status" | "error" | "pong" | "command_result";
+  type: "message" | "stream" | "status" | "error" | "pong" | "command_result" | "joined" | "typing";
   sessionId: string;
   content?: string;
   chunk?: string;
   isLast?: boolean;
+  isTyping?: boolean;
   status?: {
     state: string;
     model?: string;
@@ -60,23 +61,15 @@ export async function executeSlashCommand(
   sessionId: string,
   content: string,
   ws: ServerWebSocket<unknown>
-): Promise<OutboundMessage> {
+): Promise<OutboundMessage | null> {
   const parsed = parseSlashCommand(content);
   if (!parsed) {
-    return {
-      type: "error",
-      sessionId,
-      error: "Invalid slash command format",
-    };
+    return null;
   }
 
   const command = slashCommands.get(parsed.name);
   if (!command) {
-    return {
-      type: "error",
-      sessionId,
-      error: `Unknown command: /${parsed.name}`,
-    };
+    return null;
   }
 
   logger.info(`Executing slash command: /${parsed.name}`, { sessionId, args: parsed.args });
@@ -116,7 +109,7 @@ registerSlashCommand({
   handler: async (sessionId) => {
     const session = sessionManager.get(sessionId);
     const queueStatus = laneQueue.getStatus(sessionId);
-    
+
     return {
       sessionId,
       createdAt: session?.createdAt,

package/src/memory/notes.ts

@@ -1,7 +1,6 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
 import type { Config } from "../config/loader.ts";
 import { logger } from "../utils/logger.ts";
+import { dbService } from "../storage/sqlite.ts";
 
 export interface Note {
   title: string;
@@ -11,157 +10,56 @@ export interface Note {
 }
 
 export class MemoryStore {
-  private notesDir: string;
   private log = logger.child("memory");
 
   constructor(config: Config) {
-    this.notesDir = this.expandPath(
-      config.memory?.notesDir ?? "~/.hive/agents/main/workspace/memory"
-    );
-    this.ensureDir();
-  }
-
-  private expandPath(p: string): string {
-    if (p.startsWith("~")) {
-      return path.join(process.env.HOME ?? "", p.slice(1));
-    }
-    return p;
-  }
-
-  private ensureDir(): void {
-    if (!fs.existsSync(this.notesDir)) {
-      fs.mkdirSync(this.notesDir, { recursive: true });
-    }
-  }
-
-  private getNotePath(title: string): string {
-    const safeTitle = title.replace(/[^a-zA-Z0-9_-]/g, "_").toLowerCase();
-    return path.join(this.notesDir, `${safeTitle}.md`);
+    // Configuration can remain unused as sqlite db handles path resolution
   }
 
   write(title: string, content: string): Note {
-    const notePath = this.getNotePath(title);
-    const now = new Date();
-    
-    let note: Note;
-    
-    if (fs.existsSync(notePath)) {
-      const existing = fs.readFileSync(notePath, "utf-8");
-      const lines = existing.split("\n");
-      const createdAtLine = lines.find((l) => l.startsWith("created:"));
-      const createdAt = createdAtLine
-        ? new Date(createdAtLine.replace("created:", "").trim())
-        : now;
-      
-      note = {
-        title,
-        content,
-        createdAt,
-        updatedAt: now,
-      };
-    } else {
-      note = {
-        title,
-        content,
-        createdAt: now,
-        updatedAt: now,
-      };
-    }
-
-    const frontmatter = `---
-title: ${title}
-created: ${note.createdAt.toISOString()}
-updated: ${note.updatedAt.toISOString()}
----
-
-${content}`;
-
-    fs.writeFileSync(notePath, frontmatter, "utf-8");
+    const row = dbService.writeNote(title, content);
     this.log.debug(`Wrote note: ${title}`);
-    
-    return note;
+    return {
+      title: row.title,
+      content: row.content,
+      createdAt: new Date(row.createdAt),
+      updatedAt: new Date(row.updatedAt)
+    };
   }
 
   read(title: string): Note | null {
-    const notePath = this.getNotePath(title);
-    
-    if (!fs.existsSync(notePath)) {
-      return null;
-    }
-
-    const content = fs.readFileSync(notePath, "utf-8");
-    const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
-    
-    if (!match) {
-      return {
-        title,
-        content,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-      };
-    }
-
-    const frontmatter = match[1]!;
-    const body = match[2]!.trim();
-    
-    const titleMatch = frontmatter.match(/title:\s*(.+)/);
-    const createdMatch = frontmatter.match(/created:\s*(.+)/);
-    const updatedMatch = frontmatter.match(/updated:\s*(.+)/);
-
+    const row = dbService.readNote(title);
+    if (!row) return null;
     return {
-      title: titleMatch?.[1]?.trim() ?? title,
-      content: body,
-      createdAt: createdMatch ? new Date(createdMatch[1]!) : new Date(),
-      updatedAt: updatedMatch ? new Date(updatedMatch[1]!) : new Date(),
+      title: row.title,
+      content: row.content,
+      createdAt: new Date(row.createdAt),
+      updatedAt: new Date(row.updatedAt)
     };
   }
 
   list(): Array<{ title: string; path: string }> {
-    if (!fs.existsSync(this.notesDir)) {
-      return [];
-    }
-
-    const files = fs.readdirSync(this.notesDir).filter((f) => f.endsWith(".md"));
-    
-    return files.map((file) => {
-      const filePath = path.join(this.notesDir, file);
-      const content = fs.readFileSync(filePath, "utf-8");
-      const titleMatch = content.match(/title:\s*(.+)/);
-      
-      return {
-        title: titleMatch?.[1]?.trim() ?? file.replace(".md", ""),
-        path: filePath,
-      };
-    });
+    return dbService.listNotes().map(row => ({
+      title: row.title,
+      path: `sqlite://notes/${row.id}`
+    }));
   }
 
   delete(title: string): boolean {
-    const notePath = this.getNotePath(title);
-    
-    if (fs.existsSync(notePath)) {
-      fs.unlinkSync(notePath);
+    const deleted = dbService.deleteNote(title);
+    if (deleted) {
       this.log.debug(`Deleted note: ${title}`);
-      return true;
     }
-    
-    return false;
+    return deleted;
   }
 
   search(query: string): Note[] {
-    const results: Note[] = [];
-    const lowerQuery = query.toLowerCase();
-    
-    for (const { title } of this.list()) {
-      const note = this.read(title);
-      if (note && (
-        note.title.toLowerCase().includes(lowerQuery) ||
-        note.content.toLowerCase().includes(lowerQuery)
-      )) {
-        results.push(note);
-      }
-    }
-    
-    return results;
+    return dbService.searchNotes(query).map(row => ({
+      title: row.title,
+      content: row.content,
+      createdAt: new Date(row.createdAt),
+      updatedAt: new Date(row.updatedAt)
+    }));
   }
 }
 

package/src/multi-agent/manager.ts

@@ -3,6 +3,12 @@ import * as path from "node:path";
 import type { Config, AgentEntry } from "../config/loader.ts";
 import { Agent } from "../agent/index.ts";
 import { ToolRegistry } from "../tools/registry.ts";
+import { readTool, writeTool, editTool } from "../tools/read.ts";
+import { createExecTool } from "../tools/exec.ts";
+import { createWebSearchTool, createWebFetchTool } from "../tools/web.ts";
+import { createNotifyTool } from "../tools/notify.ts";
+import { createWorkspaceTools } from "../tools/workspace.ts";
+import { WorkspaceLoader } from "../agent/workspace.ts";
 import { logger } from "../utils/logger.ts";
 
 export interface AgentInstance {
@@ -66,6 +72,28 @@ export class AgentManager {
 
     const toolRegistry = new ToolRegistry(this.config);
 
+    const workspaceLoader = new WorkspaceLoader(workspacePath);
+    const workspaceTools = createWorkspaceTools(workspaceLoader);
+    for (const tool of workspaceTools) {
+      toolRegistry.register(tool);
+    }
+
+    toolRegistry.register(readTool);
+    toolRegistry.register(writeTool);
+    toolRegistry.register(editTool);
+
+    const execTool = createExecTool(this.config);
+    if (execTool) toolRegistry.register(execTool);
+
+    const webSearchTool = createWebSearchTool(this.config);
+    toolRegistry.register(webSearchTool);
+
+    const webFetchTool = createWebFetchTool(this.config);
+    toolRegistry.register(webFetchTool);
+
+    const notifyTool = createNotifyTool();
+    toolRegistry.register(notifyTool);
+
     const instance: AgentInstance = {
       id: entry.id,
       agent,

package/src/storage/sqlite.ts

@@ -0,0 +1,230 @@
+import { Database } from "bun:sqlite";
+import { logger } from "../utils/logger.ts";
+import * as path from "node:path";
+import * as fs from "node:fs";
+
+export interface ChatMessageRow {
+    id: string;
+    sessionId: string;
+    userId?: string;
+    role: string;
+    content: string;
+    timestamp: string;
+}
+
+export interface NoteRow {
+    id: string;
+    title: string;
+    content: string;
+    createdAt: string;
+    updatedAt: string;
+}
+
+export class DatabaseService {
+    private db: Database;
+    private log = logger.child("sqlite");
+
+    constructor(dbPath?: string) {
+        const defaultPath = path.join(process.env.HOME || "", ".hive", "hive.db");
+        const targetPath = dbPath ?? defaultPath;
+
+        // Ensure directory exists
+        const dir = path.dirname(targetPath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+
+        this.db = new Database(targetPath, { create: true });
+        this.initSchema();
+    }
+
+    private initSchema() {
+        try {
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS messages (
+          id TEXT PRIMARY KEY,
+          sessionId TEXT NOT NULL,
+          role TEXT NOT NULL,
+          content TEXT NOT NULL,
+          timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
+        );
+      `);
+
+            this.db.exec(`
+        CREATE INDEX IF NOT EXISTS idx_messages_sessionId ON messages(sessionId);
+      `);
+
+            this.db.exec(`
+        CREATE INDEX IF NOT EXISTS idx_messages_timestamp ON messages(timestamp);
+      `);
+
+            this.migrateUserId();
+            this.initNotesTable();
+            this.log.debug("Database schema initialized");
+        } catch (e: any) {
+            this.log.error(`Failed to initialize database schema: ${e.message}`);
+            throw e;
+        }
+    }
+
+    private migrateUserId(): void {
+        try {
+            const result = this.db.query("PRAGMA table_info(messages)").all() as Array<{ name: string }>;
+            const hasUserId = result.some(col => col.name === "userId");
+            if (!hasUserId) {
+                this.db.exec("ALTER TABLE messages ADD COLUMN userId TEXT");
+                this.log.info("Added userId column to messages table");
+            }
+        } catch (e: any) {
+            this.log.warn(`Migration userId: ${e.message}`);
+        }
+    }
+
+    private initNotesTable(): void {
+        this.db.exec(`
+        CREATE TABLE IF NOT EXISTS notes (
+          id TEXT PRIMARY KEY,
+          title TEXT UNIQUE NOT NULL,
+          content TEXT NOT NULL,
+          createdAt DATETIME DEFAULT CURRENT_TIMESTAMP,
+          updatedAt DATETIME DEFAULT CURRENT_TIMESTAMP
+        );
+      `);
+
+        this.db.exec(`
+        CREATE INDEX IF NOT EXISTS idx_notes_title ON notes(title);
+      `);
+    }
+
+    public addMessage(sessionId: string, role: string, content: string, userId?: string): void {
+        const stmt = this.db.query(`
+      INSERT INTO messages (id, sessionId, userId, role, content) 
+      VALUES ($id, $sessionId, $userId, $role, $content)
+    `);
+
+        try {
+            const id = crypto.randomUUID();
+            stmt.run({
+                $id: id,
+                $sessionId: sessionId,
+                $userId: userId ?? null,
+                $role: role,
+                $content: content
+            });
+            this.log.debug(`Message added for session ${sessionId}, user ${userId ?? 'unknown'}`);
+        } catch (error: any) {
+            this.log.error(`Failed to add message: ${error.message}`);
+        }
+    }
+
+    public getMessagesByUser(userId: string, limit: number = 100): ChatMessageRow[] {
+        const stmt = this.db.query(`
+      SELECT * FROM messages 
+      WHERE userId = $userId 
+      ORDER BY timestamp DESC 
+      LIMIT $limit
+    `);
+
+        try {
+            const rows = stmt.all({
+                $userId: userId,
+                $limit: limit
+            }) as ChatMessageRow[];
+            return rows.reverse();
+        } catch (error: any) {
+            this.log.error(`Failed to get messages by user: ${error.message}`);
+            return [];
+        }
+    }
+
+    public getAllUserMessages(userId: string, limit: number = 100): ChatMessageRow[] {
+        const stmt = this.db.query(`
+      SELECT * FROM messages 
+      WHERE userId = $userId OR sessionId LIKE $sessionPattern
+      ORDER BY timestamp DESC 
+      LIMIT $limit
+    `);
+
+        try {
+            const rows = stmt.all({
+                $userId: userId,
+                $sessionPattern: `%${userId}`,
+                $limit: limit
+            }) as ChatMessageRow[];
+            return rows.reverse();
+        } catch (error: any) {
+            this.log.error(`Failed to get all user messages: ${error.message}`);
+            return [];
+        }
+    }
+
+    public getMessages(sessionId: string, limit: number = 100): ChatMessageRow[] {
+        const stmt = this.db.query(`
+      SELECT * FROM messages 
+      WHERE sessionId = $sessionId 
+      ORDER BY timestamp DESC 
+      LIMIT $limit
+    `);
+
+        try {
+            const rows = stmt.all({
+                $sessionId: sessionId,
+                $limit: limit
+            }) as ChatMessageRow[];
+
+            // Return in chronological order
+            return rows.reverse();
+        } catch (error: any) {
+            this.log.error(`Failed to get messages: ${error.message}`);
+            return [];
+        }
+    }
+
+    public close(): void {
+        this.db.close();
+    }
+
+    public writeNote(title: string, content: string): NoteRow {
+        const stmt = this.db.query(`
+            INSERT INTO notes (id, title, content) 
+            VALUES ($id, $title, $content)
+            ON CONFLICT(title) DO UPDATE SET 
+                content = excluded.content,
+                updatedAt = CURRENT_TIMESTAMP
+            RETURNING *
+        `);
+        return stmt.get({
+            $id: crypto.randomUUID(),
+            $title: title,
+            $content: content
+        }) as NoteRow;
+    }
+
+    public readNote(title: string): NoteRow | null {
+        const stmt = this.db.query(`SELECT * FROM notes WHERE title = $title`);
+        return stmt.get({ $title: title }) as NoteRow | null;
+    }
+
+    public listNotes(): NoteRow[] {
+        const stmt = this.db.query(`SELECT * FROM notes ORDER BY updatedAt DESC`);
+        return stmt.all() as NoteRow[];
+    }
+
+    public searchNotes(queryText: string): NoteRow[] {
+        const stmt = this.db.query(`
+            SELECT * FROM notes 
+            WHERE title LIKE $query OR content LIKE $query
+            ORDER BY updatedAt DESC
+        `);
+        return stmt.all({ $query: `%${queryText}%` }) as NoteRow[];
+    }
+
+    public deleteNote(title: string): boolean {
+        const stmt = this.db.query(`DELETE FROM notes WHERE title = $title`);
+        const result = stmt.run({ $title: title });
+        return result.changes > 0;
+    }
+}
+
+// Singleton instance
+export const dbService = new DatabaseService();