specrails-hub 0.1.0

package/server/db.ts

@@ -0,0 +1,514 @@
+import fs from 'fs'
+import path from 'path'
+import Database from 'better-sqlite3'
+import type { JobRow, EventRow, StatsRow, JobStatus, ChatConversationRow, ChatMessageRow } from './types'
+
+// ─── Proposal types ───────────────────────────────────────────────────────────
+
+export interface ProposalRow {
+  id: string
+  idea: string
+  session_id: string | null
+  status: string
+  result_markdown: string | null
+  issue_url: string | null
+  created_at: string
+  updated_at: string
+}
+
+export type DbInstance = InstanceType<typeof Database>
+
+// ─── Internal types ──────────────────────────────────────────────────────────
+
+export interface NewJob {
+  id: string
+  command: string
+  started_at: string
+}
+
+export interface JobResult {
+  exit_code: number
+  status: JobStatus
+  tokens_in?: number
+  tokens_out?: number
+  tokens_cache_read?: number
+  tokens_cache_create?: number
+  total_cost_usd?: number
+  num_turns?: number
+  model?: string
+  duration_ms?: number
+  duration_api_ms?: number
+  session_id?: string
+}
+
+export interface AppEvent {
+  event_type: string
+  source?: string | null
+  payload: string
+}
+
+export interface ListJobsOpts {
+  limit?: number
+  offset?: number
+  status?: string
+  from?: string
+  to?: string
+}
+
+// ─── Migrations ──────────────────────────────────────────────────────────────
+
+type Migration = (db: DbInstance) => void
+
+const MIGRATIONS: Migration[] = [
+  // Migration 1: initial schema
+  (db) => {
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS schema_migrations (
+        version     INTEGER PRIMARY KEY,
+        applied_at  TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS jobs (
+        id                   TEXT    PRIMARY KEY,
+        command              TEXT    NOT NULL,
+        started_at           TEXT    NOT NULL,
+        finished_at          TEXT,
+        status               TEXT    NOT NULL DEFAULT 'running',
+        exit_code            INTEGER,
+        tokens_in            INTEGER,
+        tokens_out           INTEGER,
+        tokens_cache_read    INTEGER,
+        tokens_cache_create  INTEGER,
+        total_cost_usd       REAL,
+        num_turns            INTEGER,
+        model                TEXT,
+        duration_ms          INTEGER,
+        duration_api_ms      INTEGER,
+        session_id           TEXT
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_jobs_started_at ON jobs(started_at);
+      CREATE INDEX IF NOT EXISTS idx_jobs_status ON jobs(status);
+
+      CREATE TABLE IF NOT EXISTS events (
+        id          INTEGER PRIMARY KEY AUTOINCREMENT,
+        job_id      TEXT    NOT NULL REFERENCES jobs(id) ON DELETE CASCADE,
+        seq         INTEGER NOT NULL,
+        event_type  TEXT    NOT NULL,
+        source      TEXT,
+        payload     TEXT    NOT NULL,
+        timestamp   TEXT    NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_events_job_id ON events(job_id);
+
+      CREATE TABLE IF NOT EXISTS job_phases (
+        job_id      TEXT    NOT NULL REFERENCES jobs(id) ON DELETE CASCADE,
+        phase       TEXT    NOT NULL,
+        state       TEXT    NOT NULL,
+        updated_at  TEXT    NOT NULL,
+        PRIMARY KEY (job_id, phase)
+      );
+    `)
+  },
+
+  // Migration 2: add queue_position column to jobs
+  (db) => {
+    db.exec(`
+      ALTER TABLE jobs ADD COLUMN queue_position INTEGER;
+    `)
+  },
+
+  // Migration 3: add queue_state table for persisting queue config (e.g., paused)
+  (db) => {
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS queue_state (
+        key   TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+
+      INSERT OR IGNORE INTO queue_state (key, value) VALUES ('paused', 'false');
+    `)
+  },
+
+  // Migration 4: chat conversations and messages
+  (db) => {
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS chat_conversations (
+        id           TEXT PRIMARY KEY,
+        title        TEXT,
+        model        TEXT NOT NULL DEFAULT 'claude-sonnet-4-5',
+        session_id   TEXT,
+        created_at   TEXT NOT NULL DEFAULT (datetime('now')),
+        updated_at   TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS chat_messages (
+        id              INTEGER PRIMARY KEY AUTOINCREMENT,
+        conversation_id TEXT NOT NULL REFERENCES chat_conversations(id) ON DELETE CASCADE,
+        role            TEXT NOT NULL CHECK(role IN ('user', 'assistant')),
+        content         TEXT NOT NULL,
+        created_at      TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_chat_messages_conv ON chat_messages(conversation_id);
+    `)
+  },
+
+  // Migration 5: proposals table
+  (db) => {
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS proposals (
+        id              TEXT    PRIMARY KEY,
+        idea            TEXT    NOT NULL,
+        session_id      TEXT,
+        status          TEXT    NOT NULL DEFAULT 'input',
+        result_markdown TEXT,
+        issue_url       TEXT,
+        created_at      TEXT    NOT NULL DEFAULT (datetime('now')),
+        updated_at      TEXT    NOT NULL DEFAULT (datetime('now'))
+      );
+      CREATE INDEX IF NOT EXISTS idx_proposals_status ON proposals(status);
+      CREATE INDEX IF NOT EXISTS idx_proposals_created_at ON proposals(created_at);
+    `)
+  },
+]
+
+function applyMigrations(db: DbInstance): void {
+  // Ensure the migrations table exists (migration 1 creates it, but we need
+  // it before we can read from it)
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS schema_migrations (
+      version     INTEGER PRIMARY KEY,
+      applied_at  TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `)
+
+  const appliedVersions = new Set<number>(
+    (db.prepare('SELECT version FROM schema_migrations').all() as { version: number }[])
+      .map((r) => r.version)
+  )
+
+  for (let i = 0; i < MIGRATIONS.length; i++) {
+    const version = i + 1
+    if (!appliedVersions.has(version)) {
+      MIGRATIONS[i](db)
+      db.prepare('INSERT OR IGNORE INTO schema_migrations (version) VALUES (?)').run(version)
+    }
+  }
+}
+
+// ─── Public API ──────────────────────────────────────────────────────────────
+
+export function initDb(dbPath: string): DbInstance {
+  if (dbPath !== ':memory:') {
+    const dir = path.dirname(dbPath)
+    fs.mkdirSync(dir, { recursive: true })
+  }
+
+  const db = new Database(dbPath)
+  db.pragma('journal_mode = WAL')
+  db.pragma('foreign_keys = ON')
+
+  applyMigrations(db)
+
+  // Orphan sweep: mark any running jobs as failed on startup
+  db.prepare(
+    "UPDATE jobs SET status = 'failed', finished_at = ? WHERE status = 'running'"
+  ).run(new Date().toISOString())
+
+  // Orphan sweep: cancel any in-flight proposals from a previous server session
+  db.prepare(
+    "UPDATE proposals SET status = 'cancelled', updated_at = ? WHERE status IN ('exploring', 'refining')"
+  ).run(new Date().toISOString())
+
+  return db
+}
+
+export function createJob(db: DbInstance, job: NewJob): void {
+  db.prepare(
+    'INSERT INTO jobs (id, command, started_at, status) VALUES (?, ?, ?, ?)'
+  ).run(job.id, job.command, job.started_at, 'running')
+}
+
+export function finishJob(
+  db: DbInstance,
+  jobId: string,
+  result: JobResult
+): void {
+  db.prepare(`
+    UPDATE jobs SET
+      status              = ?,
+      exit_code           = ?,
+      finished_at         = ?,
+      tokens_in           = ?,
+      tokens_out          = ?,
+      tokens_cache_read   = ?,
+      tokens_cache_create = ?,
+      total_cost_usd      = ?,
+      num_turns           = ?,
+      model               = ?,
+      duration_ms         = ?,
+      duration_api_ms     = ?,
+      session_id          = ?
+    WHERE id = ?
+  `).run(
+    result.status,
+    result.exit_code,
+    new Date().toISOString(),
+    result.tokens_in ?? null,
+    result.tokens_out ?? null,
+    result.tokens_cache_read ?? null,
+    result.tokens_cache_create ?? null,
+    result.total_cost_usd ?? null,
+    result.num_turns ?? null,
+    result.model ?? null,
+    result.duration_ms ?? null,
+    result.duration_api_ms ?? null,
+    result.session_id ?? null,
+    jobId,
+  )
+}
+
+export function appendEvent(
+  db: DbInstance,
+  jobId: string,
+  seq: number,
+  event: AppEvent
+): void {
+  db.prepare(
+    'INSERT INTO events (job_id, seq, event_type, source, payload) VALUES (?, ?, ?, ?, ?)'
+  ).run(jobId, seq, event.event_type, event.source ?? null, event.payload)
+}
+
+export function upsertPhase(
+  db: DbInstance,
+  jobId: string,
+  phase: string,
+  state: string
+): void {
+  db.prepare(
+    'INSERT OR REPLACE INTO job_phases (job_id, phase, state, updated_at) VALUES (?, ?, ?, ?)'
+  ).run(jobId, phase, state, new Date().toISOString())
+}
+
+export function listJobs(
+  db: DbInstance,
+  opts: ListJobsOpts
+): { jobs: JobRow[]; total: number } {
+  const limit = Math.min(opts.limit ?? 50, 200)
+  const offset = opts.offset ?? 0
+
+  const conditions: string[] = []
+  const params: unknown[] = []
+
+  if (opts.status) {
+    conditions.push('status = ?')
+    params.push(opts.status)
+  }
+  if (opts.from) {
+    conditions.push('started_at >= ?')
+    params.push(opts.from)
+  }
+  if (opts.to) {
+    conditions.push('started_at <= ?')
+    params.push(opts.to)
+  }
+
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : ''
+
+  const countRow = db
+    .prepare(`SELECT COUNT(*) as count FROM jobs ${where}`)
+    .get(...params) as { count: number }
+
+  const jobs = db
+    .prepare(
+      `SELECT * FROM jobs ${where} ORDER BY started_at DESC LIMIT ? OFFSET ?`
+    )
+    .all(...params, limit, offset) as JobRow[]
+
+  return { jobs, total: countRow.count }
+}
+
+export function getJob(
+  db: DbInstance,
+  jobId: string
+): JobRow | undefined {
+  return db
+    .prepare('SELECT * FROM jobs WHERE id = ?')
+    .get(jobId) as JobRow | undefined
+}
+
+export function getJobEvents(
+  db: DbInstance,
+  jobId: string
+): EventRow[] {
+  return db
+    .prepare('SELECT * FROM events WHERE job_id = ? ORDER BY seq ASC')
+    .all(jobId) as EventRow[]
+}
+
+export function deleteJob(db: DbInstance, jobId: string): void {
+  db.prepare('DELETE FROM jobs WHERE id = ?').run(jobId)
+}
+
+export function purgeJobs(
+  db: DbInstance,
+  opts?: { from?: string; to?: string }
+): number {
+  const conditions: string[] = ["status IN ('completed', 'failed', 'canceled')"]
+  const params: unknown[] = []
+
+  if (opts?.from) {
+    conditions.push('started_at >= ?')
+    params.push(opts.from)
+  }
+  if (opts?.to) {
+    conditions.push('started_at <= ?')
+    params.push(opts.to)
+  }
+
+  const where = conditions.join(' AND ')
+
+  // Delete associated events first
+  db.prepare(`DELETE FROM events WHERE job_id IN (SELECT id FROM jobs WHERE ${where})`).run(...params)
+  // Delete associated phases
+  db.prepare(`DELETE FROM job_phases WHERE job_id IN (SELECT id FROM jobs WHERE ${where})`).run(...params)
+  // Delete the jobs
+  const result = db.prepare(`DELETE FROM jobs WHERE ${where}`).run(...params)
+  return result.changes
+}
+
+// ─── Chat DB functions ────────────────────────────────────────────────────────
+
+export function createConversation(db: DbInstance, opts: { id: string; model: string }): void {
+  db.prepare(
+    'INSERT INTO chat_conversations (id, model) VALUES (?, ?)'
+  ).run(opts.id, opts.model)
+}
+
+export function listConversations(db: DbInstance): ChatConversationRow[] {
+  return db.prepare(
+    'SELECT * FROM chat_conversations ORDER BY updated_at DESC'
+  ).all() as ChatConversationRow[]
+}
+
+export function getConversation(db: DbInstance, id: string): ChatConversationRow | undefined {
+  return db.prepare('SELECT * FROM chat_conversations WHERE id = ?').get(id) as ChatConversationRow | undefined
+}
+
+export function deleteConversation(db: DbInstance, id: string): void {
+  db.prepare('DELETE FROM chat_conversations WHERE id = ?').run(id)
+}
+
+export function updateConversation(
+  db: DbInstance,
+  id: string,
+  patch: { title?: string; session_id?: string; model?: string }
+): void {
+  const sets: string[] = ['updated_at = ?']
+  const params: unknown[] = [new Date().toISOString()]
+  if (patch.title !== undefined) { sets.push('title = ?'); params.push(patch.title) }
+  if (patch.session_id !== undefined) { sets.push('session_id = ?'); params.push(patch.session_id) }
+  if (patch.model !== undefined) { sets.push('model = ?'); params.push(patch.model) }
+  params.push(id)
+  db.prepare(`UPDATE chat_conversations SET ${sets.join(', ')} WHERE id = ?`).run(...params)
+}
+
+export function addMessage(
+  db: DbInstance,
+  msg: { conversation_id: string; role: 'user' | 'assistant'; content: string }
+): ChatMessageRow {
+  const result = db.prepare(
+    'INSERT INTO chat_messages (conversation_id, role, content) VALUES (?, ?, ?)'
+  ).run(msg.conversation_id, msg.role, msg.content)
+  return db.prepare('SELECT * FROM chat_messages WHERE id = ?').get(Number(result.lastInsertRowid)) as ChatMessageRow
+}
+
+export function getMessages(db: DbInstance, conversationId: string): ChatMessageRow[] {
+  return db.prepare(
+    'SELECT * FROM chat_messages WHERE conversation_id = ? ORDER BY id ASC'
+  ).all(conversationId) as ChatMessageRow[]
+}
+
+// ─── Proposal DB functions ────────────────────────────────────────────────────
+
+export function createProposal(db: DbInstance, opts: { id: string; idea: string }): void {
+  db.prepare(
+    'INSERT INTO proposals (id, idea, status) VALUES (?, ?, ?)'
+  ).run(opts.id, opts.idea, 'input')
+}
+
+export function getProposal(db: DbInstance, id: string): ProposalRow | undefined {
+  return db.prepare('SELECT * FROM proposals WHERE id = ?').get(id) as ProposalRow | undefined
+}
+
+export function listProposals(
+  db: DbInstance,
+  opts?: { limit?: number; offset?: number }
+): { proposals: ProposalRow[]; total: number } {
+  const limit = Math.min(opts?.limit ?? 20, 100)
+  const offset = opts?.offset ?? 0
+
+  const countRow = db
+    .prepare('SELECT COUNT(*) as count FROM proposals')
+    .get() as { count: number }
+
+  const proposals = db
+    .prepare('SELECT * FROM proposals ORDER BY created_at DESC LIMIT ? OFFSET ?')
+    .all(limit, offset) as ProposalRow[]
+
+  return { proposals, total: countRow.count }
+}
+
+export function updateProposal(
+  db: DbInstance,
+  id: string,
+  patch: {
+    status?: string
+    session_id?: string
+    result_markdown?: string
+    issue_url?: string
+  }
+): void {
+  const sets: string[] = ['updated_at = ?']
+  const params: unknown[] = [new Date().toISOString()]
+  if (patch.status !== undefined) { sets.push('status = ?'); params.push(patch.status) }
+  if (patch.session_id !== undefined) { sets.push('session_id = ?'); params.push(patch.session_id) }
+  if (patch.result_markdown !== undefined) { sets.push('result_markdown = ?'); params.push(patch.result_markdown) }
+  if (patch.issue_url !== undefined) { sets.push('issue_url = ?'); params.push(patch.issue_url) }
+  params.push(id)
+  db.prepare(`UPDATE proposals SET ${sets.join(', ')} WHERE id = ?`).run(...params)
+}
+
+export function deleteProposal(db: DbInstance, id: string): void {
+  db.prepare('DELETE FROM proposals WHERE id = ?').run(id)
+}
+
+export function getStats(db: DbInstance): StatsRow {
+  const today = new Date().toISOString().slice(0, 10) // YYYY-MM-DD
+
+  const totalRow = db.prepare(`
+    SELECT
+      COUNT(*) as totalJobs,
+      SUM(total_cost_usd) as totalCostUsd,
+      AVG(duration_ms) as avgDurationMs
+    FROM jobs
+  `).get() as { totalJobs: number; totalCostUsd: number | null; avgDurationMs: number | null }
+
+  const todayRow = db.prepare(`
+    SELECT
+      COUNT(*) as jobsToday,
+      SUM(total_cost_usd) as costToday
+    FROM jobs
+    WHERE strftime('%Y-%m-%d', started_at) = ?
+  `).get(today) as { jobsToday: number; costToday: number | null }
+
+  return {
+    totalJobs: totalRow.totalJobs,
+    jobsToday: todayRow.jobsToday,
+    totalCostUsd: totalRow.totalCostUsd ?? 0,
+    costToday: todayRow.costToday ?? 0,
+    avgDurationMs: totalRow.avgDurationMs,
+  }
+}

package/server/hooks.test.ts

@@ -0,0 +1,196 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import express from 'express'
+import { createHooksRouter, getPhaseStates, resetPhases } from './hooks'
+import type { WsMessage, PhaseName, PhaseState } from './types'
+
+// The hooks module uses module-level state, so we need a fresh import for isolation.
+// Since we can't easily re-import, we'll use resetPhases to clean up between tests.
+
+function createApp(broadcast: (msg: WsMessage) => void) {
+  const app = express()
+  app.use(express.json())
+  app.use('/hooks', createHooksRouter(broadcast))
+  return app
+}
+
+describe('getPhaseStates', () => {
+  let broadcast: ReturnType<typeof vi.fn>
+
+  beforeEach(() => {
+    broadcast = vi.fn()
+    // Reset all phases to idle before each test
+    resetPhases(broadcast)
+    broadcast.mockClear()
+  })
+
+  it('returns all phases as idle initially', () => {
+    const states = getPhaseStates()
+    expect(states).toEqual({
+      architect: 'idle',
+      developer: 'idle',
+      reviewer: 'idle',
+      ship: 'idle',
+    })
+  })
+
+  it('returns a copy, not a reference', () => {
+    const states = getPhaseStates()
+    states.architect = 'running'
+    expect(getPhaseStates().architect).toBe('idle')
+  })
+})
+
+describe('resetPhases', () => {
+  it('broadcasts a phase message for each phase', () => {
+    const broadcast = vi.fn()
+    resetPhases(broadcast)
+
+    expect(broadcast).toHaveBeenCalledTimes(4)
+    const phases: PhaseName[] = ['architect', 'developer', 'reviewer', 'ship']
+    for (const phase of phases) {
+      expect(broadcast).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'phase',
+          phase,
+          state: 'idle',
+          timestamp: expect.any(String),
+        })
+      )
+    }
+  })
+
+  it('sets all phases back to idle', async () => {
+    const broadcast = vi.fn()
+    // First, transition a phase to running via the router
+    const app = createApp(broadcast)
+    const { default: request } = await import('supertest')
+    await request(app)
+      .post('/hooks/events')
+      .send({ event: 'agent_start', agent: 'architect' })
+
+    expect(getPhaseStates().architect).toBe('running')
+
+    resetPhases(broadcast)
+    expect(getPhaseStates().architect).toBe('idle')
+  })
+})
+
+describe('POST /hooks/events', () => {
+  let broadcast: ReturnType<typeof vi.fn>
+  let app: express.Express
+  let request: any
+
+  beforeEach(async () => {
+    broadcast = vi.fn()
+    resetPhases(broadcast)
+    broadcast.mockClear()
+    app = createApp(broadcast)
+    const mod = await import('supertest')
+    request = mod.default
+  })
+
+  it('transitions phase to running on agent_start', async () => {
+    const res = await request(app)
+      .post('/hooks/events')
+      .send({ event: 'agent_start', agent: 'architect' })
+
+    expect(res.status).toBe(200)
+    expect(res.body).toEqual({ ok: true })
+    expect(getPhaseStates().architect).toBe('running')
+    expect(broadcast).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: 'phase',
+        phase: 'architect',
+        state: 'running',
+      })
+    )
+  })
+
+  it('transitions phase to done on agent_stop', async () => {
+    await request(app)
+      .post('/hooks/events')
+      .send({ event: 'agent_start', agent: 'developer' })
+    broadcast.mockClear()
+
+    const res = await request(app)
+      .post('/hooks/events')
+      .send({ event: 'agent_stop', agent: 'developer' })
+
+    expect(res.status).toBe(200)
+    expect(getPhaseStates().developer).toBe('done')
+  })
+
+  it('transitions phase to error on agent_error', async () => {
+    const res = await request(app)
+      .post('/hooks/events')
+      .send({ event: 'agent_error', agent: 'reviewer' })
+
+    expect(res.status).toBe(200)
+    expect(getPhaseStates().reviewer).toBe('error')
+  })
+
+  it('ignores unknown agent names gracefully', async () => {
+    const res = await request(app)
+      .post('/hooks/events')
+      .send({ event: 'agent_start', agent: 'unknown_agent' })
+
+    expect(res.status).toBe(200)
+    expect(res.body).toEqual({ ok: true })
+    expect(broadcast).not.toHaveBeenCalled()
+  })
+
+  it('ignores unknown event types gracefully', async () => {
+    const res = await request(app)
+      .post('/hooks/events')
+      .send({ event: 'unknown_event', agent: 'architect' })
+
+    expect(res.status).toBe(200)
+    expect(res.body).toEqual({ ok: true })
+    expect(broadcast).not.toHaveBeenCalled()
+  })
+
+  it('handles missing body gracefully', async () => {
+    const res = await request(app)
+      .post('/hooks/events')
+      .send({})
+
+    expect(res.status).toBe(200)
+    expect(res.body).toEqual({ ok: true })
+  })
+
+  it('handles all four phases', async () => {
+    const phases: PhaseName[] = ['architect', 'developer', 'reviewer', 'ship']
+    for (const phase of phases) {
+      await request(app)
+        .post('/hooks/events')
+        .send({ event: 'agent_start', agent: phase })
+      expect(getPhaseStates()[phase]).toBe('running')
+    }
+  })
+
+  it('can transition through full lifecycle: idle -> running -> done', async () => {
+    expect(getPhaseStates().ship).toBe('idle')
+
+    await request(app)
+      .post('/hooks/events')
+      .send({ event: 'agent_start', agent: 'ship' })
+    expect(getPhaseStates().ship).toBe('running')
+
+    await request(app)
+      .post('/hooks/events')
+      .send({ event: 'agent_stop', agent: 'ship' })
+    expect(getPhaseStates().ship).toBe('done')
+  })
+
+  it('can transition from running to error', async () => {
+    await request(app)
+      .post('/hooks/events')
+      .send({ event: 'agent_start', agent: 'architect' })
+    expect(getPhaseStates().architect).toBe('running')
+
+    await request(app)
+      .post('/hooks/events')
+      .send({ event: 'agent_error', agent: 'architect' })
+    expect(getPhaseStates().architect).toBe('error')
+  })
+})