hungry-ghost-hive 0.3.0

package/src/cli/commands/add-repo.ts

@@ -0,0 +1,89 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { execa } from 'execa';
+import { join } from 'path';
+import { existsSync } from 'fs';
+import { findHiveRoot, getHivePaths } from '../../utils/paths.js';
+import { getDatabase } from '../../db/client.js';
+import { createTeam, getTeamByName } from '../../db/queries/teams.js';
+
+export const addRepoCommand = new Command('add-repo')
+  .description('Add a repository as a git submodule with team assignment')
+  .requiredOption('--url <url>', 'Repository URL')
+  .requiredOption('--team <name>', 'Team name')
+  .option('--branch <branch>', 'Branch to track', 'main')
+  .action(async (options: { url: string; team: string; branch: 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 spinner = ora('Adding repository...').start();
+
+    // Extract repo name from URL
+    const repoName = options.url.split('/').pop()?.replace('.git', '') || 'repo';
+    const repoPath = join(paths.reposDir, repoName);
+    const relativeRepoPath = `repos/${repoName}`;
+
+    try {
+      // Check if team already exists
+      const db = await getDatabase(paths.hiveDir);
+      const existingTeam = getTeamByName(db.db, options.team);
+      if (existingTeam) {
+        spinner.fail(chalk.red(`Team "${options.team}" already exists`));
+        db.close();
+        process.exit(1);
+      }
+
+      // Check if repo path already exists
+      if (existsSync(repoPath)) {
+        spinner.fail(chalk.red(`Repository path already exists: ${repoPath}`));
+        db.close();
+        process.exit(1);
+      }
+
+      // Add git submodule
+      spinner.text = 'Adding git submodule...';
+      try {
+        await execa('git', ['submodule', 'add', '-b', options.branch, options.url, relativeRepoPath], {
+          cwd: root,
+        });
+      } catch (gitErr: unknown) {
+        // If submodule already exists, try to init/update instead
+        const error = gitErr as { stderr?: string };
+        if (error.stderr?.includes('already exists')) {
+          spinner.text = 'Submodule exists, initializing...';
+          await execa('git', ['submodule', 'init', relativeRepoPath], { cwd: root });
+          await execa('git', ['submodule', 'update', relativeRepoPath], { cwd: root });
+        } else {
+          throw gitErr;
+        }
+      }
+
+      // Create team in database
+      spinner.text = 'Creating team...';
+      const team = createTeam(db.db, {
+        repoUrl: options.url,
+        repoPath: relativeRepoPath,
+        name: options.team,
+      });
+
+      db.close();
+
+      spinner.succeed(chalk.green(`Repository added successfully!`));
+      console.log();
+      console.log(chalk.bold('Team created:'));
+      console.log(chalk.gray(`  ID:   ${team.id}`));
+      console.log(chalk.gray(`  Name: ${team.name}`));
+      console.log(chalk.gray(`  Repo: ${team.repo_url}`));
+      console.log(chalk.gray(`  Path: ${team.repo_path}`));
+      console.log();
+    } catch (err) {
+      spinner.fail(chalk.red('Failed to add repository'));
+      console.error(err);
+      process.exit(1);
+    }
+  });

package/src/cli/commands/agents.ts

@@ -0,0 +1,247 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { findHiveRoot, getHivePaths } from '../../utils/paths.js';
+import { getDatabase } from '../../db/client.js';
+import { getAllAgents, getAgentById, getActiveAgents, getAgentsByStatus, deleteAgent } from '../../db/queries/agents.js';
+import { getLogsByAgent } from '../../db/queries/logs.js';
+import { statusColor } from '../../utils/logger.js';
+
+export const agentsCommand = new Command('agents')
+  .description('Manage agents');
+
+agentsCommand
+  .command('list')
+  .description('List all agents')
+  .option('--active', 'Show only active agents')
+  .option('--json', 'Output as JSON')
+  .action(async (options: { active?: boolean; 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 agents = options.active ? getActiveAgents(db.db) : getAllAgents(db.db);
+
+      if (options.json) {
+        console.log(JSON.stringify(agents, null, 2));
+        return;
+      }
+
+      if (agents.length === 0) {
+        console.log(chalk.yellow('No agents found.'));
+        return;
+      }
+
+      console.log(chalk.bold('\nAgents:\n'));
+
+      // Header
+      console.log(
+        chalk.gray(
+          `${'ID'.padEnd(25)} ${'Type'.padEnd(12)} ${'Model'.padEnd(10)} ${'Team'.padEnd(15)} ${'Status'.padEnd(12)} ${'Current Story'}`
+        )
+      );
+      console.log(chalk.gray('─'.repeat(100)));
+
+      for (const agent of agents) {
+        const team = agent.team_id || '-';
+        const story = agent.current_story_id || '-';
+        const model = agent.model || '-';
+        console.log(
+          `${chalk.cyan(agent.id.padEnd(25))} ${agent.type.padEnd(12)} ${model.padEnd(10)} ${team.padEnd(15)} ${statusColor(agent.status).padEnd(12)} ${story}`
+        );
+      }
+      console.log();
+    } finally {
+      db.close();
+    }
+  });
+
+agentsCommand
+  .command('logs <agent-id>')
+  .description('View agent logs')
+  .option('-n, --limit <number>', 'Number of logs to show', '50')
+  .option('--json', 'Output as JSON')
+  .action(async (agentId: string, options: { limit: 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 {
+      const agent = getAgentById(db.db, agentId);
+      if (!agent) {
+        console.error(chalk.red(`Agent not found: ${agentId}`));
+        process.exit(1);
+      }
+
+      const logs = getLogsByAgent(db.db, agentId, parseInt(options.limit, 10));
+
+      if (options.json) {
+        console.log(JSON.stringify(logs, null, 2));
+        return;
+      }
+
+      if (logs.length === 0) {
+        console.log(chalk.yellow('No logs found for this agent.'));
+        return;
+      }
+
+      console.log(chalk.bold(`\nLogs for ${agentId}:\n`));
+
+      for (const log of logs) {
+        const time = log.timestamp.substring(0, 19).replace('T', ' ');
+        const storyInfo = log.story_id ? chalk.cyan(` [${log.story_id}]`) : '';
+        const message = log.message ? `: ${log.message}` : '';
+
+        console.log(`${chalk.gray(time)}${storyInfo} ${chalk.bold(log.event_type)}${message}`);
+
+        if (log.metadata) {
+          try {
+            const meta = JSON.parse(log.metadata);
+            console.log(chalk.gray(`  ${JSON.stringify(meta)}`));
+          } catch {
+            // Ignore parse errors
+          }
+        }
+      }
+      console.log();
+    } finally {
+      db.close();
+    }
+  });
+
+agentsCommand
+  .command('inspect <agent-id>')
+  .description('View detailed agent state')
+  .action(async (agentId: 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 agent = getAgentById(db.db, agentId);
+      if (!agent) {
+        console.error(chalk.red(`Agent not found: ${agentId}`));
+        process.exit(1);
+      }
+
+      console.log(chalk.bold(`\nAgent: ${agent.id}\n`));
+      console.log(chalk.gray(`Type:          ${agent.type}`));
+      console.log(chalk.gray(`Model:         ${agent.model || '-'}`));
+      console.log(chalk.gray(`Team:          ${agent.team_id || '-'}`));
+      console.log(chalk.gray(`Status:        ${statusColor(agent.status)}`));
+      console.log(chalk.gray(`Tmux Session:  ${agent.tmux_session || '-'}`));
+      console.log(chalk.gray(`Current Story: ${agent.current_story_id || '-'}`));
+      console.log(chalk.gray(`Created:       ${agent.created_at}`));
+      console.log(chalk.gray(`Updated:       ${agent.updated_at}`));
+
+      if (agent.memory_state) {
+        console.log(chalk.bold('\nMemory State:'));
+        try {
+          const state = JSON.parse(agent.memory_state);
+          console.log(JSON.stringify(state, null, 2));
+        } catch {
+          console.log(agent.memory_state);
+        }
+      }
+
+      // Show recent logs
+      const logs = getLogsByAgent(db.db, agentId, 5);
+      if (logs.length > 0) {
+        console.log(chalk.bold('\nRecent Activity:'));
+        for (const log of logs) {
+          const time = log.timestamp.substring(11, 19);
+          const message = log.message ? `: ${log.message.substring(0, 50)}` : '';
+          console.log(chalk.gray(`  ${time} | ${log.event_type}${message}`));
+        }
+      }
+      console.log();
+    } finally {
+      db.close();
+    }
+  });
+
+agentsCommand
+  .command('cleanup')
+  .description('Clean up terminated agents from the database')
+  .option('--dry-run', 'Show what would be deleted without actually deleting')
+  .action(async (options: { dryRun?: 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 terminatedAgents = getAgentsByStatus(db.db, 'terminated');
+
+      if (terminatedAgents.length === 0) {
+        console.log(chalk.green('No terminated agents to clean up.'));
+        return;
+      }
+
+      console.log(chalk.yellow(`\nFound ${terminatedAgents.length} terminated agent(s):\n`));
+
+      // Group by type for summary
+      const byType = terminatedAgents.reduce((acc, agent) => {
+        acc[agent.type] = (acc[agent.type] || 0) + 1;
+        return acc;
+      }, {} as Record<string, number>);
+
+      for (const [type, count] of Object.entries(byType)) {
+        console.log(chalk.gray(`  ${type}: ${count}`));
+      }
+      console.log();
+
+      if (options.dryRun) {
+        console.log(chalk.yellow('Dry run - no agents were deleted.'));
+        return;
+      }
+
+      // Delete terminated agents and their worktrees
+      let deleted = 0;
+      for (const agent of terminatedAgents) {
+        try {
+          // Remove worktree if exists
+          if (agent.worktree_path) {
+            try {
+              const { execSync } = await import('child_process');
+              const fullWorktreePath = `${root}/${agent.worktree_path}`;
+              execSync(`git worktree remove "${fullWorktreePath}" --force`, {
+                cwd: root,
+                stdio: 'pipe',
+              });
+            } catch (err) {
+              console.error(chalk.yellow(`Warning: Failed to remove worktree for ${agent.id}: ${err instanceof Error ? err.message : 'Unknown error'}`));
+            }
+          }
+
+          deleteAgent(db.db, agent.id);
+          deleted++;
+        } catch (err) {
+          console.error(chalk.red(`Failed to delete ${agent.id}: ${err instanceof Error ? err.message : 'Unknown error'}`));
+        }
+      }
+
+      console.log(chalk.green(`✓ Cleaned up ${deleted} terminated agent(s).`));
+    } finally {
+      db.close();
+    }
+  });

package/src/cli/commands/assign.ts

@@ -0,0 +1,86 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { findHiveRoot, getHivePaths } from '../../utils/paths.js';
+import { getDatabase } from '../../db/client.js';
+import { loadConfig } from '../../config/loader.js';
+import { Scheduler } from '../../orchestrator/scheduler.js';
+import { startManager, isManagerRunning } from '../../tmux/manager.js';
+
+export const assignCommand = new Command('assign')
+  .description('Assign planned stories to agents (spawns Seniors as needed)')
+  .option('--dry-run', 'Show what would be assigned without making changes')
+  .action(async (options: { dryRun?: 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);
+    const spinner = ora('Assigning stories...').start();
+
+    try {
+      const config = loadConfig(paths.hiveDir);
+
+      if (options.dryRun) {
+        spinner.info(chalk.yellow('Dry run - no changes will be made'));
+        // TODO: Add dry run logic
+        return;
+      }
+
+      const scheduler = new Scheduler(db.db, {
+        scaling: config.scaling,
+        models: config.models,
+        rootDir: root,
+      });
+
+      // Check scaling first (spawns additional seniors if needed)
+      spinner.text = 'Checking team scaling...';
+      await scheduler.checkScaling();
+
+      // Check merge queue (spawns QA agents if needed)
+      spinner.text = 'Checking merge queue...';
+      await scheduler.checkMergeQueue();
+
+      // Assign stories to agents
+      spinner.text = 'Assigning stories to agents...';
+      const result = await scheduler.assignStories();
+
+      if (result.errors.length > 0) {
+        spinner.warn(chalk.yellow(`Assigned ${result.assigned} stories with ${result.errors.length} errors`));
+        for (const error of result.errors) {
+          console.log(chalk.red(`  - ${error}`));
+        }
+      } else if (result.assigned === 0) {
+        spinner.info(chalk.gray('No stories to assign'));
+      } else {
+        spinner.succeed(chalk.green(`Assigned ${result.assigned} stories`));
+      }
+
+      // Auto-start the manager if work was assigned and it's not running
+      if (result.assigned > 0) {
+        if (!await isManagerRunning()) {
+          spinner.start('Starting manager daemon...');
+          const started = await startManager(60);
+          if (started) {
+            spinner.succeed(chalk.green('Manager daemon started (checking every 60s)'));
+          } else {
+            spinner.info(chalk.gray('Manager daemon already running'));
+          }
+        }
+      }
+
+      console.log();
+      console.log(chalk.gray('View agent status:'));
+      console.log(chalk.cyan('  hive agents list --active'));
+      console.log();
+    } catch (err) {
+      spinner.fail(chalk.red('Failed to assign stories'));
+      console.error(err);
+      process.exit(1);
+    } finally {
+      db.close();
+    }
+  });

package/src/cli/commands/config.ts

@@ -0,0 +1,121 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { stringify } from 'yaml';
+import { findHiveRoot, getHivePaths } from '../../utils/paths.js';
+import { loadConfig, saveConfig, getConfigValue, setConfigValue, ConfigError } from '../../config/loader.js';
+
+export const configCommand = new Command('config')
+  .description('Manage Hive configuration');
+
+configCommand
+  .command('show')
+  .description('Show current configuration')
+  .option('--json', 'Output as JSON')
+  .action((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);
+
+    try {
+      const config = loadConfig(paths.hiveDir);
+
+      if (options.json) {
+        console.log(JSON.stringify(config, null, 2));
+      } else {
+        console.log(stringify(config, { indent: 2 }));
+      }
+    } catch (err) {
+      if (err instanceof ConfigError) {
+        console.error(chalk.red(err.message));
+      } else {
+        console.error(chalk.red('Failed to load configuration:'), err);
+      }
+      process.exit(1);
+    }
+  });
+
+configCommand
+  .command('get <path>')
+  .description('Get a specific configuration value')
+  .action((path: 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);
+
+    try {
+      const config = loadConfig(paths.hiveDir);
+      const value = getConfigValue(config, path);
+
+      if (value === undefined) {
+        console.error(chalk.yellow(`Configuration key not found: ${path}`));
+        process.exit(1);
+      }
+
+      if (typeof value === 'object') {
+        console.log(stringify(value, { indent: 2 }));
+      } else {
+        console.log(value);
+      }
+    } catch (err) {
+      if (err instanceof ConfigError) {
+        console.error(chalk.red(err.message));
+      } else {
+        console.error(chalk.red('Failed to get configuration:'), err);
+      }
+      process.exit(1);
+    }
+  });
+
+configCommand
+  .command('set <path> <value>')
+  .description('Set a configuration value')
+  .action((path: string, value: 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);
+
+    try {
+      const config = loadConfig(paths.hiveDir);
+
+      // Try to parse value as JSON, otherwise use as string
+      let parsedValue: unknown;
+      try {
+        parsedValue = JSON.parse(value);
+      } catch {
+        // Check for boolean strings
+        if (value.toLowerCase() === 'true') {
+          parsedValue = true;
+        } else if (value.toLowerCase() === 'false') {
+          parsedValue = false;
+        } else if (!isNaN(Number(value))) {
+          parsedValue = Number(value);
+        } else {
+          parsedValue = value;
+        }
+      }
+
+      const newConfig = setConfigValue(config, path, parsedValue);
+      saveConfig(paths.hiveDir, newConfig);
+
+      console.log(chalk.green(`Set ${chalk.bold(path)} = ${JSON.stringify(parsedValue)}`));
+    } catch (err) {
+      if (err instanceof ConfigError) {
+        console.error(chalk.red(err.message));
+      } else {
+        console.error(chalk.red('Failed to set configuration:'), err);
+      }
+      process.exit(1);
+    }
+  });