orbital-command 1.0.1 → 1.1.1

package/server/wizard/detect.ts

@@ -4,16 +4,12 @@
 
 import fs from 'fs';
 import path from 'path';
-import type { SetupState, ProjectSetupState } from './types.js';
+import type { SetupState } from './types.js';
 
 const ORBITAL_HOME = path.join(process.env.HOME || process.env.USERPROFILE || '~', '.orbital');
 
 export { ORBITAL_HOME };
 
-export function isInteractiveTerminal(): boolean {
-  return !!(process.stdout.isTTY && !process.env.CI);
-}
-
 export function isOrbitalSetupDone(): boolean {
   return fs.existsSync(path.join(ORBITAL_HOME, 'config.json'));
 }
@@ -26,79 +22,3 @@ export function buildSetupState(packageVersion: string): SetupState {
   };
 }
 
-export function buildProjectState(projectRoot: string, packageVersion: string): ProjectSetupState {
-  const projectConfigExists = fs.existsSync(path.join(projectRoot, '.claude', 'orbital.config.json'));
-
-  return {
-    projectRoot,
-    isProjectInitialized: projectConfigExists,
-    packageVersion,
-  };
-}
-
-export function detectProjectName(projectRoot: string): string {
-  return path.basename(projectRoot)
-    .replace(/[-_]+/g, ' ')
-    .replace(/\b\w/g, c => c.toUpperCase());
-}
-
-export function detectCommands(projectRoot: string): Record<string, string | null> {
-  const commands: Record<string, string | null> = {
-    typeCheck: null,
-    lint: null,
-    build: null,
-    test: null,
-  };
-
-  const pkgJsonPath = path.join(projectRoot, 'package.json');
-  if (!fs.existsSync(pkgJsonPath)) return commands;
-
-  try {
-    const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf8'));
-    const scripts = pkg.scripts || {};
-
-    if (scripts.typecheck || scripts['type-check']) {
-      commands.typeCheck = `npm run ${scripts.typecheck ? 'typecheck' : 'type-check'}`;
-    }
-    if (scripts.lint) commands.lint = 'npm run lint';
-    if (scripts.build) commands.build = 'npm run build';
-    if (scripts.test) commands.test = 'npm run test';
-  } catch { /* ignore malformed package.json */ }
-
-  return commands;
-}
-
-export function detectPortConflict(serverPort: number): string | null {
-  const registryPath = path.join(ORBITAL_HOME, 'config.json');
-  if (!fs.existsSync(registryPath)) return null;
-
-  try {
-    const registry = JSON.parse(fs.readFileSync(registryPath, 'utf8'));
-    for (const project of registry.projects || []) {
-      const configPath = path.join(project.path, '.claude', 'orbital.config.json');
-      if (!fs.existsSync(configPath)) continue;
-      try {
-        const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-        if (config.serverPort === serverPort) return project.name;
-      } catch { /* skip unreadable configs */ }
-    }
-  } catch { /* skip unreadable registry */ }
-
-  return null;
-}
-
-export function isValidProjectPath(p: string): string | undefined {
-  const resolved = p.startsWith('~')
-    ? path.join(process.env.HOME || process.env.USERPROFILE || '~', p.slice(1))
-    : path.resolve(p);
-  if (!fs.existsSync(resolved)) return 'Directory does not exist';
-  if (!fs.statSync(resolved).isDirectory()) return 'Not a directory';
-  return undefined;
-}
-
-export function resolveProjectPath(p: string): string {
-  if (p.startsWith('~')) {
-    return path.join(process.env.HOME || process.env.USERPROFILE || '~', p.slice(1));
-  }
-  return path.resolve(p);
-}

package/server/wizard/index.ts

@@ -2,8 +2,8 @@
  * Interactive CLI wizard — main orchestrator.
  *
  * Entry points:
- *   runSetupWizard()   — Phase 1: first-time Orbital setup (~/.orbital/)
- *   runProjectSetup()  — Phase 2: per-project scaffolding (.claude/)
+ *   runSetupWizard()   — First-time Orbital setup (~/.orbital/)
+ *   runHub()           — Context-aware hub menu (orbital)
  *   runConfigEditor()  — interactive config editor (orbital config)
  *   runDoctor()        — health diagnostics (orbital doctor)
  */
@@ -13,25 +13,19 @@ import path from 'path';
 import { spawn, execFileSync } from 'child_process';
 import * as p from '@clack/prompts';
 import pc from 'picocolors';
-import { buildSetupState, buildProjectState } from './detect.js';
+import { buildSetupState } from './detect.js';
 import { phaseSetupWizard } from './phases/setup-wizard.js';
-import { phaseWelcome } from './phases/welcome.js';
-import { phaseProjectSetup } from './phases/project-setup.js';
-import { phaseWorkflowSetup } from './phases/workflow-setup.js';
-import { phaseConfirm, showPostInstall } from './phases/confirm.js';
-import { NOTES } from './ui.js';
 import { runConfigEditor } from './config-editor.js';
 import { runDoctor } from './doctor.js';
 import { isITerm2Available } from '../adapters/iterm2-adapter.js';
-import { registerProject } from '../global-config.js';
 
 export { runConfigEditor, runDoctor };
 
 // ─── Phase 1: Setup Wizard ─────────────────────────────────────
 
 /**
- * First-time setup. Creates ~/.orbital/, seeds primitives,
- * optionally links projects (running Phase 2 for each).
+ * First-time setup. Creates ~/.orbital/ and seeds primitives.
+ * Project setup is now handled by the frontend Add Project modal.
  */
 export async function runSetupWizard(packageVersion: string): Promise<void> {
   const state = buildSetupState(packageVersion);
@@ -40,94 +34,7 @@ export async function runSetupWizard(packageVersion: string): Promise<void> {
 
   await phaseSetupWizard(state);
 
-  // If user linked projects, run Phase 2 for each
-  for (const projectRoot of state.linkedProjects) {
-    p.log.step(`Setting up ${pc.cyan(path.basename(projectRoot))}...`);
-    await runProjectSetupInline(projectRoot, packageVersion);
-  }
-
-  if (state.linkedProjects.length === 0) {
-    p.note(NOTES.setupComplete, 'Done');
-  }
-
-  p.outro(
-    state.linkedProjects.length > 0
-      ? `Run ${pc.cyan('orbital')} to launch the dashboard.`
-      : `Run ${pc.cyan('orbital')} in a project directory to get started.`
-  );
-}
-
-// ─── Phase 2: Project Setup ────────────────────────────────────
-
-/**
- * Per-project setup. Walks through name, commands, workflow, then
- * calls runInit() to scaffold files into .claude/.
- */
-export async function runProjectSetup(projectRoot: string, packageVersion: string, args: string[]): Promise<void> {
-  const state = buildProjectState(projectRoot, packageVersion);
-  const force = args.includes('--force');
-
-  p.intro(`${pc.bgCyan(pc.black(' Orbital Command '))} ${pc.dim(`v${packageVersion}`)}`);
-
-  // Welcome gate: detect re-init / reconfigure
-  const forceFromWelcome = await phaseWelcome(state);
-  const useForce = force || forceFromWelcome;
-
-  await runProjectPhases(state, useForce);
-
-  p.outro(`Run ${pc.cyan('orbital')} to launch the dashboard.`);
-}
-
-// ─── Shared project phases (used by both flows) ────────────────
-
-/**
- * Run the project setup phases and install. Used by both
- * standalone runProjectSetup() and inline from runSetupWizard().
- */
-async function runProjectPhases(state: ReturnType<typeof buildProjectState>, useForce: boolean): Promise<void> {
-  await phaseProjectSetup(state);
-  await phaseWorkflowSetup(state);
-  await phaseConfirm(state);
-
-  // Install
-  const s = p.spinner();
-  s.start('Installing into project...');
-
-  try {
-    const { runInit } = await import('../init.js');
-
-    runInit(state.projectRoot, {
-      force: useForce,
-      quiet: true,
-      preset: state.workflowPreset,
-      projectName: state.projectName,
-      serverPort: state.serverPort,
-      clientPort: state.clientPort,
-      commands: state.selectedCommands,
-    });
-
-    registerProject(state.projectRoot, { name: state.projectName });
-    stampTemplateVersion(state.projectRoot, state.packageVersion);
-
-    s.stop('Project ready.');
-  } catch (err) {
-    s.stop('Installation failed.');
-    p.log.error(err instanceof Error ? err.message : String(err));
-    process.exit(1);
-  }
-
-  showPostInstall(state);
-}
-
-/**
- * Inline project setup — called from Phase 1 when user links a project.
- * Skips intro/outro since the setup wizard already has those.
- */
-async function runProjectSetupInline(projectRoot: string, packageVersion: string): Promise<void> {
-  const state = buildProjectState(projectRoot, packageVersion);
-
-  // Skip welcome gate for inline — this is a fresh project being linked
-  await runProjectPhases(state, false);
+  p.outro('Launching dashboard...');
 }
 
 // ─── Update Check ─────────────────────────────────────────────
@@ -138,6 +45,18 @@ interface UpdateInfo {
   isOutdated: boolean;
 }
 
+/** Returns true if `a` is older than `b` (semver comparison). */
+function isOlderThan(a: string, b: string): boolean {
+  const pa = a.match(/^(\d+)\.(\d+)\.(\d+)/);
+  const pb = b.match(/^(\d+)\.(\d+)\.(\d+)/);
+  if (!pa || !pb) return false;
+  for (let i = 1; i <= 3; i++) {
+    if (parseInt(pa[i]) < parseInt(pb[i])) return true;
+    if (parseInt(pa[i]) > parseInt(pb[i])) return false;
+  }
+  return false;
+}
+
 async function checkForUpdate(
   currentVersion: string,
   cache: { lastUpdateCheck?: string; latestVersion?: string },
@@ -146,7 +65,7 @@ async function checkForUpdate(
   if (cache.lastUpdateCheck && cache.latestVersion) {
     const age = Date.now() - new Date(cache.lastUpdateCheck).getTime();
     if (age < 24 * 60 * 60 * 1000) {
-      const isOutdated = cache.latestVersion !== currentVersion;
+      const isOutdated = isOlderThan(currentVersion, cache.latestVersion);
       return {
         info: { current: currentVersion, latest: cache.latestVersion, isOutdated },
         cacheChanged: false,
@@ -162,7 +81,7 @@ async function checkForUpdate(
     const data = await res.json() as { version: string };
     const latest = data.version;
     return {
-      info: { current: currentVersion, latest, isOutdated: latest !== currentVersion },
+      info: { current: currentVersion, latest, isOutdated: isOlderThan(currentVersion, latest) },
       cacheChanged: true,
     };
   } catch {
@@ -172,7 +91,7 @@ async function checkForUpdate(
 
 // ─── Hub Menu ─────────────────────────────────────────────────
 
-export type HubAction = 'launch' | 'init' | 'config' | 'doctor' | 'update' | 'status' | 'reset';
+export type HubAction = 'launch' | 'config' | 'doctor' | 'update' | 'status' | 'reset';
 
 export interface HubResult {
   action: HubAction;
@@ -186,7 +105,6 @@ export interface HubResult {
  */
 export async function runHub(opts: {
   packageVersion: string;
-  isProjectInitialized: boolean;
   projectNames: string[];
   itermPromptShown: boolean;
   isMac: boolean;
@@ -357,28 +275,28 @@ export async function runHub(opts: {
     }
   }
 
-  // ── Build menu options based on project state ──
-  const projectHint = opts.projectNames.length > 0
-    ? pc.dim(` (${opts.projectNames.join(', ')})`)
-    : '';
+  // ── Show menu and pick action ──
+  result.action = await promptHubAction(opts.projectNames);
+  return result;
+}
 
-  const options: Array<{ value: HubAction; label: string; hint?: string }> = [];
+/**
+ * Show the hub menu and return the chosen action.
+ * Exported separately so the CLI can loop back after executing an action.
+ */
+export async function promptHubAction(projectNames: string[]): Promise<HubAction> {
+  const projectHint = projectNames.length > 0
+    ? pc.dim(` (${projectNames.join(', ')})`)
+    : '';
 
-  if (opts.isProjectInitialized) {
-    options.push(
-      { value: 'launch', label: `Launch dashboard${projectHint}` },
-      { value: 'config', label: 'Config', hint: 'modify project settings' },
-      { value: 'doctor', label: 'Doctor', hint: 'health check & diagnostics' },
-      { value: 'update', label: 'Update templates', hint: 'sync to latest' },
-      { value: 'status', label: 'Status', hint: 'template sync status' },
-      { value: 'reset', label: 'Reset to defaults', hint: 'force-reset all templates' },
-    );
-  } else {
-    options.push(
-      { value: 'init', label: 'Initialize this project' },
-      { value: 'launch', label: `Launch dashboard${projectHint}` },
-    );
-  }
+  const options: Array<{ value: HubAction; label: string; hint?: string }> = [
+    { value: 'launch', label: `Launch dashboard${projectHint}` },
+    { value: 'config', label: 'Config', hint: 'modify project settings' },
+    { value: 'doctor', label: 'Doctor', hint: 'health check & diagnostics' },
+    { value: 'update', label: 'Update templates', hint: 'sync to latest' },
+    { value: 'status', label: 'Status', hint: 'template sync status' },
+    { value: 'reset', label: 'Reset to defaults', hint: 'force-reset all templates' },
+  ];
 
   const action = await p.select({
     message: 'What would you like to do?',
@@ -390,7 +308,7 @@ export async function runHub(opts: {
     process.exit(0);
   }
 
-  // ── Double-confirm for destructive reset ──
+  // Double-confirm for destructive reset
   if (action === 'reset') {
     p.note(
       'This will overwrite ALL hooks, skills, agents, and workflow config\n' +
@@ -403,36 +321,17 @@ export async function runHub(opts: {
       initialValue: false,
     });
     if (p.isCancel(confirmReset) || !confirmReset) {
-      p.cancel('Reset cancelled.');
-      process.exit(0);
+      return promptHubAction(projectNames);
     }
     const doubleConfirm = await p.confirm({
       message: 'This cannot be undone. Continue?',
       initialValue: false,
     });
     if (p.isCancel(doubleConfirm) || !doubleConfirm) {
-      p.cancel('Reset cancelled.');
-      process.exit(0);
+      return promptHubAction(projectNames);
     }
   }
 
-  result.action = action;
-  return result;
+  return action;
 }
 
-// ─── Template Version Stamping ─────────────────────────────────
-
-function stampTemplateVersion(projectRoot: string, packageVersion: string): void {
-  const configPath = path.join(projectRoot, '.claude', 'orbital.config.json');
-  if (!fs.existsSync(configPath)) return;
-
-  try {
-    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-    if (config.templateVersion !== packageVersion) {
-      config.templateVersion = packageVersion;
-      const tmp = configPath + `.tmp.${process.pid}`;
-      fs.writeFileSync(tmp, JSON.stringify(config, null, 2) + '\n', 'utf8');
-      fs.renameSync(tmp, configPath);
-    }
-  } catch { /* ignore malformed config */ }
-}

package/server/wizard/phases/setup-wizard.ts

@@ -7,12 +7,11 @@
 
 import fs from 'fs';
 import * as p from '@clack/prompts';
-import pc from 'picocolors';
 import type { SetupState } from '../types.js';
 import { NOTES } from '../ui.js';
-import { isValidProjectPath, resolveProjectPath, ORBITAL_HOME } from '../detect.js';
+import { ORBITAL_HOME } from '../detect.js';
 
-export async function phaseSetupWizard(state: SetupState): Promise<void> {
+export async function phaseSetupWizard(_state: SetupState): Promise<void> {
   // Welcome and core concepts
   p.note(NOTES.setupWelcome, 'Welcome');
 
@@ -40,39 +39,9 @@ export async function phaseSetupWizard(state: SetupState): Promise<void> {
     process.exit(1);
   }
 
-  // Offer to link projects
-  p.note(NOTES.addProject, 'Projects');
-
-  let addMore = true;
-  while (addMore) {
-    const wantsProject = await p.confirm({
-      message: state.linkedProjects.length === 0
-        ? 'Add a project now?'
-        : 'Add another project?',
-      initialValue: state.linkedProjects.length === 0,
-    });
-
-    if (p.isCancel(wantsProject) || !wantsProject) {
-      addMore = false;
-      break;
-    }
-
-    const projectPath = await p.text({
-      message: 'Project path',
-      placeholder: '~/Code/my-project',
-      validate: (val) => {
-        if (!val || !val.trim()) return 'Path is required';
-        return isValidProjectPath(val.trim());
-      },
-    });
-
-    if (p.isCancel(projectPath)) {
-      addMore = false;
-      break;
-    }
-
-    const resolved = resolveProjectPath(projectPath.trim());
-    state.linkedProjects.push(resolved);
-    p.log.success(`Added: ${pc.cyan(resolved)}`);
-  }
+  // Direct user to the dashboard for project setup
+  p.note(
+    'Launch the dashboard to add your first project.\nThe setup wizard will guide you through it.',
+    'Next Steps',
+  );
 }

package/server/wizard/types.ts

@@ -1,9 +1,8 @@
 /**
  * Types for the interactive CLI wizard.
  *
- * Two wizard flows:
- *   Phase 1 (SetupState)        — first-time Orbital setup, ~/.orbital/ creation
- *   Phase 2 (ProjectSetupState) — per-project scaffolding into .claude/
+ * Phase 1 (SetupState) — first-time Orbital setup, ~/.orbital/ creation.
+ * Project setup is handled by the frontend Add Project modal.
  */
 
 export interface SetupState {
@@ -12,45 +11,5 @@ export interface SetupState {
   linkedProjects: string[];       // project paths added during setup
 }
 
-export interface ProjectSetupState {
-  projectRoot: string;
-  isProjectInitialized: boolean;  // .claude/orbital.config.json exists
-  packageVersion: string;
-
-  // Collected from phases
-  projectName?: string;
-  serverPort?: number;
-  clientPort?: number;
-  detectedCommands?: Record<string, string | null>;
-  selectedCommands?: Record<string, string | null>;
-  workflowPreset?: string;        // 'default' | 'minimal' | 'development' | 'gitflow'
-}
-
-export interface PresetInfo {
-  value: string;
-  label: string;
-  hint: string;
-}
-
-export const WORKFLOW_PRESETS: PresetInfo[] = [
-  {
-    value: 'default',
-    label: 'Default',
-    hint: '7 lists, trunk-based — Icebox → Planning → Backlog → Implementing → Review → Completed → Main',
-  },
-  {
-    value: 'minimal',
-    label: 'Minimal',
-    hint: '3 lists — To Do → In Progress → Done',
-  },
-  {
-    value: 'development',
-    label: 'Development',
-    hint: '5 lists, dev branch — Backlog → Implementing → Review → Completed → Dev',
-  },
-  {
-    value: 'gitflow',
-    label: 'Gitflow',
-    hint: '9 lists, multi-branch — Full pipeline with Dev, Staging, and Production',
-  },
-];
+export type { PresetInfo } from '../../shared/workflow-presets.js';
+export { WORKFLOW_PRESETS } from '../../shared/workflow-presets.js';

package/shared/workflow-presets.ts

@@ -0,0 +1,28 @@
+export interface PresetInfo {
+  value: string;
+  label: string;
+  hint: string;
+}
+
+export const WORKFLOW_PRESETS: PresetInfo[] = [
+  {
+    value: 'default',
+    label: 'Default',
+    hint: '7 lists, trunk-based — Icebox → Planning → Backlog → Implementing → Review → Completed → Main',
+  },
+  {
+    value: 'minimal',
+    label: 'Minimal',
+    hint: '3 lists — To Do → In Progress → Done',
+  },
+  {
+    value: 'development',
+    label: 'Development',
+    hint: '5 lists, dev branch — Backlog → Implementing → Review → Completed → Dev',
+  },
+  {
+    value: 'gitflow',
+    label: 'Gitflow',
+    hint: '9 lists, multi-branch — Full pipeline with Dev, Staging, and Production',
+  },
+];

package/templates/hooks/block-push.sh

@@ -37,8 +37,22 @@ _pipeline_after() {
   echo "$result"
 }
 
+# Check if a flag file's session is still alive; remove stale flags
+_flag_alive() {
+  local flag="$1"
+  [ -f "$flag" ] || return 1
+  local pid
+  pid=$(cat "$flag" 2>/dev/null)
+  # Empty flag (legacy touch-style) or dead process → stale
+  if [ -z "$pid" ] || ! kill -0 "$pid" 2>/dev/null; then
+    rm -f "$flag"
+    return 1
+  fi
+  return 0
+}
+
 # Block git push during /git-commit
-if [ -f "$PUSH_FLAG" ]; then
+if _flag_alive "$PUSH_FLAG"; then
   if echo "$COMMAND" | grep -qE '(^|[;&|]\s*)git\s+push'; then
     "$HOOK_DIR/orbital-emit.sh" VIOLATION '{"rule":"block-push","outcome":"blocked"}' 2>/dev/null || true
     REMAINING=$(_pipeline_after "completed")
@@ -51,7 +65,7 @@ if [ -f "$PUSH_FLAG" ]; then
 fi
 
 # Block git commit/add during /scope-implement
-if [ -f "$IMPL_FLAG" ]; then
+if _flag_alive "$IMPL_FLAG"; then
   if echo "$COMMAND" | grep -qE '(^|[;&|]\s*)git\s+(commit|add)'; then
     "$HOOK_DIR/orbital-emit.sh" VIOLATION '{"rule":"block-commit-implementing","outcome":"blocked"}' 2>/dev/null || true
     REMAINING=$(_pipeline_after "implementing")

package/templates/hooks/git-commit-guard.sh

@@ -18,15 +18,16 @@ PUSH_FLAG="$PROJECT_DIR/.claude/.block-push-active"
 IMPL_FLAG="$PROJECT_DIR/.claude/.implementing-session"
 
 # /git-commit → block pushes during commit skill
+# Store parent PID so block-push.sh can detect stale flags from dead sessions
 if [ "$SKILL" = "git-commit" ]; then
-  touch "$PUSH_FLAG"
+  echo "$PPID" > "$PUSH_FLAG"
 else
   rm -f "$PUSH_FLAG"
 fi
 
 # /scope-implement → block commits during implementing
 if [ "$SKILL" = "scope-implement" ]; then
-  touch "$IMPL_FLAG"
+  echo "$PPID" > "$IMPL_FLAG"
 else
   rm -f "$IMPL_FLAG"
 fi