hungry-ghost-hive 0.48.0 → 0.49.0

package/src/db/provider.ts

@@ -0,0 +1,161 @@
+// Licensed under the Hungry Ghost Hive License. See LICENSE.
+
+import type { Database as SqlJsDatabase } from 'sql.js';
+
+/**
+ * Abstract database provider interface that supports both SQLite and Postgres backends.
+ * All methods are async to support inherently asynchronous backends like Postgres.
+ */
+export interface DatabaseProvider {
+  queryAll<T>(sql: string, params?: unknown[]): Promise<T[]>;
+  queryOne<T>(sql: string, params?: unknown[]): Promise<T | undefined>;
+  run(sql: string, params?: unknown[]): Promise<void>;
+  withTransaction<T>(fn: () => Promise<T> | T): Promise<T>;
+  close(): Promise<void>;
+}
+
+/**
+ * Extended provider for writable database connections that support persistence.
+ */
+export interface WritableDatabaseProvider extends DatabaseProvider {
+  save(): void;
+}
+
+/**
+ * Result type for query operations (useful for Postgres which returns metadata).
+ */
+export interface QueryResult<T> {
+  rows: T[];
+  rowCount: number;
+}
+
+/**
+ * SQLite implementation of DatabaseProvider using sql.js.
+ * Wraps an in-memory sql.js Database with the provider interface.
+ * Methods return resolved Promises wrapping synchronous sql.js operations.
+ */
+export class SqliteProvider implements WritableDatabaseProvider {
+  /**
+   * Direct access to the underlying sql.js Database.
+   * Exposed for backward compatibility during the migration period.
+   * New code should use the provider methods instead.
+   */
+  public readonly db: SqlJsDatabase;
+
+  private _saveFn: (() => void) | undefined;
+
+  constructor(db: SqlJsDatabase, saveFn?: () => void) {
+    this.db = db;
+    this._saveFn = saveFn;
+  }
+
+  async queryAll<T>(sql: string, params: unknown[] = []): Promise<T[]> {
+    const stmt = this.db.prepare(sql);
+    try {
+      stmt.bind(params);
+
+      const results: T[] = [];
+      while (stmt.step()) {
+        const row = stmt.getAsObject();
+        results.push(row as T);
+      }
+      return results;
+    } finally {
+      stmt.free();
+    }
+  }
+
+  async queryOne<T>(sql: string, params: unknown[] = []): Promise<T | undefined> {
+    const results = await this.queryAll<T>(sql, params);
+    return results[0];
+  }
+
+  async run(sql: string, params: unknown[] = []): Promise<void> {
+    this.db.run(sql, params);
+  }
+
+  async withTransaction<T>(fn: () => Promise<T> | T): Promise<T> {
+    try {
+      this.db.run('BEGIN IMMEDIATE');
+      const result = await fn();
+      this.db.run('COMMIT');
+      if (this._saveFn) {
+        this._saveFn();
+      }
+      return result;
+    } catch (error) {
+      try {
+        this.db.run('ROLLBACK');
+      } catch (_error) {
+        // Ignore rollback errors - transaction may have already been rolled back
+      }
+      throw error;
+    }
+  }
+
+  save(): void {
+    if (this._saveFn) {
+      this._saveFn();
+    }
+  }
+
+  async close(): Promise<void> {
+    this.db.close();
+  }
+}
+
+/**
+ * Read-only SQLite provider that does not support save operations.
+ */
+export class ReadOnlySqliteProvider implements DatabaseProvider {
+  public readonly db: SqlJsDatabase;
+
+  constructor(db: SqlJsDatabase) {
+    this.db = db;
+  }
+
+  async queryAll<T>(sql: string, params: unknown[] = []): Promise<T[]> {
+    const stmt = this.db.prepare(sql);
+    try {
+      stmt.bind(params);
+
+      const results: T[] = [];
+      while (stmt.step()) {
+        const row = stmt.getAsObject();
+        results.push(row as T);
+      }
+      return results;
+    } finally {
+      stmt.free();
+    }
+  }
+
+  async queryOne<T>(sql: string, params: unknown[] = []): Promise<T | undefined> {
+    const results = await this.queryAll<T>(sql, params);
+    return results[0];
+  }
+
+  async run(sql: string, params: unknown[] = []): Promise<void> {
+    this.db.run(sql, params);
+  }
+
+  async withTransaction<T>(fn: () => Promise<T> | T): Promise<T> {
+    try {
+      this.db.run('BEGIN IMMEDIATE');
+      const result = await fn();
+      this.db.run('COMMIT');
+      return result;
+    } catch (error) {
+      try {
+        this.db.run('ROLLBACK');
+      } catch (_error) {
+        // Ignore rollback errors
+      }
+      throw error;
+    }
+  }
+
+  async close(): Promise<void> {
+    this.db.close();
+  }
+}

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

@@ -1,7 +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 { SqliteProvider } from '../provider.js';
 import {
   createAgent,
   deleteAgent,
@@ -19,12 +19,13 @@ import { createTeam } from './teams.js';
 import { createTestDatabase } from './test-helpers.js';
 
 describe('agents queries', () => {
-  let db: Database;
+  let db: SqliteProvider;
   let teamId: string;
 
   beforeEach(async () => {
-    db = await createTestDatabase();
-    const team = createTeam(db, {
+    const rawDb = await createTestDatabase();
+    db = new SqliteProvider(rawDb);
+    const team = await createTeam(db, {
       repoUrl: 'https://github.com/test/repo.git',
       repoPath: '/path/to/repo',
       name: 'Test Team',
@@ -33,8 +34,8 @@ describe('agents queries', () => {
   });
 
   describe('createAgent', () => {
-    it('should create a tech_lead agent with fixed ID', () => {
-      const agent = createAgent(db, {
+    it('should create a tech_lead agent with fixed ID', async () => {
+      const agent = await createAgent(db, {
         type: 'tech_lead',
         teamId,
         model: 'claude-sonnet-4-5',
@@ -47,8 +48,8 @@ describe('agents queries', () => {
       expect(agent.status).toBe('idle');
     });
 
-    it('should create a senior agent with generated ID', () => {
-      const agent = createAgent(db, {
+    it('should create a senior agent with generated ID', async () => {
+      const agent = await createAgent(db, {
         type: 'senior',
         teamId,
       });
@@ -58,8 +59,8 @@ describe('agents queries', () => {
       expect(agent.status).toBe('idle');
     });
 
-    it('should handle optional fields', () => {
-      const agent = createAgent(db, {
+    it('should handle optional fields', async () => {
+      const agent = await createAgent(db, {
         type: 'junior',
         tmuxSession: 'tmux-session-1',
         model: 'claude-sonnet-4-5-20250929',
@@ -71,12 +72,12 @@ describe('agents queries', () => {
       expect(agent.worktree_path).toBe('/path/to/worktree');
     });
 
-    it('should handle null/undefined teamId', () => {
-      const agent1 = createAgent(db, {
+    it('should handle null/undefined teamId', async () => {
+      const agent1 = await createAgent(db, {
         type: 'qa',
       });
 
-      const agent2 = createAgent(db, {
+      const agent2 = await createAgent(db, {
         type: 'intermediate',
         teamId: null,
       });
@@ -85,8 +86,8 @@ describe('agents queries', () => {
       expect(agent2.team_id).toBeNull();
     });
 
-    it('should set timestamps', () => {
-      const agent = createAgent(db, {
+    it('should set timestamps', async () => {
+      const agent = await createAgent(db, {
         type: 'senior',
       });
 
@@ -97,57 +98,57 @@ describe('agents queries', () => {
   });
 
   describe('getAgentById', () => {
-    it('should retrieve an agent by ID', () => {
-      const created = createAgent(db, {
+    it('should retrieve an agent by ID', async () => {
+      const created = await createAgent(db, {
         type: 'senior',
         teamId,
       });
 
-      const retrieved = getAgentById(db, created.id);
+      const retrieved = await getAgentById(db, created.id);
 
       expect(retrieved).toBeDefined();
       expect(retrieved?.id).toBe(created.id);
       expect(retrieved?.type).toBe('senior');
     });
 
-    it('should return undefined for non-existent agent', () => {
-      const result = getAgentById(db, 'non-existent-id');
+    it('should return undefined for non-existent agent', async () => {
+      const result = await getAgentById(db, 'non-existent-id');
       expect(result).toBeUndefined();
     });
   });
 
   describe('getAgentsByTeam', () => {
-    it('should return agents for a specific team', () => {
-      const agent1 = createAgent(db, { type: 'senior', teamId });
-      const agent2 = createAgent(db, { type: 'junior', teamId });
+    it('should return agents for a specific team', async () => {
+      const agent1 = await createAgent(db, { type: 'senior', teamId });
+      const agent2 = await createAgent(db, { type: 'junior', teamId });
 
-      const team2 = createTeam(db, {
+      const team2 = await createTeam(db, {
         repoUrl: 'https://github.com/test/repo2.git',
         repoPath: '/path/to/repo2',
         name: 'Team 2',
       });
-      createAgent(db, { type: 'senior', teamId: team2.id });
+      await createAgent(db, { type: 'senior', teamId: team2.id });
 
-      const teamAgents = getAgentsByTeam(db, teamId);
+      const teamAgents = await getAgentsByTeam(db, teamId);
 
       expect(teamAgents).toHaveLength(2);
       expect(teamAgents.map(a => a.id)).toContain(agent1.id);
       expect(teamAgents.map(a => a.id)).toContain(agent2.id);
     });
 
-    it('should return empty array when no agents for team', () => {
-      const agents = getAgentsByTeam(db, 'non-existent-team');
+    it('should return empty array when no agents for team', async () => {
+      const agents = await getAgentsByTeam(db, 'non-existent-team');
       expect(agents).toEqual([]);
     });
   });
 
   describe('getAgentsByType', () => {
-    it('should filter agents by type', () => {
-      const senior1 = createAgent(db, { type: 'senior', teamId });
-      const senior2 = createAgent(db, { type: 'senior', teamId });
-      createAgent(db, { type: 'junior', teamId });
+    it('should filter agents by type', async () => {
+      const senior1 = await createAgent(db, { type: 'senior', teamId });
+      const senior2 = await createAgent(db, { type: 'senior', teamId });
+      await createAgent(db, { type: 'junior', teamId });
 
-      const seniors = getAgentsByType(db, 'senior');
+      const seniors = await getAgentsByType(db, 'senior');
 
       expect(seniors).toHaveLength(2);
       expect(seniors.map(a => a.id)).toContain(senior1.id);
@@ -156,13 +157,13 @@ describe('agents queries', () => {
   });
 
   describe('getAgentsByStatus', () => {
-    it('should filter agents by status', () => {
-      const agent1 = createAgent(db, { type: 'senior', teamId });
-      const agent2 = createAgent(db, { type: 'junior', teamId });
-      updateAgent(db, agent2.id, { status: 'working' });
+    it('should filter agents by status', async () => {
+      const agent1 = await createAgent(db, { type: 'senior', teamId });
+      const agent2 = await createAgent(db, { type: 'junior', teamId });
+      await updateAgent(db, agent2.id, { status: 'working' });
 
-      const idle = getAgentsByStatus(db, 'idle');
-      const working = getAgentsByStatus(db, 'working');
+      const idle = await getAgentsByStatus(db, 'idle');
+      const working = await getAgentsByStatus(db, 'working');
 
       expect(idle).toHaveLength(1);
       expect(idle[0].id).toBe(agent1.id);
@@ -172,34 +173,34 @@ describe('agents queries', () => {
   });
 
   describe('getAllAgents', () => {
-    it('should return all agents ordered by type and team_id', () => {
-      createAgent(db, { type: 'senior', teamId });
-      createAgent(db, { type: 'junior', teamId });
-      createAgent(db, { type: 'intermediate', teamId });
+    it('should return all agents ordered by type and team_id', async () => {
+      await createAgent(db, { type: 'senior', teamId });
+      await createAgent(db, { type: 'junior', teamId });
+      await createAgent(db, { type: 'intermediate', teamId });
 
-      const agents = getAllAgents(db);
+      const agents = await getAllAgents(db);
 
       expect(agents).toHaveLength(3);
       // Should be ordered
       expect(agents.every(a => a.id)).toBe(true);
     });
 
-    it('should return empty array when no agents', () => {
-      const agents = getAllAgents(db);
+    it('should return empty array when no agents', async () => {
+      const agents = await getAllAgents(db);
       expect(agents).toEqual([]);
     });
   });
 
   describe('getActiveAgents', () => {
-    it('should return only active agents (not terminated)', () => {
-      const agent1 = createAgent(db, { type: 'senior', teamId });
-      const agent2 = createAgent(db, { type: 'junior', teamId });
-      const agent3 = createAgent(db, { type: 'intermediate', teamId });
+    it('should return only active agents (not terminated)', async () => {
+      const agent1 = await createAgent(db, { type: 'senior', teamId });
+      const agent2 = await createAgent(db, { type: 'junior', teamId });
+      const agent3 = await createAgent(db, { type: 'intermediate', teamId });
 
-      updateAgent(db, agent2.id, { status: 'working' });
-      updateAgent(db, agent3.id, { status: 'terminated' });
+      await updateAgent(db, agent2.id, { status: 'working' });
+      await updateAgent(db, agent3.id, { status: 'terminated' });
 
-      const active = getActiveAgents(db);
+      const active = await getActiveAgents(db);
 
       expect(active).toHaveLength(2);
       expect(active.map(a => a.id)).toContain(agent1.id);
@@ -209,69 +210,69 @@ describe('agents queries', () => {
   });
 
   describe('getTechLead', () => {
-    it('should return the tech lead agent', () => {
-      createAgent(db, { type: 'tech_lead', teamId });
-      createAgent(db, { type: 'senior', teamId });
+    it('should return the tech lead agent', async () => {
+      await createAgent(db, { type: 'tech_lead', teamId });
+      await createAgent(db, { type: 'senior', teamId });
 
-      const techLead = getTechLead(db);
+      const techLead = await getTechLead(db);
 
       expect(techLead).toBeDefined();
       expect(techLead?.type).toBe('tech_lead');
       expect(techLead?.id).toBe('tech-lead');
     });
 
-    it('should return undefined when no tech lead exists', () => {
-      const techLead = getTechLead(db);
+    it('should return undefined when no tech lead exists', async () => {
+      const techLead = await getTechLead(db);
       expect(techLead).toBeUndefined();
     });
   });
 
   describe('updateAgent', () => {
-    it('should update agent status', () => {
-      const agent = createAgent(db, { type: 'senior', teamId });
+    it('should update agent status', async () => {
+      const agent = await createAgent(db, { type: 'senior', teamId });
 
-      const updated = updateAgent(db, agent.id, { status: 'working' });
+      const updated = await updateAgent(db, agent.id, { status: 'working' });
 
       expect(updated?.status).toBe('working');
     });
 
-    it('should update tmux session', () => {
-      const agent = createAgent(db, { type: 'senior', teamId });
+    it('should update tmux session', async () => {
+      const agent = await createAgent(db, { type: 'senior', teamId });
 
-      const updated = updateAgent(db, agent.id, { tmuxSession: 'new-session' });
+      const updated = await updateAgent(db, agent.id, { tmuxSession: 'new-session' });
 
       expect(updated?.tmux_session).toBe('new-session');
     });
 
-    it('should update current story ID', () => {
-      const agent = createAgent(db, { type: 'senior', teamId });
+    it('should update current story ID', async () => {
+      const agent = await createAgent(db, { type: 'senior', teamId });
 
-      const updated = updateAgent(db, agent.id, { currentStoryId: 'STORY-123' });
+      const updated = await updateAgent(db, agent.id, { currentStoryId: 'STORY-123' });
 
       expect(updated?.current_story_id).toBe('STORY-123');
     });
 
-    it('should update memory state', () => {
-      const agent = createAgent(db, { type: 'senior', teamId });
+    it('should update memory state', async () => {
+      const agent = await createAgent(db, { type: 'senior', teamId });
       const memoryState = JSON.stringify({ key: 'value' });
 
-      const updated = updateAgent(db, agent.id, { memoryState });
+      const updated = await updateAgent(db, agent.id, { memoryState });
 
       expect(updated?.memory_state).toBe(memoryState);
     });
 
-    it('should update worktree path', () => {
-      const agent = createAgent(db, { type: 'senior', teamId });
+    it('should update worktree path', async () => {
+      const agent = await createAgent(db, { type: 'senior', teamId });
 
-      const updated = updateAgent(db, agent.id, { worktreePath: '/new/path' });
+      const updated = await updateAgent(db, agent.id, { worktreePath: '/new/path' });
 
       expect(updated?.worktree_path).toBe('/new/path');
     });
 
-    it('should update multiple fields at once', () => {
-      const agent = createAgent(db, { type: 'senior', teamId });
+    it('should update multiple fields at once', async () => {
+      const agent = await createAgent(db, { type: 'senior', teamId });
 
-      const updated = updateAgent(db, agent.id, {
+      const updated = await updateAgent(db, agent.id, {
         status: 'working',
         currentStoryId: 'STORY-456',
         tmuxSession: 'updated-session',
@@ -282,46 +283,46 @@ describe('agents queries', () => {
       expect(updated?.tmux_session).toBe('updated-session');
     });
 
-    it('should update updated_at timestamp', () => {
-      const agent = createAgent(db, { type: 'senior', teamId });
+    it('should update updated_at timestamp', async () => {
+      const agent = await createAgent(db, { type: 'senior', teamId });
 
-      const updated = updateAgent(db, agent.id, { status: 'working' });
+      const updated = await updateAgent(db, agent.id, { status: 'working' });
 
       // Verify updated_at exists and is a valid timestamp
       expect(updated?.updated_at).toBeDefined();
       expect(typeof updated?.updated_at).toBe('string');
     });
 
-    it('should return agent when no updates provided', () => {
-      const agent = createAgent(db, { type: 'senior', teamId });
+    it('should return agent when no updates provided', async () => {
+      const agent = await createAgent(db, { type: 'senior', teamId });
 
-      const updated = updateAgent(db, agent.id, {});
+      const updated = await updateAgent(db, agent.id, {});
 
       expect(updated?.id).toBe(agent.id);
     });
 
-    it('should return undefined for non-existent agent', () => {
-      const updated = updateAgent(db, 'non-existent-id', { status: 'working' });
+    it('should return undefined for non-existent agent', async () => {
+      const updated = await updateAgent(db, 'non-existent-id', { status: 'working' });
       expect(updated).toBeUndefined();
     });
 
-    it('should handle setting fields to null', () => {
-      const agent = createAgent(db, {
+    it('should handle setting fields to null', async () => {
+      const agent = await createAgent(db, {
         type: 'senior',
         teamId,
         tmuxSession: 'session-1',
       });
 
-      const updated = updateAgent(db, agent.id, { tmuxSession: null });
+      const updated = await updateAgent(db, agent.id, { tmuxSession: null });
 
       expect(updated?.tmux_session).toBeNull();
     });
 
-    it('should reset created_at when createdAt is provided', () => {
-      const agent = createAgent(db, { type: 'tech_lead', teamId });
+    it('should reset created_at when createdAt is provided', async () => {
+      const agent = await createAgent(db, { type: 'tech_lead', teamId });
       const newCreatedAt = new Date(Date.now() + 60_000).toISOString();
 
-      const updated = updateAgent(db, agent.id, {
+      const updated = await updateAgent(db, agent.id, {
         status: 'working',
         createdAt: newCreatedAt,
       });
@@ -332,38 +333,38 @@ describe('agents queries', () => {
   });
 
   describe('deleteAgent', () => {
-    it('should delete an agent', () => {
-      const agent = createAgent(db, { type: 'senior', teamId });
+    it('should delete an agent', async () => {
+      const agent = await createAgent(db, { type: 'senior', teamId });
 
-      deleteAgent(db, agent.id);
+      await deleteAgent(db, agent.id);
 
-      const retrieved = getAgentById(db, agent.id);
+      const retrieved = await getAgentById(db, agent.id);
       expect(retrieved).toBeUndefined();
     });
 
-    it('should not throw when deleting non-existent agent', () => {
-      expect(() => deleteAgent(db, 'non-existent-id')).not.toThrow();
+    it('should not throw when deleting non-existent agent', async () => {
+      await expect(deleteAgent(db, 'non-existent-id')).resolves.not.toThrow();
     });
   });
 
   describe('terminateAgent', () => {
-    it('should set agent status to terminated and clear tmux session', () => {
-      const agent = createAgent(db, {
+    it('should set agent status to terminated and clear tmux session', async () => {
+      const agent = await createAgent(db, {
         type: 'senior',
         teamId,
         tmuxSession: 'session-1',
       });
 
-      terminateAgent(db, agent.id);
+      await terminateAgent(db, agent.id);
 
-      const terminated = getAgentById(db, agent.id);
+      const terminated = await getAgentById(db, agent.id);
       expect(terminated?.status).toBe('terminated');
       expect(terminated?.tmux_session).toBeNull();
     });
   });
 
   describe('edge cases', () => {
-    it('should handle all agent types', () => {
+    it('should handle all agent types', async () => {
       const types: Array<'tech_lead' | 'senior' | 'intermediate' | 'junior' | 'qa'> = [
         'tech_lead',
         'senior',
@@ -372,13 +373,13 @@ describe('agents queries', () => {
         'qa',
       ];
 
-      types.forEach(type => {
-        const agent = createAgent(db, { type });
+      for (const type of types) {
+        const agent = await createAgent(db, { type });
         expect(agent.type).toBe(type);
-      });
+      }
     });
 
-    it('should handle all agent statuses', () => {
+    it('should handle all agent statuses', async () => {
       const statuses: Array<'idle' | 'working' | 'blocked' | 'terminated'> = [
         'idle',
         'working',
@@ -386,19 +387,19 @@ describe('agents queries', () => {
         'terminated',
       ];
 
-      const agent = createAgent(db, { type: 'senior', teamId });
+      const agent = await createAgent(db, { type: 'senior', teamId });
 
-      statuses.forEach(status => {
-        const updated = updateAgent(db, agent.id, { status });
+      for (const status of statuses) {
+        const updated = await updateAgent(db, agent.id, { status });
         expect(updated?.status).toBe(status);
-      });
+      }
     });
 
-    it('should handle long memory state strings', () => {
-      const agent = createAgent(db, { type: 'senior', teamId });
+    it('should handle long memory state strings', async () => {
+      const agent = await createAgent(db, { type: 'senior', teamId });
       const longMemory = JSON.stringify({ data: 'A'.repeat(100000) });
 
-      const updated = updateAgent(db, agent.id, { memoryState: longMemory });
+      const updated = await updateAgent(db, agent.id, { memoryState: longMemory });
 
       expect(updated?.memory_state).toBe(longMemory);
     });