orbital-command 0.1.0

package/dist/server/server/services/git-service.js

@@ -0,0 +1,309 @@
+import { execFile as execFileCb } from 'child_process';
+import { promisify } from 'util';
+import { listWorktrees } from '../utils/worktree-manager.js';
+const execFile = promisify(execFileCb);
+const CACHE_TTL = 60_000; // 60 seconds
+function cached(cache, key) {
+    const entry = cache.get(key);
+    if (entry && Date.now() - entry.ts < CACHE_TTL)
+        return entry.data;
+    return null;
+}
+function setCache(cache, key, data) {
+    cache.set(key, { data, ts: Date.now() });
+}
+// ─── Service ────────────────────────────────────────────────
+const SCOPE_BRANCH_RE = /(?:feat|fix|scope)[/-](?:scope-)?(\d+)/;
+export class GitService {
+    projectRoot;
+    scopeCache;
+    cache = new Map();
+    constructor(projectRoot, scopeCache) {
+        this.projectRoot = projectRoot;
+        this.scopeCache = scopeCache;
+    }
+    async git(args, cwd) {
+        // Uses execFile (not exec) — safe against shell injection
+        const { stdout } = await execFile('git', args, {
+            cwd: cwd ?? this.projectRoot,
+            maxBuffer: 10 * 1024 * 1024,
+        });
+        return stdout;
+    }
+    // ─── Overview ──────────────────────────────────────────────
+    async getOverview(branchingMode) {
+        const cacheKey = `overview:${branchingMode}`;
+        const hit = cached(this.cache, cacheKey);
+        if (hit)
+            return hit;
+        const [branchRaw, statusRaw] = await Promise.all([
+            this.git(['branch', '--show-current']).catch(() => ''),
+            this.git(['status', '--porcelain']).catch(() => ''),
+        ]);
+        const currentBranch = branchRaw.trim() || '(detached)';
+        const dirty = statusRaw.trim().length > 0;
+        const detached = !branchRaw.trim();
+        // Main HEAD
+        let mainHead = null;
+        try {
+            const raw = await this.git(['log', 'HEAD', '-1', '--format=%H|%aI|%s']);
+            const [sha, date, ...msgParts] = raw.trim().split('|');
+            if (sha)
+                mainHead = { sha, message: msgParts.join('|'), date };
+        }
+        catch { /* no commits yet */ }
+        // Ahead/behind relative to origin/main (or origin/master)
+        let aheadBehind = null;
+        if (!detached) {
+            try {
+                const raw = await this.git(['rev-list', '--left-right', '--count', `origin/main...${currentBranch}`]);
+                const [behind, ahead] = raw.trim().split('\t').map(Number);
+                aheadBehind = { ahead: ahead ?? 0, behind: behind ?? 0 };
+            }
+            catch {
+                try {
+                    const raw = await this.git(['rev-list', '--left-right', '--count', `origin/master...${currentBranch}`]);
+                    const [behind, ahead] = raw.trim().split('\t').map(Number);
+                    aheadBehind = { ahead: ahead ?? 0, behind: behind ?? 0 };
+                }
+                catch { /* no remote tracking */ }
+            }
+        }
+        // Worktree and feature branch counts
+        let worktreeCount = 0;
+        let featureBranchCount = 0;
+        try {
+            const wts = await listWorktrees(this.projectRoot);
+            worktreeCount = wts.length;
+        }
+        catch { /* ok */ }
+        try {
+            const raw = await this.git(['branch', '--format=%(refname:short)']);
+            const branches = raw.trim().split('\n').filter(Boolean);
+            featureBranchCount = branches.filter(b => SCOPE_BRANCH_RE.test(b) || b.startsWith('feat/')).length;
+        }
+        catch { /* ok */ }
+        const result = {
+            branchingMode,
+            currentBranch,
+            dirty,
+            detached,
+            mainHead,
+            aheadBehind,
+            worktreeCount,
+            featureBranchCount,
+        };
+        setCache(this.cache, cacheKey, result);
+        return result;
+    }
+    // ─── Commits ──────────────────────────────────────────────
+    async getCommits(opts = {}) {
+        const { branch, limit = 50, offset = 0 } = opts;
+        const cacheKey = `commits:${branch ?? 'all'}:${limit}:${offset}`;
+        const hit = cached(this.cache, cacheKey);
+        if (hit)
+            return hit;
+        const args = ['log', '--format=%H|%h|%aI|%an|%s|%D'];
+        if (branch && branch !== 'all') {
+            args.push(branch);
+        }
+        else {
+            args.push('--all');
+        }
+        args.push(`--skip=${offset}`, `-${limit}`);
+        let raw;
+        try {
+            raw = await this.git(args);
+        }
+        catch {
+            return [];
+        }
+        const commits = [];
+        for (const line of raw.trim().split('\n')) {
+            if (!line)
+                continue;
+            const parts = line.split('|');
+            const sha = parts[0];
+            const shortSha = parts[1];
+            const date = parts[2];
+            const author = parts[3];
+            const message = parts[4];
+            const refStr = parts.slice(5).join('|');
+            const refs = refStr
+                ? refStr.split(',').map(r => r.trim()).filter(Boolean)
+                : [];
+            // Extract scope ID from refs or message
+            let scopeId = null;
+            for (const ref of refs) {
+                const m = SCOPE_BRANCH_RE.exec(ref);
+                if (m) {
+                    scopeId = parseInt(m[1]);
+                    break;
+                }
+            }
+            if (!scopeId) {
+                const m = SCOPE_BRANCH_RE.exec(message);
+                if (m)
+                    scopeId = parseInt(m[1]);
+            }
+            // Derive branch from first ref that looks like a branch
+            let branchName = '';
+            for (const ref of refs) {
+                const cleaned = ref.replace(/^HEAD -> /, '').replace(/^origin\//, '');
+                if (cleaned && !cleaned.startsWith('tag:')) {
+                    branchName = cleaned;
+                    break;
+                }
+            }
+            commits.push({ sha, shortSha, message, author, date, branch: branchName, scopeId, refs });
+        }
+        setCache(this.cache, cacheKey, commits);
+        return commits;
+    }
+    // ─── Branches ──────────────────────────────────────────────
+    async getBranches() {
+        const hit = cached(this.cache, 'branches');
+        if (hit)
+            return hit;
+        let raw;
+        try {
+            raw = await this.git([
+                'branch', '-a',
+                '--format=%(HEAD)|%(refname:short)|%(objectname:short)|%(committerdate:iso-strict)|%(subject)',
+            ]);
+        }
+        catch {
+            return [];
+        }
+        const now = Date.now();
+        const STALE_MS = 7 * 24 * 60 * 60 * 1000;
+        const branches = [];
+        for (const line of raw.trim().split('\n')) {
+            if (!line)
+                continue;
+            const [headMarker, name, headSha, headDate, ...msgParts] = line.split('|');
+            if (!name || name.includes('HEAD'))
+                continue;
+            const isCurrent = headMarker === '*';
+            const isRemote = name.startsWith('remotes/') || name.startsWith('origin/');
+            const cleanName = name.replace(/^remotes\//, '');
+            // Skip remote duplicates of local branches
+            if (isRemote) {
+                const localName = cleanName.replace(/^origin\//, '');
+                if (branches.some(b => !b.isRemote && b.name === localName))
+                    continue;
+            }
+            const scopeMatch = SCOPE_BRANCH_RE.exec(cleanName);
+            const scopeId = scopeMatch ? parseInt(scopeMatch[1]) : null;
+            const isStale = headDate ? (now - new Date(headDate).getTime() > STALE_MS) : false;
+            // Ahead/behind relative to origin/main
+            let aheadBehind = null;
+            if (!isRemote) {
+                try {
+                    const countRaw = await this.git(['rev-list', '--left-right', '--count', `origin/main...${name}`]);
+                    const [behind, ahead] = countRaw.trim().split('\t').map(Number);
+                    aheadBehind = { ahead: ahead ?? 0, behind: behind ?? 0 };
+                }
+                catch { /* no remote */ }
+            }
+            branches.push({
+                name: cleanName,
+                isRemote,
+                isCurrent,
+                headSha: headSha ?? '',
+                headMessage: msgParts.join('|'),
+                headDate: headDate ?? '',
+                aheadBehind,
+                scopeId,
+                isStale,
+            });
+        }
+        setCache(this.cache, 'branches', branches);
+        return branches;
+    }
+    // ─── Enhanced Worktrees ────────────────────────────────────
+    async getEnhancedWorktrees() {
+        const hit = cached(this.cache, 'worktrees-enhanced');
+        if (hit)
+            return hit;
+        let wts;
+        try {
+            wts = await listWorktrees(this.projectRoot);
+        }
+        catch {
+            return [];
+        }
+        const results = [];
+        for (const wt of wts) {
+            let head = '';
+            try {
+                head = (await this.git(['rev-parse', '--short', 'HEAD'], wt.path)).trim();
+            }
+            catch { /* ok */ }
+            let dirty = false;
+            try {
+                const status = (await this.git(['status', '--porcelain'], wt.path)).trim();
+                dirty = status.length > 0;
+            }
+            catch { /* ok */ }
+            let aheadBehind = null;
+            try {
+                const branchName = wt.branch.replace(/^refs\/heads\//, '');
+                const countRaw = await this.git(['rev-list', '--left-right', '--count', `origin/main...${branchName}`], wt.path);
+                const [behind, ahead] = countRaw.trim().split('\t').map(Number);
+                aheadBehind = { ahead: ahead ?? 0, behind: behind ?? 0 };
+            }
+            catch { /* ok */ }
+            const scope = wt.scopeId ? this.scopeCache.getById(wt.scopeId) : null;
+            results.push({
+                path: wt.path,
+                branch: wt.branch.replace(/^refs\/heads\//, ''),
+                head,
+                scopeId: wt.scopeId,
+                scopeTitle: scope?.title ?? null,
+                scopeStatus: scope?.status ?? null,
+                dirty,
+                aheadBehind,
+            });
+        }
+        setCache(this.cache, 'worktrees-enhanced', results);
+        return results;
+    }
+    // ─── Dynamic Drift ─────────────────────────────────────────
+    async getDrift(gitBranches) {
+        const cacheKey = `drift:${gitBranches.map(b => `${b.from}-${b.to}`).join(',')}`;
+        const hit = cached(this.cache, cacheKey);
+        if (hit)
+            return hit;
+        const pairs = [];
+        for (const { from, to } of gitBranches) {
+            try {
+                const raw = await this.git([
+                    'log', `origin/${from}`, '--not', `origin/${to}`,
+                    '--reverse', '--format=%H|%aI|%s|%an',
+                ]);
+                const commits = raw.trim().split('\n').filter(Boolean).map(line => {
+                    const [sha, date, ...rest] = line.split('|');
+                    return { sha, date, message: rest.slice(0, -1).join('|'), author: rest[rest.length - 1] };
+                });
+                pairs.push({ from, to, count: commits.length, commits });
+            }
+            catch {
+                pairs.push({ from, to, count: 0, commits: [] });
+            }
+        }
+        setCache(this.cache, cacheKey, pairs);
+        return pairs;
+    }
+    // ─── Git Status Polling ────────────────────────────────────
+    async getStatusHash() {
+        const [head, dirty] = await Promise.all([
+            this.git(['rev-parse', 'HEAD']).catch(() => 'none'),
+            this.git(['status', '--porcelain']).catch(() => ''),
+        ]);
+        return `${head.trim()}:${dirty.trim().length > 0 ? 'dirty' : 'clean'}`;
+    }
+    clearCache() {
+        this.cache.clear();
+    }
+}

package/dist/server/server/services/github-service.js

@@ -0,0 +1,145 @@
+import { execFile as execFileCb } from 'child_process';
+import { promisify } from 'util';
+// Uses execFile (not exec) — safe against shell injection
+const execFile = promisify(execFileCb);
+// ─── Service ────────────────────────────────────────────────
+const CACHE_TTL = 30_000; // 30 seconds
+const SCOPE_ID_RE = /(?:scope|feat)[/-](\d+)/gi;
+export class GitHubService {
+    projectRoot;
+    statusCache = null;
+    prCache = null;
+    constructor(projectRoot) {
+        this.projectRoot = projectRoot;
+    }
+    async gh(args) {
+        const { stdout } = await execFile('gh', args, {
+            cwd: this.projectRoot,
+            timeout: 10_000,
+        });
+        return stdout;
+    }
+    async ghAvailable() {
+        try {
+            await execFile('which', ['gh']);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async getStatus() {
+        if (this.statusCache && Date.now() - this.statusCache.ts < CACHE_TTL) {
+            return this.statusCache.data;
+        }
+        const available = await this.ghAvailable();
+        if (!available) {
+            const result = {
+                connected: false,
+                authUser: null,
+                repo: null,
+                openPRs: 0,
+                error: 'gh CLI not installed',
+            };
+            this.statusCache = { data: result, ts: Date.now() };
+            return result;
+        }
+        // Check auth
+        let authUser = null;
+        try {
+            const whoami = await this.gh(['api', 'user', '--jq', '.login']);
+            authUser = whoami.trim() || null;
+        }
+        catch {
+            const result = {
+                connected: false,
+                authUser: null,
+                repo: null,
+                openPRs: 0,
+                error: 'gh not authenticated — run `gh auth login`',
+            };
+            this.statusCache = { data: result, ts: Date.now() };
+            return result;
+        }
+        // Get repo info
+        let repo = null;
+        try {
+            const raw = await this.gh([
+                'repo', 'view', '--json', 'owner,name,defaultBranchRef,visibility,url',
+            ]);
+            const parsed = JSON.parse(raw);
+            repo = {
+                owner: parsed.owner?.login ?? '',
+                name: parsed.name ?? '',
+                fullName: `${parsed.owner?.login ?? ''}/${parsed.name ?? ''}`,
+                defaultBranch: parsed.defaultBranchRef?.name ?? 'main',
+                visibility: (parsed.visibility ?? 'private').toLowerCase(),
+                url: parsed.url ?? '',
+            };
+        }
+        catch {
+            const result = {
+                connected: false,
+                authUser,
+                repo: null,
+                openPRs: 0,
+                error: 'Not a GitHub repository',
+            };
+            this.statusCache = { data: result, ts: Date.now() };
+            return result;
+        }
+        // Get open PR count
+        let openPRs = 0;
+        try {
+            const raw = await this.gh(['pr', 'list', '--state', 'open', '--json', 'number', '--limit', '100']);
+            const parsed = JSON.parse(raw);
+            openPRs = Array.isArray(parsed) ? parsed.length : 0;
+        }
+        catch { /* ok */ }
+        const result = { connected: true, authUser, repo, openPRs, error: null };
+        this.statusCache = { data: result, ts: Date.now() };
+        return result;
+    }
+    async getOpenPRs() {
+        if (this.prCache && Date.now() - this.prCache.ts < CACHE_TTL) {
+            return this.prCache.data;
+        }
+        try {
+            const raw = await this.gh([
+                'pr', 'list', '--state', 'open', '--json',
+                'number,title,author,headRefName,baseRefName,state,url,createdAt',
+                '--limit', '30',
+            ]);
+            const parsed = JSON.parse(raw);
+            const prs = parsed.map(pr => {
+                const title = String(pr.title ?? '');
+                const branch = String(pr.headRefName ?? '');
+                const scopeIds = [];
+                const sources = `${title} ${branch}`;
+                let m;
+                SCOPE_ID_RE.lastIndex = 0;
+                while ((m = SCOPE_ID_RE.exec(sources)) !== null) {
+                    const id = parseInt(m[1]);
+                    if (!scopeIds.includes(id))
+                        scopeIds.push(id);
+                }
+                return {
+                    number: Number(pr.number),
+                    title,
+                    author: typeof pr.author === 'object' && pr.author ? String(pr.author.login ?? '') : '',
+                    branch,
+                    baseBranch: String(pr.baseRefName ?? ''),
+                    state: String(pr.state ?? ''),
+                    url: String(pr.url ?? ''),
+                    createdAt: String(pr.createdAt ?? ''),
+                    scopeIds,
+                };
+            });
+            this.prCache = { data: prs, ts: Date.now() };
+            return prs;
+        }
+        catch {
+            return [];
+        }
+    }
+}

package/dist/server/server/services/readiness-service.js

@@ -0,0 +1,184 @@
+import fs from 'fs';
+import path from 'path';
+// ─── ReadinessService ───────────────────────────────────
+export class ReadinessService {
+    scopeService;
+    gateService;
+    engine;
+    projectRoot;
+    constructor(scopeService, gateService, engine, projectRoot) {
+        this.scopeService = scopeService;
+        this.gateService = gateService;
+        this.engine = engine;
+        this.projectRoot = projectRoot;
+    }
+    getReadiness(scopeId) {
+        const scope = this.scopeService.getById(scopeId);
+        if (!scope)
+            return null;
+        const targets = this.engine.getValidTargets(scope.status);
+        const transitions = [];
+        for (const to of targets) {
+            const edge = this.engine.findEdge(scope.status, to);
+            if (!edge)
+                continue;
+            // Only show forward and shortcut transitions (not backward)
+            if (edge.direction === 'backward')
+                continue;
+            const hooks = this.evaluateHooks(scope, edge);
+            const gates = this.getGatesForScope(scopeId);
+            const blockers = this.computeBlockers(hooks, scope);
+            transitions.push({
+                from: scope.status,
+                to,
+                edge,
+                hooks,
+                gates,
+                ready: blockers.length === 0,
+                blockers,
+            });
+        }
+        return {
+            scope_id: scopeId,
+            current_status: scope.status,
+            transitions,
+        };
+    }
+    evaluateHooks(scope, edge) {
+        const hooks = this.engine.getHooksForEdge(edge.from, edge.to);
+        return hooks.map((hook) => {
+            const enforcement = this.engine.getHookEnforcement(hook);
+            const { status, reason } = this.evaluateHook(hook.id, scope, edge);
+            return {
+                id: hook.id,
+                label: hook.label,
+                category: hook.category,
+                enforcement,
+                status,
+                reason,
+            };
+        });
+    }
+    evaluateHook(hookId, scope, edge) {
+        switch (hookId) {
+            case 'session-enforcer':
+                return this.checkSessionEnforcer(scope, edge);
+            case 'review-gate-check':
+                return this.checkReviewGate(scope);
+            case 'completion-checklist':
+                return this.checkCompletionChecklist(scope);
+            case 'blocker-check':
+                return this.checkBlockers(scope);
+            case 'dependency-check':
+                return this.checkDependencies(scope);
+            case 'scope-create-gate':
+                return this.checkScopeStructure(scope);
+            case 'scope-transition':
+                return { status: 'pass', reason: 'Lifecycle hook (runs on transition)' };
+            case 'orbital-scope-update':
+            case 'scope-commit-logger':
+                return { status: 'pass', reason: 'Observer (post-transition)' };
+            default:
+                return { status: 'unknown', reason: 'No pre-check available' };
+        }
+    }
+    checkSessionEnforcer(scope, edge) {
+        const targetList = this.engine.getList(edge.to);
+        const sessionKey = targetList?.sessionKey;
+        if (!sessionKey)
+            return { status: 'pass', reason: 'No session key required' };
+        const sessions = scope.sessions ?? {};
+        const recorded = sessions[sessionKey];
+        if (Array.isArray(recorded) && recorded.length > 0) {
+            return { status: 'pass', reason: `Session recorded (${recorded.length} session(s))` };
+        }
+        return { status: 'fail', reason: `No '${sessionKey}' session recorded in scope frontmatter` };
+    }
+    checkReviewGate(scope) {
+        const paddedId = String(scope.id).padStart(3, '0');
+        const verdictPath = path.join(this.projectRoot, '.claude', 'review-verdicts', `${paddedId}.json`);
+        if (!fs.existsSync(verdictPath)) {
+            return { status: 'fail', reason: 'No review verdict file found' };
+        }
+        try {
+            const verdict = JSON.parse(fs.readFileSync(verdictPath, 'utf-8'));
+            if (verdict.verdict === 'PASS') {
+                return { status: 'pass', reason: 'Review verdict: PASS' };
+            }
+            return { status: 'fail', reason: `Review verdict: ${verdict.verdict ?? 'unknown'}` };
+        }
+        catch {
+            return { status: 'fail', reason: 'Failed to parse review verdict file' };
+        }
+    }
+    checkCompletionChecklist(scope) {
+        const content = scope.raw_content ?? '';
+        const unchecked = (content.match(/^- \[ \]/gm) ?? []).length;
+        const checked = (content.match(/^- \[x\]/gim) ?? []).length;
+        if (checked + unchecked === 0) {
+            return { status: 'unknown', reason: 'No checklist items found in scope' };
+        }
+        if (unchecked > 0) {
+            return { status: 'fail', reason: `${unchecked} unchecked item(s) in DoD checklist` };
+        }
+        return { status: 'pass', reason: `All ${checked} checklist item(s) complete` };
+    }
+    checkBlockers(scope) {
+        const blockedBy = scope.blocked_by ?? [];
+        if (blockedBy.length === 0) {
+            return { status: 'pass', reason: 'No blockers' };
+        }
+        const unresolved = [];
+        for (const blockerId of blockedBy) {
+            const blocker = this.scopeService.getById(blockerId);
+            if (blocker && !this.engine.isTerminalStatus(blocker.status)) {
+                unresolved.push(blockerId);
+            }
+        }
+        if (unresolved.length === 0) {
+            return { status: 'pass', reason: `All ${blockedBy.length} blocker(s) resolved` };
+        }
+        return {
+            status: 'fail',
+            reason: `Blocked by unresolved scope(s): ${unresolved.join(', ')}`,
+        };
+    }
+    checkDependencies(scope) {
+        // Same check as blockers — dependency-check and blocker-check serve similar roles
+        return this.checkBlockers(scope);
+    }
+    checkScopeStructure(scope) {
+        if (!scope.title || scope.title.trim() === '') {
+            return { status: 'fail', reason: 'Scope has no title' };
+        }
+        if (!scope.raw_content || scope.raw_content.trim() === '') {
+            return { status: 'fail', reason: 'Scope has no content body' };
+        }
+        return { status: 'pass', reason: 'Scope structure valid' };
+    }
+    getGatesForScope(scopeId) {
+        const scoped = this.gateService.getLatestForScope(scopeId);
+        if (scoped.length > 0)
+            return scoped;
+        // Fall back to global latest run if no scope-specific gates exist
+        return this.gateService.getLatestRun();
+    }
+    computeBlockers(hooks, scope) {
+        const blockers = [];
+        // Only guards (blockers) actually prevent transitions
+        for (const hook of hooks) {
+            if (hook.enforcement === 'blocker' && hook.status === 'fail') {
+                blockers.push(`${hook.label}: ${hook.reason}`);
+            }
+        }
+        // Check for unresolved scope blockers
+        const blockedBy = scope.blocked_by ?? [];
+        for (const blockerId of blockedBy) {
+            const blocker = this.scopeService.getById(blockerId);
+            if (blocker && !this.engine.isTerminalStatus(blocker.status)) {
+                blockers.push(`Blocked by scope ${blockerId} (${blocker.status})`);
+            }
+        }
+        return blockers;
+    }
+}