orbital-command 0.1.0

package/dist/server/server/routes/git-routes.js

@@ -0,0 +1,92 @@
+import { Router } from 'express';
+export function createGitRoutes({ gitService, githubService, engine }) {
+    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 || 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 = [];
+            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/dist/server/server/routes/scope-routes.js

@@ -0,0 +1,215 @@
+import { Router } from 'express';
+import { spawn } from 'child_process';
+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');
+export function createScopeRoutes({ db, io, scopeService, readinessService, projectRoot, engine }) {
+    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;
+        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;
+        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;
+        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;
+}

package/dist/server/server/routes/sprint-routes.js

@@ -0,0 +1,116 @@
+import { Router } from 'express';
+export function createSprintRoutes({ sprintService, sprintOrchestrator, batchOrchestrator }) {
+    const router = Router();
+    router.post('/sprints', (req, res) => {
+        const { name, target_column, group_type } = req.body;
+        if (!name || !name.trim()) {
+            res.status(400).json({ error: 'name is required' });
+            return;
+        }
+        const sprint = sprintService.create(name.trim(), { target_column, group_type });
+        res.status(201).json(sprint);
+    });
+    router.get('/sprints', (req, res) => {
+        const status = req.query.status;
+        const targetColumn = req.query.target_column;
+        const sprints = sprintService.getAll(status, targetColumn);
+        res.json(sprints);
+    });
+    router.get('/sprints/:id', (req, res) => {
+        const sprint = sprintService.getById(Number(req.params.id));
+        if (!sprint) {
+            res.status(404).json({ error: 'Sprint not found' });
+            return;
+        }
+        res.json(sprint);
+    });
+    router.patch('/sprints/:id', (req, res) => {
+        const { name } = req.body;
+        if (!name || !name.trim()) {
+            res.status(400).json({ error: 'name is required' });
+            return;
+        }
+        const renamed = sprintService.rename(Number(req.params.id), name.trim());
+        if (!renamed) {
+            res.status(400).json({ error: 'Sprint not found or not in assembling state' });
+            return;
+        }
+        res.json({ ok: true });
+    });
+    router.delete('/sprints/:id', (req, res) => {
+        const deleted = sprintService.delete(Number(req.params.id));
+        if (!deleted) {
+            res.status(400).json({ error: 'Cannot delete sprint (must be assembling)' });
+            return;
+        }
+        res.json({ ok: true });
+    });
+    router.post('/sprints/:id/scopes', (req, res) => {
+        const { scope_ids } = req.body;
+        if (!Array.isArray(scope_ids) || scope_ids.length === 0) {
+            res.status(400).json({ error: 'scope_ids must be a non-empty array' });
+            return;
+        }
+        const result = sprintService.addScopes(Number(req.params.id), scope_ids);
+        if (!result) {
+            res.status(400).json({ error: 'Sprint not found or not in assembling state' });
+            return;
+        }
+        res.json(result);
+    });
+    router.delete('/sprints/:id/scopes', (req, res) => {
+        const { scope_ids } = req.body;
+        if (!Array.isArray(scope_ids) || scope_ids.length === 0) {
+            res.status(400).json({ error: 'scope_ids must be a non-empty array' });
+            return;
+        }
+        const removed = sprintService.removeScopes(Number(req.params.id), scope_ids);
+        if (!removed) {
+            res.status(400).json({ error: 'Sprint not found or not in assembling state' });
+            return;
+        }
+        res.json({ ok: true });
+    });
+    router.post('/sprints/:id/dispatch', async (req, res) => {
+        const id = Number(req.params.id);
+        const sprint = sprintService.getById(id);
+        if (!sprint) {
+            res.status(404).json({ error: 'Sprint not found' });
+            return;
+        }
+        if (sprint.group_type === 'batch') {
+            const { mergeMode } = req.body;
+            const result = await batchOrchestrator.dispatch(id, mergeMode);
+            if (!result.ok) {
+                res.status(400).json({ error: result.error });
+                return;
+            }
+            res.json({ ok: true });
+        }
+        else {
+            const result = await sprintOrchestrator.startSprint(id);
+            if (!result.ok) {
+                res.status(400).json({ error: result.error });
+                return;
+            }
+            res.json({ ok: true, layers: result.layers });
+        }
+    });
+    router.post('/sprints/:id/cancel', (req, res) => {
+        const cancelled = sprintOrchestrator.cancelSprint(Number(req.params.id));
+        if (!cancelled) {
+            res.status(400).json({ error: 'Sprint not found or cannot be cancelled' });
+            return;
+        }
+        res.json({ ok: true });
+    });
+    router.get('/sprints/:id/graph', (req, res) => {
+        const graph = sprintOrchestrator.getExecutionGraph(Number(req.params.id));
+        if (!graph) {
+            res.status(404).json({ error: 'Sprint not found' });
+            return;
+        }
+        res.json(graph);
+    });
+    return router;
+}

package/dist/server/server/routes/version-routes.js

@@ -0,0 +1,130 @@
+import { Router } from 'express';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import path from 'path';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+import { createLogger } from '../utils/logger.js';
+const log = createLogger('version');
+const execFileAsync = promisify(execFile);
+/** Resolve the root directory of the orbital-command package itself. */
+function getOrbitalRoot() {
+    const __selfDir = path.dirname(fileURLToPath(import.meta.url));
+    // Walk up until we find package.json (handles both dev and compiled paths)
+    let dir = __selfDir;
+    for (let i = 0; i < 6; i++) {
+        if (fs.existsSync(path.join(dir, 'package.json'))) {
+            return dir;
+        }
+        dir = path.dirname(dir);
+    }
+    // Fallback: assume dev layout (server/routes/ → 2 levels up)
+    return path.resolve(__selfDir, '../..');
+}
+async function git(args, cwd, timeoutMs = 15_000) {
+    const { stdout } = await execFileAsync('git', args, { cwd, timeout: timeoutMs });
+    return stdout.trim();
+}
+export function createVersionRoutes({ io }) {
+    const router = Router();
+    const orbitalRoot = getOrbitalRoot();
+    // GET /version — current version info
+    router.get('/version', async (_req, res) => {
+        try {
+            const pkgPath = path.join(orbitalRoot, 'package.json');
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+            let commitSha = 'unknown';
+            let branch = 'unknown';
+            try {
+                commitSha = await git(['rev-parse', '--short', 'HEAD'], orbitalRoot);
+                branch = await git(['rev-parse', '--abbrev-ref', 'HEAD'], orbitalRoot);
+            }
+            catch {
+                // Not a git repo (installed via npm) — version only
+            }
+            res.json({
+                version: pkg.version,
+                commitSha,
+                branch,
+            });
+        }
+        catch (err) {
+            log.error('Version route error', { error: err.message });
+            res.status(500).json({ error: `Failed to read version: ${err.message}` });
+        }
+    });
+    // GET /version/check — fetch from remote and compare SHAs
+    router.get('/version/check', async (_req, res) => {
+        try {
+            const branch = await git(['rev-parse', '--abbrev-ref', 'HEAD'], orbitalRoot);
+            await git(['fetch', 'origin', branch, '--quiet'], orbitalRoot);
+            const localSha = await git(['rev-parse', 'HEAD'], orbitalRoot);
+            const remoteSha = await git(['rev-parse', `origin/${branch}`], orbitalRoot);
+            let behindCount = 0;
+            if (localSha !== remoteSha) {
+                const countStr = await git(['rev-list', '--count', `HEAD..origin/${branch}`], orbitalRoot);
+                behindCount = parseInt(countStr, 10) || 0;
+            }
+            res.json({
+                updateAvailable: behindCount > 0,
+                behindCount,
+                localSha: localSha.slice(0, 7),
+                remoteSha: remoteSha.slice(0, 7),
+                branch,
+            });
+        }
+        catch (err) {
+            log.error('Version route error', { error: err.message });
+            res.status(500).json({ error: `Failed to check for updates: ${err.message}` });
+        }
+    });
+    // POST /version/update — git pull + npm install
+    router.post('/version/update', async (req, res) => {
+        if (req.headers['x-orbital-action'] !== 'update') {
+            res.status(403).json({ error: 'Missing required X-Orbital-Action header' });
+            return;
+        }
+        let stage = 'guard';
+        try {
+            // Guard: refuse if working tree is dirty
+            const status = await git(['status', '--porcelain'], orbitalRoot);
+            if (status.length > 0) {
+                res.status(409).json({
+                    error: 'Working tree has uncommitted changes. Commit or stash before updating.',
+                    dirty: true,
+                });
+                return;
+            }
+            stage = 'pulling';
+            io.emit('version:updating', { stage });
+            await git(['pull', '--ff-only'], orbitalRoot);
+            stage = 'installing';
+            io.emit('version:updating', { stage });
+            await execFileAsync('npm', ['install'], {
+                cwd: orbitalRoot,
+                timeout: 120_000,
+            });
+            io.emit('version:updated', { success: true });
+            // Read updated version
+            const pkg = JSON.parse(fs.readFileSync(path.join(orbitalRoot, 'package.json'), 'utf-8'));
+            const commitSha = await git(['rev-parse', '--short', 'HEAD'], orbitalRoot);
+            res.json({
+                success: true,
+                version: pkg.version,
+                commitSha,
+                message: 'Update complete. Restart the server to apply changes.',
+            });
+        }
+        catch (err) {
+            log.error('Version route error', { error: err.message });
+            const recovery = stage === 'installing'
+                ? ' Git pull succeeded — run `npm install` manually to finish.'
+                : stage === 'pulling'
+                    ? ' No files were changed — safe to retry.'
+                    : '';
+            io.emit('version:updated', { success: false, error: err.message });
+            res.status(500).json({ error: `Update failed at stage "${stage}": ${err.message}.${recovery}` });
+        }
+    });
+    return router;
+}