hungry-ghost-hive 0.3.0

package/src/git/github.ts

@@ -0,0 +1,247 @@
+import { execa } from 'execa';
+
+export interface PRCreateOptions {
+  title: string;
+  body: string;
+  baseBranch: string;
+  headBranch: string;
+  draft?: boolean;
+  labels?: string[];
+  assignees?: string[];
+}
+
+export interface PRInfo {
+  number: number;
+  url: string;
+  title: string;
+  state: 'open' | 'closed' | 'merged';
+  headBranch: string;
+  baseBranch: string;
+  additions: number;
+  deletions: number;
+  changedFiles: number;
+}
+
+export interface PRReview {
+  state: 'APPROVED' | 'CHANGES_REQUESTED' | 'COMMENTED' | 'PENDING';
+  body: string;
+}
+
+/**
+ * Check if gh CLI is available and authenticated
+ */
+export async function isGitHubCLIAvailable(): Promise<boolean> {
+  try {
+    await execa('gh', ['auth', 'status']);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Create a pull request
+ */
+export async function createPullRequest(
+  workDir: string,
+  options: PRCreateOptions
+): Promise<{ number: number; url: string }> {
+  const args = [
+    'pr', 'create',
+    '--title', options.title,
+    '--body', options.body,
+    '--base', options.baseBranch,
+    '--head', options.headBranch,
+  ];
+
+  if (options.draft) {
+    args.push('--draft');
+  }
+
+  if (options.labels && options.labels.length > 0) {
+    args.push('--label', options.labels.join(','));
+  }
+
+  if (options.assignees && options.assignees.length > 0) {
+    args.push('--assignee', options.assignees.join(','));
+  }
+
+  const { stdout } = await execa('gh', args, { cwd: workDir });
+  const url = stdout.trim();
+
+  // Extract PR number from URL
+  const numberMatch = url.match(/\/pull\/(\d+)/);
+  const number = numberMatch ? parseInt(numberMatch[1], 10) : 0;
+
+  return { number, url };
+}
+
+/**
+ * Get pull request information
+ */
+export async function getPullRequest(workDir: string, prNumber: number): Promise<PRInfo> {
+  const { stdout } = await execa('gh', [
+    'pr', 'view', prNumber.toString(),
+    '--json', 'number,url,title,state,headRefName,baseRefName,additions,deletions,changedFiles',
+  ], { cwd: workDir });
+
+  const data = JSON.parse(stdout);
+
+  return {
+    number: data.number,
+    url: data.url,
+    title: data.title,
+    state: data.state.toLowerCase() as PRInfo['state'],
+    headBranch: data.headRefName,
+    baseBranch: data.baseRefName,
+    additions: data.additions,
+    deletions: data.deletions,
+    changedFiles: data.changedFiles,
+  };
+}
+
+/**
+ * List open pull requests
+ */
+export async function listPullRequests(workDir: string, state: 'open' | 'closed' | 'all' = 'open'): Promise<PRInfo[]> {
+  const { stdout } = await execa('gh', [
+    'pr', 'list',
+    '--state', state,
+    '--json', 'number,url,title,state,headRefName,baseRefName,additions,deletions,changedFiles',
+  ], { cwd: workDir });
+
+  const data = JSON.parse(stdout) as Array<{
+    number: number;
+    url: string;
+    title: string;
+    state: string;
+    headRefName: string;
+    baseRefName: string;
+    additions: number;
+    deletions: number;
+    changedFiles: number;
+  }>;
+
+  return data.map(pr => ({
+    number: pr.number,
+    url: pr.url,
+    title: pr.title,
+    state: pr.state.toLowerCase() as PRInfo['state'],
+    headBranch: pr.headRefName,
+    baseBranch: pr.baseRefName,
+    additions: pr.additions,
+    deletions: pr.deletions,
+    changedFiles: pr.changedFiles,
+  }));
+}
+
+/**
+ * Add a comment to a pull request
+ */
+export async function commentOnPullRequest(
+  workDir: string,
+  prNumber: number,
+  body: string
+): Promise<void> {
+  await execa('gh', [
+    'pr', 'comment', prNumber.toString(),
+    '--body', body,
+  ], { cwd: workDir });
+}
+
+/**
+ * Submit a review on a pull request
+ */
+export async function reviewPullRequest(
+  workDir: string,
+  prNumber: number,
+  review: PRReview
+): Promise<void> {
+  const args = [
+    'pr', 'review', prNumber.toString(),
+  ];
+
+  switch (review.state) {
+    case 'APPROVED':
+      args.push('--approve');
+      break;
+    case 'CHANGES_REQUESTED':
+      args.push('--request-changes');
+      break;
+    case 'COMMENTED':
+      args.push('--comment');
+      break;
+  }
+
+  if (review.body) {
+    args.push('--body', review.body);
+  }
+
+  await execa('gh', args, { cwd: workDir });
+}
+
+/**
+ * Merge a pull request
+ */
+export async function mergePullRequest(
+  workDir: string,
+  prNumber: number,
+  options: {
+    method?: 'merge' | 'squash' | 'rebase';
+    deleteAfterMerge?: boolean;
+  } = {}
+): Promise<void> {
+  const args = ['pr', 'merge', prNumber.toString(), '--auto'];
+
+  switch (options.method) {
+    case 'squash':
+      args.push('--squash');
+      break;
+    case 'rebase':
+      args.push('--rebase');
+      break;
+    default:
+      args.push('--merge');
+  }
+
+  if (options.deleteAfterMerge !== false) {
+    args.push('--delete-branch');
+  }
+
+  await execa('gh', args, { cwd: workDir });
+}
+
+/**
+ * Close a pull request
+ */
+export async function closePullRequest(workDir: string, prNumber: number): Promise<void> {
+  await execa('gh', ['pr', 'close', prNumber.toString()], { cwd: workDir });
+}
+
+/**
+ * Get PR diff
+ */
+export async function getPullRequestDiff(workDir: string, prNumber: number): Promise<string> {
+  const { stdout } = await execa('gh', [
+    'pr', 'diff', prNumber.toString(),
+  ], { cwd: workDir });
+
+  return stdout;
+}
+
+/**
+ * Get PR reviews
+ */
+export async function getPullRequestReviews(workDir: string, prNumber: number): Promise<Array<{
+  author: string;
+  state: string;
+  body: string;
+}>> {
+  const { stdout } = await execa('gh', [
+    'pr', 'view', prNumber.toString(),
+    '--json', 'reviews',
+  ], { cwd: workDir });
+
+  const data = JSON.parse(stdout);
+  return data.reviews || [];
+}

package/src/git/index.ts

@@ -0,0 +1,3 @@
+export * from './github.js';
+export * from './submodules.js';
+export * from './branches.js';

package/src/git/submodules.ts

@@ -0,0 +1,141 @@
+import { execa } from 'execa';
+import { existsSync } from 'fs';
+import { join } from 'path';
+
+export interface SubmoduleInfo {
+  path: string;
+  url: string;
+  branch?: string;
+  commit: string;
+}
+
+/**
+ * Add a git submodule
+ */
+export async function addSubmodule(
+  rootDir: string,
+  url: string,
+  path: string,
+  branch: string = 'main'
+): Promise<void> {
+  const fullPath = join(rootDir, path);
+
+  if (existsSync(fullPath)) {
+    throw new Error(`Path already exists: ${fullPath}`);
+  }
+
+  await execa('git', ['submodule', 'add', '-b', branch, url, path], {
+    cwd: rootDir,
+  });
+}
+
+/**
+ * Initialize submodules
+ */
+export async function initSubmodules(rootDir: string): Promise<void> {
+  await execa('git', ['submodule', 'init'], { cwd: rootDir });
+}
+
+/**
+ * Update submodules
+ */
+export async function updateSubmodules(rootDir: string, recursive: boolean = true): Promise<void> {
+  const args = ['submodule', 'update'];
+  if (recursive) {
+    args.push('--recursive');
+  }
+  await execa('git', args, { cwd: rootDir });
+}
+
+/**
+ * Initialize and update submodules
+ */
+export async function initAndUpdateSubmodules(rootDir: string): Promise<void> {
+  await execa('git', ['submodule', 'update', '--init', '--recursive'], {
+    cwd: rootDir,
+  });
+}
+
+/**
+ * Remove a submodule
+ */
+export async function removeSubmodule(rootDir: string, path: string): Promise<void> {
+  // Deinitialize the submodule
+  await execa('git', ['submodule', 'deinit', '-f', path], { cwd: rootDir });
+
+  // Remove from .git/modules
+  await execa('git', ['rm', '-f', path], { cwd: rootDir });
+}
+
+/**
+ * List all submodules
+ */
+export async function listSubmodules(rootDir: string): Promise<SubmoduleInfo[]> {
+  try {
+    const { stdout } = await execa('git', ['submodule', 'status'], {
+      cwd: rootDir,
+    });
+
+    if (!stdout.trim()) {
+      return [];
+    }
+
+    const submodules: SubmoduleInfo[] = [];
+
+    for (const line of stdout.split('\n')) {
+      const match = line.match(/^[\s+-]?([a-f0-9]+)\s+(\S+)(?:\s+\((.+)\))?/);
+      if (match) {
+        const [, commit, path, branch] = match;
+        submodules.push({
+          path,
+          url: await getSubmoduleUrl(rootDir, path),
+          branch: branch?.replace('heads/', ''),
+          commit,
+        });
+      }
+    }
+
+    return submodules;
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Get the URL of a submodule
+ */
+export async function getSubmoduleUrl(rootDir: string, path: string): Promise<string> {
+  try {
+    const { stdout } = await execa('git', [
+      'config', '--file', '.gitmodules',
+      `submodule.${path}.url`,
+    ], { cwd: rootDir });
+    return stdout.trim();
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * Check if a path is a submodule
+ */
+export async function isSubmodule(rootDir: string, path: string): Promise<boolean> {
+  const submodules = await listSubmodules(rootDir);
+  return submodules.some(s => s.path === path);
+}
+
+/**
+ * Sync submodule URLs
+ */
+export async function syncSubmodules(rootDir: string): Promise<void> {
+  await execa('git', ['submodule', 'sync'], { cwd: rootDir });
+}
+
+/**
+ * Fetch updates for all submodules
+ */
+export async function fetchSubmodules(rootDir: string): Promise<void> {
+  await execa('git', ['submodule', 'foreach', 'git', 'fetch'], {
+    cwd: rootDir,
+  });
+}

package/src/index.ts

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { spawnSync } from 'child_process';
+import {
+  initCommand,
+  configCommand,
+  addRepoCommand,
+  teamsCommand,
+  reqCommand,
+  statusCommand,
+  agentsCommand,
+  storiesCommand,
+  escalationsCommand,
+  resumeCommand,
+  assignCommand,
+  nukeCommand,
+  msgCommand,
+  myStoriesCommand,
+  prCommand,
+  managerCommand,
+} from './cli/commands/index.js';
+
+const program = new Command();
+
+program
+  .name('hive')
+  .description('AI Agent Orchestrator - Manage agile software development teams of AI agents')
+  .version('0.1.0');
+
+// Core commands
+program.addCommand(initCommand);
+program.addCommand(configCommand);
+
+// Repository and team management
+program.addCommand(addRepoCommand);
+program.addCommand(teamsCommand);
+
+// Requirement and workflow
+program.addCommand(reqCommand);
+program.addCommand(statusCommand);
+program.addCommand(resumeCommand);
+program.addCommand(assignCommand);
+
+// Entity management
+program.addCommand(agentsCommand);
+program.addCommand(storiesCommand);
+program.addCommand(escalationsCommand);
+
+// Destructive operations
+program.addCommand(nukeCommand);
+
+// Communication
+program.addCommand(msgCommand);
+
+// Agent workflow
+program.addCommand(myStoriesCommand);
+
+// PR and merge queue
+program.addCommand(prCommand);
+
+// Manager (micromanager daemon)
+program.addCommand(managerCommand);
+
+// Dashboard command
+program
+  .command('dashboard')
+  .description('Open TUI dashboard')
+  .option('-r, --refresh <ms>', 'Refresh interval in milliseconds', '5000')
+  .action(async (options: { refresh: string }) => {
+    try {
+      // Ensure higher Node heap specifically for the dashboard by re-spawning with --max-old-space-size if not already set
+      const hasHeapFlag = process.execArgv.some(arg => arg.startsWith('--max-old-space-size'));
+      const desiredMb = parseInt(process.env.HIVE_DASHBOARD_HEAP_MB || '4096', 10);
+
+      if (!hasHeapFlag) {
+        const args = [`--max-old-space-size=${desiredMb}`, process.argv[1], 'dashboard', '--refresh', String(options.refresh)];
+        const result = spawnSync(process.execPath, args, { stdio: 'inherit', env: process.env });
+        process.exit(result.status === null ? 1 : result.status);
+      }
+
+      const { startDashboard } = await import('./cli/dashboard/index.js');
+      startDashboard({ refreshInterval: parseInt(options.refresh, 10) });
+    } catch (err) {
+      console.error(chalk.red('Failed to start dashboard:'), err);
+      console.log(chalk.gray('Make sure blessed is installed: npm install blessed'));
+      process.exit(1);
+    }
+  });
+
+// Parse and run
+program.parse();

package/src/llm/anthropic.ts

@@ -0,0 +1,134 @@
+import Anthropic from '@anthropic-ai/sdk';
+import type { LLMProvider, Message, CompletionOptions, CompletionResult } from './provider.js';
+import { withTimeout } from '../utils/timeout.js';
+
+export class AnthropicProvider implements LLMProvider {
+  name = 'anthropic';
+  private client: Anthropic;
+  private model: string;
+  private defaultMaxTokens: number;
+  private defaultTemperature: number;
+
+  constructor(options: {
+    apiKey?: string;
+    model?: string;
+    maxTokens?: number;
+    temperature?: number;
+  } = {}) {
+    this.client = new Anthropic({
+      apiKey: options.apiKey || process.env.ANTHROPIC_API_KEY,
+    });
+    this.model = options.model || 'claude-sonnet-4-20250514';
+    this.defaultMaxTokens = options.maxTokens || 8000;
+    this.defaultTemperature = options.temperature ?? 0.5;
+  }
+
+  async complete(messages: Message[], options?: CompletionOptions): Promise<CompletionResult> {
+    // Extract system message if present
+    const systemMessage = messages.find(m => m.role === 'system');
+    const conversationMessages = messages.filter(m => m.role !== 'system');
+
+    const apiCall = async () => {
+      const response = await this.client.messages.create({
+        model: this.model,
+        max_tokens: options?.maxTokens ?? this.defaultMaxTokens,
+        temperature: options?.temperature ?? this.defaultTemperature,
+        system: systemMessage?.content,
+        messages: conversationMessages.map(m => ({
+          role: m.role as 'user' | 'assistant',
+          content: m.content,
+        })),
+        stop_sequences: options?.stopSequences,
+      });
+
+      const content = response.content[0];
+      const textContent = content.type === 'text' ? content.text : '';
+
+      return {
+        content: textContent,
+        stopReason: this.mapStopReason(response.stop_reason),
+        usage: {
+          inputTokens: response.usage.input_tokens,
+          outputTokens: response.usage.output_tokens,
+        },
+      };
+    };
+
+    // Apply timeout if specified
+    if (options?.timeoutMs) {
+      return withTimeout(
+        apiCall(),
+        options.timeoutMs,
+        `Anthropic API call timed out after ${options.timeoutMs}ms`
+      );
+    }
+
+    return apiCall();
+  }
+
+  async *streamComplete(messages: Message[], options?: CompletionOptions): AsyncIterable<string> {
+    const systemMessage = messages.find(m => m.role === 'system');
+    const conversationMessages = messages.filter(m => m.role !== 'system');
+    // Capture instance properties to avoid 'this' binding issues in generator
+    const client = this.client;
+    const model = this.model;
+    const defaultMaxTokens = this.defaultMaxTokens;
+    const defaultTemperature = this.defaultTemperature;
+
+    const streamGenerator = async function* () {
+      const stream = client.messages.stream({
+        model: model,
+        max_tokens: options?.maxTokens ?? defaultMaxTokens,
+        temperature: options?.temperature ?? defaultTemperature,
+        system: systemMessage?.content,
+        messages: conversationMessages.map(m => ({
+          role: m.role as 'user' | 'assistant',
+          content: m.content,
+        })),
+        stop_sequences: options?.stopSequences,
+      });
+
+      for await (const event of stream) {
+        if (event.type === 'content_block_delta' && event.delta.type === 'text_delta') {
+          yield event.delta.text;
+        }
+      }
+    };
+
+    // Apply timeout if specified
+    if (options?.timeoutMs) {
+      const timeoutPromise = new Promise<never>((_, reject) => {
+        setTimeout(() => {
+          reject(new Error(`Anthropic streaming API call timed out after ${options.timeoutMs}ms`));
+        }, options.timeoutMs);
+      });
+
+      const generator = streamGenerator();
+
+      while (true) {
+        const result = await Promise.race([
+          generator.next(),
+          timeoutPromise
+        ]);
+
+        if (result.done) break;
+        yield result.value;
+      }
+    } else {
+      yield* streamGenerator();
+    }
+  }
+
+  private mapStopReason(reason: string | null): CompletionResult['stopReason'] {
+    switch (reason) {
+      case 'end_turn':
+        return 'end_turn';
+      case 'max_tokens':
+        return 'max_tokens';
+      case 'stop_sequence':
+        return 'stop_sequence';
+      default:
+        return 'error';
+    }
+  }
+}

package/src/llm/index.ts

@@ -0,0 +1,26 @@
+import type { LLMProvider, ProviderConfig } from './provider.js';
+import { AnthropicProvider } from './anthropic.js';
+import { OpenAIProvider } from './openai.js';
+
+export * from './provider.js';
+export { AnthropicProvider } from './anthropic.js';
+export { OpenAIProvider } from './openai.js';
+
+export function createProvider(config: ProviderConfig): LLMProvider {
+  switch (config.provider) {
+    case 'anthropic':
+      return new AnthropicProvider({
+        model: config.model,
+        maxTokens: config.maxTokens,
+        temperature: config.temperature,
+      });
+    case 'openai':
+      return new OpenAIProvider({
+        model: config.model,
+        maxTokens: config.maxTokens,
+        temperature: config.temperature,
+      });
+    default:
+      throw new Error(`Unknown provider: ${config.provider}`);
+  }
+}