hungry-ghost-hive 0.48.0 → 0.49.0

package/src/db/queries/stories.ts

@@ -1,9 +1,9 @@
 // Licensed under the Hungry Ghost Hive License. See LICENSE.
 
 import { nanoid } from 'nanoid';
-import type { Database } from 'sql.js';
 import { deleteStoryMarkdown, writeStoryMarkdown } from '../../utils/story-markdown.js';
-import { queryAll, queryOne, run, type StoryRow } from '../client.js';
+import { type StoryRow } from '../client.js';
+import type { DatabaseProvider } from '../provider.js';
 
 export type { StoryRow };
 
@@ -56,15 +56,18 @@ export interface UpdateStoryInput {
   inSprint?: boolean;
 }
 
-export function createStory(db: Database, input: CreateStoryInput, storiesDir?: string): StoryRow {
+export async function createStory(
+  provider: DatabaseProvider,
+  input: CreateStoryInput,
+  storiesDir?: string
+): Promise<StoryRow> {
   const id = `STORY-${nanoid(6).toUpperCase()}`;
   const acceptanceCriteria = input.acceptanceCriteria
     ? JSON.stringify(input.acceptanceCriteria)
     : null;
   const now = new Date().toISOString();
 
-  run(
-    db,
+  await provider.run(
     `
     INSERT INTO stories (id, requirement_id, team_id, title, description, acceptance_criteria, created_at, updated_at)
     VALUES (?, ?, ?, ?, ?, ?, ?, ?)
@@ -81,52 +84,71 @@ export function createStory(db: Database, input: CreateStoryInput, storiesDir?:
     ]
   );
 
-  const story = getStoryById(db, id)!;
+  const story = (await getStoryById(provider, id))!;
 
   if (storiesDir) {
     const markdownPath = writeStoryMarkdown(storiesDir, story);
-    run(db, 'UPDATE stories SET markdown_path = ? WHERE id = ?', [markdownPath, id]);
+    await provider.run('UPDATE stories SET markdown_path = ? WHERE id = ?', [markdownPath, id]);
     story.markdown_path = markdownPath;
   }
 
   return story;
 }
 
-export function getStoryById(db: Database, id: string): StoryRow | undefined {
-  return queryOne<StoryRow>(db, 'SELECT * FROM stories WHERE id = ? COLLATE NOCASE', [id]);
+export async function getStoryById(
+  provider: DatabaseProvider,
+  id: string
+): Promise<StoryRow | undefined> {
+  return await provider.queryOne<StoryRow>('SELECT * FROM stories WHERE id = ? COLLATE NOCASE', [
+    id,
+  ]);
 }
 
-export function getStoriesByRequirement(db: Database, requirementId: string): StoryRow[] {
-  return queryAll<StoryRow>(
-    db,
+export async function getStoriesByRequirement(
+  provider: DatabaseProvider,
+  requirementId: string
+): Promise<StoryRow[]> {
+  return await provider.queryAll<StoryRow>(
     'SELECT * FROM stories WHERE requirement_id = ? ORDER BY created_at',
     [requirementId]
   );
 }
 
-export function getStoriesByTeam(db: Database, teamId: string): StoryRow[] {
-  return queryAll<StoryRow>(db, 'SELECT * FROM stories WHERE team_id = ? ORDER BY created_at', [
-    teamId,
-  ]);
+export async function getStoriesByTeam(
+  provider: DatabaseProvider,
+  teamId: string
+): Promise<StoryRow[]> {
+  return await provider.queryAll<StoryRow>(
+    'SELECT * FROM stories WHERE team_id = ? ORDER BY created_at',
+    [teamId]
+  );
 }
 
-export function getStoriesByStatus(db: Database, status: StoryStatus): StoryRow[] {
-  return queryAll<StoryRow>(db, 'SELECT * FROM stories WHERE status = ? ORDER BY created_at', [
-    status,
-  ]);
+export async function getStoriesByStatus(
+  provider: DatabaseProvider,
+  status: StoryStatus
+): Promise<StoryRow[]> {
+  return await provider.queryAll<StoryRow>(
+    'SELECT * FROM stories WHERE status = ? ORDER BY created_at',
+    [status]
+  );
 }
 
-export function getStoriesByAgent(db: Database, agentId: string): StoryRow[] {
-  return queryAll<StoryRow>(
-    db,
+export async function getStoriesByAgent(
+  provider: DatabaseProvider,
+  agentId: string
+): Promise<StoryRow[]> {
+  return await provider.queryAll<StoryRow>(
     'SELECT * FROM stories WHERE assigned_agent_id = ? ORDER BY created_at',
     [agentId]
   );
 }
 
-export function getActiveStoriesByAgent(db: Database, agentId: string): StoryRow[] {
-  return queryAll<StoryRow>(
-    db,
+export async function getActiveStoriesByAgent(
+  provider: DatabaseProvider,
+  agentId: string
+): Promise<StoryRow[]> {
+  return await provider.queryAll<StoryRow>(
     `
     SELECT * FROM stories
     WHERE assigned_agent_id = ?
@@ -137,35 +159,31 @@ export function getActiveStoriesByAgent(db: Database, agentId: string): StoryRow
   );
 }
 
-export function getAllStories(db: Database): StoryRow[] {
-  return queryAll<StoryRow>(db, 'SELECT * FROM stories ORDER BY created_at DESC');
+export async function getAllStories(provider: DatabaseProvider): Promise<StoryRow[]> {
+  return await provider.queryAll<StoryRow>('SELECT * FROM stories ORDER BY created_at DESC');
 }
 
-export function getPlannedStories(db: Database): StoryRow[] {
-  return queryAll<StoryRow>(
-    db,
-    `
+export async function getPlannedStories(provider: DatabaseProvider): Promise<StoryRow[]> {
+  return await provider.queryAll<StoryRow>(`
     SELECT * FROM stories
     WHERE status = 'planned'
     ORDER BY story_points DESC, created_at
-  `
-  );
+  `);
 }
 
-export function getInProgressStories(db: Database): StoryRow[] {
-  return queryAll<StoryRow>(
-    db,
-    `
+export async function getInProgressStories(provider: DatabaseProvider): Promise<StoryRow[]> {
+  return await provider.queryAll<StoryRow>(`
     SELECT * FROM stories
     WHERE status IN ('in_progress', 'review', 'qa', 'qa_failed')
     ORDER BY created_at
-  `
-  );
+  `);
 }
 
-export function getStoryPointsByTeam(db: Database, teamId: string): number {
-  const result = queryOne<{ total: number }>(
-    db,
+export async function getStoryPointsByTeam(
+  provider: DatabaseProvider,
+  teamId: string
+): Promise<number> {
+  const result = await provider.queryOne<{ total: number }>(
     `
     SELECT COALESCE(SUM(story_points), 0) as total
     FROM stories
@@ -176,12 +194,12 @@ export function getStoryPointsByTeam(db: Database, teamId: string): number {
   return result?.total || 0;
 }
 
-export function updateStory(
-  db: Database,
+export async function updateStory(
+  provider: DatabaseProvider,
   id: string,
   input: UpdateStoryInput,
   storiesDir?: string
-): StoryRow | undefined {
+): Promise<StoryRow | undefined> {
   const updates: string[] = ['updated_at = ?'];
   const values: (string | number | null)[] = [new Date().toISOString()];
 
@@ -276,18 +294,18 @@ export function updateStory(
   }
 
   if (updates.length === 1) {
-    return getStoryById(db, id);
+    return await getStoryById(provider, id);
   }
 
   values.push(id);
-  run(db, `UPDATE stories SET ${updates.join(', ')} WHERE id = ?`, values);
+  await provider.run(`UPDATE stories SET ${updates.join(', ')} WHERE id = ?`, values);
 
-  const updatedStory = getStoryById(db, id);
+  const updatedStory = await getStoryById(provider, id);
 
   if (storiesDir && updatedStory) {
     const markdownPath = writeStoryMarkdown(storiesDir, updatedStory);
     if (updatedStory.markdown_path !== markdownPath) {
-      run(db, 'UPDATE stories SET markdown_path = ? WHERE id = ?', [markdownPath, id]);
+      await provider.run('UPDATE stories SET markdown_path = ? WHERE id = ?', [markdownPath, id]);
       updatedStory.markdown_path = markdownPath;
     }
   }
@@ -295,18 +313,28 @@ export function updateStory(
   return updatedStory;
 }
 
-export function deleteStory(db: Database, id: string, storiesDir?: string): void {
+export async function deleteStory(
+  provider: DatabaseProvider,
+  id: string,
+  storiesDir?: string
+): Promise<void> {
   if (storiesDir) {
     deleteStoryMarkdown(storiesDir, id);
   }
-  run(db, 'DELETE FROM story_dependencies WHERE story_id = ? OR depends_on_story_id = ?', [id, id]);
-  run(db, 'DELETE FROM stories WHERE id = ?', [id]);
+  await provider.run(
+    'DELETE FROM story_dependencies WHERE story_id = ? OR depends_on_story_id = ?',
+    [id, id]
+  );
+  await provider.run('DELETE FROM stories WHERE id = ?', [id]);
 }
 
 // Story dependencies
-export function addStoryDependency(db: Database, storyId: string, dependsOnStoryId: string): void {
-  run(
-    db,
+export async function addStoryDependency(
+  provider: DatabaseProvider,
+  storyId: string,
+  dependsOnStoryId: string
+): Promise<void> {
+  await provider.run(
     `
     INSERT OR IGNORE INTO story_dependencies (story_id, depends_on_story_id)
     VALUES (?, ?)
@@ -315,20 +343,22 @@ export function addStoryDependency(db: Database, storyId: string, dependsOnStory
   );
 }
 
-export function removeStoryDependency(
-  db: Database,
+export async function removeStoryDependency(
+  provider: DatabaseProvider,
   storyId: string,
   dependsOnStoryId: string
-): void {
-  run(db, 'DELETE FROM story_dependencies WHERE story_id = ? AND depends_on_story_id = ?', [
-    storyId,
-    dependsOnStoryId,
-  ]);
+): Promise<void> {
+  await provider.run(
+    'DELETE FROM story_dependencies WHERE story_id = ? AND depends_on_story_id = ?',
+    [storyId, dependsOnStoryId]
+  );
 }
 
-export function getStoryDependencies(db: Database, storyId: string): StoryRow[] {
-  return queryAll<StoryRow>(
-    db,
+export async function getStoryDependencies(
+  provider: DatabaseProvider,
+  storyId: string
+): Promise<StoryRow[]> {
+  return await provider.queryAll<StoryRow>(
     `
     SELECT s.* FROM stories s
     JOIN story_dependencies sd ON s.id = sd.depends_on_story_id
@@ -338,9 +368,11 @@ export function getStoryDependencies(db: Database, storyId: string): StoryRow[]
   );
 }
 
-export function getStoriesDependingOn(db: Database, storyId: string): StoryRow[] {
-  return queryAll<StoryRow>(
-    db,
+export async function getStoriesDependingOn(
+  provider: DatabaseProvider,
+  storyId: string
+): Promise<StoryRow[]> {
+  return await provider.queryAll<StoryRow>(
     `
     SELECT s.* FROM stories s
     JOIN story_dependencies sd ON s.id = sd.story_id
@@ -357,12 +389,14 @@ export function getStoriesDependingOn(db: Database, storyId: string): StoryRow[]
  * @param storyIds Array of story IDs to get dependencies for
  * @returns Map of story ID to array of dependent story IDs
  */
-export function getBatchStoryDependencies(db: Database, storyIds: string[]): Map<string, string[]> {
+export async function getBatchStoryDependencies(
+  provider: DatabaseProvider,
+  storyIds: string[]
+): Promise<Map<string, string[]>> {
   if (storyIds.length === 0) return new Map();
 
   const placeholders = storyIds.map(() => '?').join(',');
-  const rows = queryAll<{ story_id: string; depends_on_story_id: string }>(
-    db,
+  const rows = await provider.queryAll<{ story_id: string; depends_on_story_id: string }>(
     `
     SELECT sd.story_id, sd.depends_on_story_id
     FROM story_dependencies sd
@@ -385,15 +419,14 @@ export function getBatchStoryDependencies(db: Database, storyIds: string[]): Map
   return deps;
 }
 
-export function getStoryCounts(db: Database): Record<StoryStatus, number> {
-  const rows = queryAll<{ status: StoryStatus; count: number }>(
-    db,
-    `
+export async function getStoryCounts(
+  provider: DatabaseProvider
+): Promise<Record<StoryStatus, number>> {
+  const rows = await provider.queryAll<{ status: StoryStatus; count: number }>(`
     SELECT status, COUNT(*) as count
     FROM stories
     GROUP BY status
-  `
-  );
+  `);
 
   const counts: Record<StoryStatus, number> = {
     draft: 0,
@@ -414,40 +447,34 @@ export function getStoryCounts(db: Database): Record<StoryStatus, number> {
   return counts;
 }
 
-export function getStoriesWithOrphanedAssignments(
-  db: Database
-): Array<{ id: string; agent_id: string }> {
-  return queryAll<{ id: string; agent_id: string }>(
-    db,
-    `
+export async function getStoriesWithOrphanedAssignments(
+  provider: DatabaseProvider
+): Promise<Array<{ id: string; agent_id: string }>> {
+  return await provider.queryAll<{ id: string; agent_id: string }>(`
     SELECT s.id, s.assigned_agent_id as agent_id
     FROM stories s
     WHERE s.assigned_agent_id IS NOT NULL
     AND s.assigned_agent_id NOT IN (
       SELECT id FROM agents WHERE status != 'terminated'
     )
-  `
-  );
+  `);
 }
 
-export function getStaleInProgressStoriesWithoutAssignment(db: Database): Array<{ id: string }> {
-  return queryAll<{ id: string }>(
-    db,
-    `
+export async function getStaleInProgressStoriesWithoutAssignment(
+  provider: DatabaseProvider
+): Promise<Array<{ id: string }>> {
+  return await provider.queryAll<{ id: string }>(`
     SELECT id
     FROM stories
     WHERE status = 'in_progress'
       AND assigned_agent_id IS NULL
-  `
-  );
+  `);
 }
 
-export function getInProgressStoriesWithInconsistentAssignments(
-  db: Database
-): Array<{ id: string; agent_id: string }> {
-  return queryAll<{ id: string; agent_id: string }>(
-    db,
-    `
+export async function getInProgressStoriesWithInconsistentAssignments(
+  provider: DatabaseProvider
+): Promise<Array<{ id: string; agent_id: string }>> {
+  return await provider.queryAll<{ id: string; agent_id: string }>(`
     SELECT s.id, s.assigned_agent_id as agent_id
     FROM stories s
     JOIN agents a ON a.id = s.assigned_agent_id
@@ -459,32 +486,36 @@ export function getInProgressStoriesWithInconsistentAssignments(
         OR a.current_story_id IS NULL
         OR a.current_story_id != s.id
       )
-  `
-  );
+  `);
 }
 
 /** @deprecated Use getStoryByExternalKey instead */
-export function getStoryByJiraKey(db: Database, jiraIssueKey: string): StoryRow | undefined {
-  return queryOne<StoryRow>(
-    db,
+export async function getStoryByJiraKey(
+  provider: DatabaseProvider,
+  jiraIssueKey: string
+): Promise<StoryRow | undefined> {
+  return await provider.queryOne<StoryRow>(
     'SELECT * FROM stories WHERE external_issue_key = ? OR jira_issue_key = ?',
     [jiraIssueKey, jiraIssueKey]
   );
 }
 
-export function getStoryByExternalKey(
-  db: Database,
+export async function getStoryByExternalKey(
+  provider: DatabaseProvider,
   externalIssueKey: string
-): StoryRow | undefined {
-  return queryOne<StoryRow>(
-    db,
+): Promise<StoryRow | undefined> {
+  return await provider.queryOne<StoryRow>(
     'SELECT * FROM stories WHERE external_issue_key = ? OR jira_issue_key = ?',
     [externalIssueKey, externalIssueKey]
   );
 }
 
-export function updateStoryAssignment(db: Database, storyId: string, agentId: string | null): void {
-  run(db, 'UPDATE stories SET assigned_agent_id = ?, updated_at = ? WHERE id = ?', [
+export async function updateStoryAssignment(
+  provider: DatabaseProvider,
+  storyId: string,
+  agentId: string | null
+): Promise<void> {
+  await provider.run('UPDATE stories SET assigned_agent_id = ?, updated_at = ? WHERE id = ?', [
     agentId,
     new Date().toISOString(),
     storyId,

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

@@ -1,20 +1,21 @@
 // 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 { createTeam, deleteTeam, getAllTeams, getTeamById, getTeamByName } from './teams.js';
 import { createTestDatabase } from './test-helpers.js';
 
 describe('teams queries', () => {
-  let db: Database;
+  let db: SqliteProvider;
 
   beforeEach(async () => {
-    db = await createTestDatabase();
+    const rawDb = await createTestDatabase();
+    db = new SqliteProvider(rawDb);
   });
 
   describe('createTeam', () => {
-    it('should create a team with all fields', () => {
-      const team = createTeam(db, {
+    it('should create a team with all fields', async () => {
+      const team = await createTeam(db, {
         repoUrl: 'https://github.com/test/repo.git',
         repoPath: '/path/to/repo',
         name: 'Test Team',
@@ -27,14 +28,14 @@ describe('teams queries', () => {
       expect(team.created_at).toBeDefined();
     });
 
-    it('should generate unique IDs for each team', () => {
-      const team1 = createTeam(db, {
+    it('should generate unique IDs for each team', async () => {
+      const team1 = await createTeam(db, {
         repoUrl: 'https://github.com/test/repo1.git',
         repoPath: '/path/to/repo1',
         name: 'Team 1',
       });
 
-      const team2 = createTeam(db, {
+      const team2 = await createTeam(db, {
         repoUrl: 'https://github.com/test/repo2.git',
         repoPath: '/path/to/repo2',
         name: 'Team 2',
@@ -45,66 +46,66 @@ describe('teams queries', () => {
   });
 
   describe('getTeamById', () => {
-    it('should retrieve a team by ID', () => {
-      const created = createTeam(db, {
+    it('should retrieve a team by ID', async () => {
+      const created = await createTeam(db, {
         repoUrl: 'https://github.com/test/repo.git',
         repoPath: '/path/to/repo',
         name: 'Test Team',
       });
 
-      const retrieved = getTeamById(db, created.id);
+      const retrieved = await getTeamById(db, created.id);
 
       expect(retrieved).toBeDefined();
       expect(retrieved?.id).toBe(created.id);
       expect(retrieved?.name).toBe('Test Team');
     });
 
-    it('should return undefined for non-existent team', () => {
-      const result = getTeamById(db, 'non-existent-id');
+    it('should return undefined for non-existent team', async () => {
+      const result = await getTeamById(db, 'non-existent-id');
       expect(result).toBeUndefined();
     });
   });
 
   describe('getTeamByName', () => {
-    it('should retrieve a team by name', () => {
-      createTeam(db, {
+    it('should retrieve a team by name', async () => {
+      await createTeam(db, {
         repoUrl: 'https://github.com/test/repo.git',
         repoPath: '/path/to/repo',
         name: 'Unique Team',
       });
 
-      const retrieved = getTeamByName(db, 'Unique Team');
+      const retrieved = await getTeamByName(db, 'Unique Team');
 
       expect(retrieved).toBeDefined();
       expect(retrieved?.name).toBe('Unique Team');
     });
 
-    it('should return undefined for non-existent team name', () => {
-      const result = getTeamByName(db, 'Non Existent Team');
+    it('should return undefined for non-existent team name', async () => {
+      const result = await getTeamByName(db, 'Non Existent Team');
       expect(result).toBeUndefined();
     });
   });
 
   describe('getAllTeams', () => {
-    it('should return empty array when no teams exist', () => {
-      const teams = getAllTeams(db);
+    it('should return empty array when no teams exist', async () => {
+      const teams = await getAllTeams(db);
       expect(teams).toEqual([]);
     });
 
-    it('should return all teams ordered by created_at', () => {
-      const team1 = createTeam(db, {
+    it('should return all teams ordered by created_at', async () => {
+      const team1 = await createTeam(db, {
         repoUrl: 'https://github.com/test/repo1.git',
         repoPath: '/path/to/repo1',
         name: 'Team 1',
       });
 
-      const team2 = createTeam(db, {
+      const team2 = await createTeam(db, {
         repoUrl: 'https://github.com/test/repo2.git',
         repoPath: '/path/to/repo2',
         name: 'Team 2',
       });
 
-      const teams = getAllTeams(db);
+      const teams = await getAllTeams(db);
 
       expect(teams).toHaveLength(2);
       expect(teams[0].id).toBe(team1.id);
@@ -113,45 +114,45 @@ describe('teams queries', () => {
   });
 
   describe('deleteTeam', () => {
-    it('should delete a team', () => {
-      const team = createTeam(db, {
+    it('should delete a team', async () => {
+      const team = await createTeam(db, {
         repoUrl: 'https://github.com/test/repo.git',
         repoPath: '/path/to/repo',
         name: 'Team to Delete',
       });
 
-      deleteTeam(db, team.id);
+      await deleteTeam(db, team.id);
 
-      const retrieved = getTeamById(db, team.id);
+      const retrieved = await getTeamById(db, team.id);
       expect(retrieved).toBeUndefined();
     });
 
-    it('should not throw when deleting non-existent team', () => {
-      expect(() => deleteTeam(db, 'non-existent-id')).not.toThrow();
+    it('should not throw when deleting non-existent team', async () => {
+      await expect(deleteTeam(db, 'non-existent-id')).resolves.not.toThrow();
     });
   });
 
   describe('edge cases', () => {
-    it('should handle special characters in team name', () => {
-      const team = createTeam(db, {
+    it('should handle special characters in team name', async () => {
+      const team = await createTeam(db, {
         repoUrl: 'https://github.com/test/repo.git',
         repoPath: '/path/to/repo',
         name: 'Team with \'quotes\' and "double quotes"',
       });
 
-      const retrieved = getTeamById(db, team.id);
+      const retrieved = await getTeamById(db, team.id);
       expect(retrieved?.name).toBe('Team with \'quotes\' and "double quotes"');
     });
 
-    it('should handle very long team names', () => {
+    it('should handle very long team names', async () => {
       const longName = 'A'.repeat(500);
-      const team = createTeam(db, {
+      const team = await createTeam(db, {
         repoUrl: 'https://github.com/test/repo.git',
         repoPath: '/path/to/repo',
         name: longName,
       });
 
-      const retrieved = getTeamById(db, team.id);
+      const retrieved = await getTeamById(db, team.id);
       expect(retrieved?.name).toBe(longName);
     });
   });