hungry-ghost-hive 0.48.0 → 0.49.0

package/src/cli/dashboard/index.test.ts

@@ -1,107 +1,108 @@
 // 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 '../../db/provider.js';
 import { createRequirement, updateRequirement } from '../../db/queries/requirements.js';
 import { createTestDatabase } from '../../db/queries/test-helpers.js';
 import { isGodmodeActive } from './index.js';
 
 describe('isGodmodeActive', () => {
-  let db: Database;
+  let db: SqliteProvider;
 
   beforeEach(async () => {
-    db = await createTestDatabase();
+    const rawDb = await createTestDatabase();
+    db = new SqliteProvider(rawDb);
   });
 
-  it('should return false when no requirements exist', () => {
-    expect(isGodmodeActive(db)).toBe(false);
+  it('should return false when no requirements exist', async () => {
+    expect(await isGodmodeActive(db)).toBe(false);
   });
 
-  it('should return false when no requirements have godmode enabled', () => {
-    createRequirement(db, {
+  it('should return false when no requirements have godmode enabled', async () => {
+    await createRequirement(db, {
       title: 'Normal Feature',
       description: 'A normal feature request',
     });
 
-    expect(isGodmodeActive(db)).toBe(false);
+    expect(await isGodmodeActive(db)).toBe(false);
   });
 
-  it('should return true when a pending requirement has godmode enabled', () => {
-    createRequirement(db, {
+  it('should return true when a pending requirement has godmode enabled', async () => {
+    await createRequirement(db, {
       title: 'Godmode Feature',
       description: 'A godmode feature request',
       godmode: true,
     });
 
-    expect(isGodmodeActive(db)).toBe(true);
+    expect(await isGodmodeActive(db)).toBe(true);
   });
 
-  it('should return true when an in_progress requirement has godmode enabled', () => {
-    const req = createRequirement(db, {
+  it('should return true when an in_progress requirement has godmode enabled', async () => {
+    const req = await createRequirement(db, {
       title: 'Godmode Feature',
       description: 'A godmode feature request',
       godmode: true,
     });
-    updateRequirement(db, req.id, { status: 'in_progress' });
+    await updateRequirement(db, req.id, { status: 'in_progress' });
 
-    expect(isGodmodeActive(db)).toBe(true);
+    expect(await isGodmodeActive(db)).toBe(true);
   });
 
-  it('should return false when godmode requirement is completed', () => {
-    const req = createRequirement(db, {
+  it('should return false when godmode requirement is completed', async () => {
+    const req = await createRequirement(db, {
       title: 'Godmode Feature',
       description: 'A godmode feature request',
       godmode: true,
     });
-    updateRequirement(db, req.id, { status: 'completed' });
+    await updateRequirement(db, req.id, { status: 'completed' });
 
-    expect(isGodmodeActive(db)).toBe(false);
+    expect(await isGodmodeActive(db)).toBe(false);
   });
 
-  it('should return true when at least one active requirement has godmode', () => {
-    createRequirement(db, {
+  it('should return true when at least one active requirement has godmode', async () => {
+    await createRequirement(db, {
       title: 'Normal Feature',
       description: 'A normal feature request',
     });
 
-    createRequirement(db, {
+    await createRequirement(db, {
       title: 'Godmode Feature',
       description: 'A godmode feature request',
       godmode: true,
     });
 
-    expect(isGodmodeActive(db)).toBe(true);
+    expect(await isGodmodeActive(db)).toBe(true);
   });
 
-  it('should return false when godmode is explicitly set to false', () => {
-    createRequirement(db, {
+  it('should return false when godmode is explicitly set to false', async () => {
+    await createRequirement(db, {
       title: 'Feature',
       description: 'A feature request',
       godmode: false,
     });
 
-    expect(isGodmodeActive(db)).toBe(false);
+    expect(await isGodmodeActive(db)).toBe(false);
   });
 
-  it('should return true for planning status with godmode', () => {
-    const req = createRequirement(db, {
+  it('should return true for planning status with godmode', async () => {
+    const req = await createRequirement(db, {
       title: 'Godmode Feature',
       description: 'A godmode feature request',
       godmode: true,
     });
-    updateRequirement(db, req.id, { status: 'planning' });
+    await updateRequirement(db, req.id, { status: 'planning' });
 
-    expect(isGodmodeActive(db)).toBe(true);
+    expect(await isGodmodeActive(db)).toBe(true);
   });
 
-  it('should return true for planned status with godmode', () => {
-    const req = createRequirement(db, {
+  it('should return true for planned status with godmode', async () => {
+    const req = await createRequirement(db, {
       title: 'Godmode Feature',
       description: 'A godmode feature request',
       godmode: true,
     });
-    updateRequirement(db, req.id, { status: 'planned' });
+    await updateRequirement(db, req.id, { status: 'planned' });
 
-    expect(isGodmodeActive(db)).toBe(true);
+    expect(await isGodmodeActive(db)).toBe(true);
   });
 });

package/src/cli/dashboard/index.ts

@@ -3,8 +3,8 @@
 import blessed from 'blessed';
 import { appendFileSync, existsSync, renameSync, statSync } from 'fs';
 import { join } from 'path';
-import type { Database } from 'sql.js';
 import { getReadOnlyDatabase, type ReadOnlyDatabaseClient } from '../../db/client.js';
+import type { DatabaseProvider } from '../../db/provider.js';
 import { getAllRequirements } from '../../db/queries/requirements.js';
 import { findHiveRoot, getHivePaths } from '../../utils/paths.js';
 import { getVersion } from '../../utils/version.js';
@@ -42,9 +42,9 @@ export interface DashboardOptions {
 /**
  * Check if godmode is active by looking for any non-completed requirement with godmode enabled.
  */
-export function isGodmodeActive(db: Database): boolean {
-  const requirements = getAllRequirements(db);
-  return requirements.some(req => req.godmode && req.status !== 'completed');
+export async function isGodmodeActive(db: DatabaseProvider): Promise<boolean> {
+  const requirements = await getAllRequirements(db);
+  return requirements.some(req => req.godmode && (req.status as string) !== 'completed');
 }
 
 export async function startDashboard(options: DashboardOptions = {}): Promise<void> {
@@ -56,9 +56,12 @@ export async function startDashboard(options: DashboardOptions = {}): Promise<vo
 
   const paths = getHivePaths(root);
   const dbPath = join(paths.hiveDir, 'hive.db');
-  debugLog(`Dashboard starting - root: ${root}, hiveDir: ${paths.hiveDir}`);
+  const isDistributed = !existsSync(dbPath);
+  debugLog(
+    `Dashboard starting - root: ${root}, hiveDir: ${paths.hiveDir}, distributed: ${isDistributed}`
+  );
   let db: ReadOnlyDatabaseClient = await getReadOnlyDatabase(paths.hiveDir);
-  let lastDbMtime = statSync(dbPath).mtimeMs;
+  let lastDbMtime = isDistributed ? 0 : statSync(dbPath).mtimeMs;
   const refreshInterval = options.refreshInterval || 5000;
   const version = getVersion();
 
@@ -95,12 +98,12 @@ export async function startDashboard(options: DashboardOptions = {}): Promise<vo
   };
 
   // Create panels
-  const agentsPanel = createAgentsPanel(screen, db.db, pauseRefresh, resumeRefresh);
+  const agentsPanel = createAgentsPanel(screen, db.provider, pauseRefresh, resumeRefresh);
   const storiesPanel = createStoriesPanel(screen, db.db);
-  const pipelinePanel = createPipelinePanel(screen, db.db);
-  const activityPanel = createActivityPanel(screen, db.db);
-  const mergeQueuePanel = createMergeQueuePanel(screen, db.db);
-  const escalationsPanel = createEscalationsPanel(screen, db.db, pauseRefresh, resumeRefresh);
+  const pipelinePanel = createPipelinePanel(screen, db.provider);
+  const activityPanel = createActivityPanel(screen, db.provider);
+  const mergeQueuePanel = createMergeQueuePanel(screen, db.provider);
+  const escalationsPanel = createEscalationsPanel(screen, db.provider, pauseRefresh, resumeRefresh);
 
   // Footer
   blessed.box({
@@ -126,13 +129,21 @@ export async function startDashboard(options: DashboardOptions = {}): Promise<vo
   const refresh = async () => {
     if (refreshPaused) return;
     try {
-      // Check if database file has been modified
-      const currentMtime = statSync(dbPath).mtimeMs;
-      if (currentMtime !== lastDbMtime) {
+      // In distributed (Postgres) mode, always refresh since there's no local file.
+      // In SQLite mode, only reload when the file has been modified.
+      const shouldReload = isDistributed
+        ? true
+        : (() => {
+            const currentMtime = statSync(dbPath).mtimeMs;
+            if (currentMtime !== lastDbMtime) {
+              lastDbMtime = currentMtime;
+              return true;
+            }
+            return false;
+          })();
+
+      if (shouldReload) {
         debugLog(`Database changed - reloading from ${paths.hiveDir}`);
-        lastDbMtime = currentMtime;
-
-        // Get new database connection first, then close old one
         const newDb = await getReadOnlyDatabase(paths.hiveDir);
         try {
           db.db.close();
@@ -143,18 +154,18 @@ export async function startDashboard(options: DashboardOptions = {}): Promise<vo
       }
 
       // Update header with godmode indicator
-      const godmode = isGodmodeActive(db.db);
+      const godmode = await isGodmodeActive(db.provider);
       const godmodeLabel = godmode ? '  {yellow-fg}{bold}GODMODE ACTIVE{/bold}{/yellow-fg}' : '';
       header.setContent(
         ` {bold}HIVE ORCHESTRATOR{/bold} v${version}${godmodeLabel}                                    [R]efresh [Q]uit`
       );
 
-      await updateAgentsPanel(agentsPanel, db.db);
+      await updateAgentsPanel(agentsPanel, db.provider);
       await updateStoriesPanel(storiesPanel, db.db);
-      await updatePipelinePanel(pipelinePanel, db.db);
-      await updateActivityPanel(activityPanel, db.db);
-      await updateMergeQueuePanel(mergeQueuePanel, db.db);
-      await updateEscalationsPanel(escalationsPanel, db.db);
+      await updatePipelinePanel(pipelinePanel, db.provider);
+      await updateActivityPanel(activityPanel, db.provider);
+      await updateMergeQueuePanel(mergeQueuePanel, db.provider);
+      await updateEscalationsPanel(escalationsPanel, db.provider);
       screen.render();
     } catch (err: unknown) {
       const errMsg = err instanceof Error ? err.message : String(err);

package/src/cli/dashboard/panels/activity.ts

@@ -1,10 +1,13 @@
 // Licensed under the Hungry Ghost Hive License. See LICENSE.
 
 import blessed, { type Widgets } from 'blessed';
-import type { Database } from 'sql.js';
+import type { DatabaseProvider } from '../../../db/provider.js';
 import { getRecentLogs } from '../../../db/queries/logs.js';
 
-export function createActivityPanel(screen: Widgets.Screen, db: Database): Widgets.BoxElement {
+export function createActivityPanel(
+  screen: Widgets.Screen,
+  db: DatabaseProvider
+): Widgets.BoxElement {
   const box = blessed.box({
     parent: screen,
     top: '55%+5',
@@ -34,8 +37,11 @@ export function createActivityPanel(screen: Widgets.Screen, db: Database): Widge
   return box;
 }
 
-export async function updateActivityPanel(box: Widgets.BoxElement, db: Database): Promise<void> {
-  const logs = getRecentLogs(db, 50);
+export async function updateActivityPanel(
+  box: Widgets.BoxElement,
+  db: DatabaseProvider
+): Promise<void> {
+  const logs = await getRecentLogs(db, 50);
 
   const lines: string[] = [];
 

package/src/cli/dashboard/panels/agents.ts

@@ -3,9 +3,9 @@
 import blessed, { type Widgets } from 'blessed';
 import { spawnSync } from 'child_process';
 import { appendFileSync } from 'fs';
-import type { Database } from 'sql.js';
 import { loadConfig } from '../../../config/loader.js';
 import type { ModelsConfig } from '../../../config/schema.js';
+import type { DatabaseProvider } from '../../../db/provider.js';
 import { getActiveAgents, type AgentRow } from '../../../db/queries/agents.js';
 import { getTeamById } from '../../../db/queries/teams.js';
 import { getHiveSessions } from '../../../tmux/manager.js';
@@ -21,7 +21,7 @@ let currentAgents: AgentRow[] = [];
 
 export function createAgentsPanel(
   screen: Widgets.Screen,
-  db: Database,
+  db: DatabaseProvider,
   pauseRefresh: () => void,
   resumeRefresh: () => void
 ): Widgets.ListElement {
@@ -116,11 +116,14 @@ interface DisplayAgent extends AgentRow {
   repo?: string;
 }
 
-export async function updateAgentsPanel(list: Widgets.ListElement, db: Database): Promise<void> {
+export async function updateAgentsPanel(
+  list: Widgets.ListElement,
+  db: DatabaseProvider
+): Promise<void> {
   // Preserve current selection before updating
   const currentSelection = (list as unknown as { selected: number }).selected;
 
-  const agents = getActiveAgents(db);
+  const agents = await getActiveAgents(db);
   debugLog(
     `updateAgentsPanel called, found ${agents.length} agents, currentSelection=${currentSelection}`
   );
@@ -172,7 +175,7 @@ export async function updateAgentsPanel(list: Widgets.ListElement, db: Database)
   for (const agent of agents) {
     const displayAgent: DisplayAgent = { ...agent };
     if (agent.team_id) {
-      const team = getTeamById(db, agent.team_id);
+      const team = await getTeamById(db, agent.team_id);
       if (team?.repo_path) {
         // Extract repo name from path (e.g., "repos/my-service" -> "my-service")
         displayAgent.repo = team.repo_path.replace(/^repos\//, '');

package/src/cli/dashboard/panels/escalations.ts

@@ -2,7 +2,7 @@
 
 import blessed, { type Widgets } from 'blessed';
 import { spawnSync } from 'child_process';
-import type { Database } from 'sql.js';
+import type { DatabaseProvider } from '../../../db/provider.js';
 import { getPendingEscalations, type EscalationRow } from '../../../db/queries/escalations.js';
 
 // Store escalations for selection lookup
@@ -23,7 +23,7 @@ function summarizeEscalationReason(reason: string): string {
 
 export function createEscalationsPanel(
   screen: Widgets.Screen,
-  db: Database,
+  db: DatabaseProvider,
   pauseRefresh: () => void,
   resumeRefresh: () => void
 ): Widgets.ListElement {
@@ -135,9 +135,9 @@ export function createEscalationsPanel(
 
 export async function updateEscalationsPanel(
   list: Widgets.ListElement,
-  db: Database
+  db: DatabaseProvider
 ): Promise<void> {
-  const escalations = getPendingEscalations(db);
+  const escalations = await getPendingEscalations(db);
   currentEscalations = escalations; // Store for selection lookup
 
   if (escalations.length === 0) {

package/src/cli/dashboard/panels/merge-queue.ts

@@ -1,12 +1,12 @@
 // Licensed under the Hungry Ghost Hive License. See LICENSE.
 
 import blessed, { type Widgets } from 'blessed';
-import type { Database } from 'sql.js';
+import type { DatabaseProvider } from '../../../db/provider.js';
 import { getMergeQueue, type PullRequestRow } from '../../../db/queries/pull-requests.js';
 
 export function createMergeQueuePanel(
   screen: Widgets.Screen,
-  db: Database
+  db: DatabaseProvider
 ): Widgets.ListTableElement {
   const table = blessed.listtable({
     parent: screen,
@@ -37,9 +37,9 @@ export function createMergeQueuePanel(
 
 export async function updateMergeQueuePanel(
   table: Widgets.ListTableElement,
-  db: Database
+  db: DatabaseProvider
 ): Promise<void> {
-  const queue = getMergeQueue(db);
+  const queue = await getMergeQueue(db);
 
   const headers = ['#', 'Branch', 'Status'];
 

package/src/cli/dashboard/panels/pipeline.ts

@@ -1,10 +1,13 @@
 // Licensed under the Hungry Ghost Hive License. See LICENSE.
 
 import blessed, { type Widgets } from 'blessed';
-import type { Database } from 'sql.js';
+import type { DatabaseProvider } from '../../../db/provider.js';
 import { getStoryCounts } from '../../../db/queries/stories.js';
 
-export function createPipelinePanel(screen: Widgets.Screen, db: Database): Widgets.BoxElement {
+export function createPipelinePanel(
+  screen: Widgets.Screen,
+  db: DatabaseProvider
+): Widgets.BoxElement {
   const box = blessed.box({
     parent: screen,
     top: '55%',
@@ -24,8 +27,11 @@ export function createPipelinePanel(screen: Widgets.Screen, db: Database): Widge
   return box;
 }
 
-export async function updatePipelinePanel(box: Widgets.BoxElement, db: Database): Promise<void> {
-  const counts = getStoryCounts(db);
+export async function updatePipelinePanel(
+  box: Widgets.BoxElement,
+  db: DatabaseProvider
+): Promise<void> {
+  const counts = await getStoryCounts(db);
 
   const stages = [
     { name: 'Planned', count: counts.planned, color: 'white' },

package/src/config/schema.ts

@@ -343,6 +343,7 @@ const ClusterConfigSchema = z
 // Main configuration schema
 export const HiveConfigSchema = z.object({
   version: z.string().default('1.0'),
+  distributed: z.boolean().default(false),
   models: ModelsConfigSchema.default({}),
   scaling: ScalingConfigSchema.default({}),
   integrations: IntegrationsConfigSchema.default({}),

package/src/connectors/project-management/operations.ts

@@ -10,10 +10,9 @@
  */
 
 import { join } from 'path';
-import type { Database } from 'sql.js';
 import type { TokenStore } from '../../auth/token-store.js';
 import type { HiveConfig } from '../../config/schema.js';
-import { queryOne } from '../../db/client.js';
+import type { DatabaseProvider } from '../../db/provider.js';
 import type { StoryRow } from '../../db/queries/stories.js';
 import * as logger from '../../utils/logger.js';
 import type {
@@ -94,7 +93,7 @@ async function resolveProvider(root: string) {
  */
 export async function syncStatusForStory(
   root: string,
-  db: Database,
+  db: DatabaseProvider,
   storyId: string,
   newStatus: string
 ): Promise<void> {
@@ -124,7 +123,7 @@ export async function syncStatusForStory(
  * Never throws — failures are logged as warnings.
  */
 export async function postLifecycleComment(
-  db: Database,
+  db: DatabaseProvider,
   _hiveDir: string,
   hiveConfig: HiveConfig | undefined,
   storyId: string,
@@ -136,7 +135,7 @@ export async function postLifecycleComment(
     const pmConfig = hiveConfig.integrations?.project_management;
     if (!pmConfig || pmConfig.provider === 'none') return;
 
-    const story = queryOne<StoryRow>(db, 'SELECT * FROM stories WHERE id = ?', [storyId]);
+    const story = await db.queryOne<StoryRow>('SELECT * FROM stories WHERE id = ?', [storyId]);
     if (!story || !story.external_issue_key) {
       logger.debug(`Story ${storyId} has no external issue key, skipping ${event} comment`);
       return;
@@ -160,7 +159,7 @@ export async function postLifecycleComment(
  * Never throws — failures are logged as warnings.
  */
 export async function postProgressUpdate(
-  db: Database,
+  db: DatabaseProvider,
   _hiveDir: string,
   hiveConfig: HiveConfig | undefined,
   storyId: string,
@@ -172,7 +171,7 @@ export async function postProgressUpdate(
     const pmConfig = hiveConfig.integrations?.project_management;
     if (!pmConfig || pmConfig.provider === 'none') return;
 
-    const story = queryOne<StoryRow>(db, 'SELECT * FROM stories WHERE id = ?', [storyId]);
+    const story = await db.queryOne<StoryRow>('SELECT * FROM stories WHERE id = ?', [storyId]);
     if (!story?.external_subtask_key) {
       logger.debug(`Story ${storyId} has no external subtask, skipping progress update`);
       return;
@@ -200,7 +199,7 @@ export async function postProgressUpdate(
  *
  * Never throws — failures are logged.
  */
-export async function syncFromProvider(root: string, db: Database): Promise<number> {
+export async function syncFromProvider(root: string, db: DatabaseProvider): Promise<number> {
   try {
     const resolved = await resolveProvider(root);
     if (!resolved) return 0;
@@ -227,7 +226,7 @@ export async function syncFromProvider(root: string, db: Database): Promise<numb
  */
 export async function syncStoryToProvider(
   root: string,
-  db: Database,
+  db: DatabaseProvider,
   story: StoryRow,
   teamName?: string
 ): Promise<{ key: string; id: string } | null> {
@@ -256,7 +255,7 @@ export async function syncStoryToProvider(
  */
 export async function syncRequirementToProvider(
   root: string,
-  db: Database,
+  db: DatabaseProvider,
   requirement: { id: string; title: string; description: string },
   storyIds: string[],
   teamName?: string

package/src/context-files/index.test.ts

@@ -115,6 +115,7 @@ describe('context-files module', () => {
 
     const mockConfig: HiveConfig = {
       version: '1.0',
+      distributed: false,
       models: {
         tech_lead: {
           provider: 'anthropic',

package/src/db/client.ts

@@ -5,12 +5,22 @@ import { dirname, join } from 'path';
 import initSqlJs, { Database as SqlJsDatabase } from 'sql.js';
 import { fileURLToPath } from 'url';
 import { DatabaseCorruptionError, InitializationError } from '../errors/index.js';
+import {
+  ReadOnlySqliteProvider,
+  SqliteProvider,
+  type DatabaseProvider,
+  type WritableDatabaseProvider,
+} from './provider.js';
+export { createPostgresProvider, PostgresProvider } from './postgres-provider.js';
+export { ReadOnlySqliteProvider, SqliteProvider } from './provider.js';
+export type { DatabaseProvider, QueryResult, WritableDatabaseProvider } from './provider.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
 export interface DatabaseClient {
   db: SqlJsDatabase;
+  provider: WritableDatabaseProvider;
   close: () => void;
   save: () => void;
   runMigrations: () => void;
@@ -18,6 +28,7 @@ export interface DatabaseClient {
 
 export interface ReadOnlyDatabaseClient {
   db: SqlJsDatabase;
+  provider: DatabaseProvider;
   close: () => void;
 }
 
@@ -186,8 +197,11 @@ export async function createDatabase(dbPath: string): Promise<DatabaseClient> {
     renameSync(tmpPath, dbPath);
   };
 
+  const provider = new SqliteProvider(db, save);
+
   const client: DatabaseClient = {
     db,
+    provider,
     close: () => {
       save();
       db.close();
@@ -660,8 +674,11 @@ export async function getReadOnlyDatabase(hiveDir: string): Promise<ReadOnlyData
     }
   }
 
+  const provider = new ReadOnlySqliteProvider(db);
+
   return {
     db,
+    provider,
     close: () => db.close(),
   };
 }