hungry-ghost-hive 0.3.0

package/src/cli-runtimes/index.test.ts

@@ -0,0 +1,261 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import {
+  getCliRuntimeBuilder,
+  validateCliBinary,
+  validateCliRuntime,
+  ClaudeRuntimeBuilder,
+  CodexRuntimeBuilder,
+  GeminiRuntimeBuilder,
+} from './index.js';
+
+vi.mock('execa');
+
+describe('CLI Runtime Builders', () => {
+  describe('ClaudeRuntimeBuilder', () => {
+    it('should build spawn command with correct flags', () => {
+      const builder = new ClaudeRuntimeBuilder();
+      const command = builder.buildSpawnCommand('claude-sonnet-4-20250514');
+
+      expect(command).toEqual([
+        'claude',
+        '--dangerously-skip-permissions',
+        '--model',
+        'claude-sonnet-4-20250514',
+      ]);
+    });
+
+    it('should build resume command with session ID', () => {
+      const builder = new ClaudeRuntimeBuilder();
+      const command = builder.buildResumeCommand('claude-sonnet-4-20250514', 'session-123');
+
+      expect(command).toEqual([
+        'claude',
+        '--dangerously-skip-permissions',
+        '--model',
+        'claude-sonnet-4-20250514',
+        '--resume',
+        'session-123',
+      ]);
+    });
+
+    it('should return correct auto-approval flag', () => {
+      const builder = new ClaudeRuntimeBuilder();
+      expect(builder.getAutoApprovalFlag()).toBe('--dangerously-skip-permissions');
+    });
+
+    it('should return correct model flag', () => {
+      const builder = new ClaudeRuntimeBuilder();
+      expect(builder.getModelFlag()).toBe('--model');
+    });
+  });
+
+  describe('CodexRuntimeBuilder', () => {
+    it('should build spawn command with correct flags', () => {
+      const builder = new CodexRuntimeBuilder();
+      const command = builder.buildSpawnCommand('gpt-4o-mini');
+
+      expect(command).toEqual([
+        'codex',
+        '--full-auto',
+        '--model',
+        'gpt-4o-mini',
+      ]);
+    });
+
+    it('should build resume command with session ID', () => {
+      const builder = new CodexRuntimeBuilder();
+      const command = builder.buildResumeCommand('gpt-4o-mini', 'session-456');
+
+      expect(command).toEqual([
+        'codex',
+        '--full-auto',
+        '--model',
+        'gpt-4o-mini',
+        '--resume',
+        'session-456',
+      ]);
+    });
+
+    it('should return correct auto-approval flag', () => {
+      const builder = new CodexRuntimeBuilder();
+      expect(builder.getAutoApprovalFlag()).toBe('--full-auto');
+    });
+
+    it('should return correct model flag', () => {
+      const builder = new CodexRuntimeBuilder();
+      expect(builder.getModelFlag()).toBe('--model');
+    });
+  });
+
+  describe('GeminiRuntimeBuilder', () => {
+    it('should build spawn command with correct flags', () => {
+      const builder = new GeminiRuntimeBuilder();
+      const command = builder.buildSpawnCommand('gemini-2.0-flash-exp');
+
+      expect(command).toEqual([
+        'gemini',
+        '--model',
+        'gemini-2.0-flash-exp',
+        '--sandbox',
+        'none',
+      ]);
+    });
+
+    it('should build resume command with session ID', () => {
+      const builder = new GeminiRuntimeBuilder();
+      const command = builder.buildResumeCommand('gemini-2.0-flash-exp', 'session-789');
+
+      expect(command).toEqual([
+        'gemini',
+        '--model',
+        'gemini-2.0-flash-exp',
+        '--sandbox',
+        'none',
+        '--resume',
+        'session-789',
+      ]);
+    });
+
+    it('should return correct auto-approval flag', () => {
+      const builder = new GeminiRuntimeBuilder();
+      expect(builder.getAutoApprovalFlag()).toBe('--sandbox');
+    });
+
+    it('should return correct model flag', () => {
+      const builder = new GeminiRuntimeBuilder();
+      expect(builder.getModelFlag()).toBe('--model');
+    });
+  });
+
+  describe('getCliRuntimeBuilder', () => {
+    it('should return ClaudeRuntimeBuilder for claude type', () => {
+      const builder = getCliRuntimeBuilder('claude');
+      expect(builder).toBeInstanceOf(ClaudeRuntimeBuilder);
+    });
+
+    it('should return CodexRuntimeBuilder for codex type', () => {
+      const builder = getCliRuntimeBuilder('codex');
+      expect(builder).toBeInstanceOf(CodexRuntimeBuilder);
+    });
+
+    it('should return GeminiRuntimeBuilder for gemini type', () => {
+      const builder = getCliRuntimeBuilder('gemini');
+      expect(builder).toBeInstanceOf(GeminiRuntimeBuilder);
+    });
+
+    it('should throw error for unknown runtime type', () => {
+      expect(() => {
+        // @ts-expect-error Testing invalid input
+        getCliRuntimeBuilder('unknown');
+      }).toThrow('Unknown CLI runtime type: unknown');
+    });
+  });
+
+  describe('validateCliBinary', () => {
+    beforeEach(() => {
+      vi.clearAllMocks();
+    });
+
+    afterEach(() => {
+      vi.restoreAllMocks();
+    });
+
+    it('should return true when binary exists', async () => {
+      const { execa } = await import('execa');
+      vi.mocked(execa).mockResolvedValue({
+        stdout: '/usr/local/bin/claude',
+        stderr: '',
+        exitCode: 0,
+        command: 'which claude',
+        escapedCommand: 'which claude',
+        failed: false,
+        timedOut: false,
+        isCanceled: false,
+        killed: false,
+      } as any);
+
+      const result = await validateCliBinary('claude');
+      expect(result).toBe(true);
+    });
+
+    it('should return false when binary does not exist', async () => {
+      const { execa } = await import('execa');
+      vi.mocked(execa).mockRejectedValue(new Error('Command failed'));
+
+      const result = await validateCliBinary('nonexistent');
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('validateCliRuntime', () => {
+    beforeEach(() => {
+      vi.clearAllMocks();
+    });
+
+    afterEach(() => {
+      vi.restoreAllMocks();
+    });
+
+    it('should validate claude runtime', async () => {
+      const { execa } = await import('execa');
+      vi.mocked(execa).mockResolvedValue({
+        stdout: '/usr/local/bin/claude',
+        stderr: '',
+        exitCode: 0,
+        command: 'which claude',
+        escapedCommand: 'which claude',
+        failed: false,
+        timedOut: false,
+        isCanceled: false,
+        killed: false,
+      } as any);
+
+      const result = await validateCliRuntime('claude');
+      expect(result).toBe(true);
+    });
+
+    it('should validate codex runtime', async () => {
+      const { execa } = await import('execa');
+      vi.mocked(execa).mockResolvedValue({
+        stdout: '/usr/local/bin/codex',
+        stderr: '',
+        exitCode: 0,
+        command: 'which codex',
+        escapedCommand: 'which codex',
+        failed: false,
+        timedOut: false,
+        isCanceled: false,
+        killed: false,
+      } as any);
+
+      const result = await validateCliRuntime('codex');
+      expect(result).toBe(true);
+    });
+
+    it('should validate gemini runtime', async () => {
+      const { execa } = await import('execa');
+      vi.mocked(execa).mockResolvedValue({
+        stdout: '/usr/local/bin/gemini',
+        stderr: '',
+        exitCode: 0,
+        command: 'which gemini',
+        escapedCommand: 'which gemini',
+        failed: false,
+        timedOut: false,
+        isCanceled: false,
+        killed: false,
+      } as any);
+
+      const result = await validateCliRuntime('gemini');
+      expect(result).toBe(true);
+    });
+
+    it('should return false for missing runtime binary', async () => {
+      const { execa } = await import('execa');
+      vi.mocked(execa).mockRejectedValue(new Error('Command failed'));
+
+      const result = await validateCliRuntime('claude');
+      expect(result).toBe(false);
+    });
+  });
+});

package/src/cli-runtimes/index.ts

@@ -0,0 +1,52 @@
+import { execa } from 'execa';
+import { CliRuntimeType, CliRuntimeBuilder } from './types.js';
+import { ClaudeRuntimeBuilder } from './claude.js';
+import { CodexRuntimeBuilder } from './codex.js';
+import { GeminiRuntimeBuilder } from './gemini.js';
+
+/**
+ * Factory function to get the appropriate CLI runtime builder
+ * @param runtimeType - The type of CLI runtime to use
+ * @returns The corresponding runtime builder instance
+ * @throws Error if the runtime type is unknown
+ */
+export function getCliRuntimeBuilder(runtimeType: CliRuntimeType): CliRuntimeBuilder {
+  switch (runtimeType) {
+    case 'claude':
+      return new ClaudeRuntimeBuilder();
+    case 'codex':
+      return new CodexRuntimeBuilder();
+    case 'gemini':
+      return new GeminiRuntimeBuilder();
+    default:
+      throw new Error(`Unknown CLI runtime type: ${runtimeType}`);
+  }
+}
+
+/**
+ * Validate that a CLI binary is available in the system PATH
+ * @param binary - The name of the binary to check
+ * @returns Promise that resolves to true if binary exists, false otherwise
+ */
+export async function validateCliBinary(binary: string): Promise<boolean> {
+  try {
+    await execa('which', [binary]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Validate that the CLI runtime binary is available
+ * @param runtimeType - The type of CLI runtime to validate
+ * @returns Promise that resolves to true if binary exists, false otherwise
+ */
+export async function validateCliRuntime(runtimeType: CliRuntimeType): Promise<boolean> {
+  return validateCliBinary(runtimeType);
+}
+
+export type { CliRuntimeType, CliRuntimeBuilder };
+export { ClaudeRuntimeBuilder } from './claude.js';
+export { CodexRuntimeBuilder } from './codex.js';
+export { GeminiRuntimeBuilder } from './gemini.js';

package/src/cli-runtimes/types.ts

@@ -0,0 +1,30 @@
+export type CliRuntimeType = 'claude' | 'codex' | 'gemini';
+
+export interface CliRuntimeBuilder {
+  /**
+   * Build command array for spawning a new agent session
+   * @param model - The model identifier to use
+   * @returns Array of command and arguments suitable for spawn
+   */
+  buildSpawnCommand(model: string): string[];
+
+  /**
+   * Build command array for resuming an existing agent session
+   * @param model - The model identifier to use
+   * @param sessionId - The session ID to resume
+   * @returns Array of command and arguments suitable for spawn
+   */
+  buildResumeCommand(model: string, sessionId: string): string[];
+
+  /**
+   * Get the auto-approval flag for this CLI runtime
+   * @returns The flag string that enables auto-approval mode
+   */
+  getAutoApprovalFlag(): string;
+
+  /**
+   * Get the model flag for this CLI runtime
+   * @returns The flag string used to specify the model
+   */
+  getModelFlag(): string;
+}

package/src/config/index.ts

@@ -0,0 +1,2 @@
+export * from './schema.js';
+export * from './loader.js';

package/src/config/loader.ts

@@ -0,0 +1,89 @@
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { parse, stringify } from 'yaml';
+import { HiveConfigSchema, type HiveConfig, generateDefaultConfigYaml } from './schema.js';
+
+export class ConfigError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'ConfigError';
+  }
+}
+
+export function loadConfig(hiveDir: string): HiveConfig {
+  const configPath = join(hiveDir, 'hive.config.yaml');
+
+  if (!existsSync(configPath)) {
+    throw new ConfigError(`Config file not found: ${configPath}`);
+  }
+
+  const content = readFileSync(configPath, 'utf-8');
+  const rawConfig = parse(content);
+
+  const result = HiveConfigSchema.safeParse(rawConfig);
+
+  if (!result.success) {
+    const errors = result.error.errors.map(e => `  - ${e.path.join('.')}: ${e.message}`).join('\n');
+    throw new ConfigError(`Invalid configuration:\n${errors}`);
+  }
+
+  return result.data;
+}
+
+export function saveConfig(hiveDir: string, config: HiveConfig): void {
+  const configPath = join(hiveDir, 'hive.config.yaml');
+  const content = stringify(config, { indent: 2 });
+  writeFileSync(configPath, content, 'utf-8');
+}
+
+export function createDefaultConfig(hiveDir: string): HiveConfig {
+  const configPath = join(hiveDir, 'hive.config.yaml');
+  const content = generateDefaultConfigYaml();
+  writeFileSync(configPath, content, 'utf-8');
+  return loadConfig(hiveDir);
+}
+
+export function configExists(hiveDir: string): boolean {
+  const configPath = join(hiveDir, 'hive.config.yaml');
+  return existsSync(configPath);
+}
+
+export function getConfigValue(config: HiveConfig, path: string): unknown {
+  const parts = path.split('.');
+  let current: unknown = config;
+
+  for (const part of parts) {
+    if (current === null || current === undefined || typeof current !== 'object') {
+      return undefined;
+    }
+    current = (current as Record<string, unknown>)[part];
+  }
+
+  return current;
+}
+
+export function setConfigValue(config: HiveConfig, path: string, value: unknown): HiveConfig {
+  const parts = path.split('.');
+  const newConfig = JSON.parse(JSON.stringify(config)) as HiveConfig;
+
+  let current = newConfig as Record<string, unknown>;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (current[part] === undefined || typeof current[part] !== 'object') {
+      current[part] = {};
+    }
+    current = current[part] as Record<string, unknown>;
+  }
+
+  const lastPart = parts[parts.length - 1];
+  current[lastPart] = value;
+
+  // Validate the new config
+  const result = HiveConfigSchema.safeParse(newConfig);
+  if (!result.success) {
+    const errors = result.error.errors.map(e => `  - ${e.path.join('.')}: ${e.message}`).join('\n');
+    throw new ConfigError(`Invalid configuration after update:\n${errors}`);
+  }
+
+  return result.data;
+}

package/src/config/schema.test.ts

@@ -0,0 +1,135 @@
+import { describe, it, expect } from 'vitest';
+import { HiveConfigSchema, DEFAULT_CONFIG } from './schema.js';
+
+describe('HiveConfigSchema', () => {
+  it('should validate default config', () => {
+    const result = HiveConfigSchema.safeParse(DEFAULT_CONFIG);
+    expect(result.success).toBe(true);
+  });
+
+  it('should accept valid config with cli_tool', () => {
+    const config = {
+      version: '1.0',
+      models: {
+        tech_lead: {
+          provider: 'anthropic',
+          model: 'claude-opus-4-20250514',
+          max_tokens: 16000,
+          temperature: 0.7,
+          cli_tool: 'claude',
+        },
+        senior: {
+          provider: 'anthropic',
+          model: 'claude-sonnet-4-20250514',
+          max_tokens: 8000,
+          temperature: 0.5,
+          cli_tool: 'claude',
+        },
+        intermediate: {
+          provider: 'anthropic',
+          model: 'claude-haiku-3-5-20241022',
+          max_tokens: 4000,
+          temperature: 0.3,
+          cli_tool: 'claude',
+        },
+        junior: {
+          provider: 'openai',
+          model: 'gpt-4o-mini',
+          max_tokens: 4000,
+          temperature: 0.2,
+          cli_tool: 'codex',
+        },
+        qa: {
+          provider: 'anthropic',
+          model: 'claude-sonnet-4-20250514',
+          max_tokens: 8000,
+          temperature: 0.2,
+          cli_tool: 'claude',
+        },
+      },
+      scaling: {
+        senior_capacity: 20,
+        junior_max_complexity: 3,
+        intermediate_max_complexity: 5,
+      },
+      github: {
+        base_branch: 'main',
+      },
+    };
+
+    const result = HiveConfigSchema.safeParse(config);
+    expect(result.success).toBe(true);
+  });
+
+  it('should apply defaults for empty config', () => {
+    const result = HiveConfigSchema.safeParse({});
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.version).toBe('1.0');
+      expect(result.data.scaling.senior_capacity).toBe(20);
+    }
+  });
+
+  it('should reject invalid scaling values', () => {
+    const config = {
+      scaling: {
+        junior_max_complexity: 15, // Invalid: max is 13
+      },
+    };
+
+    const result = HiveConfigSchema.safeParse(config);
+    expect(result.success).toBe(false);
+  });
+
+  it('should accept all valid cli_tool values (claude, codex, gemini)', () => {
+    const tools = ['claude', 'codex', 'gemini'];
+
+    for (const tool of tools) {
+      const config = {
+        models: {
+          junior: {
+            provider: 'openai',
+            model: 'gpt-4o-mini',
+            cli_tool: tool,
+          },
+        },
+      };
+
+      const result = HiveConfigSchema.safeParse(config);
+      expect(result.success).toBe(true);
+    }
+  });
+
+  it('should reject invalid cli_tool values', () => {
+    const config = {
+      models: {
+        junior: {
+          provider: 'openai',
+          model: 'gpt-4o-mini',
+          max_tokens: 4000,
+          temperature: 0.2,
+          cli_tool: 'invalid_tool',
+        },
+      },
+    };
+
+    const result = HiveConfigSchema.safeParse(config);
+    expect(result.success).toBe(false);
+  });
+
+  it('should apply cli_tool default to all tiers', () => {
+    const config = HiveConfigSchema.parse({});
+    expect(config.models.tech_lead.cli_tool).toBe('claude');
+    expect(config.models.senior.cli_tool).toBe('claude');
+    expect(config.models.intermediate.cli_tool).toBe('claude');
+    expect(config.models.junior.cli_tool).toBe('claude');
+    expect(config.models.qa.cli_tool).toBe('claude');
+  });
+
+  it('should export ModelConfig type with cli_tool', () => {
+    const config = DEFAULT_CONFIG;
+    expect(config.models).toBeDefined();
+    expect(config.models.junior.cli_tool).toBe('claude');
+    expect(typeof config.models.junior.cli_tool).toBe('string');
+  });
+});