hungry-ghost-hive 0.3.0

package/src/cli/commands/stories.ts

@@ -0,0 +1,131 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { findHiveRoot, getHivePaths } from '../../utils/paths.js';
+import { getDatabase } from '../../db/client.js';
+import { getAllStories, getStoryById, getStoriesByStatus, getStoryDependencies, type StoryStatus } from '../../db/queries/stories.js';
+import { statusColor } from '../../utils/logger.js';
+
+export const storiesCommand = new Command('stories')
+  .description('Manage stories');
+
+storiesCommand
+  .command('list')
+  .description('List all stories')
+  .option('--status <status>', 'Filter by status')
+  .option('--json', 'Output as JSON')
+  .action(async (options: { status?: string; json?: boolean }) => {
+    const root = findHiveRoot();
+    if (!root) {
+      console.error(chalk.red('Not in a Hive workspace. Run "hive init" first.'));
+      process.exit(1);
+    }
+
+    const paths = getHivePaths(root);
+    const db = await getDatabase(paths.hiveDir);
+
+    try {
+      let stories;
+      if (options.status) {
+        stories = getStoriesByStatus(db.db, options.status as StoryStatus);
+      } else {
+        stories = getAllStories(db.db);
+      }
+
+      if (options.json) {
+        console.log(JSON.stringify(stories, null, 2));
+        return;
+      }
+
+      if (stories.length === 0) {
+        console.log(chalk.yellow('No stories found.'));
+        return;
+      }
+
+      console.log(chalk.bold('\nStories:\n'));
+
+      // Header
+      console.log(
+        chalk.gray(
+          `${'ID'.padEnd(15)} ${'Title'.padEnd(40)} ${'Status'.padEnd(15)} ${'Points'.padEnd(8)} ${'Assigned'}`
+        )
+      );
+      console.log(chalk.gray('─'.repeat(100)));
+
+      for (const story of stories) {
+        const title = story.title.length > 37 ? story.title.substring(0, 37) + '...' : story.title;
+        const points = story.story_points?.toString() || '-';
+        const assigned = story.assigned_agent_id || '-';
+
+        console.log(
+          `${chalk.cyan(story.id.padEnd(15))} ${title.padEnd(40)} ${statusColor(story.status).padEnd(15)} ${points.padEnd(8)} ${assigned}`
+        );
+      }
+      console.log();
+    } finally {
+      db.close();
+    }
+  });
+
+storiesCommand
+  .command('show <story-id>')
+  .description('Show story details')
+  .action(async (storyId: string) => {
+    const root = findHiveRoot();
+    if (!root) {
+      console.error(chalk.red('Not in a Hive workspace. Run "hive init" first.'));
+      process.exit(1);
+    }
+
+    const paths = getHivePaths(root);
+    const db = await getDatabase(paths.hiveDir);
+
+    try {
+      const story = getStoryById(db.db, storyId);
+      if (!story) {
+        console.error(chalk.red(`Story not found: ${storyId}`));
+        process.exit(1);
+      }
+
+      const dependencies = getStoryDependencies(db.db, story.id);
+
+      console.log(chalk.bold(`\nStory: ${story.id}\n`));
+      console.log(chalk.bold('Title:'), story.title);
+      console.log(chalk.bold('Status:'), statusColor(story.status));
+
+      console.log(chalk.bold('\nDescription:'));
+      console.log(chalk.gray(story.description));
+
+      if (story.acceptance_criteria) {
+        console.log(chalk.bold('\nAcceptance Criteria:'));
+        try {
+          const criteria = JSON.parse(story.acceptance_criteria) as string[];
+          for (const c of criteria) {
+            console.log(chalk.gray(`  • ${c}`));
+          }
+        } catch {
+          console.log(chalk.gray(story.acceptance_criteria));
+        }
+      }
+
+      console.log(chalk.bold('\nDetails:'));
+      console.log(chalk.gray(`  Requirement:    ${story.requirement_id || '-'}`));
+      console.log(chalk.gray(`  Team:           ${story.team_id || '-'}`));
+      console.log(chalk.gray(`  Complexity:     ${story.complexity_score || '-'}`));
+      console.log(chalk.gray(`  Story Points:   ${story.story_points || '-'}`));
+      console.log(chalk.gray(`  Assigned Agent: ${story.assigned_agent_id || '-'}`));
+      console.log(chalk.gray(`  Branch:         ${story.branch_name || '-'}`));
+      console.log(chalk.gray(`  PR URL:         ${story.pr_url || '-'}`));
+      console.log(chalk.gray(`  Created:        ${story.created_at}`));
+      console.log(chalk.gray(`  Updated:        ${story.updated_at}`));
+
+      if (dependencies.length > 0) {
+        console.log(chalk.bold('\nDependencies:'));
+        for (const dep of dependencies) {
+          console.log(`  ${chalk.cyan(dep.id)} - ${dep.title.substring(0, 40)}... - ${statusColor(dep.status)}`);
+        }
+      }
+      console.log();
+    } finally {
+      db.close();
+    }
+  });

package/src/cli/commands/teams.ts

@@ -0,0 +1,158 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { findHiveRoot, getHivePaths } from '../../utils/paths.js';
+import { getDatabase } from '../../db/client.js';
+import { getAllTeams, getTeamByName, deleteTeam } from '../../db/queries/teams.js';
+import { getAgentsByTeam } from '../../db/queries/agents.js';
+import { getStoriesByTeam, getStoryPointsByTeam } from '../../db/queries/stories.js';
+
+export const teamsCommand = new Command('teams')
+  .description('Manage teams');
+
+teamsCommand
+  .command('list')
+  .description('List all teams')
+  .option('--json', 'Output as JSON')
+  .action(async (options: { json?: boolean }) => {
+    const root = findHiveRoot();
+    if (!root) {
+      console.error(chalk.red('Not in a Hive workspace. Run "hive init" first.'));
+      process.exit(1);
+    }
+
+    const paths = getHivePaths(root);
+    const db = await getDatabase(paths.hiveDir);
+
+    try {
+      const teams = getAllTeams(db.db);
+
+      if (options.json) {
+        console.log(JSON.stringify(teams, null, 2));
+        return;
+      }
+
+      if (teams.length === 0) {
+        console.log(chalk.yellow('No teams found.'));
+        console.log(chalk.gray('Use "hive add-repo --url <url> --team <name>" to add a team.'));
+        return;
+      }
+
+      console.log(chalk.bold('\nTeams:\n'));
+
+      for (const team of teams) {
+        const agents = getAgentsByTeam(db.db, team.id);
+        const stories = getStoriesByTeam(db.db, team.id);
+        const storyPoints = getStoryPointsByTeam(db.db, team.id);
+
+        console.log(chalk.cyan(`  ${team.name}`));
+        console.log(chalk.gray(`    ID:           ${team.id}`));
+        console.log(chalk.gray(`    Repository:   ${team.repo_url}`));
+        console.log(chalk.gray(`    Path:         ${team.repo_path}`));
+        console.log(chalk.gray(`    Agents:       ${agents.length}`));
+        console.log(chalk.gray(`    Stories:      ${stories.length}`));
+        console.log(chalk.gray(`    Story Points: ${storyPoints}`));
+        console.log();
+      }
+    } finally {
+      db.close();
+    }
+  });
+
+teamsCommand
+  .command('show <name>')
+  .description('Show team details')
+  .action(async (name: string) => {
+    const root = findHiveRoot();
+    if (!root) {
+      console.error(chalk.red('Not in a Hive workspace. Run "hive init" first.'));
+      process.exit(1);
+    }
+
+    const paths = getHivePaths(root);
+    const db = await getDatabase(paths.hiveDir);
+
+    try {
+      const team = getTeamByName(db.db, name);
+
+      if (!team) {
+        console.error(chalk.red(`Team not found: ${name}`));
+        process.exit(1);
+      }
+
+      const agents = getAgentsByTeam(db.db, team.id);
+      const stories = getStoriesByTeam(db.db, team.id);
+      const storyPoints = getStoryPointsByTeam(db.db, team.id);
+
+      console.log(chalk.bold(`\nTeam: ${team.name}\n`));
+      console.log(chalk.gray(`ID:           ${team.id}`));
+      console.log(chalk.gray(`Repository:   ${team.repo_url}`));
+      console.log(chalk.gray(`Path:         ${team.repo_path}`));
+      console.log(chalk.gray(`Created:      ${team.created_at}`));
+      console.log();
+
+      if (agents.length > 0) {
+        console.log(chalk.bold('Agents:'));
+        for (const agent of agents) {
+          const statusColor = agent.status === 'working' ? chalk.yellow : agent.status === 'idle' ? chalk.gray : chalk.red;
+          console.log(`  ${chalk.cyan(agent.id)} - ${agent.type} - ${statusColor(agent.status)}`);
+        }
+        console.log();
+      }
+
+      if (stories.length > 0) {
+        console.log(chalk.bold('Stories:'));
+        for (const story of stories) {
+          const statusColor = story.status === 'merged' ? chalk.green : story.status === 'in_progress' ? chalk.yellow : chalk.gray;
+          console.log(`  ${chalk.cyan(story.id)} - ${story.title.substring(0, 40)}... - ${statusColor(story.status)}`);
+        }
+        console.log();
+      }
+
+      console.log(chalk.bold('Summary:'));
+      console.log(`  Total Stories: ${stories.length}`);
+      console.log(`  Active Story Points: ${storyPoints}`);
+      console.log(`  Active Agents: ${agents.filter(a => a.status !== 'terminated').length}`);
+    } finally {
+      db.close();
+    }
+  });
+
+teamsCommand
+  .command('remove <name>')
+  .description('Remove a team')
+  .option('--force', 'Force removal even if team has active stories')
+  .action(async (name: string, options: { force?: boolean }) => {
+    const root = findHiveRoot();
+    if (!root) {
+      console.error(chalk.red('Not in a Hive workspace. Run "hive init" first.'));
+      process.exit(1);
+    }
+
+    const paths = getHivePaths(root);
+    const db = await getDatabase(paths.hiveDir);
+
+    try {
+      const team = getTeamByName(db.db, name);
+
+      if (!team) {
+        console.error(chalk.red(`Team not found: ${name}`));
+        process.exit(1);
+      }
+
+      const stories = getStoriesByTeam(db.db, team.id);
+      const activeStories = stories.filter(s => !['merged', 'draft'].includes(s.status));
+
+      if (activeStories.length > 0 && !options.force) {
+        console.error(chalk.red(`Team has ${activeStories.length} active stories. Use --force to remove anyway.`));
+        process.exit(1);
+      }
+
+      deleteTeam(db.db, team.id);
+      console.log(chalk.green(`Team "${name}" removed successfully.`));
+      console.log(chalk.yellow('Note: Git submodule was not removed. Run the following to remove it:'));
+      console.log(chalk.gray(`  git submodule deinit -f ${team.repo_path}`));
+      console.log(chalk.gray(`  git rm -f ${team.repo_path}`));
+    } finally {
+      db.close();
+    }
+  });

package/src/cli/dashboard/index.ts

@@ -0,0 +1,141 @@
+import blessed from 'blessed';
+import { appendFileSync, statSync } from 'fs';
+import { join } from 'path';
+import { getDatabase, type DatabaseClient } from '../../db/client.js';
+import { findHiveRoot, getHivePaths } from '../../utils/paths.js';
+
+function debugLog(msg: string) {
+  appendFileSync('/tmp/hive-dashboard-debug.log', `${new Date().toISOString()} ${msg}\n`);
+}
+import { createAgentsPanel, updateAgentsPanel } from './panels/agents.js';
+import { createStoriesPanel, updateStoriesPanel } from './panels/stories.js';
+import { createPipelinePanel, updatePipelinePanel } from './panels/pipeline.js';
+import { createActivityPanel, updateActivityPanel } from './panels/activity.js';
+import { createMergeQueuePanel, updateMergeQueuePanel } from './panels/merge-queue.js';
+import { createEscalationsPanel, updateEscalationsPanel } from './panels/escalations.js';
+
+export interface DashboardOptions {
+  refreshInterval?: number;
+}
+
+export async function startDashboard(options: DashboardOptions = {}): Promise<void> {
+  const root = findHiveRoot();
+  if (!root) {
+    console.error('Not in a Hive workspace. Run "hive init" first.');
+    process.exit(1);
+  }
+
+  const paths = getHivePaths(root);
+  const dbPath = join(paths.hiveDir, 'hive.db');
+  debugLog(`Dashboard starting - root: ${root}, hiveDir: ${paths.hiveDir}`);
+  let db: DatabaseClient = await getDatabase(paths.hiveDir);
+  let lastDbMtime = statSync(dbPath).mtimeMs;
+  const refreshInterval = options.refreshInterval || 5000;
+
+  // Create screen
+  const screen = blessed.screen({
+    smartCSR: true,
+    title: 'Hive Orchestrator Dashboard',
+  });
+
+  // Header
+  blessed.box({
+    parent: screen,
+    top: 0,
+    left: 0,
+    width: '100%',
+    height: 1,
+    content: ' {bold}HIVE ORCHESTRATOR{/bold}                                    [R]efresh [Q]uit',
+    style: {
+      bg: 'blue',
+      fg: 'white',
+    },
+    tags: true,
+  });
+
+  // Create panels
+  const agentsPanel = createAgentsPanel(screen, db.db);
+  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);
+
+  // Footer
+  blessed.box({
+    parent: screen,
+    bottom: 0,
+    left: 0,
+    width: '100%',
+    height: 1,
+    content: ' Tab: Switch panels | ↑↓: Navigate | Enter: Attach to tmux | Ctrl+B,D: Detach | Q: Quit',
+    style: {
+      bg: 'blue',
+      fg: 'white',
+    },
+  });
+
+  // Focus management
+  const panels = [agentsPanel, storiesPanel, activityPanel, mergeQueuePanel, escalationsPanel];
+  let focusIndex = 0;
+  panels[focusIndex].focus();
+
+  // Refresh function - only reloads database when file has changed
+  const refresh = async () => {
+    try {
+      // Check if database file has been modified
+      const currentMtime = statSync(dbPath).mtimeMs;
+      if (currentMtime !== lastDbMtime) {
+        debugLog(`Database changed - reloading from ${paths.hiveDir}`);
+        lastDbMtime = currentMtime;
+
+        // Get new database connection first, then close old one
+        const newDb = await getDatabase(paths.hiveDir);
+        try { db.db.close(); } catch { /* ignore close errors */ }
+        db = newDb;
+      }
+
+      await updateAgentsPanel(agentsPanel, db.db);
+      updateStoriesPanel(storiesPanel, db.db);
+      updatePipelinePanel(pipelinePanel, db.db);
+      updateActivityPanel(activityPanel, db.db);
+      updateMergeQueuePanel(mergeQueuePanel, db.db);
+      updateEscalationsPanel(escalationsPanel, db.db);
+      screen.render();
+    } catch (err) {
+      debugLog(`Refresh error: ${err}`);
+      process.stderr.write(`Dashboard refresh error: ${err}\n`);
+    }
+  };
+
+  // Auto-refresh - wrap in arrow function to handle async properly
+  const timer = setInterval(() => { refresh(); }, refreshInterval);
+
+  // Key bindings
+  screen.key(['q', 'C-c', 'escape'], () => {
+    clearInterval(timer);
+    try { db.db.close(); } catch { /* ignore */ }
+    screen.destroy();
+    process.exit(0);
+  });
+
+  screen.key(['r'], () => {
+    refresh();
+  });
+
+  screen.key(['tab'], () => {
+    focusIndex = (focusIndex + 1) % panels.length;
+    panels[focusIndex].focus();
+    screen.render();
+  });
+
+  screen.key(['S-tab'], () => {
+    focusIndex = (focusIndex - 1 + panels.length) % panels.length;
+    panels[focusIndex].focus();
+    screen.render();
+  });
+
+  // Initial refresh and render
+  await refresh();
+  screen.render();
+}

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

@@ -0,0 +1,77 @@
+import type { Database } from 'sql.js';
+import blessed, { type Widgets } from 'blessed';
+import { getRecentLogs } from '../../../db/queries/logs.js';
+
+export function createActivityPanel(screen: Widgets.Screen, db: Database): Widgets.BoxElement {
+
+  const box = blessed.box({
+    parent: screen,
+    top: '55%+5',
+    left: 0,
+    width: '50%',
+    height: '35%',
+    border: { type: 'line' },
+    label: ' Recent Activity ',
+    scrollable: true,
+    alwaysScroll: true,
+    keys: true,
+    vi: true,
+    mouse: true,
+    style: {
+      border: { fg: 'cyan' },
+    },
+    tags: true,
+    scrollbar: {
+      ch: ' ',
+      track: { bg: 'gray' },
+      style: { bg: 'white' },
+    },
+  });
+
+  updateActivityPanel(box, db);
+
+  return box;
+}
+
+export function updateActivityPanel(box: Widgets.BoxElement, db: Database): void {
+  const logs = getRecentLogs(db, 50);
+
+  const lines: string[] = [];
+
+  for (const entry of logs.reverse()) {
+    const time = formatTimestamp(entry.timestamp);
+    const agent = entry.agent_id.padEnd(15).substring(0, 15);
+    const event = formatEventType(entry.event_type);
+    const message = entry.message ? `: ${entry.message.substring(0, 40)}` : '';
+
+    lines.push(`{gray-fg}${time}{/} {cyan-fg}${agent}{/} ${event}${message}`);
+  }
+
+  box.setContent(lines.join('\n'));
+
+  // Always scroll to the latest (bottom) entries
+  box.setScrollPerc(100);
+}
+
+function formatTimestamp(timestamp: string): string {
+  return timestamp.substring(11, 19);
+}
+
+function formatEventType(event: string): string {
+  const colors: Record<string, string> = {
+    AGENT_SPAWNED: 'green',
+    AGENT_TERMINATED: 'red',
+    AGENT_RESUMED: 'yellow',
+    STORY_STARTED: 'blue',
+    STORY_COMPLETED: 'green',
+    STORY_QA_PASSED: 'green',
+    STORY_QA_FAILED: 'red',
+    STORY_PR_CREATED: 'magenta',
+    ESCALATION_CREATED: 'red',
+    BUILD_PASSED: 'green',
+    BUILD_FAILED: 'red',
+  };
+
+  const color = colors[event] || 'white';
+  return `{${color}-fg}${event}{/}`;
+}