orbital-command 0.1.0

package/server/routes/dispatch-routes.ts

@@ -0,0 +1,275 @@
+import { Router } from 'express';
+import type Database from 'better-sqlite3';
+import type { Server } from 'socket.io';
+import type { ScopeService } from '../services/scope-service.js';
+import { launchInCategorizedTerminal, escapeForAnsiC, buildSessionName, snapshotSessionPids, discoverNewSession, renameSession } from '../utils/terminal-launcher.js';
+import { resolveDispatchEvent, resolveAbandonedDispatchesForScope, getActiveScopeIds, getAbandonedScopeIds, linkPidToDispatch } from '../utils/dispatch-utils.js';
+import type { WorkflowEngine } from '../../shared/workflow-engine.js';
+import { createLogger } from '../utils/logger.js';
+
+const log = createLogger('dispatch');
+
+const MAX_BATCH_SIZE = 20;
+
+interface DispatchBody {
+  scope_id?: number;
+  command: string;
+  prompt?: string;
+  transition?: { from: string; to: string };
+}
+
+interface DispatchRouteDeps {
+  db: Database.Database;
+  io: Server;
+  scopeService: ScopeService;
+  projectRoot: string;
+  engine: WorkflowEngine;
+}
+
+export function createDispatchRoutes({ db, io, scopeService, projectRoot, engine }: DispatchRouteDeps): Router {
+  const router = Router();
+
+  router.get('/dispatch/active-scopes', (_req, res) => {
+    const scope_ids = getActiveScopeIds(db, scopeService, engine);
+    const abandoned_scopes = getAbandonedScopeIds(db, scopeService, engine, scope_ids);
+    res.json({ scope_ids, abandoned_scopes });
+  });
+
+  router.get('/dispatch/active', (req, res) => {
+    const scopeId = Number(req.query.scope_id);
+    if (isNaN(scopeId) || scopeId <= 0) {
+      res.status(400).json({ error: 'Valid scope_id query param required' });
+      return;
+    }
+    const active = db.prepare(
+      `SELECT id, timestamp, JSON_EXTRACT(data, '$.command') as command
+       FROM events
+       WHERE type = 'DISPATCH' AND scope_id = ? AND JSON_EXTRACT(data, '$.resolved') IS NULL
+       ORDER BY timestamp DESC LIMIT 1`
+    ).get(scopeId) as { id: string; timestamp: string; command: string } | undefined;
+
+    res.json({ active: active ?? null });
+  });
+
+  router.post('/dispatch', async (req, res) => {
+    const { scope_id, command, prompt, transition } = req.body as DispatchBody;
+
+    if (!command || !engine.isAllowedCommand(command)) {
+      res.status(400).json({ error: 'Command must start with /scope-, /git-, /test-, or /session-' });
+      return;
+    }
+
+    // W-11: Validate prompt field against allowed command prefixes
+    if (prompt && !engine.isAllowedCommand(prompt)) {
+      res.status(400).json({ error: 'Prompt must start with /scope-, /git-, /test-, or /session-' });
+      return;
+    }
+
+    // Active session guard
+    if (scope_id != null) {
+      const active = db.prepare(
+        `SELECT id FROM events
+         WHERE type = 'DISPATCH' AND scope_id = ? AND JSON_EXTRACT(data, '$.resolved') IS NULL
+         ORDER BY timestamp DESC LIMIT 1`
+      ).get(scope_id) as { id: string } | undefined;
+
+      if (active) {
+        res.status(409).json({ error: 'Active dispatch exists', dispatch_id: active.id });
+        return;
+      }
+    }
+
+    // Update scope status if transition provided
+    if (scope_id != null && transition?.to) {
+      const result = scopeService.updateStatus(scope_id, transition.to, 'dispatch');
+      if (!result.ok) {
+        res.status(400).json({ error: result.error });
+        return;
+      }
+    }
+
+    // Record DISPATCH event
+    const eventId = crypto.randomUUID();
+    const eventData = { command, transition: transition ?? null, resolved: null };
+    db.prepare(
+      `INSERT INTO events (id, type, scope_id, session_id, agent, data, timestamp)
+       VALUES (?, 'DISPATCH', ?, NULL, 'dashboard', ?, ?)`
+    ).run(eventId, scope_id ?? null, JSON.stringify(eventData), new Date().toISOString());
+
+    io.emit('event:new', {
+      id: eventId, type: 'DISPATCH', scope_id: scope_id ?? null,
+      session_id: null, agent: 'dashboard', data: eventData,
+      timestamp: new Date().toISOString(),
+    });
+
+    // Build scope-aware session name before launch
+    const scope = scope_id != null ? scopeService.getById(scope_id) : undefined;
+    const sessionName = buildSessionName({ scopeId: scope_id ?? undefined, title: scope?.title, command });
+    const beforePids = snapshotSessionPids(projectRoot);
+
+    // Launch in iTerm — interactive TUI mode (no -p) for full visibility
+    const promptText = prompt ?? command;
+    const escaped = escapeForAnsiC(promptText);
+    const fullCmd = `cd '${projectRoot}' && ORBITAL_DISPATCH_ID='${eventId}' claude --dangerously-skip-permissions $'${escaped}'`;
+    try {
+      await launchInCategorizedTerminal(command, fullCmd, sessionName);
+      res.json({ ok: true, dispatch_id: eventId, scope_id: scope_id ?? null });
+
+      // Fire-and-forget: discover session PID, link to dispatch, and rename
+      discoverNewSession(projectRoot, beforePids)
+        .then((session) => {
+          if (!session) return;
+          linkPidToDispatch(db, eventId, session.pid);
+          if (sessionName) renameSession(projectRoot, session.sessionId, sessionName);
+        })
+        .catch(err => log.error('PID discovery failed', { error: err.message }));
+    } catch (err) {
+      if (scope_id != null && transition?.from) {
+        scopeService.updateStatus(scope_id, transition.from, 'rollback');
+      }
+      resolveDispatchEvent(db, io, eventId, 'failed', String(err));
+      res.status(500).json({ error: 'Failed to launch terminal', details: String(err) });
+    }
+  });
+
+  router.post('/dispatch/:id/resolve', (req, res) => {
+    const eventId = req.params.id;
+    const row = db.prepare('SELECT id FROM events WHERE id = ? AND type = ?')
+      .get(eventId, 'DISPATCH') as { id: string } | undefined;
+
+    if (!row) {
+      res.status(404).json({ error: 'Dispatch event not found' });
+      return;
+    }
+
+    resolveDispatchEvent(db, io, eventId, 'completed');
+    res.json({ ok: true, dispatch_id: eventId });
+  });
+
+  /** Recover an abandoned scope by reverting it to its pre-dispatch status. */
+  router.post('/dispatch/recover/:scopeId', (req, res) => {
+    try {
+      const scopeId = Number(req.params.scopeId);
+      if (isNaN(scopeId) || scopeId <= 0) {
+        res.status(400).json({ error: 'Valid scopeId required' });
+        return;
+      }
+
+      const { from_status } = req.body as { from_status?: string };
+      if (!from_status) {
+        res.status(400).json({ error: 'from_status is required' });
+        return;
+      }
+
+      // Revert scope to its pre-dispatch status
+      const result = scopeService.updateStatus(scopeId, from_status, 'rollback');
+      if (!result.ok) {
+        res.status(400).json({ error: result.error });
+        return;
+      }
+
+      resolveAbandonedDispatchesForScope(db, io, scopeId);
+      res.json({ ok: true, scope_id: scopeId, reverted_to: from_status });
+    } catch (err) {
+      log.error('Error recovering scope', { error: String(err) });
+      res.status(500).json({ error: 'Internal server error', details: String(err) });
+    }
+  });
+
+  /** Dismiss abandoned state without reverting scope status. */
+  router.post('/dispatch/dismiss-abandoned/:scopeId', (req, res) => {
+    try {
+      const scopeId = Number(req.params.scopeId);
+      if (isNaN(scopeId) || scopeId <= 0) {
+        res.status(400).json({ error: 'Valid scopeId required' });
+        return;
+      }
+
+      const dismissed = resolveAbandonedDispatchesForScope(db, io, scopeId);
+      res.json({ ok: true, scope_id: scopeId, dismissed });
+    } catch (err) {
+      log.error('Error dismissing abandoned dispatches', { error: String(err) });
+      res.status(500).json({ error: 'Internal server error', details: String(err) });
+    }
+  });
+
+  router.post('/dispatch/batch', async (req, res) => {
+    const { scope_ids, command, transition } = req.body as {
+      scope_ids: number[];
+      command: string;
+      transition?: { from: string; to: string };
+    };
+
+    if (!command || !engine.isAllowedCommand(command)) {
+      res.status(400).json({ error: 'Command must start with /scope-, /git-, /test-, or /session-' });
+      return;
+    }
+
+    if (!Array.isArray(scope_ids) || scope_ids.length === 0) {
+      res.status(400).json({ error: 'scope_ids must be a non-empty array' });
+      return;
+    }
+
+    // W-12: Validate batch size and scope ID types
+    if (scope_ids.length > MAX_BATCH_SIZE) {
+      res.status(400).json({ error: `Maximum batch size is ${MAX_BATCH_SIZE}` });
+      return;
+    }
+    if (!scope_ids.every(id => Number.isInteger(id) && id > 0)) {
+      res.status(400).json({ error: 'scope_ids must contain positive integers' });
+      return;
+    }
+
+    // Update all scope statuses
+    if (transition?.to) {
+      for (const id of scope_ids) {
+        const result = scopeService.updateStatus(id, transition.to, 'dispatch');
+        if (!result.ok) {
+          res.status(400).json({ error: `Scope ${id}: ${result.error}` });
+          return;
+        }
+      }
+    }
+
+    // Record single DISPATCH event for the batch
+    const eventId = crypto.randomUUID();
+    const eventData = { command, transition: transition ?? null, scope_ids, batch: true, resolved: null };
+    db.prepare(
+      `INSERT INTO events (id, type, scope_id, session_id, agent, data, timestamp)
+       VALUES (?, 'DISPATCH', NULL, NULL, 'dashboard', ?, ?)`
+    ).run(eventId, JSON.stringify(eventData), new Date().toISOString());
+
+    io.emit('event:new', {
+      id: eventId, type: 'DISPATCH', scope_id: null,
+      session_id: null, agent: 'dashboard', data: eventData,
+      timestamp: new Date().toISOString(),
+    });
+
+    // Launch single CLI session
+    const batchEscaped = escapeForAnsiC(command);
+    const beforePids = snapshotSessionPids(projectRoot);
+    const fullCmd = `cd '${projectRoot}' && ORBITAL_DISPATCH_ID='${eventId}' claude --dangerously-skip-permissions -p $'${batchEscaped}'`;
+    try {
+      await launchInCategorizedTerminal(command, fullCmd);
+      res.json({ ok: true, dispatch_id: eventId, scope_ids });
+
+      // Fire-and-forget: discover session PID and link to dispatch
+      discoverNewSession(projectRoot, beforePids)
+        .then((session) => {
+          if (!session) return;
+          linkPidToDispatch(db, eventId, session.pid);
+        })
+        .catch(err => log.error('Batch PID discovery failed', { error: err.message }));
+    } catch (err) {
+      if (transition?.from) {
+        for (const id of scope_ids) {
+          scopeService.updateStatus(id, transition.from, 'rollback');
+        }
+      }
+      resolveDispatchEvent(db, io, eventId, 'failed', String(err));
+      res.status(500).json({ error: 'Failed to launch terminal', details: String(err) });
+    }
+  });
+
+  return router;
+}

package/server/routes/git-routes.ts

@@ -0,0 +1,112 @@
+import { Router } from 'express';
+import type { GitService } from '../services/git-service.js';
+import type { GitHubService } from '../services/github-service.js';
+import type { WorkflowEngine } from '../../shared/workflow-engine.js';
+
+interface GitRoutesDeps {
+  gitService: GitService;
+  githubService: GitHubService;
+  engine: WorkflowEngine;
+}
+
+export function createGitRoutes({ gitService, githubService, engine }: GitRoutesDeps): Router {
+  const router = Router();
+
+  // ─── Git Overview ──────────────────────────────────────────
+
+  router.get('/git/overview', async (_req, res) => {
+    try {
+      const config = engine.getConfig();
+      const branchingMode = config.branchingMode ?? 'trunk';
+      const overview = await gitService.getOverview(branchingMode);
+      res.json(overview);
+    } catch (err) {
+      res.status(500).json({ error: 'Failed to get git overview', details: String(err) });
+    }
+  });
+
+  // ─── Commits ──────────────────────────────────────────────
+
+  router.get('/git/commits', async (req, res) => {
+    try {
+      const branch = (req.query.branch as string) || undefined;
+      const limit = Number(req.query.limit) || 50;
+      const offset = Number(req.query.offset) || 0;
+      const commits = await gitService.getCommits({ branch, limit, offset });
+      res.json(commits);
+    } catch (err) {
+      res.status(500).json({ error: 'Failed to get commits', details: String(err) });
+    }
+  });
+
+  // ─── Branches ──────────────────────────────────────────────
+
+  router.get('/git/branches', async (_req, res) => {
+    try {
+      const branches = await gitService.getBranches();
+      res.json(branches);
+    } catch (err) {
+      res.status(500).json({ error: 'Failed to get branches', details: String(err) });
+    }
+  });
+
+  // ─── Enhanced Worktrees ────────────────────────────────────
+
+  router.get('/git/worktrees', async (_req, res) => {
+    try {
+      const worktrees = await gitService.getEnhancedWorktrees();
+      res.json(worktrees);
+    } catch (err) {
+      res.status(500).json({ error: 'Failed to get worktrees', details: String(err) });
+    }
+  });
+
+  // ─── Dynamic Drift ─────────────────────────────────────────
+
+  router.get('/git/drift', async (_req, res) => {
+    try {
+      // Build drift pairs from workflow lists that have gitBranch set
+      const config = engine.getConfig();
+      const listsWithBranch = config.lists
+        .filter(l => l.gitBranch)
+        .sort((a, b) => a.order - b.order);
+
+      const pairs: Array<{ from: string; to: string }> = [];
+      for (let i = 0; i < listsWithBranch.length - 1; i++) {
+        pairs.push({
+          from: listsWithBranch[i].gitBranch!,
+          to: listsWithBranch[i + 1].gitBranch!,
+        });
+      }
+
+      const drift = await gitService.getDrift(pairs);
+      res.json(drift);
+    } catch (err) {
+      res.status(500).json({ error: 'Failed to compute drift', details: String(err) });
+    }
+  });
+
+  // ─── GitHub Status ─────────────────────────────────────────
+
+  router.get('/github/status', async (_req, res) => {
+    try {
+      const status = await githubService.getStatus();
+      res.json(status);
+    } catch (err) {
+      res.status(500).json({ error: 'Failed to get GitHub status', details: String(err) });
+    }
+  });
+
+  // ─── GitHub PRs ────────────────────────────────────────────
+
+  router.get('/github/prs', async (_req, res) => {
+    try {
+      const prs = await githubService.getOpenPRs();
+      res.json(prs);
+    } catch (err) {
+      res.status(500).json({ error: 'Failed to get PRs', details: String(err) });
+    }
+  });
+
+  return router;
+}

package/server/routes/scope-routes.ts

@@ -0,0 +1,262 @@
+import { Router } from 'express';
+import { spawn } from 'child_process';
+import type Database from 'better-sqlite3';
+import type { Server } from 'socket.io';
+import type { ScopeService } from '../services/scope-service.js';
+import type { ReadinessService } from '../services/readiness-service.js';
+import type { WorkflowEngine } from '../../shared/workflow-engine.js';
+import { launchInTerminal, escapeForAnsiC, buildSessionName, snapshotSessionPids, discoverNewSession, renameSession } from '../utils/terminal-launcher.js';
+import { resolveDispatchEvent, linkPidToDispatch } from '../utils/dispatch-utils.js';
+import { getConfig } from '../config.js';
+import { createLogger } from '../utils/logger.js';
+
+const log = createLogger('dispatch');
+
+interface ScopeRouteDeps {
+  db: Database.Database;
+  io: Server;
+  scopeService: ScopeService;
+  readinessService: ReadinessService;
+  projectRoot: string;
+  engine: WorkflowEngine;
+}
+
+export function createScopeRoutes({ db, io, scopeService, readinessService, projectRoot, engine }: ScopeRouteDeps): Router {
+  const router = Router();
+
+  // ─── Scope CRUD ──────────────────────────────────────────
+
+  router.get('/scopes', (_req, res) => {
+    res.json(scopeService.getAll());
+  });
+
+  // ─── Transition Readiness ──────────────────────────────────
+
+  router.get('/scopes/:id/readiness', (req, res) => {
+    const readiness = readinessService.getReadiness(Number(req.params.id));
+    if (!readiness) {
+      res.status(404).json({ error: 'Scope not found' });
+      return;
+    }
+    res.json(readiness);
+  });
+
+  /** Bulk update — must come before :id route to avoid matching "bulk" as an id */
+  router.patch('/scopes/bulk/status', (req, res) => {
+    const { scopes } = req.body as { scopes: Array<{ id: number; status: string }> };
+    if (!Array.isArray(scopes)) {
+      res.status(400).json({ error: 'Expected { scopes: [{id, status}] }' });
+      return;
+    }
+    let updated = 0;
+    for (const { id, status } of scopes) {
+      const result = scopeService.updateStatus(id, status, 'bulk-sync');
+      if (result.ok) updated++;
+    }
+    res.json({ updated, total: scopes.length });
+  });
+
+  router.get('/scopes/:id', (req, res) => {
+    const scope = scopeService.getById(Number(req.params.id));
+    if (!scope) {
+      res.status(404).json({ error: 'Scope not found' });
+      return;
+    }
+    res.json(scope);
+  });
+
+  router.patch('/scopes/:id', (req, res) => {
+    const id = Number(req.params.id);
+    const result = scopeService.updateScopeFrontmatter(id, req.body);
+    if (!result.ok) {
+      const code = result.code === 'NOT_FOUND' ? 404 : 400;
+      res.status(code).json({ error: result.error, code: result.code });
+      return;
+    }
+    const scope = scopeService.getById(id);
+    res.json(scope ?? { ok: true });
+  });
+
+  // ─── Idea Routes ─────────────────────────────────────────
+
+  router.post('/ideas', (req, res) => {
+    const { title, description } = req.body as { title?: string; description?: string };
+    if (!title?.trim()) {
+      res.status(400).json({ error: 'title is required' });
+      return;
+    }
+    const idea = scopeService.createIdeaFile(title.trim(), (description ?? '').trim());
+    res.status(201).json(idea);
+  });
+
+  router.patch('/ideas/:id', (req, res) => {
+    const id = Number(req.params.id);
+    const { title, description } = req.body as { title?: string; description?: string };
+    if (!title?.trim()) {
+      res.status(400).json({ error: 'title is required' });
+      return;
+    }
+    const updated = scopeService.updateIdeaFile(id, title.trim(), (description ?? '').trim());
+    if (!updated) {
+      res.status(404).json({ error: 'Idea not found' });
+      return;
+    }
+    res.json({ ok: true });
+  });
+
+  router.delete('/ideas/:id', (req, res) => {
+    const id = Number(req.params.id);
+    const deleted = scopeService.deleteIdeaFile(id);
+    if (!deleted) {
+      res.status(404).json({ error: 'Idea not found' });
+      return;
+    }
+    res.json({ ok: true });
+  });
+
+  router.post('/ideas/:id/promote', async (req, res) => {
+    const ideaId = Number(req.params.id);
+    const result = scopeService.promoteIdea(ideaId);
+    if (!result) {
+      res.status(404).json({ error: 'Idea not found' });
+      return;
+    }
+
+    const scopeId = result.id;
+
+    // Read command from workflow edge config (user-overridable)
+    const entryPoint = engine.getEntryPoint();
+    const targets = engine.getValidTargets(entryPoint.id);
+    const promoteTarget = targets[0] ?? 'planning';
+    const edge = engine.findEdge(entryPoint.id, promoteTarget);
+    const edgeCommand = edge ? engine.buildCommand(edge, scopeId) : null;
+    const command = edgeCommand ?? `/scope-create ${String(scopeId).padStart(3, '0')}`;
+
+    // Record DISPATCH event for audit trail
+    const eventId = crypto.randomUUID();
+    const eventData = {
+      command,
+      transition: { from: entryPoint.id, to: promoteTarget },
+      resolved: null,
+    };
+    db.prepare(
+      `INSERT INTO events (id, type, scope_id, session_id, agent, data, timestamp)
+       VALUES (?, 'DISPATCH', ?, NULL, 'dashboard', ?, ?)`
+    ).run(eventId, scopeId, JSON.stringify(eventData), new Date().toISOString());
+
+    io.emit('event:new', {
+      id: eventId, type: 'DISPATCH', scope_id: scopeId,
+      session_id: null, agent: 'dashboard', data: eventData,
+      timestamp: new Date().toISOString(),
+    });
+
+    const escaped = escapeForAnsiC(command);
+    const fullCmd = `cd '${projectRoot}' && claude --dangerously-skip-permissions $'${escaped}'`;
+
+    const promoteSessionName = buildSessionName({ scopeId, title: result.title, command });
+    const promoteBeforePids = snapshotSessionPids(projectRoot);
+
+    try {
+      await launchInTerminal(fullCmd);
+      res.json({ ok: true, id: scopeId, filePath: result.filePath });
+
+      discoverNewSession(projectRoot, promoteBeforePids)
+        .then((session) => {
+          if (!session) return;
+          linkPidToDispatch(db, eventId, session.pid);
+          if (promoteSessionName) renameSession(projectRoot, session.sessionId, promoteSessionName);
+        })
+        .catch(err => log.error('PID discovery failed', { error: err.message }));
+    } catch (err) {
+      resolveDispatchEvent(db, io, eventId, 'failed', String(err));
+      res.status(500).json({ error: 'Failed to launch terminal', details: String(err) });
+    }
+  });
+
+  // ─── Surprise Me (AI idea generation) ────────────────────
+
+  let surpriseInProgress = false;
+
+  router.post('/ideas/surprise', (_req, res) => {
+    if (surpriseInProgress) {
+      res.status(409).json({ error: 'Surprise generation already in progress' });
+      return;
+    }
+    surpriseInProgress = true;
+
+    const nextIdStart = scopeService.getNextIceboxId();
+    const today = new Date().toISOString().split('T')[0];
+    const idRange = Array.from({ length: 5 }, (_, i) => nextIdStart + i);
+
+    const prompt = `You are analyzing the ${getConfig().projectName} codebase to suggest feature ideas. Your ONLY job is to create markdown files.
+
+Create exactly 3 idea files in the scopes/icebox/ directory. Each file must use this EXACT format:
+
+File: scopes/icebox/{ID}-{kebab-slug}.md
+
+---
+id: {ID}
+title: "{title}"
+status: icebox
+ghost: true
+created: ${today}
+updated: ${today}
+blocked_by: []
+blocks: []
+tags: []
+---
+
+{2-3 sentence description of the feature, what problem it solves, and a rough approach.}
+
+Use these IDs: ${idRange[0]}, ${idRange[1]}, ${idRange[2]}
+
+Rules:
+- Focus on practical improvements: performance, UX, security, developer experience, monitoring, or reliability
+- Be specific and actionable — not vague architectural rewrites
+- Keep descriptions concise (2-3 sentences max)
+- Filenames must be {ID}-{kebab-case-slug}.md
+- The ghost: true field is required in frontmatter
+- Do NOT create any other files or make any other changes`;
+
+    const child = spawn('claude', ['-p', prompt, '--output-format', 'text'], {
+      cwd: projectRoot,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: { ...process.env, CLAUDE_CODE_ENTRYPOINT: 'orbital-surprise' },
+    });
+
+    child.unref();
+
+    child.on('close', () => {
+      surpriseInProgress = false;
+      const eventId = crypto.randomUUID();
+      io.emit('event:new', {
+        id: eventId, type: 'AGENT_COMPLETED', scope_id: null,
+        session_id: null, agent: 'surprise-me',
+        data: { action: 'surprise-ideas-generated' },
+        timestamp: new Date().toISOString(),
+      });
+    });
+
+    child.on('error', () => {
+      surpriseInProgress = false;
+    });
+
+    res.json({ ok: true, status: 'generating' });
+  });
+
+  router.post('/ideas/:id/approve', (req, res) => {
+    const id = Number(req.params.id);
+    const approved = scopeService.approveGhostIdea(id);
+    if (!approved) {
+      res.status(404).json({ error: 'Ghost idea not found' });
+      return;
+    }
+    res.json({ ok: true });
+  });
+
+  router.get('/ideas/surprise/status', (_req, res) => {
+    res.json({ generating: surpriseInProgress });
+  });
+
+  return router;
+}