specrails-hub 0.1.0

package/server/hooks.ts

@@ -0,0 +1,117 @@
+import { Router, Request, Response } from 'express'
+import type { PhaseState, PhaseDefinition, WsMessage } from './types'
+import type { DbInstance } from './db'
+import { upsertPhase } from './db'
+
+const DEFAULT_PHASE_DEFINITIONS: PhaseDefinition[] = [
+  { key: 'architect', label: 'Architect', description: 'Analyzes the issue, researches the codebase, and designs the implementation plan' },
+  { key: 'developer', label: 'Developer', description: 'Implements the changes: writes code, edits files, runs tests' },
+  { key: 'reviewer', label: 'Reviewer', description: 'Reviews the implementation for correctness, edge cases, and code quality' },
+  { key: 'ship', label: 'Ship', description: 'Creates the PR, writes the description, and finalizes the changes for merge' },
+]
+
+let activePhaseKeys: string[] = DEFAULT_PHASE_DEFINITIONS.map((d) => d.key)
+let activePhaseDefinitions: PhaseDefinition[] = [...DEFAULT_PHASE_DEFINITIONS]
+const phases: Record<string, PhaseState> = {
+  architect: 'idle',
+  developer: 'idle',
+  reviewer: 'idle',
+  ship: 'idle',
+}
+
+function isValidPhase(value: string): boolean {
+  return activePhaseKeys.includes(value)
+}
+
+function eventToState(event: string): PhaseState | null {
+  if (event === 'agent_start') return 'running'
+  if (event === 'agent_stop') return 'done'
+  if (event === 'agent_error') return 'error'
+  return null
+}
+
+export function getPhaseStates(): Record<string, PhaseState> {
+  return { ...phases }
+}
+
+export function getPhaseDefinitions(): PhaseDefinition[] {
+  return [...activePhaseDefinitions]
+}
+
+export function setActivePhases(
+  definitions: PhaseDefinition[],
+  broadcast: (msg: WsMessage) => void
+): void {
+  // Clear old phase entries
+  for (const key of activePhaseKeys) {
+    delete phases[key]
+  }
+  // Install new phase set
+  activePhaseDefinitions = definitions
+  activePhaseKeys = definitions.map((d) => d.key)
+  for (const key of activePhaseKeys) {
+    phases[key] = 'idle'
+  }
+  // Broadcast idle state for each new phase
+  for (const key of activePhaseKeys) {
+    broadcast({
+      type: 'phase',
+      phase: key,
+      state: 'idle',
+      timestamp: new Date().toISOString(),
+    })
+  }
+}
+
+export function resetPhases(broadcast: (msg: WsMessage) => void): void {
+  for (const key of activePhaseKeys) {
+    phases[key] = 'idle'
+    broadcast({
+      type: 'phase',
+      phase: key,
+      state: 'idle',
+      timestamp: new Date().toISOString(),
+    })
+  }
+}
+
+export function createHooksRouter(
+  broadcast: (msg: WsMessage) => void,
+  db?: DbInstance,
+  activeJobRef?: { current: string | null }
+): Router {
+  const router = Router()
+
+  router.post('/events', (req: Request, res: Response) => {
+    const { event, agent } = req.body ?? {}
+
+    if (!agent || !isValidPhase(agent)) {
+      console.warn(`[hooks] unknown agent: ${agent}`)
+      res.json({ ok: true })
+      return
+    }
+
+    const newState = eventToState(event)
+    if (!newState) {
+      console.warn(`[hooks] unknown event: ${event}`)
+      res.json({ ok: true })
+      return
+    }
+
+    phases[agent] = newState
+    broadcast({
+      type: 'phase',
+      phase: agent,
+      state: newState,
+      timestamp: new Date().toISOString(),
+    })
+
+    if (db && activeJobRef?.current) {
+      upsertPhase(db, activeJobRef.current, agent, newState)
+    }
+
+    res.json({ ok: true })
+  })
+
+  return router
+}

package/server/hub-db.ts

@@ -0,0 +1,141 @@
+import fs from 'fs'
+import path from 'path'
+import os from 'os'
+import Database from 'better-sqlite3'
+import type { DbInstance } from './db'
+
+// ─── Types ────────────────────────────────────────────────────────────────────
+
+export interface ProjectRow {
+  id: string
+  slug: string
+  name: string
+  path: string
+  db_path: string
+  added_at: string
+  last_seen_at: string
+}
+
+// ─── Hub DB path ──────────────────────────────────────────────────────────────
+
+export function getHubDbPath(): string {
+  return path.join(os.homedir(), '.specrails', 'hub.sqlite')
+}
+
+function getProjectDbPath(slug: string): string {
+  return path.join(os.homedir(), '.specrails', 'projects', slug, 'jobs.sqlite')
+}
+
+// ─── Schema migrations ────────────────────────────────────────────────────────
+
+function applyHubMigrations(db: DbInstance): void {
+  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)
+  )
+
+  const migrations: Array<() => void> = [
+    // Migration 1: projects and hub_settings tables
+    () => {
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS projects (
+          id           TEXT PRIMARY KEY,
+          slug         TEXT NOT NULL UNIQUE,
+          name         TEXT NOT NULL,
+          path         TEXT NOT NULL UNIQUE,
+          db_path      TEXT NOT NULL,
+          added_at     TEXT NOT NULL DEFAULT (datetime('now')),
+          last_seen_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_projects_slug ON projects(slug);
+        CREATE INDEX IF NOT EXISTS idx_projects_path ON projects(path);
+
+        CREATE TABLE IF NOT EXISTS hub_settings (
+          key   TEXT PRIMARY KEY,
+          value TEXT NOT NULL
+        );
+      `)
+    },
+  ]
+
+  for (let i = 0; i < migrations.length; i++) {
+    const version = i + 1
+    if (!appliedVersions.has(version)) {
+      migrations[i]()
+      db.prepare('INSERT OR IGNORE INTO schema_migrations (version) VALUES (?)').run(version)
+    }
+  }
+}
+
+// ─── Public API ───────────────────────────────────────────────────────────────
+
+export function initHubDb(dbPath: string = getHubDbPath()): DbInstance {
+  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')
+
+  applyHubMigrations(db)
+  return db
+}
+
+export function listProjects(db: DbInstance): ProjectRow[] {
+  return db.prepare(
+    'SELECT * FROM projects ORDER BY added_at ASC'
+  ).all() as ProjectRow[]
+}
+
+export function getProject(db: DbInstance, id: string): ProjectRow | undefined {
+  return db.prepare('SELECT * FROM projects WHERE id = ?').get(id) as ProjectRow | undefined
+}
+
+export function getProjectBySlug(db: DbInstance, slug: string): ProjectRow | undefined {
+  return db.prepare('SELECT * FROM projects WHERE slug = ?').get(slug) as ProjectRow | undefined
+}
+
+export function getProjectByPath(db: DbInstance, projectPath: string): ProjectRow | undefined {
+  return db.prepare('SELECT * FROM projects WHERE path = ?').get(projectPath) as ProjectRow | undefined
+}
+
+export function addProject(
+  db: DbInstance,
+  project: { id: string; slug: string; name: string; path: string }
+): ProjectRow {
+  const dbPath = getProjectDbPath(project.slug)
+  db.prepare(`
+    INSERT INTO projects (id, slug, name, path, db_path)
+    VALUES (?, ?, ?, ?, ?)
+  `).run(project.id, project.slug, project.name, project.path, dbPath)
+  return db.prepare('SELECT * FROM projects WHERE id = ?').get(project.id) as ProjectRow
+}
+
+export function removeProject(db: DbInstance, id: string): void {
+  db.prepare('DELETE FROM projects WHERE id = ?').run(id)
+}
+
+export function touchProject(db: DbInstance, id: string): void {
+  db.prepare(
+    "UPDATE projects SET last_seen_at = datetime('now') WHERE id = ?"
+  ).run(id)
+}
+
+export function getHubSetting(db: DbInstance, key: string): string | undefined {
+  const row = db.prepare('SELECT value FROM hub_settings WHERE key = ?').get(key) as { value: string } | undefined
+  return row?.value
+}
+
+export function setHubSetting(db: DbInstance, key: string, value: string): void {
+  db.prepare(
+    'INSERT OR REPLACE INTO hub_settings (key, value) VALUES (?, ?)'
+  ).run(key, value)
+}

package/server/hub-router.ts

@@ -0,0 +1,137 @@
+import { Router } from 'express'
+import path from 'path'
+import fs from 'fs'
+import type { WsMessage } from './types'
+import type { ProjectRegistry } from './project-registry'
+import { getHubSetting, setHubSetting, listProjects } from './hub-db'
+
+function slugify(name: string): string {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '')
+}
+
+function deriveProjectName(projectPath: string): string {
+  return path.basename(projectPath)
+}
+
+function hasSpecrails(projectPath: string): boolean {
+  return fs.existsSync(path.join(projectPath, '.claude', 'commands', 'sr'))
+}
+
+export function createHubRouter(
+  registry: ProjectRegistry,
+  broadcast: (msg: WsMessage) => void
+): Router {
+  const router = Router()
+
+  // GET /api/hub/projects — list all registered projects
+  router.get('/projects', (_req, res) => {
+    const projects = listProjects(registry.hubDb)
+    res.json({ projects })
+  })
+
+  // POST /api/hub/projects — register a new project by path
+  router.post('/projects', (req, res) => {
+    const { path: projectPath, name } = req.body ?? {}
+    if (!projectPath || typeof projectPath !== 'string') {
+      res.status(400).json({ error: 'path is required' })
+      return
+    }
+
+    const resolvedPath = path.resolve(projectPath)
+
+    // Validate path exists
+    if (!fs.existsSync(resolvedPath)) {
+      res.status(400).json({ error: `Path does not exist: ${resolvedPath}` })
+      return
+    }
+
+    const derivedName = (name && typeof name === 'string' && name.trim())
+      ? name.trim()
+      : deriveProjectName(resolvedPath)
+    const slug = slugify(derivedName)
+    const id = crypto.randomUUID()
+    const specrailsInstalled = hasSpecrails(resolvedPath)
+
+    try {
+      const ctx = registry.addProject({ id, slug, name: derivedName, path: resolvedPath })
+      broadcast({
+        type: 'hub.project_added',
+        project: ctx.project,
+        timestamp: new Date().toISOString(),
+      })
+      res.status(201).json({ project: ctx.project, has_specrails: specrailsInstalled })
+    } catch (err) {
+      const message = (err as Error).message ?? ''
+      // SQLite UNIQUE constraint violation means path or slug already registered
+      if (message.includes('UNIQUE')) {
+        res.status(409).json({ error: 'A project with this path is already registered' })
+      } else {
+        console.error('[hub] add project error:', err)
+        res.status(500).json({ error: 'Failed to register project' })
+      }
+    }
+  })
+
+  // DELETE /api/hub/projects/:id — unregister a project
+  router.delete('/projects/:id', (req, res) => {
+    const { id } = req.params
+    const ctx = registry.getContext(id)
+    if (!ctx) {
+      res.status(404).json({ error: 'Project not found' })
+      return
+    }
+
+    registry.removeProject(id)
+    broadcast({
+      type: 'hub.project_removed',
+      projectId: id,
+      timestamp: new Date().toISOString(),
+    })
+    res.json({ ok: true })
+  })
+
+  // GET /api/hub/state — hub-level state summary
+  router.get('/state', (_req, res) => {
+    const projects = listProjects(registry.hubDb)
+    res.json({
+      projects,
+      projectCount: projects.length,
+    })
+  })
+
+  // GET /api/hub/resolve?path=<cwd> — resolve a project from a filesystem path
+  router.get('/resolve', (req, res) => {
+    const queryPath = req.query.path as string | undefined
+    if (!queryPath) {
+      res.status(400).json({ error: 'path query parameter is required' })
+      return
+    }
+
+    const resolvedPath = path.resolve(queryPath)
+    const ctx = registry.getContextByPath(resolvedPath)
+    if (!ctx) {
+      res.status(404).json({ error: 'No project registered for this path' })
+      return
+    }
+
+    registry.touchProject(ctx.project.id)
+    res.json({ project: ctx.project })
+  })
+
+  // GET /api/hub/settings — get hub-level settings
+  router.get('/settings', (_req, res) => {
+    const port = getHubSetting(registry.hubDb, 'port') ?? '4200'
+    res.json({ port: parseInt(port, 10) })
+  })
+
+  // PUT /api/hub/settings — update hub-level settings
+  router.put('/settings', (req, res) => {
+    const { port } = req.body ?? {}
+    if (port !== undefined) {
+      setHubSetting(registry.hubDb, 'port', String(port))
+    }
+    res.json({ ok: true })
+  })
+
+  return router
+}