hungry-ghost-hive 0.3.0

package/src/cli/commands/msg.ts

@@ -0,0 +1,232 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { nanoid } from 'nanoid';
+import { findHiveRoot, getHivePaths } from '../../utils/paths.js';
+import { getDatabase, queryAll, queryOne, run } from '../../db/client.js';
+
+interface MessageRow {
+  id: string;
+  from_session: string;
+  to_session: string;
+  subject: string | null;
+  body: string;
+  reply: string | null;
+  status: 'pending' | 'read' | 'replied';
+  created_at: string;
+  replied_at: string | null;
+}
+
+export const msgCommand = new Command('msg')
+  .description('Inter-agent messaging');
+
+msgCommand
+  .command('send <to-session> <message>')
+  .description('Send a message to another agent')
+  .option('-s, --subject <subject>', 'Message subject')
+  .option('-f, --from <session>', 'Your session name (defaults to hive-tech-lead)')
+  .action(async (toSession: string, message: string, options: { subject?: string; from?: string }) => {
+    const root = findHiveRoot();
+    if (!root) {
+      console.error(chalk.red('Not in a Hive workspace.'));
+      process.exit(1);
+    }
+
+    const paths = getHivePaths(root);
+    const db = await getDatabase(paths.hiveDir);
+
+    try {
+      const id = `msg-${nanoid(8)}`;
+      const fromSession = options.from || 'hive-tech-lead';
+
+      run(db.db, `
+        INSERT INTO messages (id, from_session, to_session, subject, body, status, created_at)
+        VALUES (?, ?, ?, ?, ?, 'pending', datetime('now'))
+      `, [id, fromSession, toSession, options.subject || null, message]);
+      db.save();
+
+      console.log(chalk.green(`Message sent: ${id}`));
+      console.log(chalk.gray(`To: ${toSession}`));
+      console.log(chalk.gray(`Subject: ${options.subject || '(none)'}`));
+    } finally {
+      db.close();
+    }
+  });
+
+msgCommand
+  .command('inbox [session]')
+  .description('Check inbox for messages')
+  .option('--all', 'Show all messages including read')
+  .action(async (session: string | undefined, options: { all?: boolean }) => {
+    const root = findHiveRoot();
+    if (!root) {
+      console.error(chalk.red('Not in a Hive workspace.'));
+      process.exit(1);
+    }
+
+    const paths = getHivePaths(root);
+    const db = await getDatabase(paths.hiveDir);
+
+    try {
+      const targetSession = session || 'hive-tech-lead';
+
+      let query = `
+        SELECT * FROM messages
+        WHERE to_session = ?
+      `;
+      if (!options.all) {
+        query += ` AND status = 'pending'`;
+      }
+      query += ` ORDER BY created_at DESC`;
+
+      const messages = queryAll<MessageRow>(db.db, query, [targetSession]);
+
+      if (messages.length === 0) {
+        console.log(chalk.gray(`No ${options.all ? '' : 'pending '}messages for ${targetSession}`));
+        return;
+      }
+
+      console.log(chalk.bold(`\nInbox for ${targetSession} (${messages.length} messages):\n`));
+
+      for (const msg of messages) {
+        const statusIcon = msg.status === 'pending' ? chalk.yellow('●') :
+                          msg.status === 'replied' ? chalk.green('✓') : chalk.gray('○');
+        const time = msg.created_at.substring(0, 16).replace('T', ' ');
+
+        console.log(`${statusIcon} ${chalk.cyan(msg.id)} from ${chalk.bold(msg.from_session)}`);
+        console.log(`  ${chalk.gray(time)} ${msg.subject || ''}`);
+        console.log(`  ${msg.body.substring(0, 80)}${msg.body.length > 80 ? '...' : ''}`);
+        if (msg.reply) {
+          console.log(chalk.green(`  Reply: ${msg.reply.substring(0, 60)}${msg.reply.length > 60 ? '...' : ''}`));
+        }
+        console.log();
+      }
+    } finally {
+      db.close();
+    }
+  });
+
+msgCommand
+  .command('read <msg-id>')
+  .description('Read a specific message')
+  .action(async (msgId: string) => {
+    const root = findHiveRoot();
+    if (!root) {
+      console.error(chalk.red('Not in a Hive workspace.'));
+      process.exit(1);
+    }
+
+    const paths = getHivePaths(root);
+    const db = await getDatabase(paths.hiveDir);
+
+    try {
+      const msg = queryOne<MessageRow>(db.db, 'SELECT * FROM messages WHERE id = ?', [msgId]);
+
+      if (!msg) {
+        console.error(chalk.red(`Message not found: ${msgId}`));
+        process.exit(1);
+      }
+
+      // Mark as read
+      if (msg.status === 'pending') {
+        run(db.db, `UPDATE messages SET status = 'read' WHERE id = ?`, [msgId]);
+        db.save();
+      }
+
+      console.log(chalk.bold(`\nMessage: ${msg.id}\n`));
+      console.log(`From:    ${chalk.cyan(msg.from_session)}`);
+      console.log(`To:      ${msg.to_session}`);
+      console.log(`Subject: ${msg.subject || '(none)'}`);
+      console.log(`Time:    ${msg.created_at}`);
+      console.log(`Status:  ${msg.status}`);
+      console.log(chalk.gray('─'.repeat(50)));
+      console.log(msg.body);
+
+      if (msg.reply) {
+        console.log(chalk.gray('─'.repeat(50)));
+        console.log(chalk.green('Reply:'));
+        console.log(msg.reply);
+      }
+      console.log();
+    } finally {
+      db.close();
+    }
+  });
+
+msgCommand
+  .command('reply <msg-id> <response>')
+  .description('Reply to a message')
+  .action(async (msgId: string, response: string) => {
+    const root = findHiveRoot();
+    if (!root) {
+      console.error(chalk.red('Not in a Hive workspace.'));
+      process.exit(1);
+    }
+
+    const paths = getHivePaths(root);
+    const db = await getDatabase(paths.hiveDir);
+
+    try {
+      const msg = queryOne<MessageRow>(db.db, 'SELECT * FROM messages WHERE id = ?', [msgId]);
+
+      if (!msg) {
+        console.error(chalk.red(`Message not found: ${msgId}`));
+        process.exit(1);
+      }
+
+      run(db.db, `
+        UPDATE messages
+        SET reply = ?, status = 'replied', replied_at = datetime('now')
+        WHERE id = ?
+      `, [response, msgId]);
+      db.save();
+
+      console.log(chalk.green(`Reply sent to ${msg.from_session}`));
+    } finally {
+      db.close();
+    }
+  });
+
+msgCommand
+  .command('outbox [session]')
+  .description('Check sent messages and their replies')
+  .action(async (session: string | undefined) => {
+    const root = findHiveRoot();
+    if (!root) {
+      console.error(chalk.red('Not in a Hive workspace.'));
+      process.exit(1);
+    }
+
+    const paths = getHivePaths(root);
+    const db = await getDatabase(paths.hiveDir);
+
+    try {
+      const fromSession = session || 'hive-tech-lead';
+
+      const messages = queryAll<MessageRow>(db.db, `
+        SELECT * FROM messages
+        WHERE from_session = ?
+        ORDER BY created_at DESC
+      `, [fromSession]);
+
+      if (messages.length === 0) {
+        console.log(chalk.gray(`No sent messages from ${fromSession}`));
+        return;
+      }
+
+      console.log(chalk.bold(`\nSent messages from ${fromSession} (${messages.length}):\n`));
+
+      for (const msg of messages) {
+        const statusIcon = msg.status === 'replied' ? chalk.green('✓ REPLIED') :
+                          msg.status === 'read' ? chalk.yellow('○ READ') : chalk.gray('● PENDING');
+
+        console.log(`${chalk.cyan(msg.id)} → ${chalk.bold(msg.to_session)} ${statusIcon}`);
+        console.log(`  ${msg.body.substring(0, 60)}${msg.body.length > 60 ? '...' : ''}`);
+        if (msg.reply) {
+          console.log(chalk.green(`  ↳ ${msg.reply.substring(0, 60)}${msg.reply.length > 60 ? '...' : ''}`));
+        }
+        console.log();
+      }
+    } finally {
+      db.close();
+    }
+  });

package/src/cli/commands/my-stories.ts

@@ -0,0 +1,198 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { findHiveRoot, getHivePaths } from '../../utils/paths.js';
+import { getDatabase, queryAll, queryOne, run, type StoryRow } from '../../db/client.js';
+
+export const myStoriesCommand = new Command('my-stories')
+  .description('View and manage stories assigned to an agent')
+  .argument('[session]', 'Tmux session name (e.g., hive-senior-myteam)')
+  .option('--all', 'Show all stories for the team, not just assigned')
+  .action(async (session: string | undefined, options: { all?: boolean }) => {
+    const root = findHiveRoot();
+    if (!root) {
+      console.error(chalk.red('Not in a Hive workspace.'));
+      process.exit(1);
+    }
+
+    const paths = getHivePaths(root);
+    const db = await getDatabase(paths.hiveDir);
+
+    try {
+      if (!session) {
+        // Show all in-progress stories
+        const stories = queryAll<StoryRow & { tmux_session?: string }>(db.db, `
+          SELECT s.*, a.tmux_session
+          FROM stories s
+          LEFT JOIN agents a ON s.assigned_agent_id = a.id
+          WHERE s.status IN ('planned', 'in_progress', 'review', 'qa', 'qa_failed')
+          ORDER BY s.status, s.created_at
+        `);
+
+        if (stories.length === 0) {
+          console.log(chalk.gray('No active stories found.'));
+          return;
+        }
+
+        console.log(chalk.bold('\nActive Stories:\n'));
+        for (const story of stories) {
+          printStory(story, story.tmux_session);
+        }
+        return;
+      }
+
+      // Find agent by tmux session
+      const agent = queryOne<{ id: string; team_id: string }>(db.db,
+        'SELECT id, team_id FROM agents WHERE tmux_session = ?', [session]);
+
+      if (!agent) {
+        console.error(chalk.red(`No agent found with session: ${session}`));
+        console.log(chalk.gray('Available sessions:'));
+        const agents = queryAll<{ tmux_session: string }>(db.db,
+          'SELECT tmux_session FROM agents WHERE tmux_session IS NOT NULL');
+        for (const a of agents) {
+          console.log(chalk.gray(`  - ${a.tmux_session}`));
+        }
+        process.exit(1);
+      }
+
+      let stories: StoryRow[];
+      if (options.all && agent.team_id) {
+        // Show all team stories
+        stories = queryAll<StoryRow>(db.db, `
+          SELECT * FROM stories
+          WHERE team_id = ?
+          ORDER BY
+            CASE status
+              WHEN 'in_progress' THEN 1
+              WHEN 'planned' THEN 2
+              WHEN 'review' THEN 3
+              WHEN 'qa' THEN 4
+              ELSE 5
+            END,
+            complexity_score DESC
+        `, [agent.team_id]);
+      } else {
+        // Show only assigned active stories (exclude merged/terminal states)
+        stories = queryAll<StoryRow>(db.db, `
+          SELECT * FROM stories
+          WHERE assigned_agent_id = ?
+          AND status IN ('planned', 'in_progress', 'review', 'qa', 'qa_failed', 'pr_submitted')
+          ORDER BY created_at
+        `, [agent.id]);
+      }
+
+      if (stories.length === 0) {
+        console.log(chalk.yellow(`No stories ${options.all ? 'for your team' : 'assigned to you'}.`));
+        if (!options.all) {
+          console.log(chalk.gray('Use --all to see all team stories.'));
+        }
+        return;
+      }
+
+      console.log(chalk.bold(`\nStories for ${session}${options.all ? ' (all team)' : ''}:\n`));
+
+      for (const story of stories) {
+        printStory(story);
+      }
+
+    } finally {
+      db.close();
+    }
+  });
+
+myStoriesCommand
+  .command('claim <story-id>')
+  .description('Claim a story to work on')
+  .requiredOption('-s, --session <session>', 'Your tmux session name')
+  .action(async (storyId: string, options: { session: string }) => {
+    const root = findHiveRoot();
+    if (!root) {
+      console.error(chalk.red('Not in a Hive workspace.'));
+      process.exit(1);
+    }
+
+    const paths = getHivePaths(root);
+    const db = await getDatabase(paths.hiveDir);
+
+    try {
+      // Find agent by session
+      const agent = queryOne<{ id: string }>(db.db,
+        'SELECT id FROM agents WHERE tmux_session = ?', [options.session]);
+
+      if (!agent) {
+        console.error(chalk.red(`No agent found with session: ${options.session}`));
+        process.exit(1);
+      }
+
+      // Check story exists and is available
+      const story = queryOne<StoryRow>(db.db, 'SELECT * FROM stories WHERE id = ?', [storyId]);
+      if (!story) {
+        console.error(chalk.red(`Story not found: ${storyId}`));
+        process.exit(1);
+      }
+
+      if (story.assigned_agent_id && story.assigned_agent_id !== agent.id) {
+        console.error(chalk.red(`Story already assigned to another agent.`));
+        process.exit(1);
+      }
+
+      // Claim the story
+      run(db.db, `
+        UPDATE stories
+        SET assigned_agent_id = ?, status = 'in_progress', updated_at = datetime('now')
+        WHERE id = ?
+      `, [agent.id, storyId]);
+      db.save();
+
+      console.log(chalk.green(`Claimed story: ${storyId}`));
+      console.log(chalk.gray(`Title: ${story.title}`));
+    } finally {
+      db.close();
+    }
+  });
+
+myStoriesCommand
+  .command('complete <story-id>')
+  .description('Mark a story as complete (ready for review)')
+  .action(async (storyId: string) => {
+    const root = findHiveRoot();
+    if (!root) {
+      console.error(chalk.red('Not in a Hive workspace.'));
+      process.exit(1);
+    }
+
+    const paths = getHivePaths(root);
+    const db = await getDatabase(paths.hiveDir);
+
+    try {
+      const story = queryOne<StoryRow>(db.db, 'SELECT * FROM stories WHERE id = ?', [storyId]);
+      if (!story) {
+        console.error(chalk.red(`Story not found: ${storyId}`));
+        process.exit(1);
+      }
+
+      run(db.db, `
+        UPDATE stories
+        SET status = 'review', updated_at = datetime('now')
+        WHERE id = ?
+      `, [storyId]);
+      db.save();
+
+      console.log(chalk.green(`Story ${storyId} marked as ready for review.`));
+    } finally {
+      db.close();
+    }
+  });
+
+function printStory(story: StoryRow, assignedSession?: string): void {
+  console.log(chalk.cyan(`[${story.id}]`) + ` ${story.title}`);
+  console.log(`  Status: ${story.status.toUpperCase()} | Complexity: ${story.complexity_score || '?'}`);
+  if (assignedSession) {
+    console.log(`  Assigned: ${assignedSession}`);
+  }
+  if (story.description) {
+    const desc = story.description.substring(0, 100);
+    console.log(chalk.gray(`  ${desc}${story.description.length > 100 ? '...' : ''}`));
+  }
+  console.log();
+}

package/src/cli/commands/nuke.ts

@@ -0,0 +1,223 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import readline from 'readline';
+import { findHiveRoot, getHivePaths } from '../../utils/paths.js';
+import { getDatabase } from '../../db/client.js';
+import { queryOne, run } from '../../db/client.js';
+import { killAllHiveSessions } from '../../tmux/manager.js';
+
+async function confirm(message: string): Promise<boolean> {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question(`${message} (yes/no): `, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === 'yes' || answer.toLowerCase() === 'y');
+    });
+  });
+}
+
+export const nukeCommand = new Command('nuke')
+  .description('Delete data (use with caution)')
+  .addCommand(
+    new Command('stories')
+      .description('Delete all stories')
+      .option('--force', 'Skip confirmation')
+      .action(async (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 {
+          // Count stories
+          const count = queryOne<{ count: number }>(db.db, 'SELECT COUNT(*) as count FROM stories');
+          const storyCount = count?.count || 0;
+
+          if (storyCount === 0) {
+            console.log(chalk.yellow('No stories to delete.'));
+            return;
+          }
+
+          console.log(chalk.yellow(`\nThis will delete ${storyCount} stories and their dependencies.`));
+          console.log(chalk.red('This action cannot be undone.\n'));
+
+          if (!options.force) {
+            const confirmed = await confirm(chalk.bold('Are you sure you want to delete all stories?'));
+            if (!confirmed) {
+              console.log(chalk.gray('Aborted.'));
+              return;
+            }
+          }
+
+          // Delete in order to respect foreign keys
+          run(db.db, 'DELETE FROM pull_requests');
+          run(db.db, 'UPDATE escalations SET story_id = NULL');
+          run(db.db, 'DELETE FROM story_dependencies');
+          run(db.db, 'DELETE FROM stories');
+          db.save();
+
+          console.log(chalk.green(`\nDeleted ${storyCount} stories.`));
+        } finally {
+          db.close();
+        }
+      })
+  )
+  .addCommand(
+    new Command('agents')
+      .description('Kill all agent tmux sessions and delete from database')
+      .option('--force', 'Skip confirmation')
+      .action(async (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 count = queryOne<{ count: number }>(db.db, 'SELECT COUNT(*) as count FROM agents');
+          const agentCount = count?.count || 0;
+
+          console.log(chalk.yellow(`\nThis will kill all hive tmux sessions and delete ${agentCount} agents.`));
+          console.log(chalk.red('This action cannot be undone.\n'));
+
+          if (!options.force) {
+            const confirmed = await confirm(chalk.bold('Are you sure you want to kill all agents?'));
+            if (!confirmed) {
+              console.log(chalk.gray('Aborted.'));
+              return;
+            }
+          }
+
+          // Kill all hive tmux sessions
+          const killed = await killAllHiveSessions();
+          console.log(chalk.gray(`Killed ${killed} tmux sessions.`));
+
+          // Clear agent references from stories first
+          run(db.db, 'UPDATE stories SET assigned_agent_id = NULL');
+          // Delete from database
+          run(db.db, 'DELETE FROM agent_logs');
+          run(db.db, 'DELETE FROM escalations');
+          run(db.db, 'DELETE FROM agents');
+          db.save();
+
+          console.log(chalk.green(`\nDeleted ${agentCount} agents.`));
+        } finally {
+          db.close();
+        }
+      })
+  )
+  .addCommand(
+    new Command('requirements')
+      .description('Delete all requirements')
+      .option('--force', 'Skip confirmation')
+      .action(async (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 count = queryOne<{ count: number }>(db.db, 'SELECT COUNT(*) as count FROM requirements');
+          const reqCount = count?.count || 0;
+
+          if (reqCount === 0) {
+            console.log(chalk.yellow('No requirements to delete.'));
+            return;
+          }
+
+          const storyCount = queryOne<{ count: number }>(db.db, 'SELECT COUNT(*) as count FROM stories')?.count || 0;
+
+          console.log(chalk.yellow(`\nThis will delete ${reqCount} requirements and ${storyCount} related stories.`));
+          console.log(chalk.red('This action cannot be undone.\n'));
+
+          if (!options.force) {
+            const confirmed = await confirm(chalk.bold('Are you sure you want to delete all requirements?'));
+            if (!confirmed) {
+              console.log(chalk.gray('Aborted.'));
+              return;
+            }
+          }
+
+          // Delete stories first (they reference requirements)
+          run(db.db, 'DELETE FROM pull_requests');
+          run(db.db, 'UPDATE escalations SET story_id = NULL');
+          run(db.db, 'DELETE FROM story_dependencies');
+          run(db.db, 'DELETE FROM stories');
+          run(db.db, 'DELETE FROM requirements');
+          db.save();
+
+          console.log(chalk.green(`\nDeleted ${reqCount} requirements and ${storyCount} stories.`));
+        } finally {
+          db.close();
+        }
+      })
+  )
+  .addCommand(
+    new Command('all')
+      .description('Kill all agents and delete all data')
+      .option('--force', 'Skip confirmation')
+      .action(async (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 {
+          console.log(chalk.red('\nThis will:'));
+          console.log(chalk.yellow('  - Kill all hive tmux sessions'));
+          console.log(chalk.yellow('  - Delete all stories and dependencies'));
+          console.log(chalk.yellow('  - Delete all agents and logs'));
+          console.log(chalk.yellow('  - Delete all requirements'));
+          console.log(chalk.yellow('  - Delete all escalations'));
+          console.log(chalk.yellow('  - Delete all pull requests'));
+          console.log(chalk.red('\nThis action cannot be undone.\n'));
+
+          if (!options.force) {
+            const confirmed = await confirm(chalk.bold('Are you sure you want to nuke EVERYTHING?'));
+            if (!confirmed) {
+              console.log(chalk.gray('Aborted.'));
+              return;
+            }
+          }
+
+          // Kill all hive tmux sessions first
+          const killed = await killAllHiveSessions();
+          console.log(chalk.gray(`Killed ${killed} tmux sessions.`));
+
+          // Clear foreign key references first
+          run(db.db, 'UPDATE stories SET assigned_agent_id = NULL');
+          // Delete in order to respect foreign keys
+          run(db.db, 'DELETE FROM pull_requests');
+          run(db.db, 'DELETE FROM escalations');
+          run(db.db, 'DELETE FROM agent_logs');
+          run(db.db, 'DELETE FROM story_dependencies');
+          run(db.db, 'DELETE FROM stories');
+          run(db.db, 'DELETE FROM agents');
+          run(db.db, 'DELETE FROM requirements');
+          db.save();
+
+          console.log(chalk.green('\nAll data deleted.'));
+        } finally {
+          db.close();
+        }
+      })
+  );