hungry-ghost-hive 0.3.0

package/src/db/queries/pull-requests.ts

@@ -0,0 +1,170 @@
+import type { Database } from 'sql.js';
+import { nanoid } from 'nanoid';
+import { queryAll, queryOne, run, type PullRequestRow } from '../client.js';
+
+export type { PullRequestRow };
+
+export type PullRequestStatus = 'queued' | 'reviewing' | 'approved' | 'merged' | 'rejected' | 'closed';
+
+export interface CreatePullRequestInput {
+  storyId?: string | null;
+  teamId?: string | null;
+  branchName: string;
+  githubPrNumber?: number | null;
+  githubPrUrl?: string | null;
+  submittedBy?: string | null;
+}
+
+export interface UpdatePullRequestInput {
+  status?: PullRequestStatus;
+  reviewedBy?: string | null;
+  reviewNotes?: string | null;
+  githubPrNumber?: number | null;
+  githubPrUrl?: string | null;
+}
+
+export function createPullRequest(db: Database, input: CreatePullRequestInput): PullRequestRow {
+  const id = `pr-${nanoid(8)}`;
+  const now = new Date().toISOString();
+
+  run(db, `
+    INSERT INTO pull_requests (id, story_id, team_id, branch_name, github_pr_number, github_pr_url, submitted_by, status, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, 'queued', ?, ?)
+  `, [
+    id,
+    input.storyId || null,
+    input.teamId || null,
+    input.branchName,
+    input.githubPrNumber || null,
+    input.githubPrUrl || null,
+    input.submittedBy || null,
+    now,
+    now,
+  ]);
+
+  return getPullRequestById(db, id)!;
+}
+
+export function getPullRequestById(db: Database, id: string): PullRequestRow | undefined {
+  return queryOne<PullRequestRow>(db, 'SELECT * FROM pull_requests WHERE id = ?', [id]);
+}
+
+export function getPullRequestByStory(db: Database, storyId: string): PullRequestRow | undefined {
+  return queryOne<PullRequestRow>(db, 'SELECT * FROM pull_requests WHERE story_id = ?', [storyId]);
+}
+
+export function getPullRequestByGithubNumber(db: Database, prNumber: number): PullRequestRow | undefined {
+  return queryOne<PullRequestRow>(db, 'SELECT * FROM pull_requests WHERE github_pr_number = ?', [prNumber]);
+}
+
+// Merge Queue functions
+
+export function getMergeQueue(db: Database, teamId?: string): PullRequestRow[] {
+  if (teamId) {
+    return queryAll<PullRequestRow>(db, `
+      SELECT * FROM pull_requests
+      WHERE team_id = ? AND status IN ('queued', 'reviewing')
+      ORDER BY created_at ASC
+    `, [teamId]);
+  }
+  return queryAll<PullRequestRow>(db, `
+    SELECT * FROM pull_requests
+    WHERE status IN ('queued', 'reviewing')
+    ORDER BY created_at ASC
+  `);
+}
+
+export function getNextInQueue(db: Database, teamId?: string): PullRequestRow | undefined {
+  if (teamId) {
+    return queryOne<PullRequestRow>(db, `
+      SELECT * FROM pull_requests
+      WHERE team_id = ? AND status = 'queued'
+      ORDER BY created_at ASC
+      LIMIT 1
+    `, [teamId]);
+  }
+  return queryOne<PullRequestRow>(db, `
+    SELECT * FROM pull_requests
+    WHERE status = 'queued'
+    ORDER BY created_at ASC
+    LIMIT 1
+  `);
+}
+
+export function getQueuePosition(db: Database, prId: string): number {
+  const pr = getPullRequestById(db, prId);
+  if (!pr || !['queued', 'reviewing'].includes(pr.status)) return -1;
+
+  const queue = getMergeQueue(db, pr.team_id || undefined);
+  return queue.findIndex(p => p.id === prId) + 1;
+}
+
+export function getPullRequestsByStatus(db: Database, status: PullRequestStatus): PullRequestRow[] {
+  return queryAll<PullRequestRow>(db, `
+    SELECT * FROM pull_requests
+    WHERE status = ?
+    ORDER BY created_at DESC
+  `, [status]);
+}
+
+export function getApprovedPullRequests(db: Database): PullRequestRow[] {
+  return queryAll<PullRequestRow>(db, `
+    SELECT * FROM pull_requests
+    WHERE status = 'approved'
+    ORDER BY created_at ASC
+  `);
+}
+
+export function getAllPullRequests(db: Database): PullRequestRow[] {
+  return queryAll<PullRequestRow>(db, 'SELECT * FROM pull_requests ORDER BY created_at DESC');
+}
+
+export function getPullRequestsByTeam(db: Database, teamId: string): PullRequestRow[] {
+  return queryAll<PullRequestRow>(db, `
+    SELECT * FROM pull_requests
+    WHERE team_id = ?
+    ORDER BY created_at DESC
+  `, [teamId]);
+}
+
+export function updatePullRequest(db: Database, id: string, input: UpdatePullRequestInput): PullRequestRow | undefined {
+  const updates: string[] = ['updated_at = ?'];
+  const values: (string | number | null)[] = [new Date().toISOString()];
+
+  if (input.status !== undefined) {
+    updates.push('status = ?');
+    values.push(input.status);
+    if (['reviewing', 'approved', 'rejected', 'merged'].includes(input.status)) {
+      updates.push('reviewed_at = ?');
+      values.push(new Date().toISOString());
+    }
+  }
+  if (input.reviewedBy !== undefined) {
+    updates.push('reviewed_by = ?');
+    values.push(input.reviewedBy);
+  }
+  if (input.reviewNotes !== undefined) {
+    updates.push('review_notes = ?');
+    values.push(input.reviewNotes);
+  }
+  if (input.githubPrNumber !== undefined) {
+    updates.push('github_pr_number = ?');
+    values.push(input.githubPrNumber);
+  }
+  if (input.githubPrUrl !== undefined) {
+    updates.push('github_pr_url = ?');
+    values.push(input.githubPrUrl);
+  }
+
+  if (updates.length === 1) {
+    return getPullRequestById(db, id);
+  }
+
+  values.push(id);
+  run(db, `UPDATE pull_requests SET ${updates.join(', ')} WHERE id = ?`, values);
+  return getPullRequestById(db, id);
+}
+
+export function deletePullRequest(db: Database, id: string): void {
+  run(db, 'DELETE FROM pull_requests WHERE id = ?', [id]);
+}

package/src/db/queries/requirements.ts

@@ -0,0 +1,81 @@
+import type { Database } from 'sql.js';
+import { nanoid } from 'nanoid';
+import { queryAll, queryOne, run, type RequirementRow } from '../client.js';
+
+export type { RequirementRow };
+
+export type RequirementStatus = 'pending' | 'planning' | 'planned' | 'in_progress' | 'completed';
+
+export interface CreateRequirementInput {
+  title: string;
+  description: string;
+  submittedBy?: string;
+}
+
+export interface UpdateRequirementInput {
+  title?: string;
+  description?: string;
+  status?: RequirementStatus;
+}
+
+export function createRequirement(db: Database, input: CreateRequirementInput): RequirementRow {
+  const id = `REQ-${nanoid(8).toUpperCase()}`;
+  const now = new Date().toISOString();
+
+  run(db, `
+    INSERT INTO requirements (id, title, description, submitted_by, created_at)
+    VALUES (?, ?, ?, ?, ?)
+  `, [id, input.title, input.description, input.submittedBy || 'human', now]);
+
+  return getRequirementById(db, id)!;
+}
+
+export function getRequirementById(db: Database, id: string): RequirementRow | undefined {
+  return queryOne<RequirementRow>(db, 'SELECT * FROM requirements WHERE id = ?', [id]);
+}
+
+export function getAllRequirements(db: Database): RequirementRow[] {
+  return queryAll<RequirementRow>(db, 'SELECT * FROM requirements ORDER BY created_at DESC');
+}
+
+export function getRequirementsByStatus(db: Database, status: RequirementStatus): RequirementRow[] {
+  return queryAll<RequirementRow>(db, 'SELECT * FROM requirements WHERE status = ? ORDER BY created_at DESC', [status]);
+}
+
+export function getPendingRequirements(db: Database): RequirementRow[] {
+  return queryAll<RequirementRow>(db, `
+    SELECT * FROM requirements
+    WHERE status IN ('pending', 'planning', 'in_progress')
+    ORDER BY created_at
+  `);
+}
+
+export function updateRequirement(db: Database, id: string, input: UpdateRequirementInput): RequirementRow | undefined {
+  const updates: string[] = [];
+  const values: string[] = [];
+
+  if (input.title !== undefined) {
+    updates.push('title = ?');
+    values.push(input.title);
+  }
+  if (input.description !== undefined) {
+    updates.push('description = ?');
+    values.push(input.description);
+  }
+  if (input.status !== undefined) {
+    updates.push('status = ?');
+    values.push(input.status);
+  }
+
+  if (updates.length === 0) {
+    return getRequirementById(db, id);
+  }
+
+  values.push(id);
+  run(db, `UPDATE requirements SET ${updates.join(', ')} WHERE id = ?`, values);
+  return getRequirementById(db, id);
+}
+
+export function deleteRequirement(db: Database, id: string): void {
+  run(db, 'DELETE FROM requirements WHERE id = ?', [id]);
+}

package/src/db/queries/stories.ts

@@ -0,0 +1,223 @@
+import type { Database } from 'sql.js';
+import { nanoid } from 'nanoid';
+import { queryAll, queryOne, run, type StoryRow } from '../client.js';
+
+export type { StoryRow };
+
+export type StoryStatus =
+  | 'draft'
+  | 'estimated'
+  | 'planned'
+  | 'in_progress'
+  | 'review'
+  | 'qa'
+  | 'qa_failed'
+  | 'pr_submitted'
+  | 'merged';
+
+export interface CreateStoryInput {
+  requirementId?: string | null;
+  teamId?: string | null;
+  title: string;
+  description: string;
+  acceptanceCriteria?: string[] | null;
+}
+
+export interface UpdateStoryInput {
+  teamId?: string | null;
+  title?: string;
+  description?: string;
+  acceptanceCriteria?: string[] | null;
+  complexityScore?: number | null;
+  storyPoints?: number | null;
+  status?: StoryStatus;
+  assignedAgentId?: string | null;
+  branchName?: string | null;
+  prUrl?: string | null;
+}
+
+export function createStory(db: Database, input: CreateStoryInput): StoryRow {
+  const id = `STORY-${nanoid(6).toUpperCase()}`;
+  const acceptanceCriteria = input.acceptanceCriteria
+    ? JSON.stringify(input.acceptanceCriteria)
+    : null;
+  const now = new Date().toISOString();
+
+  run(db, `
+    INSERT INTO stories (id, requirement_id, team_id, title, description, acceptance_criteria, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `, [id, input.requirementId || null, input.teamId || null, input.title, input.description, acceptanceCriteria, now, now]);
+
+  return getStoryById(db, id)!;
+}
+
+export function getStoryById(db: Database, id: string): StoryRow | undefined {
+  return queryOne<StoryRow>(db, 'SELECT * FROM stories WHERE id = ?', [id]);
+}
+
+export function getStoriesByRequirement(db: Database, requirementId: string): StoryRow[] {
+  return queryAll<StoryRow>(db, 'SELECT * FROM stories WHERE requirement_id = ? ORDER BY created_at', [requirementId]);
+}
+
+export function getStoriesByTeam(db: Database, teamId: string): StoryRow[] {
+  return queryAll<StoryRow>(db, 'SELECT * FROM stories WHERE team_id = ? ORDER BY created_at', [teamId]);
+}
+
+export function getStoriesByStatus(db: Database, status: StoryStatus): StoryRow[] {
+  return queryAll<StoryRow>(db, 'SELECT * FROM stories WHERE status = ? ORDER BY created_at', [status]);
+}
+
+export function getStoriesByAgent(db: Database, agentId: string): StoryRow[] {
+  return queryAll<StoryRow>(db, 'SELECT * FROM stories WHERE assigned_agent_id = ? ORDER BY created_at', [agentId]);
+}
+
+export function getActiveStoriesByAgent(db: Database, agentId: string): StoryRow[] {
+  return queryAll<StoryRow>(db, `
+    SELECT * FROM stories
+    WHERE assigned_agent_id = ?
+    AND status IN ('planned', 'in_progress', 'review', 'qa', 'qa_failed', 'pr_submitted')
+    ORDER BY created_at
+  `, [agentId]);
+}
+
+export function getAllStories(db: Database): StoryRow[] {
+  return queryAll<StoryRow>(db, 'SELECT * FROM stories ORDER BY created_at DESC');
+}
+
+export function getPlannedStories(db: Database): StoryRow[] {
+  return queryAll<StoryRow>(db, `
+    SELECT * FROM stories
+    WHERE status = 'planned'
+    ORDER BY story_points DESC, created_at
+  `);
+}
+
+export function getInProgressStories(db: Database): StoryRow[] {
+  return queryAll<StoryRow>(db, `
+    SELECT * FROM stories
+    WHERE status IN ('in_progress', 'review', 'qa', 'qa_failed')
+    ORDER BY created_at
+  `);
+}
+
+export function getStoryPointsByTeam(db: Database, teamId: string): number {
+  const result = queryOne<{ total: number }>(db, `
+    SELECT COALESCE(SUM(story_points), 0) as total
+    FROM stories
+    WHERE team_id = ? AND status IN ('planned', 'in_progress', 'review', 'qa')
+  `, [teamId]);
+  return result?.total || 0;
+}
+
+export function updateStory(db: Database, id: string, input: UpdateStoryInput): StoryRow | undefined {
+  const updates: string[] = ['updated_at = ?'];
+  const values: (string | number | null)[] = [new Date().toISOString()];
+
+  if (input.teamId !== undefined) {
+    updates.push('team_id = ?');
+    values.push(input.teamId);
+  }
+  if (input.title !== undefined) {
+    updates.push('title = ?');
+    values.push(input.title);
+  }
+  if (input.description !== undefined) {
+    updates.push('description = ?');
+    values.push(input.description);
+  }
+  if (input.acceptanceCriteria !== undefined) {
+    updates.push('acceptance_criteria = ?');
+    values.push(input.acceptanceCriteria ? JSON.stringify(input.acceptanceCriteria) : null);
+  }
+  if (input.complexityScore !== undefined) {
+    updates.push('complexity_score = ?');
+    values.push(input.complexityScore);
+  }
+  if (input.storyPoints !== undefined) {
+    updates.push('story_points = ?');
+    values.push(input.storyPoints);
+  }
+  if (input.status !== undefined) {
+    updates.push('status = ?');
+    values.push(input.status);
+  }
+  if (input.assignedAgentId !== undefined) {
+    updates.push('assigned_agent_id = ?');
+    values.push(input.assignedAgentId);
+  }
+  if (input.branchName !== undefined) {
+    updates.push('branch_name = ?');
+    values.push(input.branchName);
+  }
+  if (input.prUrl !== undefined) {
+    updates.push('pr_url = ?');
+    values.push(input.prUrl);
+  }
+
+  if (updates.length === 1) {
+    return getStoryById(db, id);
+  }
+
+  values.push(id);
+  run(db, `UPDATE stories SET ${updates.join(', ')} WHERE id = ?`, values);
+  return getStoryById(db, id);
+}
+
+export function deleteStory(db: Database, id: string): void {
+  run(db, 'DELETE FROM story_dependencies WHERE story_id = ? OR depends_on_story_id = ?', [id, id]);
+  run(db, 'DELETE FROM stories WHERE id = ?', [id]);
+}
+
+// Story dependencies
+export function addStoryDependency(db: Database, storyId: string, dependsOnStoryId: string): void {
+  run(db, `
+    INSERT OR IGNORE INTO story_dependencies (story_id, depends_on_story_id)
+    VALUES (?, ?)
+  `, [storyId, dependsOnStoryId]);
+}
+
+export function removeStoryDependency(db: Database, storyId: string, dependsOnStoryId: string): void {
+  run(db, 'DELETE FROM story_dependencies WHERE story_id = ? AND depends_on_story_id = ?', [storyId, dependsOnStoryId]);
+}
+
+export function getStoryDependencies(db: Database, storyId: string): StoryRow[] {
+  return queryAll<StoryRow>(db, `
+    SELECT s.* FROM stories s
+    JOIN story_dependencies sd ON s.id = sd.depends_on_story_id
+    WHERE sd.story_id = ?
+  `, [storyId]);
+}
+
+export function getStoriesDependingOn(db: Database, storyId: string): StoryRow[] {
+  return queryAll<StoryRow>(db, `
+    SELECT s.* FROM stories s
+    JOIN story_dependencies sd ON s.id = sd.story_id
+    WHERE sd.depends_on_story_id = ?
+  `, [storyId]);
+}
+
+export function getStoryCounts(db: Database): Record<StoryStatus, number> {
+  const rows = queryAll<{ status: StoryStatus; count: number }>(db, `
+    SELECT status, COUNT(*) as count
+    FROM stories
+    GROUP BY status
+  `);
+
+  const counts: Record<StoryStatus, number> = {
+    draft: 0,
+    estimated: 0,
+    planned: 0,
+    in_progress: 0,
+    review: 0,
+    qa: 0,
+    qa_failed: 0,
+    pr_submitted: 0,
+    merged: 0,
+  };
+
+  for (const row of rows) {
+    counts[row.status] = row.count;
+  }
+
+  return counts;
+}

package/src/db/queries/teams.ts

@@ -0,0 +1,39 @@
+import type { Database } from 'sql.js';
+import { nanoid } from 'nanoid';
+import { queryAll, queryOne, run, type TeamRow } from '../client.js';
+
+export type { TeamRow };
+
+export interface CreateTeamInput {
+  repoUrl: string;
+  repoPath: string;
+  name: string;
+}
+
+export function createTeam(db: Database, input: CreateTeamInput): TeamRow {
+  const id = `team-${nanoid(10)}`;
+  const now = new Date().toISOString();
+
+  run(db, `
+    INSERT INTO teams (id, repo_url, repo_path, name, created_at)
+    VALUES (?, ?, ?, ?, ?)
+  `, [id, input.repoUrl, input.repoPath, input.name, now]);
+
+  return getTeamById(db, id)!;
+}
+
+export function getTeamById(db: Database, id: string): TeamRow | undefined {
+  return queryOne<TeamRow>(db, 'SELECT * FROM teams WHERE id = ?', [id]);
+}
+
+export function getTeamByName(db: Database, name: string): TeamRow | undefined {
+  return queryOne<TeamRow>(db, 'SELECT * FROM teams WHERE name = ?', [name]);
+}
+
+export function getAllTeams(db: Database): TeamRow[] {
+  return queryAll<TeamRow>(db, 'SELECT * FROM teams ORDER BY created_at');
+}
+
+export function deleteTeam(db: Database, id: string): void {
+  run(db, 'DELETE FROM teams WHERE id = ?', [id]);
+}

package/src/git/branches.ts

@@ -0,0 +1,186 @@
+import { execa } from 'execa';
+
+export interface BranchInfo {
+  name: string;
+  current: boolean;
+  remote?: string;
+  upstream?: string;
+  lastCommit: string;
+}
+
+/**
+ * Get current branch name
+ */
+export async function getCurrentBranch(workDir: string): Promise<string> {
+  const { stdout } = await execa('git', ['branch', '--show-current'], {
+    cwd: workDir,
+  });
+  return stdout.trim();
+}
+
+/**
+ * List all local branches
+ */
+export async function listBranches(workDir: string): Promise<BranchInfo[]> {
+  const { stdout } = await execa('git', [
+    'branch', '-v', '--format=%(refname:short)|%(objectname:short)|%(HEAD)',
+  ], { cwd: workDir });
+
+  return stdout.split('\n').filter(Boolean).map(line => {
+    const [name, lastCommit, head] = line.split('|');
+    return {
+      name,
+      current: head === '*',
+      lastCommit,
+    };
+  });
+}
+
+/**
+ * Create a new branch
+ */
+export async function createBranch(
+  workDir: string,
+  name: string,
+  startPoint?: string
+): Promise<void> {
+  const args = ['branch', name];
+  if (startPoint) {
+    args.push(startPoint);
+  }
+  await execa('git', args, { cwd: workDir });
+}
+
+/**
+ * Checkout a branch
+ */
+export async function checkoutBranch(
+  workDir: string,
+  name: string,
+  create: boolean = false
+): Promise<void> {
+  const args = ['checkout'];
+  if (create) {
+    args.push('-b');
+  }
+  args.push(name);
+  await execa('git', args, { cwd: workDir });
+}
+
+/**
+ * Delete a branch
+ */
+export async function deleteBranch(
+  workDir: string,
+  name: string,
+  force: boolean = false
+): Promise<void> {
+  const args = ['branch', force ? '-D' : '-d', name];
+  await execa('git', args, { cwd: workDir });
+}
+
+/**
+ * Check if branch exists
+ */
+export async function branchExists(workDir: string, name: string): Promise<boolean> {
+  try {
+    await execa('git', ['rev-parse', '--verify', name], { cwd: workDir });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get branch tracking info
+ */
+export async function getBranchTracking(workDir: string, branch: string): Promise<{
+  upstream: string | null;
+  ahead: number;
+  behind: number;
+}> {
+  try {
+    const { stdout: upstream } = await execa('git', [
+      'rev-parse', '--abbrev-ref', `${branch}@{upstream}`,
+    ], { cwd: workDir });
+
+    const { stdout: counts } = await execa('git', [
+      'rev-list', '--left-right', '--count', `${upstream.trim()}...${branch}`,
+    ], { cwd: workDir });
+
+    const [behind, ahead] = counts.trim().split('\t').map(Number);
+
+    return {
+      upstream: upstream.trim(),
+      ahead,
+      behind,
+    };
+  } catch {
+    return { upstream: null, ahead: 0, behind: 0 };
+  }
+}
+
+/**
+ * Push branch to remote
+ */
+export async function pushBranch(
+  workDir: string,
+  branch: string,
+  remote: string = 'origin',
+  setUpstream: boolean = false
+): Promise<void> {
+  const args = ['push', remote, branch];
+  if (setUpstream) {
+    args.splice(1, 0, '-u');
+  }
+  await execa('git', args, { cwd: workDir });
+}
+
+/**
+ * Create and checkout a feature branch
+ */
+export async function createFeatureBranch(
+  workDir: string,
+  storyId: string,
+  description: string,
+  baseBranch: string = 'main'
+): Promise<string> {
+  // Normalize the description for branch name
+  const slug = description
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-|-$/g, '')
+    .substring(0, 30);
+
+  const branchName = `feature/${storyId.toLowerCase()}-${slug}`;
+
+  // Make sure we're on the base branch and up to date
+  await checkoutBranch(workDir, baseBranch);
+
+  try {
+    await execa('git', ['pull', 'origin', baseBranch], { cwd: workDir });
+  } catch {
+    // Pull might fail if no remote tracking, continue anyway
+  }
+
+  // Create and checkout the feature branch
+  await checkoutBranch(workDir, branchName, true);
+
+  return branchName;
+}
+
+/**
+ * Merge a branch
+ */
+export async function mergeBranch(
+  workDir: string,
+  branch: string,
+  noFf: boolean = true
+): Promise<void> {
+  const args = ['merge'];
+  if (noFf) {
+    args.push('--no-ff');
+  }
+  args.push(branch);
+  await execa('git', args, { cwd: workDir });
+}