hungry-ghost-hive 0.48.0 → 0.49.0

package/src/db/queries/logs.ts

@@ -1,7 +1,7 @@
 // Licensed under the Hungry Ghost Hive License. See LICENSE.
 
-import type { Database } from 'sql.js';
-import { queryAll, queryOne, run, type AgentLogRow } from '../client.js';
+import { type AgentLogRow } from '../client.js';
+import type { DatabaseProvider } from '../provider.js';
 
 export type { AgentLogRow };
 
@@ -91,23 +91,22 @@ function inferAgentType(
   return 'tech_lead';
 }
 
-function getAgentColumnNames(db: Database): Set<string> {
-  const result = db.exec('PRAGMA table_info(agents)');
-  if (result.length === 0) return new Set<string>();
-
+async function getAgentColumnNames(provider: DatabaseProvider): Promise<Set<string>> {
+  const rows = await provider.queryAll<{ name: string }>('PRAGMA table_info(agents)');
   const columnNames = new Set<string>();
-  for (const row of result[0].values) {
-    // PRAGMA table_info columns: cid, name, type, notnull, dflt_value, pk
-    columnNames.add(String(row[1]));
+  for (const row of rows) {
+    columnNames.add(row.name);
   }
   return columnNames;
 }
 
-function ensureLogAgentExists(db: Database, agentId: string): void {
-  const existing = queryOne<{ id: string }>(db, 'SELECT id FROM agents WHERE id = ?', [agentId]);
+async function ensureLogAgentExists(provider: DatabaseProvider, agentId: string): Promise<void> {
+  const existing = await provider.queryOne<{ id: string }>('SELECT id FROM agents WHERE id = ?', [
+    agentId,
+  ]);
   if (existing?.id) return;
 
-  const columns = getAgentColumnNames(db);
+  const columns = await getAgentColumnNames(provider);
   const now = new Date().toISOString();
   const insertColumns: string[] = ['id'];
   const insertValues: (string | null)[] = [agentId];
@@ -134,8 +133,7 @@ function ensureLogAgentExists(db: Database, agentId: string): void {
   }
 
   const placeholders = insertColumns.map(() => '?').join(', ');
-  run(
-    db,
+  await provider.run(
     `
     INSERT OR IGNORE INTO agents (${insertColumns.join(', ')})
     VALUES (${placeholders})
@@ -144,17 +142,18 @@ function ensureLogAgentExists(db: Database, agentId: string): void {
   );
 }
 
-function resolveLogAgentId(db: Database, rawAgentId: string): string {
-  const direct = queryOne<{ id: string }>(db, 'SELECT id FROM agents WHERE id = ?', [rawAgentId]);
+async function resolveLogAgentId(provider: DatabaseProvider, rawAgentId: string): Promise<string> {
+  const direct = await provider.queryOne<{ id: string }>('SELECT id FROM agents WHERE id = ?', [
+    rawAgentId,
+  ]);
   if (direct?.id) return direct.id;
 
-  const columns = getAgentColumnNames(db);
+  const columns = await getAgentColumnNames(provider);
 
   // Many call-sites provide tmux session names (for example: "hive-qa-team-1").
   // Prefer resolving those back to canonical agent IDs so logs remain linked.
   if (columns.has('tmux_session')) {
-    const bySession = queryOne<{ id: string }>(
-      db,
+    const bySession = await provider.queryOne<{ id: string }>(
       `SELECT id FROM agents WHERE tmux_session = ?${
         columns.has('updated_at') ? ' ORDER BY updated_at DESC' : ''
       } LIMIT 1`,
@@ -165,24 +164,31 @@ function resolveLogAgentId(db: Database, rawAgentId: string): string {
 
   // Last resort: create a lightweight synthetic agent row for system/session actors
   // like "manager" or "scheduler" so FK constraints cannot fail logging.
-  ensureLogAgentExists(db, rawAgentId);
+  await ensureLogAgentExists(provider, rawAgentId);
   return rawAgentId;
 }
 
-function resolveLogStoryId(db: Database, storyId?: string | null): string | null {
+async function resolveLogStoryId(
+  provider: DatabaseProvider,
+  storyId?: string | null
+): Promise<string | null> {
   if (!storyId) return null;
-  const story = queryOne<{ id: string }>(db, 'SELECT id FROM stories WHERE id = ?', [storyId]);
+  const story = await provider.queryOne<{ id: string }>('SELECT id FROM stories WHERE id = ?', [
+    storyId,
+  ]);
   return story?.id || null;
 }
 
-export function createLog(db: Database, input: CreateLogInput): AgentLogRow {
+export async function createLog(
+  provider: DatabaseProvider,
+  input: CreateLogInput
+): Promise<AgentLogRow> {
   const metadata = input.metadata ? JSON.stringify(input.metadata) : null;
   const now = new Date().toISOString();
-  const resolvedAgentId = resolveLogAgentId(db, input.agentId);
-  const resolvedStoryId = resolveLogStoryId(db, input.storyId);
+  const resolvedAgentId = await resolveLogAgentId(provider, input.agentId);
+  const resolvedStoryId = await resolveLogStoryId(provider, input.storyId);
 
-  run(
-    db,
+  await provider.run(
     `
     INSERT INTO agent_logs (agent_id, story_id, event_type, status, message, metadata, timestamp)
     VALUES (?, ?, ?, ?, ?, ?, ?)
@@ -199,17 +205,23 @@ export function createLog(db: Database, input: CreateLogInput): AgentLogRow {
   );
 
   // Get the last inserted row
-  const result = queryOne<{ id: number }>(db, 'SELECT last_insert_rowid() as id');
-  return getLogById(db, result?.id || 0)!;
+  const result = await provider.queryOne<{ id: number }>('SELECT last_insert_rowid() as id');
+  return (await getLogById(provider, result?.id || 0))!;
 }
 
-export function getLogById(db: Database, id: number): AgentLogRow | undefined {
-  return queryOne<AgentLogRow>(db, 'SELECT * FROM agent_logs WHERE id = ?', [id]);
+export async function getLogById(
+  provider: DatabaseProvider,
+  id: number
+): Promise<AgentLogRow | undefined> {
+  return await provider.queryOne<AgentLogRow>('SELECT * FROM agent_logs WHERE id = ?', [id]);
 }
 
-export function getLogsByAgent(db: Database, agentId: string, limit = 100): AgentLogRow[] {
-  return queryAll<AgentLogRow>(
-    db,
+export async function getLogsByAgent(
+  provider: DatabaseProvider,
+  agentId: string,
+  limit = 100
+): Promise<AgentLogRow[]> {
+  return await provider.queryAll<AgentLogRow>(
     `
     SELECT * FROM agent_logs
     WHERE agent_id = ?
@@ -220,9 +232,11 @@ export function getLogsByAgent(db: Database, agentId: string, limit = 100): Agen
   );
 }
 
-export function getLogsByStory(db: Database, storyId: string): AgentLogRow[] {
-  return queryAll<AgentLogRow>(
-    db,
+export async function getLogsByStory(
+  provider: DatabaseProvider,
+  storyId: string
+): Promise<AgentLogRow[]> {
+  return await provider.queryAll<AgentLogRow>(
     `
     SELECT * FROM agent_logs
     WHERE story_id = ?
@@ -232,9 +246,12 @@ export function getLogsByStory(db: Database, storyId: string): AgentLogRow[] {
   );
 }
 
-export function getLogsByEventType(db: Database, eventType: EventType, limit = 100): AgentLogRow[] {
-  return queryAll<AgentLogRow>(
-    db,
+export async function getLogsByEventType(
+  provider: DatabaseProvider,
+  eventType: EventType,
+  limit = 100
+): Promise<AgentLogRow[]> {
+  return await provider.queryAll<AgentLogRow>(
     `
     SELECT * FROM agent_logs
     WHERE event_type = ?
@@ -245,9 +262,11 @@ export function getLogsByEventType(db: Database, eventType: EventType, limit = 1
   );
 }
 
-export function getRecentLogs(db: Database, limit = 50): AgentLogRow[] {
-  return queryAll<AgentLogRow>(
-    db,
+export async function getRecentLogs(
+  provider: DatabaseProvider,
+  limit = 50
+): Promise<AgentLogRow[]> {
+  return await provider.queryAll<AgentLogRow>(
     `
     SELECT * FROM agent_logs
     ORDER BY timestamp DESC
@@ -257,9 +276,11 @@ export function getRecentLogs(db: Database, limit = 50): AgentLogRow[] {
   );
 }
 
-export function getLogsSince(db: Database, since: string): AgentLogRow[] {
-  return queryAll<AgentLogRow>(
-    db,
+export async function getLogsSince(
+  provider: DatabaseProvider,
+  since: string
+): Promise<AgentLogRow[]> {
+  return await provider.queryAll<AgentLogRow>(
     `
     SELECT * FROM agent_logs
     WHERE timestamp > ?
@@ -269,9 +290,11 @@ export function getLogsSince(db: Database, since: string): AgentLogRow[] {
   );
 }
 
-export function countQaFailuresByStory(db: Database, storyId: string): number {
-  const result = queryOne<{ count: number }>(
-    db,
+export async function countQaFailuresByStory(
+  provider: DatabaseProvider,
+  storyId: string
+): Promise<number> {
+  const result = await provider.queryOne<{ count: number }>(
     `
     SELECT COUNT(*) as count
     FROM agent_logs
@@ -282,21 +305,23 @@ export function countQaFailuresByStory(db: Database, storyId: string): number {
   return result?.count || 0;
 }
 
-export function pruneOldLogs(db: Database, retentionDays: number): number {
+export async function pruneOldLogs(
+  provider: DatabaseProvider,
+  retentionDays: number
+): Promise<number> {
   const cutoffDate = new Date();
   cutoffDate.setDate(cutoffDate.getDate() - retentionDays);
   const cutoff = cutoffDate.toISOString();
 
   // Get count before delete
-  const before = queryOne<{ count: number }>(
-    db,
+  const before = await provider.queryOne<{ count: number }>(
     `
     SELECT COUNT(*) as count FROM agent_logs WHERE timestamp < ?
   `,
     [cutoff]
   );
 
-  run(db, `DELETE FROM agent_logs WHERE timestamp < ?`, [cutoff]);
+  await provider.run(`DELETE FROM agent_logs WHERE timestamp < ?`, [cutoff]);
 
   return before?.count || 0;
 }

package/src/db/queries/messages.test.ts

@@ -1,8 +1,7 @@
 // Licensed under the Hungry Ghost Hive License. See LICENSE.
 
-import type { Database } from 'sql.js';
 import { beforeEach, describe, expect, it } from 'vitest';
-import { run } from '../client.js';
+import { SqliteProvider } from '../provider.js';
 import {
   getAllPendingMessages,
   getMessageById,
@@ -12,10 +11,11 @@ import {
 import { createTestDatabase } from './test-helpers.js';
 
 describe('messages queries', () => {
-  let db: Database;
+  let db: SqliteProvider;
 
   beforeEach(async () => {
-    db = await createTestDatabase();
+    const rawDb = await createTestDatabase();
+    db = new SqliteProvider(rawDb);
   });
 
   // Helper function to create a test message
@@ -28,8 +28,7 @@ describe('messages queries', () => {
     subject?: string | null
   ): void {
     const now = new Date().toISOString();
-    run(
-      db,
+    db.db.run(
       `
       INSERT INTO messages (id, from_session, to_session, subject, body, status, created_at)
       VALUES (?, ?, ?, ?, ?, ?, ?)
@@ -39,12 +38,12 @@ describe('messages queries', () => {
   }
 
   describe('getUnreadMessages', () => {
-    it('should return unread messages for a session', () => {
+    it('should return unread messages for a session', async () => {
       createMessage('msg1', 'session-a', 'session-b', 'Message 1', 'pending');
       createMessage('msg2', 'session-a', 'session-b', 'Message 2', 'pending');
       createMessage('msg3', 'session-a', 'session-b', 'Message 3', 'read');
 
-      const unread = getUnreadMessages(db, 'session-b');
+      const unread = await getUnreadMessages(db, 'session-b');
 
       expect(unread).toHaveLength(2);
       expect(unread.map(m => m.id)).toContain('msg1');
@@ -52,21 +51,21 @@ describe('messages queries', () => {
       expect(unread.map(m => m.id)).not.toContain('msg3');
     });
 
-    it('should return empty array when no unread messages', () => {
+    it('should return empty array when no unread messages', async () => {
       createMessage('msg1', 'session-a', 'session-b', 'Message 1', 'read');
 
-      const unread = getUnreadMessages(db, 'session-b');
+      const unread = await getUnreadMessages(db, 'session-b');
 
       expect(unread).toEqual([]);
     });
 
-    it('should order messages by created_at ASC', () => {
+    it('should order messages by created_at ASC', async () => {
       // Create messages with slight delays to ensure ordering
       createMessage('msg1', 'session-a', 'session-b', 'First', 'pending');
       createMessage('msg2', 'session-a', 'session-b', 'Second', 'pending');
       createMessage('msg3', 'session-a', 'session-b', 'Third', 'pending');
 
-      const unread = getUnreadMessages(db, 'session-b');
+      const unread = await getUnreadMessages(db, 'session-b');
 
       expect(unread).toHaveLength(3);
       expect(unread[0].id).toBe('msg1');
@@ -74,12 +73,12 @@ describe('messages queries', () => {
       expect(unread[2].id).toBe('msg3');
     });
 
-    it('should filter by recipient session', () => {
+    it('should filter by recipient session', async () => {
       createMessage('msg1', 'session-a', 'session-b', 'For B', 'pending');
       createMessage('msg2', 'session-a', 'session-c', 'For C', 'pending');
 
-      const unreadB = getUnreadMessages(db, 'session-b');
-      const unreadC = getUnreadMessages(db, 'session-c');
+      const unreadB = await getUnreadMessages(db, 'session-b');
+      const unreadC = await getUnreadMessages(db, 'session-c');
 
       expect(unreadB).toHaveLength(1);
       expect(unreadB[0].id).toBe('msg1');
@@ -89,43 +88,43 @@ describe('messages queries', () => {
   });
 
   describe('markMessageRead', () => {
-    it('should mark a pending message as read', () => {
+    it('should mark a pending message as read', async () => {
       createMessage('msg1', 'session-a', 'session-b', 'Message', 'pending');
 
-      markMessageRead(db, 'msg1');
+      await markMessageRead(db, 'msg1');
 
-      const message = getMessageById(db, 'msg1');
+      const message = await getMessageById(db, 'msg1');
       expect(message?.status).toBe('read');
     });
 
-    it('should not affect already read messages', () => {
+    it('should not affect already read messages', async () => {
       createMessage('msg1', 'session-a', 'session-b', 'Message', 'read');
 
-      markMessageRead(db, 'msg1');
+      await markMessageRead(db, 'msg1');
 
-      const message = getMessageById(db, 'msg1');
+      const message = await getMessageById(db, 'msg1');
       expect(message?.status).toBe('read');
     });
 
-    it('should not affect replied messages', () => {
+    it('should not affect replied messages', async () => {
       createMessage('msg1', 'session-a', 'session-b', 'Message', 'replied');
 
-      markMessageRead(db, 'msg1');
+      await markMessageRead(db, 'msg1');
 
-      const message = getMessageById(db, 'msg1');
+      const message = await getMessageById(db, 'msg1');
       expect(message?.status).toBe('replied');
     });
 
-    it('should not throw for non-existent message', () => {
-      expect(() => markMessageRead(db, 'non-existent-id')).not.toThrow();
+    it('should not throw for non-existent message', async () => {
+      await expect(markMessageRead(db, 'non-existent-id')).resolves.not.toThrow();
     });
   });
 
   describe('getMessageById', () => {
-    it('should retrieve a message by ID', () => {
+    it('should retrieve a message by ID', async () => {
       createMessage('msg1', 'session-a', 'session-b', 'Test message', 'pending', 'Test subject');
 
-      const message = getMessageById(db, 'msg1');
+      const message = await getMessageById(db, 'msg1');
 
       expect(message).toBeDefined();
       expect(message?.id).toBe('msg1');
@@ -136,15 +135,15 @@ describe('messages queries', () => {
       expect(message?.status).toBe('pending');
     });
 
-    it('should return undefined for non-existent message', () => {
-      const message = getMessageById(db, 'non-existent-id');
+    it('should return undefined for non-existent message', async () => {
+      const message = await getMessageById(db, 'non-existent-id');
       expect(message).toBeUndefined();
     });
 
-    it('should handle messages without subject', () => {
+    it('should handle messages without subject', async () => {
       createMessage('msg1', 'session-a', 'session-b', 'Message without subject', 'pending');
 
-      const message = getMessageById(db, 'msg1');
+      const message = await getMessageById(db, 'msg1');
 
       expect(message?.subject).toBeNull();
       expect(message?.body).toBe('Message without subject');
@@ -152,32 +151,32 @@ describe('messages queries', () => {
   });
 
   describe('getAllPendingMessages', () => {
-    it('should return all pending messages across all sessions', () => {
+    it('should return all pending messages across all sessions', async () => {
       createMessage('msg1', 'session-a', 'session-b', 'Message 1', 'pending');
       createMessage('msg2', 'session-b', 'session-c', 'Message 2', 'pending');
       createMessage('msg3', 'session-c', 'session-a', 'Message 3', 'read');
       createMessage('msg4', 'session-a', 'session-d', 'Message 4', 'replied');
 
-      const pending = getAllPendingMessages(db);
+      const pending = await getAllPendingMessages(db);
 
       expect(pending).toHaveLength(2);
       expect(pending.map(m => m.id)).toContain('msg1');
       expect(pending.map(m => m.id)).toContain('msg2');
     });
 
-    it('should return empty array when no pending messages', () => {
+    it('should return empty array when no pending messages', async () => {
       createMessage('msg1', 'session-a', 'session-b', 'Message', 'read');
 
-      const pending = getAllPendingMessages(db);
+      const pending = await getAllPendingMessages(db);
 
       expect(pending).toEqual([]);
     });
 
-    it('should order by created_at ASC', () => {
+    it('should order by created_at ASC', async () => {
       createMessage('msg1', 'session-a', 'session-b', 'First', 'pending');
       createMessage('msg2', 'session-a', 'session-b', 'Second', 'pending');
 
-      const pending = getAllPendingMessages(db);
+      const pending = await getAllPendingMessages(db);
 
       expect(pending[0].id).toBe('msg1');
       expect(pending[1].id).toBe('msg2');
@@ -185,31 +184,31 @@ describe('messages queries', () => {
   });
 
   describe('edge cases', () => {
-    it('should handle messages with null subject', () => {
+    it('should handle messages with null subject', async () => {
       createMessage('msg1', 'session-a', 'session-b', 'Body text', 'pending', null);
 
-      const message = getMessageById(db, 'msg1');
+      const message = await getMessageById(db, 'msg1');
       expect(message?.subject).toBeNull();
       expect(message?.body).toBe('Body text');
     });
 
-    it('should handle messages with very long body text', () => {
+    it('should handle messages with very long body text', async () => {
       const longBody = 'A'.repeat(50000);
       createMessage('msg1', 'session-a', 'session-b', longBody, 'pending');
 
-      const message = getMessageById(db, 'msg1');
+      const message = await getMessageById(db, 'msg1');
       expect(message?.body).toBe(longBody);
     });
 
-    it('should handle special characters in message content', () => {
+    it('should handle special characters in message content', async () => {
       const specialBody = 'Message with \'quotes\' "double" and\nnewlines\ttabs';
       createMessage('msg1', 'session-a', 'session-b', specialBody, 'pending', 'Special chars');
 
-      const message = getMessageById(db, 'msg1');
+      const message = await getMessageById(db, 'msg1');
       expect(message?.body).toBe(specialBody);
     });
 
-    it('should handle session names with special characters', () => {
+    it('should handle session names with special characters', async () => {
       createMessage(
         'msg1',
         'session-with-dashes',
@@ -218,15 +217,14 @@ describe('messages queries', () => {
         'pending'
       );
 
-      const unread = getUnreadMessages(db, 'session_with_underscores');
+      const unread = await getUnreadMessages(db, 'session_with_underscores');
       expect(unread).toHaveLength(1);
       expect(unread[0].from_session).toBe('session-with-dashes');
     });
 
-    it('should handle reply and replied_at fields', () => {
+    it('should handle reply and replied_at fields', async () => {
       const now = new Date().toISOString();
-      run(
-        db,
+      db.db.run(
         `
         INSERT INTO messages (id, from_session, to_session, body, status, reply, replied_at, created_at)
         VALUES (?, ?, ?, ?, ?, ?, ?, ?)
@@ -234,7 +232,7 @@ describe('messages queries', () => {
         ['msg1', 'session-a', 'session-b', 'Original message', 'replied', 'Reply text', now, now]
       );
 
-      const message = getMessageById(db, 'msg1');
+      const message = await getMessageById(db, 'msg1');
       expect(message?.status).toBe('replied');
       expect(message?.reply).toBe('Reply text');
       expect(message?.replied_at).toBeDefined();

package/src/db/queries/messages.ts

@@ -1,7 +1,6 @@
 // Licensed under the Hungry Ghost Hive License. See LICENSE.
 
-import type { Database } from 'sql.js';
-import { queryAll, queryOne, run } from '../client.js';
+import type { DatabaseProvider } from '../provider.js';
 
 export interface MessageRow {
   id: string;
@@ -15,9 +14,11 @@ export interface MessageRow {
   replied_at: string | null;
 }
 
-export function getUnreadMessages(db: Database, toSession: string): MessageRow[] {
-  return queryAll<MessageRow>(
-    db,
+export async function getUnreadMessages(
+  provider: DatabaseProvider,
+  toSession: string
+): Promise<MessageRow[]> {
+  return await provider.queryAll<MessageRow>(
     `
     SELECT * FROM messages
     WHERE to_session = ? AND status = 'pending'
@@ -27,31 +28,38 @@ export function getUnreadMessages(db: Database, toSession: string): MessageRow[]
   );
 }
 
-export function markMessageRead(db: Database, messageId: string): void {
-  run(db, `UPDATE messages SET status = 'read' WHERE id = ? AND status = 'pending'`, [messageId]);
+export async function markMessageRead(
+  provider: DatabaseProvider,
+  messageId: string
+): Promise<void> {
+  await provider.run(`UPDATE messages SET status = 'read' WHERE id = ? AND status = 'pending'`, [
+    messageId,
+  ]);
 }
 
-export function markMessagesRead(db: Database, messageIds: string[]): void {
+export async function markMessagesRead(
+  provider: DatabaseProvider,
+  messageIds: string[]
+): Promise<void> {
   if (messageIds.length === 0) return;
   const placeholders = messageIds.map(() => '?').join(',');
-  run(
-    db,
+  await provider.run(
     `UPDATE messages SET status = 'read' WHERE id IN (${placeholders}) AND status = 'pending'`,
     messageIds
   );
 }
 
-export function getMessageById(db: Database, id: string): MessageRow | undefined {
-  return queryOne<MessageRow>(db, 'SELECT * FROM messages WHERE id = ?', [id]);
+export async function getMessageById(
+  provider: DatabaseProvider,
+  id: string
+): Promise<MessageRow | undefined> {
+  return await provider.queryOne<MessageRow>('SELECT * FROM messages WHERE id = ?', [id]);
 }
 
-export function getAllPendingMessages(db: Database): MessageRow[] {
-  return queryAll<MessageRow>(
-    db,
-    `
+export async function getAllPendingMessages(provider: DatabaseProvider): Promise<MessageRow[]> {
+  return await provider.queryAll<MessageRow>(`
     SELECT * FROM messages
     WHERE status = 'pending'
     ORDER BY created_at ASC
-  `
-  );
+  `);
 }