orbital-command 0.1.0

package/server/services/event-service.ts

@@ -0,0 +1,98 @@
+import type Database from 'better-sqlite3';
+import type { Server } from 'socket.io';
+import type { RawEvent } from '../parsers/event-parser.js';
+import { createLogger } from '../utils/logger.js';
+
+const log = createLogger('event');
+
+export type EventIngestCallback = (type: string, scopeId: unknown, data: Record<string, unknown>) => void;
+
+export interface EventRow {
+  id: string;
+  type: string;
+  scope_id: number | null;
+  session_id: string | null;
+  agent: string | null;
+  data: string;
+  timestamp: string;
+  processed: number;
+}
+
+export class EventService {
+  private onIngestCallbacks: EventIngestCallback[] = [];
+
+  constructor(
+    private db: Database.Database,
+    private io: Server
+  ) {}
+
+  /** Register a callback to be called after each successful event ingest */
+  onIngest(callback: EventIngestCallback): void {
+    this.onIngestCallbacks.push(callback);
+  }
+
+  /** Ingest a parsed event into the database and broadcast it */
+  ingest(event: RawEvent): void {
+    const result = this.db.prepare(
+      `INSERT OR IGNORE INTO events (id, type, scope_id, session_id, agent, data, timestamp, processed)
+       VALUES (?, ?, ?, ?, ?, ?, ?, 1)`
+    ).run(
+      event.id,
+      event.type,
+      event.scope_id ?? null,
+      event.session_id ?? null,
+      event.agent ?? null,
+      JSON.stringify(event.data ?? {}),
+      event.timestamp
+    );
+
+    // Only broadcast if this was a new insert (not a duplicate)
+    if (result.changes === 0) {
+      log.debug('Event duplicate skipped', { id: event.id });
+      return;
+    }
+
+    log.info('Event ingested', { type: event.type, id: event.id, scope_id: event.scope_id, agent: event.agent });
+    const data = event.data ?? {};
+    this.io.emit('event:new', {
+      id: event.id,
+      type: event.type,
+      scope_id: event.scope_id ?? null,
+      session_id: event.session_id ?? null,
+      agent: event.agent ?? null,
+      data,
+      timestamp: event.timestamp,
+    });
+
+    // Trigger event-driven inference
+    for (const cb of this.onIngestCallbacks) {
+      cb(event.type, event.scope_id ?? data.scope_id, data);
+    }
+  }
+
+  /** Get recent events, optionally filtered by type */
+  getRecent(limit: number = 50, type?: string): EventRow[] {
+    if (type) {
+      return this.db
+        .prepare('SELECT * FROM events WHERE type = ? ORDER BY timestamp DESC LIMIT ?')
+        .all(type, limit) as EventRow[];
+    }
+    return this.db
+      .prepare('SELECT * FROM events ORDER BY timestamp DESC LIMIT ?')
+      .all(limit) as EventRow[];
+  }
+
+  /** Get events for a specific agent */
+  getByAgent(agent: string, limit: number = 50): EventRow[] {
+    return this.db
+      .prepare('SELECT * FROM events WHERE agent = ? ORDER BY timestamp DESC LIMIT ?')
+      .all(agent, limit) as EventRow[];
+  }
+
+  /** Get events for a specific scope */
+  getByScope(scopeId: number, limit: number = 50): EventRow[] {
+    return this.db
+      .prepare('SELECT * FROM events WHERE scope_id = ? ORDER BY timestamp DESC LIMIT ?')
+      .all(scopeId, limit) as EventRow[];
+  }
+}

package/server/services/gate-service.ts

@@ -0,0 +1,126 @@
+import type Database from 'better-sqlite3';
+import type { Server } from 'socket.io';
+import type { GateStatus } from '../../shared/api-types.js';
+import { createLogger } from '../utils/logger.js';
+
+const log = createLogger('gate');
+
+export interface GateResult {
+  scope_id: number | null;
+  gate_name: string;
+  status: GateStatus;
+  details: string | null;
+  duration_ms: number | null;
+  commit_sha: string | null;
+}
+
+export interface GateRow {
+  id: number;
+  scope_id: number | null;
+  gate_name: string;
+  status: GateStatus;
+  details: string | null;
+  duration_ms: number | null;
+  run_at: string;
+  commit_sha: string | null;
+}
+
+// The 13 quality gates from /test-checks
+export const GATE_NAMES = [
+  'type-check',
+  'lint',
+  'build',
+  'template-validation',
+  'doc-links',
+  'doc-freshness',
+  'rule-enforcement',
+  'no-placeholders',
+  'no-mock-data',
+  'no-shortcuts',
+  'no-default-secrets',
+  'no-stale-scopes',
+  'tests',
+] as const;
+
+export class GateService {
+  constructor(
+    private db: Database.Database,
+    private io: Server
+  ) {}
+
+  /** Record a gate result */
+  record(gate: GateResult): void {
+    const result = this.db.prepare(
+      `INSERT INTO quality_gates (scope_id, gate_name, status, details, duration_ms, run_at, commit_sha)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      gate.scope_id,
+      gate.gate_name,
+      gate.status,
+      gate.details,
+      gate.duration_ms,
+      new Date().toISOString(),
+      gate.commit_sha
+    );
+
+    log.info('Gate recorded', { scope_id: gate.scope_id, gate: gate.gate_name, status: gate.status, duration_ms: gate.duration_ms });
+    const inserted = this.db.prepare('SELECT * FROM quality_gates WHERE id = ?').get(result.lastInsertRowid);
+    if (inserted) {
+      this.io.emit('gate:updated', inserted);
+    }
+  }
+
+  /** Get latest gate results for a scope */
+  getLatestForScope(scopeId: number): GateRow[] {
+    return this.db.prepare(`
+      SELECT * FROM quality_gates
+      WHERE scope_id = ? AND id IN (
+        SELECT MAX(id) FROM quality_gates
+        WHERE scope_id = ?
+        GROUP BY gate_name
+      )
+      ORDER BY gate_name
+    `).all(scopeId, scopeId) as GateRow[];
+  }
+
+  /** Get latest gate run (all gates from most recent execution) */
+  getLatestRun(): GateRow[] {
+    // Get the most recent run_at timestamp
+    const latest = this.db.prepare(
+      'SELECT run_at FROM quality_gates ORDER BY run_at DESC LIMIT 1'
+    ).get() as { run_at: string } | undefined;
+
+    if (!latest) return [];
+
+    // Get all gates from that run (within 60 seconds of each other)
+    return this.db.prepare(`
+      SELECT * FROM quality_gates
+      WHERE run_at >= datetime(?, '-60 seconds')
+      ORDER BY gate_name
+    `).all(latest.run_at) as GateRow[];
+  }
+
+  /** Get gate history for trend chart */
+  getTrend(limit: number = 30): GateRow[] {
+    return this.db.prepare(`
+      SELECT gate_name, status, run_at, duration_ms
+      FROM quality_gates
+      ORDER BY run_at DESC
+      LIMIT ?
+    `).all(limit * GATE_NAMES.length) as GateRow[]; // Get enough to cover N runs
+  }
+
+  /** Get aggregate pass/fail stats */
+  getStats(): { gate_name: string; total: number; passed: number; failed: number }[] {
+    return this.db.prepare(`
+      SELECT
+        gate_name,
+        COUNT(*) as total,
+        SUM(CASE WHEN status = 'pass' THEN 1 ELSE 0 END) as passed,
+        SUM(CASE WHEN status = 'fail' THEN 1 ELSE 0 END) as failed
+      FROM quality_gates
+      GROUP BY gate_name
+      ORDER BY gate_name
+    `).all() as { gate_name: string; total: number; passed: number; failed: number }[];
+  }
+}

package/server/services/git-service.ts

@@ -0,0 +1,391 @@
+import { execFile as execFileCb } from 'child_process';
+import { promisify } from 'util';
+import { listWorktrees } from '../utils/worktree-manager.js';
+import type { ScopeCache } from './scope-cache.js';
+
+const execFile = promisify(execFileCb);
+
+// ─── Types ──────────────────────────────────────────────────
+
+export interface GitOverview {
+  branchingMode: 'trunk' | 'worktree';
+  currentBranch: string;
+  dirty: boolean;
+  detached: boolean;
+  mainHead: { sha: string; message: string; date: string } | null;
+  aheadBehind: { ahead: number; behind: number } | null;
+  worktreeCount: number;
+  featureBranchCount: number;
+}
+
+export interface CommitEntry {
+  sha: string;
+  shortSha: string;
+  message: string;
+  author: string;
+  date: string;
+  branch: string;
+  scopeId: number | null;
+  refs: string[];
+}
+
+export interface BranchInfo {
+  name: string;
+  isRemote: boolean;
+  isCurrent: boolean;
+  headSha: string;
+  headMessage: string;
+  headDate: string;
+  aheadBehind: { ahead: number; behind: number } | null;
+  scopeId: number | null;
+  isStale: boolean;
+}
+
+export interface WorktreeDetail {
+  path: string;
+  branch: string;
+  head: string;
+  scopeId: number | null;
+  scopeTitle: string | null;
+  scopeStatus: string | null;
+  dirty: boolean;
+  aheadBehind: { ahead: number; behind: number } | null;
+}
+
+export interface DriftPair {
+  from: string;
+  to: string;
+  count: number;
+  commits: Array<{ sha: string; message: string; author: string; date: string }>;
+}
+
+// ─── Cache Utility ──────────────────────────────────────────
+
+interface CacheEntry<T> { data: T; ts: number }
+
+const CACHE_TTL = 60_000; // 60 seconds
+
+function cached<T>(cache: Map<string, CacheEntry<T>>, key: string): T | null {
+  const entry = cache.get(key);
+  if (entry && Date.now() - entry.ts < CACHE_TTL) return entry.data;
+  return null;
+}
+
+function setCache<T>(cache: Map<string, CacheEntry<T>>, key: string, data: T): void {
+  cache.set(key, { data, ts: Date.now() });
+}
+
+// ─── Service ────────────────────────────────────────────────
+
+const SCOPE_BRANCH_RE = /(?:feat|fix|scope)[/-](?:scope-)?(\d+)/;
+
+export class GitService {
+  private cache = new Map<string, CacheEntry<unknown>>();
+
+  constructor(
+    private projectRoot: string,
+    private scopeCache: ScopeCache,
+  ) {}
+
+  private async git(args: string[], cwd?: string): Promise<string> {
+    // Uses execFile (not exec) — safe against shell injection
+    const { stdout } = await execFile('git', args, {
+      cwd: cwd ?? this.projectRoot,
+      maxBuffer: 10 * 1024 * 1024,
+    });
+    return stdout;
+  }
+
+  // ─── Overview ──────────────────────────────────────────────
+
+  async getOverview(branchingMode: 'trunk' | 'worktree'): Promise<GitOverview> {
+    const cacheKey = `overview:${branchingMode}`;
+    const hit = cached<GitOverview>(this.cache as Map<string, CacheEntry<GitOverview>>, cacheKey);
+    if (hit) return hit;
+
+    const [branchRaw, statusRaw] = await Promise.all([
+      this.git(['branch', '--show-current']).catch(() => ''),
+      this.git(['status', '--porcelain']).catch(() => ''),
+    ]);
+
+    const currentBranch = branchRaw.trim() || '(detached)';
+    const dirty = statusRaw.trim().length > 0;
+    const detached = !branchRaw.trim();
+
+    // Main HEAD
+    let mainHead: GitOverview['mainHead'] = null;
+    try {
+      const raw = await this.git(['log', 'HEAD', '-1', '--format=%H|%aI|%s']);
+      const [sha, date, ...msgParts] = raw.trim().split('|');
+      if (sha) mainHead = { sha, message: msgParts.join('|'), date };
+    } catch { /* no commits yet */ }
+
+    // Ahead/behind relative to origin/main (or origin/master)
+    let aheadBehind: GitOverview['aheadBehind'] = null;
+    if (!detached) {
+      try {
+        const raw = await this.git(['rev-list', '--left-right', '--count', `origin/main...${currentBranch}`]);
+        const [behind, ahead] = raw.trim().split('\t').map(Number);
+        aheadBehind = { ahead: ahead ?? 0, behind: behind ?? 0 };
+      } catch {
+        try {
+          const raw = await this.git(['rev-list', '--left-right', '--count', `origin/master...${currentBranch}`]);
+          const [behind, ahead] = raw.trim().split('\t').map(Number);
+          aheadBehind = { ahead: ahead ?? 0, behind: behind ?? 0 };
+        } catch { /* no remote tracking */ }
+      }
+    }
+
+    // Worktree and feature branch counts
+    let worktreeCount = 0;
+    let featureBranchCount = 0;
+    try {
+      const wts = await listWorktrees(this.projectRoot);
+      worktreeCount = wts.length;
+    } catch { /* ok */ }
+    try {
+      const raw = await this.git(['branch', '--format=%(refname:short)']);
+      const branches = raw.trim().split('\n').filter(Boolean);
+      featureBranchCount = branches.filter(b => SCOPE_BRANCH_RE.test(b) || b.startsWith('feat/')).length;
+    } catch { /* ok */ }
+
+    const result: GitOverview = {
+      branchingMode,
+      currentBranch,
+      dirty,
+      detached,
+      mainHead,
+      aheadBehind,
+      worktreeCount,
+      featureBranchCount,
+    };
+    setCache(this.cache as Map<string, CacheEntry<GitOverview>>, cacheKey, result);
+    return result;
+  }
+
+  // ─── Commits ──────────────────────────────────────────────
+
+  async getCommits(opts: { branch?: string; limit?: number; offset?: number } = {}): Promise<CommitEntry[]> {
+    const { branch, limit = 50, offset = 0 } = opts;
+    const cacheKey = `commits:${branch ?? 'all'}:${limit}:${offset}`;
+    const hit = cached<CommitEntry[]>(this.cache as Map<string, CacheEntry<CommitEntry[]>>, cacheKey);
+    if (hit) return hit;
+
+    const args = ['log', '--format=%H|%h|%aI|%an|%s|%D'];
+    if (branch && branch !== 'all') {
+      args.push(branch);
+    } else {
+      args.push('--all');
+    }
+    args.push(`--skip=${offset}`, `-${limit}`);
+
+    let raw: string;
+    try {
+      raw = await this.git(args);
+    } catch {
+      return [];
+    }
+
+    const commits: CommitEntry[] = [];
+    for (const line of raw.trim().split('\n')) {
+      if (!line) continue;
+      const parts = line.split('|');
+      const sha = parts[0];
+      const shortSha = parts[1];
+      const date = parts[2];
+      const author = parts[3];
+      const message = parts[4];
+      const refStr = parts.slice(5).join('|');
+
+      const refs = refStr
+        ? refStr.split(',').map(r => r.trim()).filter(Boolean)
+        : [];
+
+      // Extract scope ID from refs or message
+      let scopeId: number | null = null;
+      for (const ref of refs) {
+        const m = SCOPE_BRANCH_RE.exec(ref);
+        if (m) { scopeId = parseInt(m[1]); break; }
+      }
+      if (!scopeId) {
+        const m = SCOPE_BRANCH_RE.exec(message);
+        if (m) scopeId = parseInt(m[1]);
+      }
+
+      // Derive branch from first ref that looks like a branch
+      let branchName = '';
+      for (const ref of refs) {
+        const cleaned = ref.replace(/^HEAD -> /, '').replace(/^origin\//, '');
+        if (cleaned && !cleaned.startsWith('tag:')) {
+          branchName = cleaned;
+          break;
+        }
+      }
+
+      commits.push({ sha, shortSha, message, author, date, branch: branchName, scopeId, refs });
+    }
+
+    setCache(this.cache as Map<string, CacheEntry<CommitEntry[]>>, cacheKey, commits);
+    return commits;
+  }
+
+  // ─── Branches ──────────────────────────────────────────────
+
+  async getBranches(): Promise<BranchInfo[]> {
+    const hit = cached<BranchInfo[]>(this.cache as Map<string, CacheEntry<BranchInfo[]>>, 'branches');
+    if (hit) return hit;
+
+    let raw: string;
+    try {
+      raw = await this.git([
+        'branch', '-a',
+        '--format=%(HEAD)|%(refname:short)|%(objectname:short)|%(committerdate:iso-strict)|%(subject)',
+      ]);
+    } catch {
+      return [];
+    }
+
+    const now = Date.now();
+    const STALE_MS = 7 * 24 * 60 * 60 * 1000;
+    const branches: BranchInfo[] = [];
+
+    for (const line of raw.trim().split('\n')) {
+      if (!line) continue;
+      const [headMarker, name, headSha, headDate, ...msgParts] = line.split('|');
+      if (!name || name.includes('HEAD')) continue;
+
+      const isCurrent = headMarker === '*';
+      const isRemote = name.startsWith('remotes/') || name.startsWith('origin/');
+      const cleanName = name.replace(/^remotes\//, '');
+
+      // Skip remote duplicates of local branches
+      if (isRemote) {
+        const localName = cleanName.replace(/^origin\//, '');
+        if (branches.some(b => !b.isRemote && b.name === localName)) continue;
+      }
+
+      const scopeMatch = SCOPE_BRANCH_RE.exec(cleanName);
+      const scopeId = scopeMatch ? parseInt(scopeMatch[1]) : null;
+      const isStale = headDate ? (now - new Date(headDate).getTime() > STALE_MS) : false;
+
+      // Ahead/behind relative to origin/main
+      let aheadBehind: BranchInfo['aheadBehind'] = null;
+      if (!isRemote) {
+        try {
+          const countRaw = await this.git(['rev-list', '--left-right', '--count', `origin/main...${name}`]);
+          const [behind, ahead] = countRaw.trim().split('\t').map(Number);
+          aheadBehind = { ahead: ahead ?? 0, behind: behind ?? 0 };
+        } catch { /* no remote */ }
+      }
+
+      branches.push({
+        name: cleanName,
+        isRemote,
+        isCurrent,
+        headSha: headSha ?? '',
+        headMessage: msgParts.join('|'),
+        headDate: headDate ?? '',
+        aheadBehind,
+        scopeId,
+        isStale,
+      });
+    }
+
+    setCache(this.cache as Map<string, CacheEntry<BranchInfo[]>>, 'branches', branches);
+    return branches;
+  }
+
+  // ─── Enhanced Worktrees ────────────────────────────────────
+
+  async getEnhancedWorktrees(): Promise<WorktreeDetail[]> {
+    const hit = cached<WorktreeDetail[]>(this.cache as Map<string, CacheEntry<WorktreeDetail[]>>, 'worktrees-enhanced');
+    if (hit) return hit;
+
+    let wts: Array<{ path: string; branch: string; scopeId: number }>;
+    try {
+      wts = await listWorktrees(this.projectRoot);
+    } catch {
+      return [];
+    }
+
+    const results: WorktreeDetail[] = [];
+    for (const wt of wts) {
+      let head = '';
+      try {
+        head = (await this.git(['rev-parse', '--short', 'HEAD'], wt.path)).trim();
+      } catch { /* ok */ }
+
+      let dirty = false;
+      try {
+        const status = (await this.git(['status', '--porcelain'], wt.path)).trim();
+        dirty = status.length > 0;
+      } catch { /* ok */ }
+
+      let aheadBehind: WorktreeDetail['aheadBehind'] = null;
+      try {
+        const branchName = wt.branch.replace(/^refs\/heads\//, '');
+        const countRaw = await this.git(['rev-list', '--left-right', '--count', `origin/main...${branchName}`], wt.path);
+        const [behind, ahead] = countRaw.trim().split('\t').map(Number);
+        aheadBehind = { ahead: ahead ?? 0, behind: behind ?? 0 };
+      } catch { /* ok */ }
+
+      const scope = wt.scopeId ? this.scopeCache.getById(wt.scopeId) : null;
+
+      results.push({
+        path: wt.path,
+        branch: wt.branch.replace(/^refs\/heads\//, ''),
+        head,
+        scopeId: wt.scopeId,
+        scopeTitle: scope?.title ?? null,
+        scopeStatus: scope?.status ?? null,
+        dirty,
+        aheadBehind,
+      });
+    }
+
+    setCache(this.cache as Map<string, CacheEntry<WorktreeDetail[]>>, 'worktrees-enhanced', results);
+    return results;
+  }
+
+  // ─── Dynamic Drift ─────────────────────────────────────────
+
+  async getDrift(gitBranches: Array<{ from: string; to: string }>): Promise<DriftPair[]> {
+    const cacheKey = `drift:${gitBranches.map(b => `${b.from}-${b.to}`).join(',')}`;
+    const hit = cached<DriftPair[]>(this.cache as Map<string, CacheEntry<DriftPair[]>>, cacheKey);
+    if (hit) return hit;
+
+    const pairs: DriftPair[] = [];
+    for (const { from, to } of gitBranches) {
+      try {
+        const raw = await this.git([
+          'log', `origin/${from}`, '--not', `origin/${to}`,
+          '--reverse', '--format=%H|%aI|%s|%an',
+        ]);
+        const commits = raw.trim().split('\n').filter(Boolean).map(line => {
+          const [sha, date, ...rest] = line.split('|');
+          return { sha, date, message: rest.slice(0, -1).join('|'), author: rest[rest.length - 1] };
+        });
+        pairs.push({ from, to, count: commits.length, commits });
+      } catch {
+        pairs.push({ from, to, count: 0, commits: [] });
+      }
+    }
+
+    setCache(this.cache as Map<string, CacheEntry<DriftPair[]>>, cacheKey, pairs);
+    return pairs;
+  }
+
+  // ─── Git Status Polling ────────────────────────────────────
+
+  async getStatusHash(): Promise<string> {
+    const [head, dirty] = await Promise.all([
+      this.git(['rev-parse', 'HEAD']).catch(() => 'none'),
+      this.git(['status', '--porcelain']).catch(() => ''),
+    ]);
+    return `${head.trim()}:${dirty.trim().length > 0 ? 'dirty' : 'clean'}`;
+  }
+
+  clearCache(): void {
+    this.cache.clear();
+  }
+}