orbital-command 0.2.0 → 1.0.0

package/server/services/git-service.ts

@@ -1,9 +1,11 @@
 import { execFile as execFileCb } from 'child_process';
 import { promisify } from 'util';
 import { listWorktrees } from '../utils/worktree-manager.js';
+import { createLogger } from '../utils/logger.js';
 import type { ScopeCache } from './scope-cache.js';
 
 const execFile = promisify(execFileCb);
+const log = createLogger('git');
 
 // ─── Types ──────────────────────────────────────────────────
 
@@ -182,7 +184,8 @@ export class GitService {
     let raw: string;
     try {
       raw = await this.git(args);
-    } catch {
+    } catch (err) {
+      log.debug('Commits query failed', { branch: branch ?? 'all', error: String(err) });
       return [];
     }
 
@@ -241,7 +244,8 @@ export class GitService {
         'branch', '-a',
         '--format=%(HEAD)|%(refname:short)|%(objectname:short)|%(committerdate:iso-strict)|%(subject)',
       ]);
-    } catch {
+    } catch (err) {
+      log.debug('Branch listing failed', { error: String(err) });
       return [];
     }
 
@@ -304,7 +308,8 @@ export class GitService {
     let wts: Array<{ path: string; branch: string; scopeId: number }>;
     try {
       wts = await listWorktrees(this.projectRoot);
-    } catch {
+    } catch (err) {
+      log.warn('Failed to list worktrees', { error: String(err) });
       return [];
     }
 
@@ -366,7 +371,8 @@ export class GitService {
           return { sha, date, message: rest.slice(0, -1).join('|'), author: rest[rest.length - 1] };
         });
         pairs.push({ from, to, count: commits.length, commits });
-      } catch {
+      } catch (err) {
+        log.debug('Drift query failed', { from, to, error: String(err) });
         pairs.push({ from, to, count: 0, commits: [] });
       }
     }
@@ -375,6 +381,83 @@ export class GitService {
     return pairs;
   }
 
+  // ─── Activity Series ────────────────────────────────────────
+
+  async getActivitySeries(days: number = 30): Promise<Array<{ date: string; count: number }>> {
+    const cacheKey = `activity:${days}`;
+    const hit = cached<Array<{ date: string; count: number }>>(this.cache as Map<string, CacheEntry<Array<{ date: string; count: number }>>>, cacheKey);
+    if (hit) return hit;
+
+    try {
+      const raw = await this.git(['log', `--since=${days}.days.ago`, '--format=%aI', '--all']);
+      const counts = new Map<string, number>();
+
+      // Initialize all days to 0
+      const now = new Date();
+      for (let i = 0; i < days; i++) {
+        const d = new Date(now);
+        d.setDate(d.getDate() - i);
+        counts.set(d.toISOString().slice(0, 10), 0);
+      }
+
+      for (const line of raw.trim().split('\n')) {
+        if (!line) continue;
+        const dateKey = line.slice(0, 10);
+        counts.set(dateKey, (counts.get(dateKey) ?? 0) + 1);
+      }
+
+      const series = [...counts.entries()]
+        .map(([date, count]) => ({ date, count }))
+        .sort((a, b) => a.date.localeCompare(b.date));
+
+      setCache(this.cache as Map<string, CacheEntry<Array<{ date: string; count: number }>>>, cacheKey, series);
+      return series;
+    } catch (err) {
+      log.debug('Activity series query failed', { days, error: String(err) });
+      return [];
+    }
+  }
+
+  // ─── Health Metrics ────────────────────────────────────────
+
+  async getHealthMetrics(githubPrAges?: number[]): Promise<{
+    commitsPerWeek: number;
+    avgPrAgeDays: number;
+    staleBranchCount: number;
+    driftSeverity: 'clean' | 'low' | 'moderate' | 'high';
+    grade: 'A' | 'B' | 'C' | 'D' | 'F';
+  }> {
+    // Commits per week
+    let commitsPerWeek = 0;
+    try {
+      const raw = await this.git(['log', '--since=7.days.ago', '--oneline', '--all']);
+      commitsPerWeek = raw.trim().split('\n').filter(Boolean).length;
+    } catch { /* ok */ }
+
+    // Stale branches
+    const branches = await this.getBranches();
+    const staleBranchCount = branches.filter(b => b.isStale && !b.isRemote).length;
+
+    // Avg PR age
+    let avgPrAgeDays = 0;
+    if (githubPrAges && githubPrAges.length > 0) {
+      avgPrAgeDays = Math.round(githubPrAges.reduce((a, b) => a + b, 0) / githubPrAges.length);
+    }
+
+    // Drift severity (reuse cached data if available)
+    const driftSeverity: 'clean' | 'low' | 'moderate' | 'high' = 'clean';
+
+    // Grade computation: start at 100
+    let score = 100;
+    score -= Math.min(30, staleBranchCount * 5);
+    if (commitsPerWeek < 5) score -= 10;
+    if (avgPrAgeDays > 3) score -= Math.min(25, (avgPrAgeDays - 3) * 5);
+
+    const grade = score >= 90 ? 'A' : score >= 80 ? 'B' : score >= 70 ? 'C' : score >= 60 ? 'D' : 'F';
+
+    return { commitsPerWeek, avgPrAgeDays, staleBranchCount, driftSeverity, grade };
+  }
+
   // ─── Git Status Polling ────────────────────────────────────
 
   async getStatusHash(): Promise<string> {
@@ -385,6 +468,56 @@ export class GitService {
     return `${head.trim()}:${dirty.trim().length > 0 ? 'dirty' : 'clean'}`;
   }
 
+  // ─── Pipeline Drift ─────────────────────────────────────────
+
+  async getPipelineDrift(): Promise<{
+    devToStaging: { count: number; commits: Array<{ sha: string; message: string; author: string; date: string }>; oldestDate: string | null };
+    stagingToMain: { count: number; commits: Array<{ sha: string; message: string; author: string; date: string }>; oldestDate: string | null };
+    heads: { dev: { sha: string; date: string; message: string }; staging: { sha: string; date: string; message: string }; main: { sha: string; date: string; message: string } };
+  }> {
+    type DriftCommit = { sha: string; message: string; author: string; date: string };
+    type BranchHead = { sha: string; date: string; message: string };
+
+    const cacheKey = 'pipeline-drift';
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const hit = cached<any>(this.cache as Map<string, CacheEntry<any>>, cacheKey);
+    if (hit) return hit;
+
+    function parseDriftCommits(raw: string): DriftCommit[] {
+      if (!raw) return [];
+      return raw.split('\n').map((line) => {
+        const [sha, date, message, author] = line.split('|');
+        return { sha, date, message: message ?? '', author: author ?? '' };
+      });
+    }
+
+    function parseHead(raw: string): BranchHead {
+      const [sha, date, message] = raw.split('|');
+      return { sha: sha ?? '', date: date ?? '', message: message ?? '' };
+    }
+
+    const [devToStagingRaw, stagingToMainRaw, devHead, stagingHead, mainHead] =
+      await Promise.all([
+        this.git(['log', 'origin/dev', '--not', 'origin/staging', '--reverse', '--format=%H|%aI|%s|%an']).catch(() => ''),
+        this.git(['log', 'origin/staging', '--not', 'origin/main', '--reverse', '--format=%H|%aI|%s|%an']).catch(() => ''),
+        this.git(['log', 'origin/dev', '-1', '--format=%H|%aI|%s']).catch(() => ''),
+        this.git(['log', 'origin/staging', '-1', '--format=%H|%aI|%s']).catch(() => ''),
+        this.git(['log', 'origin/main', '-1', '--format=%H|%aI|%s']).catch(() => ''),
+      ]);
+
+    const devToStaging = parseDriftCommits(devToStagingRaw);
+    const stagingToMain = parseDriftCommits(stagingToMainRaw);
+
+    const data = {
+      devToStaging: { count: devToStaging.length, commits: devToStaging, oldestDate: devToStaging[0]?.date ?? null },
+      stagingToMain: { count: stagingToMain.length, commits: stagingToMain, oldestDate: stagingToMain[0]?.date ?? null },
+      heads: { dev: parseHead(devHead), staging: parseHead(stagingHead), main: parseHead(mainHead) },
+    };
+
+    setCache(this.cache as Map<string, CacheEntry<typeof data>>, cacheKey, data);
+    return data;
+  }
+
   clearCache(): void {
     this.cache.clear();
   }

package/server/services/github-service.ts

@@ -1,4 +1,4 @@
-import { execFile as execFileCb } from 'child_process';
+import { execFile as execFileCb, spawn } from 'child_process';
 import { promisify } from 'util';
 
 // Uses execFile (not exec) — safe against shell injection
@@ -144,7 +144,7 @@ export class GitHubService {
     try {
       const raw = await this.gh([
         'pr', 'list', '--state', 'open', '--json',
-        'number,title,author,headRefName,baseRefName,state,url,createdAt',
+        'number,title,author,headRefName,baseRefName,state,url,createdAt,updatedAt,reviewDecision',
         '--limit', '30',
       ]);
       const parsed = JSON.parse(raw);
@@ -171,6 +171,8 @@ export class GitHubService {
           url: String(pr.url ?? ''),
           createdAt: String(pr.createdAt ?? ''),
           scopeIds,
+          reviewDecision: (pr.reviewDecision as string) || null,
+          lastActivityAt: String(pr.updatedAt ?? pr.createdAt ?? ''),
         };
       });
 
@@ -180,4 +182,120 @@ export class GitHubService {
       return [];
     }
   }
+
+  // ─── Auth Flow ─────────────────────────────────────────────
+
+  /** Start OAuth flow via gh CLI — opens browser. Client polls getAuthStatus(). */
+  async connectOAuth(): Promise<{ success: boolean; error?: string }> {
+    return new Promise((resolve) => {
+      // spawn is safe here: no shell, args are hardcoded literals
+      const child = spawn('gh', ['auth', 'login', '--web', '--git-protocol', 'https'], {
+        cwd: this.projectRoot,
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+
+      let stderr = '';
+      child.stderr?.on('data', (data: Buffer) => { stderr += data.toString(); });
+
+      // Resolve quickly — the gh process runs in background, client polls auth status
+      setTimeout(() => {
+        resolve({ success: true });
+      }, 500);
+
+      child.on('error', () => {
+        resolve({ success: false, error: stderr || 'Failed to start auth flow' });
+      });
+    });
+  }
+
+  /** Authenticate using a Personal Access Token piped to gh stdin. */
+  async connectWithToken(token: string): Promise<{ success: boolean; error?: string }> {
+    try {
+      // spawn is safe: no shell, args are hardcoded literals, token via stdin (not args)
+      const child = spawn('gh', ['auth', 'login', '--with-token'], {
+        cwd: this.projectRoot,
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+
+      return new Promise((resolve) => {
+        let stderr = '';
+        child.stderr?.on('data', (data: Buffer) => { stderr += data.toString(); });
+
+        child.on('close', (code) => {
+          this.clearCaches();
+          if (code === 0) {
+            resolve({ success: true });
+          } else {
+            resolve({ success: false, error: stderr || 'Authentication failed' });
+          }
+        });
+
+        child.on('error', () => {
+          resolve({ success: false, error: 'Failed to run gh auth' });
+        });
+
+        child.stdin?.write(token);
+        child.stdin?.end();
+      });
+    } catch {
+      return { success: false, error: 'Failed to authenticate' };
+    }
+  }
+
+  /** Lightweight auth check — returns current user if authenticated. */
+  async getAuthStatus(): Promise<{ authenticated: boolean; user?: string }> {
+    try {
+      const whoami = await this.gh(['api', 'user', '--jq', '.login']);
+      const user = whoami.trim();
+      return user ? { authenticated: true, user } : { authenticated: false };
+    } catch {
+      return { authenticated: false };
+    }
+  }
+
+  /** Log out of GitHub CLI. */
+  async disconnect(): Promise<{ success: boolean; error?: string }> {
+    try {
+      // execFile is safe — no shell injection
+      await execFile('gh', ['auth', 'logout', '--hostname', 'github.com'], {
+        cwd: this.projectRoot,
+        timeout: 10_000,
+        env: { ...process.env, GH_PROMPT_DISABLED: '1' },
+      });
+      this.clearCaches();
+      return { success: true };
+    } catch (err) {
+      this.clearCaches();
+      return { success: false, error: String(err) };
+    }
+  }
+
+  // ─── CI Checks ─────────────────────────────────────────────
+
+  /** Fetch GitHub Actions check runs for a commit ref. */
+  async getCheckRuns(ref: string): Promise<Array<{ name: string; status: string; conclusion: string | null; url: string }>> {
+    // Validate ref to prevent path traversal — only allow hex SHA and branch-like names
+    if (!/^[a-zA-Z0-9._/-]+$/.test(ref)) return [];
+
+    try {
+      const raw = await this.gh([
+        'api', `repos/{owner}/{repo}/commits/${ref}/check-runs`,
+        '--jq', '.check_runs | map({name, status, conclusion, html_url})',
+      ]);
+      const parsed = JSON.parse(raw);
+      return (parsed as Array<Record<string, unknown>>).map(c => ({
+        name: String(c.name ?? ''),
+        status: String(c.status ?? 'queued'),
+        conclusion: c.conclusion ? String(c.conclusion) : null,
+        url: String(c.html_url ?? ''),
+      }));
+    } catch {
+      return [];
+    }
+  }
+
+  private clearCaches(): void {
+    this.statusCache = null;
+    this.prCache = null;
+  }
 }

package/server/services/readiness-service.test.ts

@@ -0,0 +1,217 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { ReadinessService } from './readiness-service.js';
+import { WorkflowEngine } from '../../shared/workflow-engine.js';
+import { CONFIG_WITH_HOOKS } from '../../shared/__fixtures__/workflow-configs.js';
+import type { ParsedScope } from '../parsers/scope-parser.js';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+function makeScope(overrides: Partial<ParsedScope> & { id: number }): ParsedScope {
+  return {
+    title: `Scope ${overrides.id}`,
+    slug: undefined,
+    status: 'backlog',
+    priority: null,
+    effort_estimate: null,
+    category: null,
+    tags: [],
+    blocked_by: [],
+    blocks: [],
+    file_path: `/scopes/backlog/${String(overrides.id).padStart(3, '0')}-test.md`,
+    created_at: null,
+    updated_at: null,
+    raw_content: '# Test Scope\nSome content here.',
+    sessions: {},
+    is_ghost: false,
+    favourite: false,
+    ...overrides,
+  };
+}
+
+describe('ReadinessService', () => {
+  let engine: WorkflowEngine;
+  let tmpDir: string;
+  let service: ReadinessService;
+  let mockScopeService: { getById: (id: number) => ParsedScope | undefined };
+  let mockGateService: { getLatestForScope: ReturnType<typeof vi.fn>; getLatestRun: ReturnType<typeof vi.fn> };
+  let scopes: ParsedScope[];
+
+  beforeEach(() => {
+    engine = new WorkflowEngine(CONFIG_WITH_HOOKS);
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'readiness-test-'));
+
+    scopes = [
+      makeScope({ id: 1, status: 'backlog', sessions: { implementScope: ['sess-1'] } }),
+      makeScope({ id: 2, status: 'active', sessions: { implementScope: ['sess-1'] }, blocked_by: [99] }),
+      makeScope({ id: 3, status: 'active', sessions: { implementScope: ['sess-1'] }, raw_content: '# Scope\n- [ ] Task 1\n- [x] Task 2' }),
+      makeScope({ id: 99, status: 'shipped' }), // terminal blocker
+      makeScope({ id: 100, status: 'backlog' }), // non-terminal blocker
+    ];
+
+    mockScopeService = { getById: (id: number) => scopes.find(s => s.id === id) };
+    mockGateService = {
+      getLatestForScope: vi.fn().mockReturnValue([]),
+      getLatestRun: vi.fn().mockReturnValue([]),
+    };
+
+    service = new ReadinessService(
+      mockScopeService as any,
+      mockGateService as any,
+      engine,
+      tmpDir,
+    );
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  describe('getReadiness()', () => {
+    it('returns null for unknown scope', () => {
+      expect(service.getReadiness(999)).toBeNull();
+    });
+
+    it('returns readiness with transitions for known scope', () => {
+      const result = service.getReadiness(1);
+      expect(result).not.toBeNull();
+      expect(result!.scope_id).toBe(1);
+      expect(result!.transitions).toBeDefined();
+      expect(result!.transitions.length).toBeGreaterThan(0);
+    });
+
+    it('includes hook statuses for each transition', () => {
+      const result = service.getReadiness(1)!;
+      const transition = result.transitions[0];
+      expect(transition.hooks).toBeDefined();
+      expect(Array.isArray(transition.hooks)).toBe(true);
+    });
+  });
+
+  describe('session-enforcer hook', () => {
+    it('passes when session key exists for target column', () => {
+      // Scope 1 is in backlog, transition to active requires implementScope session key
+      // Scope 1 has sessions.implementScope = ['sess-1']
+      const result = service.getReadiness(1)!;
+      const toActive = result.transitions.find(t => t.to === 'active');
+      if (toActive) {
+        const enforcer = toActive.hooks.find(h => h.id === 'session-enforcer');
+        // If session-enforcer is on this edge, it should look at the target session key
+        if (enforcer) {
+          // The scope has the required session, so it should pass
+          expect(['pass', 'unknown']).toContain(enforcer.status);
+        }
+      }
+    });
+  });
+
+  describe('blocker-check hook', () => {
+    it('passes when blocker is in terminal status', () => {
+      // Scope 2 blocked_by [99], scope 99 is shipped (terminal)
+      const result = service.getReadiness(2)!;
+      const transition = result.transitions.find(t => t.hooks.some(h => h.id === 'blocker-check'));
+      if (transition) {
+        const blockerHook = transition.hooks.find(h => h.id === 'blocker-check');
+        expect(blockerHook?.status).toBe('pass');
+      }
+    });
+
+    it('fails when blocker is not in terminal status', () => {
+      // Add a scope blocked by non-terminal scope
+      scopes.push(makeScope({ id: 5, status: 'active', blocked_by: [100], sessions: { implementScope: ['s'] } }));
+      const result = service.getReadiness(5)!;
+      const transition = result.transitions.find(t => t.hooks.some(h => h.id === 'blocker-check'));
+      if (transition) {
+        const blockerHook = transition.hooks.find(h => h.id === 'blocker-check');
+        expect(blockerHook?.status).toBe('fail');
+      }
+    });
+  });
+
+  describe('review-gate-check hook', () => {
+    it('passes when verdict file exists with PASS', () => {
+      const verdictDir = path.join(tmpDir, '.claude', 'review-verdicts');
+      fs.mkdirSync(verdictDir, { recursive: true });
+      fs.writeFileSync(path.join(verdictDir, '002.json'), JSON.stringify({ verdict: 'PASS' }));
+
+      // Scope 2 is in active, edge active→review has review-gate-check
+      const result = service.getReadiness(2)!;
+      const toReview = result.transitions.find(t => t.to === 'review');
+      if (toReview) {
+        const reviewHook = toReview.hooks.find(h => h.id === 'review-gate-check');
+        if (reviewHook) {
+          expect(reviewHook.status).toBe('pass');
+        }
+      }
+    });
+
+    it('fails when verdict file is missing', () => {
+      const result = service.getReadiness(2)!;
+      const toReview = result.transitions.find(t => t.to === 'review');
+      if (toReview) {
+        const reviewHook = toReview.hooks.find(h => h.id === 'review-gate-check');
+        if (reviewHook) {
+          expect(reviewHook.status).toBe('fail');
+        }
+      }
+    });
+  });
+
+  describe('completion-checklist hook', () => {
+    it('fails when scope has unchecked items', () => {
+      // Scope 3 has raw_content with "- [ ] Task 1" (unchecked)
+      const result = service.getReadiness(3)!;
+      for (const transition of result.transitions) {
+        const checklist = transition.hooks.find(h => h.id === 'completion-checklist');
+        if (checklist) {
+          expect(checklist.status).toBe('fail');
+        }
+      }
+    });
+  });
+
+  describe('scope-create-gate hook', () => {
+    it('passes when scope has title and content', () => {
+      const result = service.getReadiness(1)!;
+      for (const transition of result.transitions) {
+        const gate = transition.hooks.find(h => h.id === 'scope-create-gate');
+        if (gate) {
+          expect(gate.status).toBe('pass');
+        }
+      }
+    });
+
+    it('fails when scope has no content', () => {
+      scopes.push(makeScope({ id: 6, status: 'backlog', title: '', raw_content: '' }));
+      const result = service.getReadiness(6)!;
+      for (const transition of result.transitions) {
+        const gate = transition.hooks.find(h => h.id === 'scope-create-gate');
+        if (gate) {
+          expect(gate.status).toBe('fail');
+        }
+      }
+    });
+  });
+
+  describe('lifecycle/observer hooks', () => {
+    it('scope-transition always passes', () => {
+      const result = service.getReadiness(1)!;
+      for (const transition of result.transitions) {
+        const lifecycle = transition.hooks.find(h => h.id === 'scope-transition');
+        if (lifecycle) {
+          expect(lifecycle.status).toBe('pass');
+        }
+      }
+    });
+
+    it('dashboard-sync always passes', () => {
+      const result = service.getReadiness(1)!;
+      for (const transition of result.transitions) {
+        const observer = transition.hooks.find(h => h.id === 'dashboard-sync');
+        if (observer) {
+          expect(observer.status).toBe('pass');
+        }
+      }
+    });
+  });
+});