hungry-ghost-hive 0.47.4 → 0.49.0

package/src/db/queries/escalations.ts

@@ -1,8 +1,8 @@
 // Licensed under the Hungry Ghost Hive License. See LICENSE.
 
 import { nanoid } from 'nanoid';
-import type { Database } from 'sql.js';
-import { queryAll, queryOne, run, type EscalationRow } from '../client.js';
+import { type EscalationRow } from '../client.js';
+import type { DatabaseProvider } from '../provider.js';
 
 export type { EscalationRow };
 
@@ -21,12 +21,14 @@ export interface UpdateEscalationInput {
   resolution?: string | null;
 }
 
-export function createEscalation(db: Database, input: CreateEscalationInput): EscalationRow {
+export async function createEscalation(
+  provider: DatabaseProvider,
+  input: CreateEscalationInput
+): Promise<EscalationRow> {
   const id = `ESC-${nanoid(6).toUpperCase()}`;
   const now = new Date().toISOString();
 
-  run(
-    db,
+  await provider.run(
     `
     INSERT INTO escalations (id, story_id, from_agent_id, to_agent_id, reason, created_at)
     VALUES (?, ?, ?, ?, ?, ?)
@@ -41,16 +43,21 @@ export function createEscalation(db: Database, input: CreateEscalationInput): Es
     ]
   );
 
-  return getEscalationById(db, id)!;
+  return (await getEscalationById(provider, id))!;
 }
 
-export function getEscalationById(db: Database, id: string): EscalationRow | undefined {
-  return queryOne<EscalationRow>(db, 'SELECT * FROM escalations WHERE id = ?', [id]);
+export async function getEscalationById(
+  provider: DatabaseProvider,
+  id: string
+): Promise<EscalationRow | undefined> {
+  return await provider.queryOne<EscalationRow>('SELECT * FROM escalations WHERE id = ?', [id]);
 }
 
-export function getEscalationsByStory(db: Database, storyId: string): EscalationRow[] {
-  return queryAll<EscalationRow>(
-    db,
+export async function getEscalationsByStory(
+  provider: DatabaseProvider,
+  storyId: string
+): Promise<EscalationRow[]> {
+  return await provider.queryAll<EscalationRow>(
     `
     SELECT * FROM escalations
     WHERE story_id = ?
@@ -60,9 +67,11 @@ export function getEscalationsByStory(db: Database, storyId: string): Escalation
   );
 }
 
-export function getEscalationsByFromAgent(db: Database, agentId: string): EscalationRow[] {
-  return queryAll<EscalationRow>(
-    db,
+export async function getEscalationsByFromAgent(
+  provider: DatabaseProvider,
+  agentId: string
+): Promise<EscalationRow[]> {
+  return await provider.queryAll<EscalationRow>(
     `
     SELECT * FROM escalations
     WHERE from_agent_id = ?
@@ -72,19 +81,18 @@ export function getEscalationsByFromAgent(db: Database, agentId: string): Escala
   );
 }
 
-export function getEscalationsByToAgent(db: Database, agentId: string | null): EscalationRow[] {
+export async function getEscalationsByToAgent(
+  provider: DatabaseProvider,
+  agentId: string | null
+): Promise<EscalationRow[]> {
   if (agentId === null) {
-    return queryAll<EscalationRow>(
-      db,
-      `
+    return await provider.queryAll<EscalationRow>(`
       SELECT * FROM escalations
       WHERE to_agent_id IS NULL
       ORDER BY created_at DESC
-    `
-    );
+    `);
   }
-  return queryAll<EscalationRow>(
-    db,
+  return await provider.queryAll<EscalationRow>(
     `
     SELECT * FROM escalations
     WHERE to_agent_id = ?
@@ -94,9 +102,11 @@ export function getEscalationsByToAgent(db: Database, agentId: string | null): E
   );
 }
 
-export function getEscalationsByStatus(db: Database, status: EscalationStatus): EscalationRow[] {
-  return queryAll<EscalationRow>(
-    db,
+export async function getEscalationsByStatus(
+  provider: DatabaseProvider,
+  status: EscalationStatus
+): Promise<EscalationRow[]> {
+  return await provider.queryAll<EscalationRow>(
     `
     SELECT * FROM escalations
     WHERE status = ?
@@ -106,28 +116,26 @@ export function getEscalationsByStatus(db: Database, status: EscalationStatus):
   );
 }
 
-export function getPendingEscalations(db: Database): EscalationRow[] {
-  return getEscalationsByStatus(db, 'pending');
+export async function getPendingEscalations(provider: DatabaseProvider): Promise<EscalationRow[]> {
+  return await getEscalationsByStatus(provider, 'pending');
 }
 
-export function getPendingHumanEscalations(db: Database): EscalationRow[] {
-  return queryAll<EscalationRow>(
-    db,
-    `
+export async function getPendingHumanEscalations(
+  provider: DatabaseProvider
+): Promise<EscalationRow[]> {
+  return await provider.queryAll<EscalationRow>(`
     SELECT * FROM escalations
     WHERE status = 'pending' AND to_agent_id IS NULL
     ORDER BY created_at
-  `
-  );
+  `);
 }
 
-export function getRecentEscalationsForAgent(
-  db: Database,
+export async function getRecentEscalationsForAgent(
+  provider: DatabaseProvider,
   agentId: string,
   minutesBack: number = 30
-): EscalationRow[] {
-  return queryAll<EscalationRow>(
-    db,
+): Promise<EscalationRow[]> {
+  return await provider.queryAll<EscalationRow>(
     `
     SELECT * FROM escalations
     WHERE from_agent_id = ?
@@ -138,9 +146,11 @@ export function getRecentEscalationsForAgent(
   );
 }
 
-export function getActiveEscalationsForAgent(db: Database, agentId: string): EscalationRow[] {
-  return queryAll<EscalationRow>(
-    db,
+export async function getActiveEscalationsForAgent(
+  provider: DatabaseProvider,
+  agentId: string
+): Promise<EscalationRow[]> {
+  return await provider.queryAll<EscalationRow>(
     `
     SELECT * FROM escalations
     WHERE from_agent_id = ?
@@ -151,15 +161,17 @@ export function getActiveEscalationsForAgent(db: Database, agentId: string): Esc
   );
 }
 
-export function getAllEscalations(db: Database): EscalationRow[] {
-  return queryAll<EscalationRow>(db, 'SELECT * FROM escalations ORDER BY created_at DESC');
+export async function getAllEscalations(provider: DatabaseProvider): Promise<EscalationRow[]> {
+  return await provider.queryAll<EscalationRow>(
+    'SELECT * FROM escalations ORDER BY created_at DESC'
+  );
 }
 
-export function updateEscalation(
-  db: Database,
+export async function updateEscalation(
+  provider: DatabaseProvider,
   id: string,
   input: UpdateEscalationInput
-): EscalationRow | undefined {
+): Promise<EscalationRow | undefined> {
   const updates: string[] = [];
   const values: (string | null)[] = [];
 
@@ -181,26 +193,29 @@ export function updateEscalation(
   }
 
   if (updates.length === 0) {
-    return getEscalationById(db, id);
+    return await getEscalationById(provider, id);
   }
 
   values.push(id);
-  run(db, `UPDATE escalations SET ${updates.join(', ')} WHERE id = ?`, values);
-  return getEscalationById(db, id);
+  await provider.run(`UPDATE escalations SET ${updates.join(', ')} WHERE id = ?`, values);
+  return await getEscalationById(provider, id);
 }
 
-export function resolveEscalation(
-  db: Database,
+export async function resolveEscalation(
+  provider: DatabaseProvider,
   id: string,
   resolution: string
-): EscalationRow | undefined {
-  return updateEscalation(db, id, { status: 'resolved', resolution });
+): Promise<EscalationRow | undefined> {
+  return await updateEscalation(provider, id, { status: 'resolved', resolution });
 }
 
-export function acknowledgeEscalation(db: Database, id: string): EscalationRow | undefined {
-  return updateEscalation(db, id, { status: 'acknowledged' });
+export async function acknowledgeEscalation(
+  provider: DatabaseProvider,
+  id: string
+): Promise<EscalationRow | undefined> {
+  return await updateEscalation(provider, id, { status: 'acknowledged' });
 }
 
-export function deleteEscalation(db: Database, id: string): void {
-  run(db, 'DELETE FROM escalations WHERE id = ?', [id]);
+export async function deleteEscalation(provider: DatabaseProvider, id: string): Promise<void> {
+  await provider.run('DELETE FROM escalations WHERE id = ?', [id]);
 }

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

@@ -1,19 +1,20 @@
 // 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 } from './agents.js';
 import { getStaleAgents, isAgentHeartbeatCurrent, updateAgentHeartbeat } from './heartbeat.js';
 import { createTeam } from './teams.js';
 import { createTestDatabase } from './test-helpers.js';
 
 describe('heartbeat 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',
@@ -22,15 +23,15 @@ describe('heartbeat queries', () => {
   });
 
   describe('updateAgentHeartbeat', () => {
-    it('should update agent last_seen timestamp', () => {
-      const agent = createAgent(db, {
+    it('should update agent last_seen timestamp', async () => {
+      const agent = await createAgent(db, {
         type: 'senior',
         teamId,
       });
 
-      updateAgentHeartbeat(db, agent.id);
+      await updateAgentHeartbeat(db, agent.id);
 
-      const stmt = db.prepare(`SELECT last_seen FROM agents WHERE id = ?`);
+      const stmt = db.db.prepare(`SELECT last_seen FROM agents WHERE id = ?`);
       stmt.bind([agent.id]);
       const afterUpdate = [];
       while (stmt.step()) afterUpdate.push(stmt.getAsObject());
@@ -41,17 +42,17 @@ describe('heartbeat queries', () => {
       expect(typeof updatedLastSeen).toBe('string');
     });
 
-    it('should handle multiple heartbeat updates', () => {
-      const agent = createAgent(db, {
+    it('should handle multiple heartbeat updates', async () => {
+      const agent = await createAgent(db, {
         type: 'senior',
         teamId,
       });
 
-      updateAgentHeartbeat(db, agent.id);
-      updateAgentHeartbeat(db, agent.id);
-      updateAgentHeartbeat(db, agent.id);
+      await updateAgentHeartbeat(db, agent.id);
+      await updateAgentHeartbeat(db, agent.id);
+      await updateAgentHeartbeat(db, agent.id);
 
-      const stmtResult = db.prepare(`SELECT last_seen FROM agents WHERE id = ?`);
+      const stmtResult = db.db.prepare(`SELECT last_seen FROM agents WHERE id = ?`);
       stmtResult.bind([agent.id]);
       const result = [];
       while (stmtResult.step()) result.push(stmtResult.getAsObject());
@@ -61,135 +62,133 @@ describe('heartbeat queries', () => {
       expect(lastSeen).toBeDefined();
     });
 
-    it('should not throw error for non-existent agent', () => {
-      expect(() => {
-        updateAgentHeartbeat(db, 'non-existent-agent');
-      }).not.toThrow();
+    it('should not throw error for non-existent agent', async () => {
+      await expect(updateAgentHeartbeat(db, 'non-existent-agent')).resolves.not.toThrow();
     });
   });
 
   describe('getStaleAgents', () => {
-    it('should return agents with stale heartbeats', () => {
+    it('should return agents with stale heartbeats', async () => {
       // Create agent and manually set old last_seen
-      const agent = createAgent(db, {
+      const agent = await createAgent(db, {
         type: 'senior',
         teamId,
       });
 
       // Set last_seen to 30 seconds ago
       const oldTimestamp = new Date(Date.now() - 30000).toISOString();
-      db.run(`UPDATE agents SET last_seen = ? WHERE id = ?`, [oldTimestamp, agent.id]);
+      db.db.run(`UPDATE agents SET last_seen = ? WHERE id = ?`, [oldTimestamp, agent.id]);
 
-      const staleAgents = getStaleAgents(db, 15);
+      const staleAgents = await getStaleAgents(db, 15);
 
       expect(staleAgents.length).toBeGreaterThan(0);
       expect(staleAgents[0].id).toBe(agent.id);
       expect(staleAgents[0].seconds_since_heartbeat).toBeGreaterThan(15);
     });
 
-    it('should not return agents with current heartbeats', () => {
-      const agent = createAgent(db, {
+    it('should not return agents with current heartbeats', async () => {
+      const agent = await createAgent(db, {
         type: 'senior',
         teamId,
       });
 
-      updateAgentHeartbeat(db, agent.id);
+      await updateAgentHeartbeat(db, agent.id);
 
-      const staleAgents = getStaleAgents(db, 15);
+      const staleAgents = await getStaleAgents(db, 15);
 
       expect(staleAgents).toEqual([]);
     });
 
-    it('should respect timeout parameter', () => {
-      const agent = createAgent(db, {
+    it('should respect timeout parameter', async () => {
+      const agent = await createAgent(db, {
         type: 'senior',
         teamId,
       });
 
       // Set last_seen to 10 seconds ago
       const timestamp = new Date(Date.now() - 10000).toISOString();
-      db.run(`UPDATE agents SET last_seen = ? WHERE id = ?`, [timestamp, agent.id]);
+      db.db.run(`UPDATE agents SET last_seen = ? WHERE id = ?`, [timestamp, agent.id]);
 
       // With 5 second timeout, should be stale
-      const staleWith5 = getStaleAgents(db, 5);
+      const staleWith5 = await getStaleAgents(db, 5);
       expect(staleWith5.length).toBeGreaterThan(0);
 
       // With 20 second timeout, should not be stale
-      const staleWith20 = getStaleAgents(db, 20);
+      const staleWith20 = await getStaleAgents(db, 20);
       expect(staleWith20).toEqual([]);
     });
 
-    it('should only return active agents (working/idle)', () => {
-      const workingAgent = createAgent(db, {
+    it('should only return active agents (working/idle)', async () => {
+      const workingAgent = await createAgent(db, {
         type: 'senior',
         teamId,
       });
 
-      const terminatedAgent = createAgent(db, {
+      const terminatedAgent = await createAgent(db, {
         type: 'junior',
         teamId,
       });
 
       // Set both to old heartbeat
       const oldTimestamp = new Date(Date.now() - 30000).toISOString();
-      db.run(`UPDATE agents SET last_seen = ? WHERE id = ?`, [oldTimestamp, workingAgent.id]);
-      db.run(`UPDATE agents SET last_seen = ?, status = 'terminated' WHERE id = ?`, [
+      db.db.run(`UPDATE agents SET last_seen = ? WHERE id = ?`, [oldTimestamp, workingAgent.id]);
+      db.db.run(`UPDATE agents SET last_seen = ?, status = 'terminated' WHERE id = ?`, [
         oldTimestamp,
         terminatedAgent.id,
       ]);
 
-      const staleAgents = getStaleAgents(db, 15);
+      const staleAgents = await getStaleAgents(db, 15);
 
       // Should only include working/idle agents
       expect(staleAgents.some(a => a.id === workingAgent.id)).toBe(true);
       expect(staleAgents.some(a => a.id === terminatedAgent.id)).toBe(false);
     });
 
-    it('should handle agents with null last_seen after grace period', () => {
-      const agent = createAgent(db, {
+    it('should handle agents with null last_seen after grace period', async () => {
+      const agent = await createAgent(db, {
         type: 'senior',
         teamId,
       });
 
       // Set last_seen to null and created_at to old timestamp (> 60 + timeout seconds ago)
       const oldCreatedAt = new Date(Date.now() - 90000).toISOString(); // 90 seconds ago
-      db.run(`UPDATE agents SET last_seen = NULL, created_at = ? WHERE id = ?`, [
+      db.db.run(`UPDATE agents SET last_seen = NULL, created_at = ? WHERE id = ?`, [
         oldCreatedAt,
         agent.id,
       ]);
 
-      const staleAgents = getStaleAgents(db, 15);
+      const staleAgents = await getStaleAgents(db, 15);
 
       // Should be detected as stale (older than 60 + 15 = 75 seconds)
       expect(staleAgents.some(a => a.id === agent.id)).toBe(true);
     });
 
-    it('should not return recently created agents with null last_seen', () => {
-      const agent = createAgent(db, {
+    it('should not return recently created agents with null last_seen', async () => {
+      const agent = await createAgent(db, {
         type: 'senior',
         teamId,
       });
 
       // Set last_seen to null but keep recent created_at
-      db.run(`UPDATE agents SET last_seen = NULL WHERE id = ?`, [agent.id]);
+      db.db.run(`UPDATE agents SET last_seen = NULL WHERE id = ?`, [agent.id]);
 
-      const staleAgents = getStaleAgents(db, 15);
+      const staleAgents = await getStaleAgents(db, 15);
 
       // Should not be stale (within grace period)
       expect(staleAgents.some(a => a.id === agent.id)).toBe(false);
     });
 
-    it('should calculate seconds_since_heartbeat correctly', () => {
-      const agent = createAgent(db, {
+    it('should calculate seconds_since_heartbeat correctly', async () => {
+      const agent = await createAgent(db, {
         type: 'senior',
         teamId,
       });
 
       // Set last_seen to exactly 30 seconds ago
       const timestamp = new Date(Date.now() - 30000).toISOString();
-      db.run(`UPDATE agents SET last_seen = ? WHERE id = ?`, [timestamp, agent.id]);
+      db.db.run(`UPDATE agents SET last_seen = ? WHERE id = ?`, [timestamp, agent.id]);
 
-      const staleAgents = getStaleAgents(db, 15);
+      const staleAgents = await getStaleAgents(db, 15);
 
       const staleAgent = staleAgents.find(a => a.id === agent.id);
       expect(staleAgent).toBeDefined();
@@ -198,100 +197,100 @@ describe('heartbeat queries', () => {
       expect(staleAgent!.seconds_since_heartbeat).toBeLessThanOrEqual(35);
     });
 
-    it('should return multiple stale agents', () => {
-      const agent1 = createAgent(db, { type: 'senior', teamId });
-      const agent2 = createAgent(db, { type: 'intermediate', teamId });
-      const agent3 = createAgent(db, { type: 'junior', teamId });
+    it('should return multiple stale agents', async () => {
+      const agent1 = await createAgent(db, { type: 'senior', teamId });
+      const agent2 = await createAgent(db, { type: 'intermediate', teamId });
+      const agent3 = await createAgent(db, { type: 'junior', teamId });
 
       const oldTimestamp = new Date(Date.now() - 30000).toISOString();
-      db.run(`UPDATE agents SET last_seen = ? WHERE id IN (?, ?, ?)`, [
+      db.db.run(`UPDATE agents SET last_seen = ? WHERE id IN (?, ?, ?)`, [
         oldTimestamp,
         agent1.id,
         agent2.id,
         agent3.id,
       ]);
 
-      const staleAgents = getStaleAgents(db, 15);
+      const staleAgents = await getStaleAgents(db, 15);
 
       expect(staleAgents.length).toBe(3);
     });
   });
 
   describe('isAgentHeartbeatCurrent', () => {
-    it('should return true for agent with current heartbeat', () => {
-      const agent = createAgent(db, {
+    it('should return true for agent with current heartbeat', async () => {
+      const agent = await createAgent(db, {
         type: 'senior',
         teamId,
       });
 
-      updateAgentHeartbeat(db, agent.id);
+      await updateAgentHeartbeat(db, agent.id);
 
-      const isCurrent = isAgentHeartbeatCurrent(db, agent.id, 15);
+      const isCurrent = await isAgentHeartbeatCurrent(db, agent.id, 15);
 
       expect(isCurrent).toBe(true);
     });
 
-    it('should return false for agent with stale heartbeat', () => {
-      const agent = createAgent(db, {
+    it('should return false for agent with stale heartbeat', async () => {
+      const agent = await createAgent(db, {
         type: 'senior',
         teamId,
       });
 
       // Set last_seen to 30 seconds ago
       const oldTimestamp = new Date(Date.now() - 30000).toISOString();
-      db.run(`UPDATE agents SET last_seen = ? WHERE id = ?`, [oldTimestamp, agent.id]);
+      db.db.run(`UPDATE agents SET last_seen = ? WHERE id = ?`, [oldTimestamp, agent.id]);
 
-      const isCurrent = isAgentHeartbeatCurrent(db, agent.id, 15);
+      const isCurrent = await isAgentHeartbeatCurrent(db, agent.id, 15);
 
       expect(isCurrent).toBe(false);
     });
 
-    it('should return false for agent with null last_seen', () => {
-      const agent = createAgent(db, {
+    it('should return false for agent with null last_seen', async () => {
+      const agent = await createAgent(db, {
         type: 'senior',
         teamId,
       });
 
       // Set last_seen to null
-      db.run(`UPDATE agents SET last_seen = NULL WHERE id = ?`, [agent.id]);
+      db.db.run(`UPDATE agents SET last_seen = NULL WHERE id = ?`, [agent.id]);
 
-      const isCurrent = isAgentHeartbeatCurrent(db, agent.id, 15);
+      const isCurrent = await isAgentHeartbeatCurrent(db, agent.id, 15);
 
       expect(isCurrent).toBe(false);
     });
 
-    it('should respect custom timeout', () => {
-      const agent = createAgent(db, {
+    it('should respect custom timeout', async () => {
+      const agent = await createAgent(db, {
         type: 'senior',
         teamId,
       });
 
       // Set last_seen to 10 seconds ago
       const timestamp = new Date(Date.now() - 10000).toISOString();
-      db.run(`UPDATE agents SET last_seen = ? WHERE id = ?`, [timestamp, agent.id]);
+      db.db.run(`UPDATE agents SET last_seen = ? WHERE id = ?`, [timestamp, agent.id]);
 
       // With 5 second timeout, should be false
-      expect(isAgentHeartbeatCurrent(db, agent.id, 5)).toBe(false);
+      expect(await isAgentHeartbeatCurrent(db, agent.id, 5)).toBe(false);
 
       // With 20 second timeout, should be true
-      expect(isAgentHeartbeatCurrent(db, agent.id, 20)).toBe(true);
+      expect(await isAgentHeartbeatCurrent(db, agent.id, 20)).toBe(true);
     });
 
-    it('should return false for non-existent agent', () => {
-      const isCurrent = isAgentHeartbeatCurrent(db, 'non-existent-agent', 15);
+    it('should return false for non-existent agent', async () => {
+      const isCurrent = await isAgentHeartbeatCurrent(db, 'non-existent-agent', 15);
       expect(isCurrent).toBe(false);
     });
 
-    it('should use default timeout of 15 seconds', () => {
-      const agent = createAgent(db, {
+    it('should use default timeout of 15 seconds', async () => {
+      const agent = await createAgent(db, {
         type: 'senior',
         teamId,
       });
 
-      updateAgentHeartbeat(db, agent.id);
+      await updateAgentHeartbeat(db, agent.id);
 
       // Should use default 15 second timeout
-      const isCurrent = isAgentHeartbeatCurrent(db, agent.id);
+      const isCurrent = await isAgentHeartbeatCurrent(db, agent.id);
 
       expect(isCurrent).toBe(true);
     });