orbital-command 0.2.0 → 0.3.0

package/dist/server/shared/__fixtures__/workflow-configs.js

@@ -0,0 +1,75 @@
+import defaultWorkflowJson from '../default-workflow.json' with { type: 'json' };
+/** The full 7-list trunk-based workflow from default-workflow.json */
+export const DEFAULT_CONFIG = defaultWorkflowJson;
+/** Smallest valid config: 2 lists, 1 edge, 1 entry point */
+export const MINIMAL_CONFIG = {
+    version: 1,
+    name: 'Minimal',
+    lists: [
+        { id: 'todo', label: 'To Do', order: 0, color: '0 0% 50%', hex: '#808080', isEntryPoint: true, hasDirectory: true },
+        { id: 'done', label: 'Done', order: 1, color: '120 50% 50%', hex: '#40bf40', hasDirectory: true },
+    ],
+    edges: [
+        { from: 'todo', to: 'done', direction: 'forward', command: null, confirmLevel: 'quick', label: 'Complete', description: 'Mark as done' },
+    ],
+    terminalStatuses: ['done'],
+    allowedCommandPrefixes: ['/test-'],
+};
+/** Config with hooks for hook-related tests */
+export const CONFIG_WITH_HOOKS = {
+    version: 1,
+    name: 'With Hooks',
+    lists: [
+        { id: 'backlog', label: 'Backlog', order: 0, color: '0 0% 50%', hex: '#808080', isEntryPoint: true, hasDirectory: true, supportsSprint: true },
+        { id: 'active', label: 'Active', order: 1, color: '200 80% 50%', hex: '#1a8ccc', hasDirectory: true, sessionKey: 'implementScope' },
+        { id: 'review', label: 'Review', order: 2, color: '45 90% 50%', hex: '#f0c010', hasDirectory: true, supportsBatch: true, sessionKey: 'reviewGate' },
+        { id: 'shipped', label: 'Shipped', order: 3, color: '120 70% 40%', hex: '#30a030', hasDirectory: true, gitBranch: 'main' },
+    ],
+    edges: [
+        { from: 'backlog', to: 'active', direction: 'forward', command: '/scope-implement {id}', confirmLevel: 'quick', label: 'Start', description: 'Begin work', dispatchOnly: true, autoRevert: true, hooks: ['blocker-check'], agents: ['architect'] },
+        { from: 'active', to: 'review', direction: 'forward', command: '/scope-post-review {id}', confirmLevel: 'quick', label: 'Review', description: 'Submit for review', dispatchOnly: true, hooks: ['blocker-check', 'session-enforcer'] },
+        { from: 'review', to: 'shipped', direction: 'forward', command: '/git-main', confirmLevel: 'quick', label: 'Ship', description: 'Push to main', dispatchOnly: true },
+        { from: 'active', to: 'backlog', direction: 'backward', command: null, confirmLevel: 'quick', label: 'Revert', description: 'Back to backlog', humanOnly: true },
+        { from: 'review', to: 'active', direction: 'backward', command: null, confirmLevel: 'quick', label: 'Rework', description: 'Back to active' },
+    ],
+    hooks: [
+        { id: 'blocker-check', label: 'Blocker Check', timing: 'before', type: 'shell', target: '.claude/hooks/blocker-check.sh', blocking: false, category: 'gate', description: 'Checks for blockers' },
+        { id: 'session-enforcer', label: 'Session Auth', timing: 'before', type: 'shell', target: '.claude/hooks/session-enforcer.sh', blocking: true, category: 'guard', description: 'Enforces session auth' },
+        { id: 'scope-transition', label: 'File Mover', timing: 'before', type: 'shell', target: '.claude/hooks/scope-transition.sh', blocking: false, category: 'lifecycle' },
+        { id: 'dashboard-sync', label: 'Dashboard Sync', timing: 'after', type: 'shell', target: '.claude/hooks/dashboard-sync.sh', blocking: false, category: 'observer' },
+    ],
+    groups: [
+        { id: 'planning', label: 'Planning', order: 0 },
+        { id: 'development', label: 'Development', order: 1 },
+    ],
+    eventInference: [
+        { eventType: 'SCOPE_STATUS_CHANGED', targetStatus: '', dataField: 'to', forwardOnly: true },
+        { eventType: 'AGENT_STARTED', targetStatus: 'active', forwardOnly: true },
+        { eventType: 'AGENT_COMPLETED', targetStatus: '', conditions: { outcome: ['success', 'failure'], dispatchResolution: true }, forwardOnly: false },
+    ],
+    terminalStatuses: ['shipped'],
+    allowedCommandPrefixes: ['/scope-', '/git-'],
+};
+/** Named invalid configs for constructor error tests */
+export const INVALID_CONFIGS = {
+    noLists: { version: 1, name: 'No Lists', lists: [], edges: [{ from: 'a', to: 'b', direction: 'forward', command: null, confirmLevel: 'quick', label: 'X', description: 'X' }] },
+    noEdges: { version: 1, name: 'No Edges', lists: [{ id: 'a', label: 'A', order: 0, color: '0 0% 0%', hex: '#000', isEntryPoint: true, hasDirectory: true }], edges: [] },
+    twoEntryPoints: {
+        version: 1,
+        name: 'Two Entry Points',
+        lists: [
+            { id: 'a', label: 'A', order: 0, color: '0 0% 0%', hex: '#000', isEntryPoint: true, hasDirectory: true },
+            { id: 'b', label: 'B', order: 1, color: '0 0% 0%', hex: '#000', isEntryPoint: true, hasDirectory: true },
+        ],
+        edges: [{ from: 'a', to: 'b', direction: 'forward', command: null, confirmLevel: 'quick', label: 'X', description: 'X' }],
+    },
+    zeroEntryPoints: {
+        version: 1,
+        name: 'Zero Entry Points',
+        lists: [
+            { id: 'a', label: 'A', order: 0, color: '0 0% 0%', hex: '#000', hasDirectory: true },
+            { id: 'b', label: 'B', order: 1, color: '0 0% 0%', hex: '#000', hasDirectory: true },
+        ],
+        edges: [{ from: 'a', to: 'b', direction: 'forward', command: null, confirmLevel: 'quick', label: 'X', description: 'X' }],
+    },
+};

package/dist/server/shared/default-workflow.json

@@ -100,6 +100,7 @@
             "label": "Team Review",
             "description": "Runs full agent team review, locks spec, moves to backlog.",
             "dispatchOnly": true,
+            "autoRevert": true,
             "hooks": ["session-enforcer", "blocker-check", "dependency-check", "scope-transition", "orbital-scope-update"]
         },
         {
@@ -128,6 +129,7 @@
             "label": "Start Implementing",
             "description": "Opens a Claude session running /scope-implement.",
             "dispatchOnly": true,
+            "autoRevert": true,
             "hooks": ["session-enforcer", "blocker-check", "dependency-check", "scope-transition", "orbital-scope-update"]
         },
         {
@@ -139,6 +141,7 @@
             "label": "Launch Post-Review",
             "description": "Runs quality gates, formal verification, and code review.",
             "dispatchOnly": true,
+            "autoRevert": true,
             "hooks": ["session-enforcer", "review-gate-check", "blocker-check", "dependency-check", "scope-transition", "orbital-scope-update"]
         },
         {
@@ -179,6 +182,7 @@
             "label": "Commit",
             "description": "Commits scope work.",
             "dispatchOnly": true,
+            "autoRevert": true,
             "hooks": ["session-enforcer", "completion-checklist", "blocker-check", "dependency-check", "scope-transition", "orbital-scope-update", "scope-commit-logger"]
         },
         {
@@ -190,6 +194,7 @@
             "label": "Push to Main",
             "description": "Pushes or PRs scope work to the main branch.",
             "dispatchOnly": true,
+            "autoRevert": true,
             "hooks": ["session-enforcer", "blocker-check", "dependency-check", "scope-transition", "orbital-scope-update", "scope-commit-logger"]
         },
         {
@@ -248,6 +253,66 @@
             "dispatchOnly": false,
             "humanOnly": true,
             "hooks": ["session-enforcer", "scope-transition", "orbital-scope-update"]
+        },
+        {
+            "from": "backlog",
+            "to": "icebox",
+            "direction": "backward",
+            "command": null,
+            "confirmLevel": "quick",
+            "label": "Shelve to Icebox",
+            "description": "Shelves this scope back to the icebox for later consideration.",
+            "dispatchOnly": false,
+            "humanOnly": true,
+            "hooks": ["session-enforcer", "scope-transition", "orbital-scope-update"]
+        },
+        {
+            "from": "implementing",
+            "to": "icebox",
+            "direction": "backward",
+            "command": null,
+            "confirmLevel": "full",
+            "checklist": [
+                "No uncommitted work will be lost",
+                "This scope is being abandoned, not paused"
+            ],
+            "label": "Shelve to Icebox",
+            "description": "Abandons implementation and shelves this scope back to the icebox.",
+            "dispatchOnly": false,
+            "humanOnly": true,
+            "hooks": ["session-enforcer", "scope-transition", "orbital-scope-update"]
+        },
+        {
+            "from": "review",
+            "to": "icebox",
+            "direction": "backward",
+            "command": null,
+            "confirmLevel": "full",
+            "checklist": [
+                "No uncommitted work will be lost",
+                "This scope is being abandoned, not paused"
+            ],
+            "label": "Shelve to Icebox",
+            "description": "Abandons review and shelves this scope back to the icebox.",
+            "dispatchOnly": false,
+            "humanOnly": true,
+            "hooks": ["session-enforcer", "scope-transition", "orbital-scope-update"]
+        },
+        {
+            "from": "completed",
+            "to": "icebox",
+            "direction": "backward",
+            "command": null,
+            "confirmLevel": "full",
+            "checklist": [
+                "Committed work has been reverted or is acceptable to leave",
+                "This scope is being abandoned, not paused"
+            ],
+            "label": "Shelve to Icebox",
+            "description": "Shelves this completed scope back to the icebox.",
+            "dispatchOnly": false,
+            "humanOnly": true,
+            "hooks": ["session-enforcer", "scope-transition", "orbital-scope-update"]
         }
     ],
     "hooks": [

package/dist/server/shared/onboarding-tour.test.js

@@ -0,0 +1,81 @@
+import { describe, it, expect } from 'vitest';
+import { TOUR_STEPS } from '../src/components/onboarding/tour-steps';
+describe('onboarding tour steps', () => {
+    it('should have at least one step', () => {
+        expect(TOUR_STEPS.length).toBeGreaterThan(0);
+    });
+    it('should have unique step IDs', () => {
+        const ids = TOUR_STEPS.map(s => s.id);
+        expect(new Set(ids).size).toBe(ids.length);
+    });
+    it('should have unique targets', () => {
+        const targets = TOUR_STEPS.map(s => s.target);
+        expect(new Set(targets).size).toBe(targets.length);
+    });
+    it('should have title and description for every step', () => {
+        for (const step of TOUR_STEPS) {
+            expect(step.title).toBeTruthy();
+            expect(step.description).toBeTruthy();
+        }
+    });
+    it('should have valid placement values', () => {
+        const validPlacements = new Set(['top', 'bottom', 'left', 'right']);
+        for (const step of TOUR_STEPS) {
+            if (step.placement) {
+                expect(validPlacements.has(step.placement)).toBe(true);
+            }
+        }
+    });
+    it('should mark dynamic content steps as optional', () => {
+        const dynamicTargets = ['kanban-column', 'scope-card'];
+        for (const step of TOUR_STEPS) {
+            if (dynamicTargets.includes(step.target)) {
+                expect(step.optional).toBe(true);
+            }
+        }
+    });
+    it('should cover all expected pages', () => {
+        const pages = new Set(TOUR_STEPS.filter(s => s.page).map(s => s.page));
+        expect(pages.has('/')).toBe(true);
+        expect(pages.has('/primitives')).toBe(true);
+        expect(pages.has('/guards')).toBe(true);
+        expect(pages.has('/repo')).toBe(true);
+        expect(pages.has('/sessions')).toBe(true);
+        expect(pages.has('/workflow')).toBe(true);
+    });
+    describe('step sequencing', () => {
+        it('first step should target the Kanban nav', () => {
+            expect(TOUR_STEPS[0].target).toBe('nav-kanban');
+            expect(TOUR_STEPS[0].page).toBe('/');
+        });
+        it('last step should target Settings', () => {
+            const last = TOUR_STEPS[TOUR_STEPS.length - 1];
+            expect(last.target).toBe('nav-settings');
+        });
+        it('should complete a full traversal of all steps', () => {
+            let index = 0;
+            const visited = [];
+            while (index < TOUR_STEPS.length) {
+                visited.push(TOUR_STEPS[index].id);
+                index++;
+            }
+            expect(visited.length).toBe(TOUR_STEPS.length);
+            expect(visited[0]).toBe('welcome');
+            expect(visited[visited.length - 1]).toBe('nav-settings');
+        });
+    });
+    describe('completion tracking', () => {
+        it('default state should be pending', () => {
+            const DEFAULT_STATE = 'pending';
+            expect(DEFAULT_STATE).toBe('pending');
+        });
+        it('completed state should be the string completed', () => {
+            const state = 'completed';
+            expect(state).toBe('completed');
+        });
+        it('dismissed state should be the string dismissed', () => {
+            const state = 'dismissed';
+            expect(state).toBe('dismissed');
+        });
+    });
+});

package/dist/server/shared/project-colors.js

@@ -0,0 +1,24 @@
+/** Predefined project color palette (HSL strings). Used for auto-assigning
+ *  project badge colors when projects are registered with Orbital Command. */
+export const PROJECT_COLORS = [
+    '0 90% 62%', // red
+    '20 95% 60%', // vermilion
+    '40 95% 56%', // orange
+    '58 90% 52%', // amber
+    '76 85% 50%', // chartreuse
+    '100 80% 48%', // lime
+    '130 80% 48%', // green
+    '158 85% 46%', // emerald
+    '178 90% 46%', // teal
+    '194 95% 52%', // cyan
+    '212 90% 60%', // sky
+    '232 88% 64%', // blue
+    '254 85% 66%', // indigo
+    '272 85% 64%', // purple
+    '292 82% 62%', // violet
+    '312 85% 58%', // magenta
+    '330 88% 58%', // hot pink
+    '348 92% 60%', // rose
+    '150 82% 52%', // mint
+    '56 95% 62%', // gold
+];

package/dist/server/shared/workflow-config.test.js

@@ -0,0 +1,84 @@
+import { describe, it, expect } from 'vitest';
+import { isWorkflowConfig, isWorkflowList, isWorkflowEdge, getHookEnforcement, } from './workflow-config.js';
+import { MINIMAL_CONFIG, DEFAULT_CONFIG } from './__fixtures__/workflow-configs.js';
+describe('isWorkflowConfig()', () => {
+    it('returns true for valid minimal config', () => {
+        expect(isWorkflowConfig(MINIMAL_CONFIG)).toBe(true);
+    });
+    it('returns true for full default config', () => {
+        expect(isWorkflowConfig(DEFAULT_CONFIG)).toBe(true);
+    });
+    it('returns false for null', () => {
+        expect(isWorkflowConfig(null)).toBe(false);
+    });
+    it('returns false for undefined', () => {
+        expect(isWorkflowConfig(undefined)).toBe(false);
+    });
+    it('returns false for non-object', () => {
+        expect(isWorkflowConfig('string')).toBe(false);
+        expect(isWorkflowConfig(42)).toBe(false);
+    });
+    it('returns false when version != 1', () => {
+        expect(isWorkflowConfig({ ...MINIMAL_CONFIG, version: 2 })).toBe(false);
+    });
+    it('returns false when lists is not an array', () => {
+        expect(isWorkflowConfig({ ...MINIMAL_CONFIG, lists: 'not-array' })).toBe(false);
+    });
+    it('returns false when name is not a string', () => {
+        expect(isWorkflowConfig({ ...MINIMAL_CONFIG, name: 123 })).toBe(false);
+    });
+    it('returns false when branchingMode is invalid', () => {
+        expect(isWorkflowConfig({ ...MINIMAL_CONFIG, branchingMode: 'invalid' })).toBe(false);
+    });
+    it('returns true when branchingMode is trunk or worktree', () => {
+        expect(isWorkflowConfig({ ...MINIMAL_CONFIG, branchingMode: 'trunk' })).toBe(true);
+        expect(isWorkflowConfig({ ...MINIMAL_CONFIG, branchingMode: 'worktree' })).toBe(true);
+    });
+});
+describe('isWorkflowList()', () => {
+    const validList = MINIMAL_CONFIG.lists[0];
+    it('returns true for valid list', () => {
+        expect(isWorkflowList(validList)).toBe(true);
+    });
+    it('returns false for non-object', () => {
+        expect(isWorkflowList(null)).toBe(false);
+        expect(isWorkflowList('string')).toBe(false);
+    });
+    it('returns false when missing required fields', () => {
+        expect(isWorkflowList({ id: 'a', label: 'A' })).toBe(false); // missing order, color, hex, hasDirectory
+    });
+    it('returns true with optional fields present', () => {
+        expect(isWorkflowList({ ...validList, gitBranch: 'main', sessionKey: 'test' })).toBe(true);
+    });
+});
+describe('isWorkflowEdge()', () => {
+    const validEdge = MINIMAL_CONFIG.edges[0];
+    it('returns true for valid edge', () => {
+        expect(isWorkflowEdge(validEdge)).toBe(true);
+    });
+    it('returns false for non-object', () => {
+        expect(isWorkflowEdge(null)).toBe(false);
+        expect(isWorkflowEdge(42)).toBe(false);
+    });
+    it('returns false when missing required string fields', () => {
+        expect(isWorkflowEdge({ from: 'a', to: 'b' })).toBe(false); // missing direction, label, description
+    });
+});
+describe('getHookEnforcement()', () => {
+    const makeHook = (category) => ({
+        id: 'test', label: 'Test', timing: 'before', type: 'shell',
+        target: 'test.sh', category: category,
+    });
+    it('guard -> blocker', () => {
+        expect(getHookEnforcement(makeHook('guard'))).toBe('blocker');
+    });
+    it('gate -> advisor', () => {
+        expect(getHookEnforcement(makeHook('gate'))).toBe('advisor');
+    });
+    it('lifecycle -> operator', () => {
+        expect(getHookEnforcement(makeHook('lifecycle'))).toBe('operator');
+    });
+    it('observer -> silent', () => {
+        expect(getHookEnforcement(makeHook('observer'))).toBe('silent');
+    });
+});