orbital-command 0.2.0 → 0.3.0

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

@@ -0,0 +1,242 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { EventService } from './event-service.js';
+import { createTestDb } from '../__tests__/helpers/db.js';
+import { createMockEmitter } from '../__tests__/helpers/mock-emitter.js';
+import type Database from 'better-sqlite3';
+import type { Emitter } from '../project-emitter.js';
+
+describe('EventService', () => {
+  let db: Database.Database;
+  let cleanup: () => void;
+  let emitter: Emitter & { emit: ReturnType<typeof vi.fn> };
+  let service: EventService;
+
+  beforeEach(() => {
+    ({ db, cleanup } = createTestDb());
+    emitter = createMockEmitter();
+    service = new EventService(db, emitter);
+  });
+
+  afterEach(() => {
+    cleanup?.();
+  });
+
+  const makeEvent = (overrides: Record<string, unknown> = {}) => ({
+    id: `evt-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+    type: 'TEST_EVENT',
+    scope_id: 1,
+    session_id: 'sess-1',
+    agent: 'test-agent',
+    data: {},
+    timestamp: new Date().toISOString(),
+    ...overrides,
+  });
+
+  // ─── ingest() ───────────────────────────────────────────────
+
+  describe('ingest()', () => {
+    it('inserts event into DB and emits event:new', () => {
+      const event = makeEvent();
+      service.ingest(event);
+
+      const row = db.prepare('SELECT * FROM events WHERE id = ?').get(event.id) as Record<string, unknown>;
+      expect(row).toBeDefined();
+      expect(row.type).toBe('TEST_EVENT');
+
+      expect(emitter.emit).toHaveBeenCalledWith('event:new', expect.objectContaining({
+        id: event.id,
+        type: 'TEST_EVENT',
+      }));
+    });
+
+    it('skips duplicate events (no emit)', () => {
+      const event = makeEvent();
+      service.ingest(event);
+      emitter.emit.mockClear();
+
+      service.ingest(event); // same id
+      expect(emitter.emit).not.toHaveBeenCalled();
+    });
+
+    it('calls registered onIngest callbacks', () => {
+      const callback = vi.fn();
+      service.onIngest(callback);
+
+      const event = makeEvent({ type: 'SCOPE_STATUS_CHANGED', data: { to: 'review' } });
+      service.ingest(event);
+
+      expect(callback).toHaveBeenCalledWith('SCOPE_STATUS_CHANGED', 1, { to: 'review' });
+    });
+
+    it('handles null optional fields', () => {
+      const event = makeEvent({ scope_id: undefined, session_id: undefined, agent: undefined });
+      service.ingest(event);
+
+      const row = db.prepare('SELECT * FROM events WHERE id = ?').get(event.id) as Record<string, unknown>;
+      expect(row.scope_id).toBeNull();
+      expect(row.session_id).toBeNull();
+      expect(row.agent).toBeNull();
+    });
+  });
+
+  // ─── getRecent() ────────────────────────────────────────────
+
+  describe('getRecent()', () => {
+    it('returns events ordered by timestamp DESC with limit', () => {
+      for (let i = 0; i < 5; i++) {
+        service.ingest(makeEvent({ id: `evt-${i}`, timestamp: `2026-01-0${i + 1}T00:00:00Z` }));
+      }
+
+      const recent = service.getRecent(3);
+      expect(recent).toHaveLength(3);
+      expect(recent[0].timestamp).toBe('2026-01-05T00:00:00Z');
+    });
+
+    it('filters by type when provided', () => {
+      service.ingest(makeEvent({ id: 'a', type: 'TYPE_A' }));
+      service.ingest(makeEvent({ id: 'b', type: 'TYPE_B' }));
+      service.ingest(makeEvent({ id: 'c', type: 'TYPE_A' }));
+
+      const result = service.getRecent(50, 'TYPE_A');
+      expect(result).toHaveLength(2);
+      expect(result.every(r => r.type === 'TYPE_A')).toBe(true);
+    });
+  });
+
+  // ─── getFiltered() ──────────────────────────────────────────
+
+  describe('getFiltered()', () => {
+    beforeEach(() => {
+      service.ingest(makeEvent({ id: 'f1', type: 'A', scope_id: 1 }));
+      service.ingest(makeEvent({ id: 'f2', type: 'B', scope_id: 1 }));
+      service.ingest(makeEvent({ id: 'f3', type: 'A', scope_id: 2 }));
+    });
+
+    it('filters by type', () => {
+      const result = service.getFiltered({ type: 'A' });
+      expect(result).toHaveLength(2);
+    });
+
+    it('filters by scopeId', () => {
+      const result = service.getFiltered({ scopeId: 2 });
+      expect(result).toHaveLength(1);
+      expect(result[0].id).toBe('f3');
+    });
+
+    it('combines type + scopeId', () => {
+      const result = service.getFiltered({ type: 'A', scopeId: 1 });
+      expect(result).toHaveLength(1);
+      expect(result[0].id).toBe('f1');
+    });
+  });
+
+  // ─── getByAgent() / getByScope() ───────────────────────────
+
+  describe('getByAgent()', () => {
+    it('filters by agent name', () => {
+      service.ingest(makeEvent({ id: 'a1', agent: 'attacker' }));
+      service.ingest(makeEvent({ id: 'a2', agent: 'architect' }));
+      service.ingest(makeEvent({ id: 'a3', agent: 'attacker' }));
+
+      const result = service.getByAgent('attacker');
+      expect(result).toHaveLength(2);
+    });
+  });
+
+  describe('getByScope()', () => {
+    it('filters by scope_id', () => {
+      service.ingest(makeEvent({ id: 's1', scope_id: 42 }));
+      service.ingest(makeEvent({ id: 's2', scope_id: 99 }));
+
+      const result = service.getByScope(42);
+      expect(result).toHaveLength(1);
+    });
+  });
+
+  // ─── getViolationSummary() ──────────────────────────────────
+
+  describe('getViolationSummary()', () => {
+    it('returns zeros when no violation events exist', () => {
+      const summary = service.getViolationSummary();
+      expect(summary.totalViolations).toBe(0);
+      expect(summary.totalOverrides).toBe(0);
+      expect(summary.byRule).toEqual([]);
+      expect(summary.byFile).toEqual([]);
+    });
+
+    it('aggregates violation data', () => {
+      service.ingest(makeEvent({ id: 'v1', type: 'VIOLATION', data: { rule: 'no-todo', file: 'src/app.ts' } }));
+      service.ingest(makeEvent({ id: 'v2', type: 'VIOLATION', data: { rule: 'no-todo', file: 'src/app.ts' } }));
+      service.ingest(makeEvent({ id: 'v3', type: 'VIOLATION', data: { rule: 'no-mock', file: 'src/lib.ts' } }));
+      service.ingest(makeEvent({ id: 'o1', type: 'OVERRIDE', data: { rule: 'no-todo', reason: 'legitimate use' } }));
+
+      const summary = service.getViolationSummary();
+      expect(summary.totalViolations).toBe(3);
+      expect(summary.totalOverrides).toBe(1);
+      expect(summary.byRule).toHaveLength(2);
+      expect(summary.byRule[0].rule).toBe('no-todo');
+      expect(summary.byRule[0].count).toBe(2);
+      expect(summary.byFile).toHaveLength(2);
+      expect(summary.overrides).toHaveLength(1);
+    });
+  });
+
+  // ─── getViolationStatsByRule() ──────────────────────────────
+
+  describe('getViolationStatsByRule()', () => {
+    it('returns maps keyed by rule name', () => {
+      service.ingest(makeEvent({ id: 'v1', type: 'VIOLATION', data: { rule: 'no-todo' } }));
+      service.ingest(makeEvent({ id: 'o1', type: 'OVERRIDE', data: { rule: 'no-todo' } }));
+
+      const stats = service.getViolationStatsByRule();
+      expect(stats.violations.get('no-todo')?.count).toBe(1);
+      expect(stats.overrides.get('no-todo')?.count).toBe(1);
+    });
+  });
+
+  // ─── getViolationTrend() ────────────────────────────────────
+
+  describe('getViolationTrend()', () => {
+    it('returns violations grouped by day and rule', () => {
+      service.ingest(makeEvent({ id: 'vt1', type: 'VIOLATION', data: { rule: 'no-todo' }, timestamp: '2026-04-01T10:00:00Z' }));
+      service.ingest(makeEvent({ id: 'vt2', type: 'VIOLATION', data: { rule: 'no-todo' }, timestamp: '2026-04-01T14:00:00Z' }));
+      service.ingest(makeEvent({ id: 'vt3', type: 'VIOLATION', data: { rule: 'no-mock' }, timestamp: '2026-04-02T10:00:00Z' }));
+
+      const trend = service.getViolationTrend(365);
+      expect(trend.length).toBeGreaterThanOrEqual(2);
+      const day1 = trend.find(t => t.day === '2026-04-01' && t.rule === 'no-todo');
+      expect(day1?.count).toBe(2);
+    });
+
+    it('returns empty array when no violations exist', () => {
+      expect(service.getViolationTrend()).toEqual([]);
+    });
+  });
+
+  // ─── getDeployFrequency() ───────────────────────────────────
+
+  describe('getDeployFrequency()', () => {
+    it('returns deployment counts grouped by week and environment', () => {
+      const now = new Date();
+      const ts = now.toISOString();
+      // Insert deployments directly into the DB (EventService queries the deployments table)
+      db.prepare(
+        `INSERT INTO deployments (environment, status, commit_sha, branch, started_at, details) VALUES (?, ?, ?, ?, ?, ?)`
+      ).run('staging', 'healthy', 'abc', 'main', ts, '{}');
+      db.prepare(
+        `INSERT INTO deployments (environment, status, commit_sha, branch, started_at, details) VALUES (?, ?, ?, ?, ?, ?)`
+      ).run('production', 'healthy', 'def', 'main', ts, '{}');
+
+      const freq = service.getDeployFrequency();
+      expect(freq.length).toBeGreaterThanOrEqual(1);
+      const week = freq[0];
+      expect(week).toHaveProperty('week');
+      expect(week).toHaveProperty('staging');
+      expect(week).toHaveProperty('production');
+    });
+
+    it('returns empty array when no deployments exist', () => {
+      expect(service.getDeployFrequency()).toEqual([]);
+    });
+  });
+});

package/server/services/event-service.ts

@@ -1,5 +1,5 @@
 import type Database from 'better-sqlite3';
-import type { Server } from 'socket.io';
+import type { Emitter } from '../project-emitter.js';
 import type { RawEvent } from '../parsers/event-parser.js';
 import { createLogger } from '../utils/logger.js';
 
@@ -23,7 +23,7 @@ export class EventService {
 
   constructor(
     private db: Database.Database,
-    private io: Server
+    private io: Emitter
   ) {}
 
   /** Register a callback to be called after each successful event ingest */
@@ -52,7 +52,7 @@ export class EventService {
       return;
     }
 
-    log.info('Event ingested', { type: event.type, id: event.id, scope_id: event.scope_id, agent: event.agent });
+    log.debug('Event ingested', { type: event.type, id: event.id, scope_id: event.scope_id });
     const data = event.data ?? {};
     this.io.emit('event:new', {
       id: event.id,
@@ -95,4 +95,93 @@ export class EventService {
       .prepare('SELECT * FROM events WHERE scope_id = ? ORDER BY timestamp DESC LIMIT ?')
       .all(scopeId, limit) as EventRow[];
   }
+
+  /** Get filtered events with optional type and scope_id filters */
+  getFiltered(options: { limit?: number; type?: string; scopeId?: number }): EventRow[] {
+    const { limit = 50, type, scopeId } = options;
+    let query = 'SELECT * FROM events WHERE 1=1';
+    const params: unknown[] = [];
+    if (type) { query += ' AND type = ?'; params.push(type); }
+    if (scopeId) { query += ' AND scope_id = ?'; params.push(scopeId); }
+    query += ' ORDER BY timestamp DESC LIMIT ?';
+    params.push(limit);
+    return this.db.prepare(query).all(...params) as EventRow[];
+  }
+
+  /** Get violation summary: by rule, by file, overrides, and totals */
+  getViolationSummary(): {
+    byRule: Array<{ rule: string; count: number; last_seen: string }>;
+    byFile: Array<{ file: string; count: number }>;
+    overrides: Array<{ rule: string; reason: string; date: string }>;
+    totalViolations: number;
+    totalOverrides: number;
+  } {
+    const byRule = this.db.prepare(
+      `SELECT JSON_EXTRACT(data, '$.rule') as rule, COUNT(*) as count, MAX(timestamp) as last_seen
+       FROM events WHERE type = 'VIOLATION' GROUP BY rule ORDER BY count DESC`
+    ).all() as Array<{ rule: string; count: number; last_seen: string }>;
+
+    const byFile = this.db.prepare(
+      `SELECT JSON_EXTRACT(data, '$.file') as file, COUNT(*) as count FROM events
+       WHERE type = 'VIOLATION' AND JSON_EXTRACT(data, '$.file') IS NOT NULL AND JSON_EXTRACT(data, '$.file') != ''
+       GROUP BY file ORDER BY count DESC LIMIT 20`
+    ).all() as Array<{ file: string; count: number }>;
+
+    const overrides = this.db.prepare(
+      `SELECT JSON_EXTRACT(data, '$.rule') as rule, JSON_EXTRACT(data, '$.reason') as reason, timestamp as date
+       FROM events WHERE type = 'OVERRIDE' ORDER BY timestamp DESC LIMIT 50`
+    ).all() as Array<{ rule: string; reason: string; date: string }>;
+
+    const totalViolations = (this.db.prepare(`SELECT COUNT(*) as count FROM events WHERE type = 'VIOLATION'`).get() as { count: number }).count;
+    const totalOverrides = (this.db.prepare(`SELECT COUNT(*) as count FROM events WHERE type = 'OVERRIDE'`).get() as { count: number }).count;
+
+    return { byRule, byFile, overrides, totalViolations, totalOverrides };
+  }
+
+  /** Get per-rule violation and override counts (for enforcement rules view) */
+  getViolationStatsByRule(): {
+    violations: Map<string, { count: number; last_seen: string }>;
+    overrides: Map<string, { count: number }>;
+  } {
+    const violationStats = this.db.prepare(
+      `SELECT JSON_EXTRACT(data, '$.rule') as rule, COUNT(*) as count, MAX(timestamp) as last_seen
+       FROM events WHERE type = 'VIOLATION' GROUP BY rule`
+    ).all() as Array<{ rule: string; count: number; last_seen: string }>;
+
+    const overrideStats = this.db.prepare(
+      `SELECT JSON_EXTRACT(data, '$.rule') as rule, COUNT(*) as count
+       FROM events WHERE type = 'OVERRIDE' GROUP BY rule`
+    ).all() as Array<{ rule: string; count: number }>;
+
+    return {
+      violations: new Map(violationStats.map(v => [v.rule, v])),
+      overrides: new Map(overrideStats.map(o => [o.rule, o])),
+    };
+  }
+
+  /** Get violation trend data grouped by day and rule */
+  getViolationTrend(days: number = 30): Array<{ day: string; rule: string; count: number }> {
+    return this.db.prepare(
+      `SELECT date(timestamp) as day, JSON_EXTRACT(data, '$.rule') as rule, COUNT(*) as count
+       FROM events WHERE type = 'VIOLATION' AND timestamp >= datetime('now', ? || ' days')
+       GROUP BY day, rule ORDER BY day ASC`
+    ).all(`-${days}`) as Array<{ day: string; rule: string; count: number }>;
+  }
+
+  /** Get deployment frequency by week and environment */
+  getDeployFrequency(): Array<{ week: string; staging: number; production: number }> {
+    const rows = this.db.prepare(
+      `SELECT environment, strftime('%Y-W%W', started_at) as week, COUNT(*) as count
+       FROM deployments WHERE started_at > datetime('now', '-56 days') GROUP BY environment, week ORDER BY week ASC`
+    ).all() as Array<{ environment: string; week: string; count: number }>;
+
+    const weekMap = new Map<string, { week: string; staging: number; production: number }>();
+    for (const row of rows) {
+      if (!weekMap.has(row.week)) weekMap.set(row.week, { week: row.week, staging: 0, production: 0 });
+      const entry = weekMap.get(row.week)!;
+      if (row.environment === 'staging') entry.staging = row.count;
+      if (row.environment === 'production') entry.production = row.count;
+    }
+    return [...weekMap.values()];
+  }
 }

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

@@ -0,0 +1,131 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { GateService } from './gate-service.js';
+import { createTestDb } from '../__tests__/helpers/db.js';
+import { createMockEmitter } from '../__tests__/helpers/mock-emitter.js';
+import type Database from 'better-sqlite3';
+import type { Emitter } from '../project-emitter.js';
+
+describe('GateService', () => {
+  let db: Database.Database;
+  let cleanup: () => void;
+  let emitter: Emitter & { emit: ReturnType<typeof vi.fn> };
+  let service: GateService;
+
+  beforeEach(() => {
+    ({ db, cleanup } = createTestDb());
+    emitter = createMockEmitter();
+    service = new GateService(db, emitter);
+  });
+
+  afterEach(() => {
+    cleanup?.();
+  });
+
+  // ─── record() ─────────────────────────────────────────────
+
+  describe('record()', () => {
+    it('inserts gate result and emits gate:updated', () => {
+      service.record({
+        scope_id: 1,
+        gate_name: 'type-check',
+        status: 'pass',
+        details: null,
+        duration_ms: 1200,
+        commit_sha: 'abc1234',
+      });
+
+      const rows = db.prepare('SELECT * FROM quality_gates').all() as Array<Record<string, unknown>>;
+      expect(rows).toHaveLength(1);
+      expect(rows[0].gate_name).toBe('type-check');
+      expect(rows[0].status).toBe('pass');
+      expect(rows[0].duration_ms).toBe(1200);
+
+      expect(emitter.emit).toHaveBeenCalledWith('gate:updated', expect.objectContaining({
+        gate_name: 'type-check',
+        status: 'pass',
+      }));
+    });
+
+    it('sets run_at to current timestamp', () => {
+      service.record({
+        scope_id: null,
+        gate_name: 'lint',
+        status: 'fail',
+        details: 'ESLint errors',
+        duration_ms: null,
+        commit_sha: null,
+      });
+
+      const row = db.prepare('SELECT run_at FROM quality_gates').get() as { run_at: string };
+      expect(row.run_at).toMatch(/^\d{4}-\d{2}-\d{2}T/);
+    });
+  });
+
+  // ─── getLatestForScope() ──────────────────────────────────
+
+  describe('getLatestForScope()', () => {
+    it('returns latest gate per gate_name for scope', () => {
+      service.record({ scope_id: 1, gate_name: 'type-check', status: 'fail', details: null, duration_ms: null, commit_sha: null });
+      service.record({ scope_id: 1, gate_name: 'type-check', status: 'pass', details: null, duration_ms: null, commit_sha: null });
+      service.record({ scope_id: 1, gate_name: 'lint', status: 'pass', details: null, duration_ms: null, commit_sha: null });
+
+      const latest = service.getLatestForScope(1);
+      expect(latest).toHaveLength(2);
+      const typeCheck = latest.find(g => g.gate_name === 'type-check');
+      expect(typeCheck?.status).toBe('pass'); // latest one
+    });
+
+    it('returns empty for unknown scope', () => {
+      expect(service.getLatestForScope(999)).toEqual([]);
+    });
+  });
+
+  // ─── getLatestRun() ───────────────────────────────────────
+
+  describe('getLatestRun()', () => {
+    it('returns all gates from most recent run', () => {
+      service.record({ scope_id: null, gate_name: 'type-check', status: 'pass', details: null, duration_ms: null, commit_sha: null });
+      service.record({ scope_id: null, gate_name: 'lint', status: 'pass', details: null, duration_ms: null, commit_sha: null });
+
+      const run = service.getLatestRun();
+      expect(run.length).toBeGreaterThanOrEqual(2);
+    });
+
+    it('returns empty when no gates exist', () => {
+      expect(service.getLatestRun()).toEqual([]);
+    });
+  });
+
+  // ─── getTrend() ───────────────────────────────────────────
+
+  describe('getTrend()', () => {
+    it('returns gate history ordered by run_at DESC', () => {
+      service.record({ scope_id: null, gate_name: 'build', status: 'pass', details: null, duration_ms: 500, commit_sha: null });
+      service.record({ scope_id: null, gate_name: 'build', status: 'fail', details: null, duration_ms: 600, commit_sha: null });
+
+      const trend = service.getTrend(10);
+      expect(trend.length).toBe(2);
+    });
+  });
+
+  // ─── getStats() ───────────────────────────────────────────
+
+  describe('getStats()', () => {
+    it('returns aggregate pass/fail per gate_name', () => {
+      service.record({ scope_id: null, gate_name: 'type-check', status: 'pass', details: null, duration_ms: null, commit_sha: null });
+      service.record({ scope_id: null, gate_name: 'type-check', status: 'pass', details: null, duration_ms: null, commit_sha: null });
+      service.record({ scope_id: null, gate_name: 'type-check', status: 'fail', details: null, duration_ms: null, commit_sha: null });
+
+      const stats = service.getStats();
+      const typeCheck = stats.find(s => s.gate_name === 'type-check');
+      expect(typeCheck).toBeDefined();
+      expect(typeCheck!.total).toBe(3);
+      expect(typeCheck!.passed).toBe(2);
+      expect(typeCheck!.failed).toBe(1);
+    });
+
+    it('returns empty array when no gates exist', () => {
+      expect(service.getStats()).toEqual([]);
+    });
+  });
+});

package/server/services/gate-service.ts

@@ -1,5 +1,5 @@
 import type Database from 'better-sqlite3';
-import type { Server } from 'socket.io';
+import type { Emitter } from '../project-emitter.js';
 import type { GateStatus } from '../../shared/api-types.js';
 import { createLogger } from '../utils/logger.js';
 
@@ -45,7 +45,7 @@ export const GATE_NAMES = [
 export class GateService {
   constructor(
     private db: Database.Database,
-    private io: Server
+    private io: Emitter
   ) {}
 
   /** Record a gate result */