hungry-ghost-hive 0.3.0

package/src/agents/senior.ts

@@ -0,0 +1,307 @@
+import { BaseAgent, type AgentContext } from './base-agent.js';
+import { getTeamById, type TeamRow } from '../db/queries/teams.js';
+import { getStoriesByTeam, updateStory, type StoryRow } from '../db/queries/stories.js';
+import { createAgent, updateAgent, getTechLead } from '../db/queries/agents.js';
+import { createEscalation } from '../db/queries/escalations.js';
+import { spawnTmuxSession, generateSessionName } from '../tmux/manager.js';
+import { loadConfig } from '../config/index.js';
+import { getCliRuntimeBuilder } from '../cli-runtimes/index.js';
+import { findHiveRoot, getHivePaths } from '../utils/paths.js';
+
+export interface SeniorContext extends AgentContext {
+  teamId: string;
+}
+
+export class SeniorAgent extends BaseAgent {
+  private team: TeamRow | null = null;
+  private assignedStories: StoryRow[] = [];
+
+  constructor(context: SeniorContext) {
+    super(context);
+    if (context.teamId) {
+      this.team = getTeamById(this.db, context.teamId) || null;
+      this.assignedStories = getStoriesByTeam(this.db, context.teamId)
+        .filter(s => ['planned', 'in_progress', 'review'].includes(s.status));
+    }
+  }
+
+  getSystemPrompt(): string {
+    const teamInfo = this.team
+      ? `Team: ${this.team.name}\nRepository: ${this.team.repo_url}\nPath: ${this.team.repo_path}`
+      : 'No team assigned';
+
+    const storiesInfo = this.assignedStories.length > 0
+      ? this.assignedStories.map(s => `- ${s.id}: ${s.title} (${s.status}, complexity: ${s.complexity_score})`).join('\n')
+      : 'No stories assigned';
+
+    return `You are a Senior Developer responsible for a specific team and repository.
+
+## Your Team
+${teamInfo}
+
+## Assigned Stories
+${storiesInfo}
+
+## Your Responsibilities
+1. Conduct codebase analysis when requested
+2. Estimate story complexity accurately
+3. Delegate work based on complexity:
+   - 1-3 points → Delegate to Junior
+   - 4-5 points → Delegate to Intermediate
+   - 6+ points → Handle directly
+4. Review code from delegated work
+5. Handle complex implementations
+6. Escalate blockers to Tech Lead
+
+## Development Guidelines
+- Create feature branches: feature/{story-id}-{slug}
+- Write clean, tested code following existing patterns
+- Update story status as you progress
+- Commit frequently with clear messages
+- If stuck after 2 attempts, escalate
+
+## Current Context
+${this.memoryState.conversationSummary || 'Starting fresh.'}`;
+  }
+
+  async execute(): Promise<void> {
+    if (!this.team) {
+      this.log('CODEBASE_SWEEP_STARTED', 'No team assigned, waiting for assignment');
+      return;
+    }
+
+    this.log('CODEBASE_SWEEP_STARTED', `Analyzing codebase for ${this.team.name}`);
+
+    // Perform codebase sweep
+    await this.analyzeCodebase();
+
+    // Process assigned stories
+    for (const story of this.assignedStories) {
+      if (story.status === 'planned') {
+        await this.processStory(story);
+      } else if (story.status === 'review') {
+        await this.reviewStory(story);
+      }
+    }
+  }
+
+  private async analyzeCodebase(): Promise<void> {
+    const prompt = `Analyze the codebase structure for this repository.
+
+Working directory: ${this.workDir}
+
+Please identify:
+1. Main technology stack
+2. Key directories and their purposes
+3. Coding patterns and conventions used
+4. Testing setup
+5. Build/deployment configuration
+
+This will help with story estimation and implementation.`;
+
+    const analysis = await this.chat(prompt);
+
+    this.memoryState.context.codebaseNotes = analysis;
+    this.saveMemoryState();
+
+    this.log('CODEBASE_SWEEP_COMPLETED', 'Codebase analysis complete', {
+      summary: analysis.substring(0, 200),
+    });
+  }
+
+  private async processStory(story: StoryRow): Promise<void> {
+    const complexity = story.complexity_score || 5;
+
+    this.setCurrentTask(story.id, 'processing');
+    this.log('STORY_STARTED', `Processing story: ${story.title}`, { storyId: story.id });
+
+    if (complexity <= 3) {
+      // Delegate to Junior
+      await this.delegateStory(story, 'junior');
+    } else if (complexity <= 5) {
+      // Delegate to Intermediate
+      await this.delegateStory(story, 'intermediate');
+    } else {
+      // Handle directly
+      await this.implementStory(story);
+    }
+  }
+
+  private async delegateStory(story: StoryRow, agentType: 'junior' | 'intermediate'): Promise<void> {
+    this.log('STORY_ASSIGNED', `Delegating to ${agentType}`, {
+      storyId: story.id,
+      agentType,
+    });
+
+    // Create subordinate agent
+    const subordinate = createAgent(this.db, {
+      type: agentType,
+      teamId: this.teamId,
+    });
+
+    // Spawn tmux session
+    const sessionName = generateSessionName(agentType, this.team?.name);
+    try {
+      // Load config and get CLI runtime settings for the subordinate agent type
+      const hiveRoot = findHiveRoot(this.workDir);
+      if (!hiveRoot) {
+        throw new Error('Hive root not found');
+      }
+      const paths = getHivePaths(hiveRoot);
+      const config = loadConfig(paths.hiveDir);
+      const agentConfig = config.models[agentType];
+      const cliTool = agentConfig.cli_tool;
+      const model = agentConfig.model;
+
+      // Build spawn command using CLI runtime builder (spawn fresh session, will be resumed later)
+      const runtimeBuilder = getCliRuntimeBuilder(cliTool);
+      const commandArray = runtimeBuilder.buildSpawnCommand(model);
+      const command = commandArray.join(' ');
+
+      await spawnTmuxSession({
+        sessionName,
+        workDir: this.workDir,
+        command,
+      });
+
+      updateAgent(this.db, subordinate.id, {
+        tmuxSession: sessionName,
+        status: 'working',
+        currentStoryId: story.id,
+      });
+
+      // Update story assignment
+      updateStory(this.db, story.id, {
+        assignedAgentId: subordinate.id,
+        status: 'in_progress',
+      });
+
+      this.log('AGENT_SPAWNED', `${agentType} spawned for story ${story.id}`, {
+        agentId: subordinate.id,
+        storyId: story.id,
+      });
+    } catch (err) {
+      // If delegation fails, handle it ourselves
+      this.log('STORY_PROGRESS_UPDATE', `Failed to delegate, handling directly: ${err instanceof Error ? err.message : 'Unknown error'}`, {
+        storyId: story.id,
+      });
+      await this.implementStory(story);
+    }
+  }
+
+  private async implementStory(story: StoryRow): Promise<void> {
+    // Update assignment
+    updateStory(this.db, story.id, {
+      assignedAgentId: this.agentId,
+      status: 'in_progress',
+    });
+    updateAgent(this.db, this.agentId, { currentStoryId: story.id });
+
+    // Create feature branch
+    const branchName = `feature/${story.id.toLowerCase()}-${story.title.toLowerCase().replace(/[^a-z0-9]+/g, '-').substring(0, 30)}`;
+
+    this.log('STORY_STARTED', `Implementing: ${story.title}`, { branchName });
+
+    const prompt = `Implement this story:
+
+## Story: ${story.id}
+**Title:** ${story.title}
+
+**Description:**
+${story.description}
+
+**Acceptance Criteria:**
+${story.acceptance_criteria ? JSON.parse(story.acceptance_criteria).join('\n- ') : 'None specified'}
+
+## Instructions
+1. First, create a feature branch: ${branchName}
+2. Analyze the codebase to understand where changes need to be made
+3. Implement the changes following existing patterns
+4. Write/update tests as needed
+5. Commit your changes with clear messages
+6. Report when complete
+
+Let me know when you're ready to proceed or if you have questions.`;
+
+    const response = await this.chat(prompt);
+    this.updateTaskProgress('Implementation started', []);
+
+    // Continue the conversation to complete implementation
+    // In a real scenario, this would be an iterative process
+    this.log('STORY_PROGRESS_UPDATE', response.substring(0, 200), { storyId: story.id });
+
+    // Mark for review when done (simplified)
+    updateStory(this.db, story.id, {
+      branchName,
+      status: 'review',
+    });
+
+    this.log('STORY_COMPLETED', `Implementation complete, ready for review`, {
+      storyId: story.id,
+      branchName,
+    });
+  }
+
+  private async reviewStory(story: StoryRow): Promise<void> {
+    if (story.assigned_agent_id === this.agentId) {
+      // Self-review, move to QA
+      updateStory(this.db, story.id, { status: 'qa' });
+      this.log('STORY_REVIEW_REQUESTED', 'Self-implemented, moving to QA', { storyId: story.id });
+      return;
+    }
+
+    this.log('STORY_REVIEW_REQUESTED', `Reviewing story: ${story.title}`, { storyId: story.id });
+
+    const prompt = `Review the code for this story:
+
+## Story: ${story.id}
+**Title:** ${story.title}
+**Branch:** ${story.branch_name}
+
+Please review:
+1. Code quality and adherence to patterns
+2. Test coverage
+3. Potential bugs or issues
+4. Performance considerations
+
+If issues found, describe them. If approved, confirm.`;
+
+    const review = await this.chat(prompt);
+
+    // Parse review result (simplified)
+    const hasIssues = review.toLowerCase().includes('issue') ||
+                      review.toLowerCase().includes('problem') ||
+                      review.toLowerCase().includes('fix');
+
+    if (hasIssues) {
+      // Send back for fixes
+      updateStory(this.db, story.id, { status: 'in_progress' });
+      this.log('STORY_PROGRESS_UPDATE', 'Review issues found, sent back for fixes', {
+        storyId: story.id,
+        review: review.substring(0, 200),
+      });
+    } else {
+      // Approve and move to QA
+      updateStory(this.db, story.id, { status: 'qa' });
+      this.log('STORY_REVIEW_REQUESTED', 'Review passed, moving to QA', { storyId: story.id });
+    }
+  }
+
+  async escalateToTechLead(reason: string): Promise<void> {
+    const techLead = getTechLead(this.db);
+
+    const escalation = createEscalation(this.db, {
+      storyId: this.memoryState.currentTask?.storyId,
+      fromAgentId: this.agentId,
+      toAgentId: techLead?.id,
+      reason,
+    });
+
+    this.log('ESCALATION_CREATED', reason, {
+      escalationId: escalation.id,
+    });
+
+    this.updateStatus('blocked');
+    this.addBlocker(`Escalated to Tech Lead: ${reason}`);
+  }
+}

package/src/agents/tech-lead.ts

@@ -0,0 +1,324 @@
+import { BaseAgent, type AgentContext } from './base-agent.js';
+import { getAllTeams, type TeamRow } from '../db/queries/teams.js';
+import { getRequirementById, updateRequirement, type RequirementRow } from '../db/queries/requirements.js';
+import { createStory, updateStory, getStoryById } from '../db/queries/stories.js';
+import { createAgent, getAgentsByType, updateAgent } from '../db/queries/agents.js';
+import { createEscalation } from '../db/queries/escalations.js';
+import { spawnTmuxSession, generateSessionName } from '../tmux/manager.js';
+import { queryAll } from '../db/client.js';
+import { addStoryDependency } from '../db/queries/stories.js';
+import { loadConfig } from '../config/index.js';
+import { getCliRuntimeBuilder } from '../cli-runtimes/index.js';
+import { findHiveRoot, getHivePaths } from '../utils/paths.js';
+
+export interface TechLeadContext extends AgentContext {
+  requirementId?: string;
+}
+
+export class TechLeadAgent extends BaseAgent {
+  private teams: TeamRow[] = [];
+  private requirementId?: string;
+  private requirement?: RequirementRow;
+
+  constructor(context: TechLeadContext) {
+    super(context);
+    this.requirementId = context.requirementId;
+    this.teams = getAllTeams(this.db);
+
+    if (this.requirementId) {
+      this.requirement = getRequirementById(this.db, this.requirementId);
+    }
+  }
+
+  getSystemPrompt(): string {
+    const teamList = this.teams
+      .map(t => `- ${t.name} (${t.repo_path}): ${t.repo_url}`)
+      .join('\n');
+
+    return `You are the Tech Lead of Hive, an AI development team orchestrator.
+
+## Your Role
+You coordinate multiple autonomous teams, each responsible for a specific service/repository. You are the strategic decision maker who:
+1. Analyzes requirements and breaks them into implementable stories
+2. Identifies affected teams and cross-repo dependencies
+3. Coordinates with Senior developers for estimation and planning
+4. Manages escalations from teams
+5. Ensures consistent progress across all teams
+
+## Teams Under Your Coordination
+${teamList || 'No teams configured yet.'}
+
+## Current Context
+${this.memoryState.conversationSummary || 'Starting fresh.'}
+
+## Guidelines
+- Break down requirements into atomic, testable stories
+- Each story should have clear acceptance criteria
+- Identify dependencies between stories across repos
+- Estimate complexity using Fibonacci scale (1, 2, 3, 5, 8, 13)
+- Delegate appropriately:
+  - 1-3 points: Junior can handle
+  - 4-5 points: Intermediate level
+  - 6+ points: Senior should handle directly
+
+## Communication
+You communicate via this conversation. Log important decisions and progress updates.
+When you need to spawn Senior agents for team-specific work, describe what you need and I'll help coordinate.
+
+## Escalation Protocol
+Escalate to human (me) only for:
+- Ambiguous requirements that need clarification
+- Architectural decisions with significant trade-offs
+- Security concerns
+- External dependency blockers`;
+  }
+
+  async execute(): Promise<void> {
+    if (!this.requirement) {
+      this.log('PLANNING_STARTED', 'Tech Lead ready, waiting for requirement');
+      return;
+    }
+
+    this.log('PLANNING_STARTED', `Analyzing requirement: ${this.requirement.title}`);
+
+    // Analyze the requirement
+    const analysis = await this.analyzeRequirement();
+
+    // If we need human input, escalate
+    if (analysis.needsHumanInput) {
+      await this.escalateToHuman(analysis.escalationReason || 'Clarification needed');
+      return;
+    }
+
+    // Create stories based on analysis
+    const stories = await this.createStories(analysis);
+
+    // Spawn Seniors to estimate and potentially begin work
+    await this.coordinateWithSeniors(stories);
+
+    // Update requirement status
+    updateRequirement(this.db, this.requirement.id, { status: 'planned' });
+    this.log('PLANNING_COMPLETED', `Created ${stories.length} stories`);
+  }
+
+  private async analyzeRequirement(): Promise<{
+    affectedTeams: string[];
+    stories: Array<{
+      title: string;
+      description: string;
+      acceptanceCriteria: string[];
+      teamName: string;
+      estimatedComplexity: number;
+      dependencies?: string[];
+    }>;
+    needsHumanInput: boolean;
+    escalationReason?: string;
+  }> {
+    const prompt = `Analyze this requirement and create a plan:
+
+## Requirement
+Title: ${this.requirement!.title}
+
+Description:
+${this.requirement!.description}
+
+## Available Teams
+${this.teams.map(t => `- ${t.name}: ${t.repo_path}`).join('\n')}
+
+## Instructions
+1. Identify which teams are affected
+2. Break down into atomic stories (each completable in a single session)
+3. For each story provide:
+   - Title (concise, action-oriented)
+   - Description (what needs to be done)
+   - Acceptance criteria (testable conditions)
+   - Team assignment
+   - Estimated complexity (1-13 Fibonacci)
+   - Dependencies on other stories (if any)
+4. If anything is unclear, indicate that human input is needed
+
+Respond in JSON format:
+{
+  "affectedTeams": ["team-name"],
+  "stories": [
+    {
+      "title": "...",
+      "description": "...",
+      "acceptanceCriteria": ["..."],
+      "teamName": "...",
+      "estimatedComplexity": 3,
+      "dependencies": []
+    }
+  ],
+  "needsHumanInput": false,
+  "escalationReason": null
+}`;
+
+    const response = await this.chat(prompt);
+
+    // Parse the JSON response
+    try {
+      const jsonMatch = response.match(/\{[\s\S]*\}/);
+      if (jsonMatch) {
+        return JSON.parse(jsonMatch[0]);
+      }
+    } catch {
+      // If parsing fails, request clarification
+    }
+
+    return {
+      affectedTeams: [],
+      stories: [],
+      needsHumanInput: true,
+      escalationReason: 'Could not parse requirement analysis. Please review and clarify.',
+    };
+  }
+
+  private async createStories(analysis: Awaited<ReturnType<typeof this.analyzeRequirement>>): Promise<string[]> {
+    const storyIds: string[] = [];
+    const storyIdMap: Record<string, string> = {};
+
+    for (const story of analysis.stories) {
+      const team = this.teams.find(t => t.name === story.teamName);
+
+      const storyRow = createStory(this.db, {
+        requirementId: this.requirement!.id,
+        teamId: team?.id,
+        title: story.title,
+        description: story.description,
+        acceptanceCriteria: story.acceptanceCriteria,
+      });
+
+      // Update with complexity
+      updateStory(this.db, storyRow.id, {
+        complexityScore: story.estimatedComplexity,
+        storyPoints: story.estimatedComplexity,
+        status: 'estimated',
+      });
+
+      storyIds.push(storyRow.id);
+      storyIdMap[story.title] = storyRow.id;
+
+      this.log('STORY_CREATED', story.title, {
+        storyId: storyRow.id,
+        teamId: team?.id,
+        complexity: story.estimatedComplexity,
+      });
+    }
+
+    // Set up dependencies
+    for (const story of analysis.stories) {
+      if (story.dependencies && story.dependencies.length > 0) {
+        const storyId = storyIdMap[story.title];
+        for (const depTitle of story.dependencies) {
+          const depId = storyIdMap[depTitle];
+          if (depId) {
+            addStoryDependency(this.db, storyId, depId);
+          }
+        }
+      }
+    }
+
+    return storyIds;
+  }
+
+  private async coordinateWithSeniors(storyIds: string[]): Promise<void> {
+    // Get unique teams from stories
+    const teamIds = new Set<string>();
+    for (const storyId of storyIds) {
+      const story = getStoryById(this.db, storyId);
+      if (story?.team_id) {
+        teamIds.add(story.team_id);
+      }
+    }
+
+    // Spawn or assign Senior for each team
+    for (const teamId of teamIds) {
+      const team = this.teams.find(t => t.id === teamId);
+      if (!team) continue;
+
+      // Check if Senior already exists for this team
+      let seniors = getAgentsByType(this.db, 'senior').filter(s => s.team_id === teamId);
+
+      if (seniors.length === 0) {
+        // Create a new Senior agent
+        const senior = createAgent(this.db, {
+          type: 'senior',
+          teamId,
+        });
+        seniors = [senior];
+
+        // Spawn tmux session for the Senior
+        const sessionName = generateSessionName('senior', team.name);
+        try {
+          // Load config and get CLI runtime settings for the senior agent type
+          const hiveRoot = findHiveRoot(this.workDir);
+          if (!hiveRoot) {
+            throw new Error('Hive root not found');
+          }
+          const paths = getHivePaths(hiveRoot);
+          const config = loadConfig(paths.hiveDir);
+          const agentConfig = config.models.senior;
+          const cliTool = agentConfig.cli_tool;
+          const model = agentConfig.model;
+
+          // Build spawn command using CLI runtime builder (spawn fresh session, will be resumed later)
+          const runtimeBuilder = getCliRuntimeBuilder(cliTool);
+          const commandArray = runtimeBuilder.buildSpawnCommand(model);
+          const command = commandArray.join(' ');
+
+          await spawnTmuxSession({
+            sessionName,
+            workDir: `${this.workDir}/${team.repo_path}`,
+            command,
+          });
+
+          updateAgent(this.db, senior.id, {
+            tmuxSession: sessionName,
+            status: 'working',
+          });
+
+          this.log('AGENT_SPAWNED', `Senior spawned for team ${team.name}`, {
+            agentId: senior.id,
+            teamId,
+            tmuxSession: sessionName,
+          });
+        } catch (err) {
+          this.log('AGENT_SPAWNED', `Failed to spawn Senior tmux session: ${err instanceof Error ? err.message : 'Unknown error'}`, {
+            agentId: senior.id,
+            teamId,
+          });
+        }
+      }
+
+      // Assign stories to the Senior
+      const teamStories = queryAll<{ id: string }>(this.db, `
+        SELECT id FROM stories WHERE team_id = ? AND status = 'estimated'
+      `, [teamId]);
+
+      for (const story of teamStories) {
+        updateStory(this.db, story.id, { status: 'planned' });
+        this.log('STORY_ASSIGNED', `Story ${story.id} assigned to team ${team.name}`, {
+          storyId: story.id,
+          teamId,
+        });
+      }
+    }
+  }
+
+  private async escalateToHuman(reason: string): Promise<void> {
+    const escalation = createEscalation(this.db, {
+      storyId: null,
+      fromAgentId: this.agentId,
+      toAgentId: null, // null = human
+      reason,
+    });
+
+    this.log('ESCALATION_CREATED', reason, {
+      escalationId: escalation.id,
+    });
+
+    this.updateStatus('blocked');
+    this.addBlocker(`Waiting for human input: ${reason}`);
+  }
+}