orbital-command 0.2.0 → 1.0.0

package/server/watchers/scope-watcher.ts

@@ -18,19 +18,31 @@ export function startScopeWatcher(
 
   watcher
     .on('add', (filePath: string) => {
-      if (!filePath.endsWith('.md') || scopeService.isSuppressed(filePath)) return;
-      log.info('Scope added', { file: path.basename(filePath) });
-      scopeService.updateFromFile(filePath);
+      try {
+        if (!filePath.endsWith('.md') || scopeService.isSuppressed(filePath)) return;
+        log.debug('Scope added', { file: path.basename(filePath) });
+        scopeService.updateFromFile(filePath);
+      } catch (err) {
+        log.error('Scope watcher add failed', { file: path.basename(filePath), error: String(err) });
+      }
     })
     .on('change', (filePath: string) => {
-      if (!filePath.endsWith('.md') || scopeService.isSuppressed(filePath)) return;
-      log.debug('Scope changed', { file: path.basename(filePath) });
-      scopeService.updateFromFile(filePath);
+      try {
+        if (!filePath.endsWith('.md') || scopeService.isSuppressed(filePath)) return;
+        log.debug('Scope changed', { file: path.basename(filePath) });
+        scopeService.updateFromFile(filePath);
+      } catch (err) {
+        log.error('Scope watcher change failed', { file: path.basename(filePath), error: String(err) });
+      }
     })
     .on('unlink', (filePath: string) => {
-      if (!filePath.endsWith('.md') || scopeService.isSuppressed(filePath)) return;
-      log.info('Scope removed', { file: path.basename(filePath) });
-      scopeService.removeByFilePath(filePath);
+      try {
+        if (!filePath.endsWith('.md') || scopeService.isSuppressed(filePath)) return;
+        log.info('Scope removed', { file: path.basename(filePath) });
+        scopeService.removeByFilePath(filePath);
+      } catch (err) {
+        log.error('Scope watcher unlink failed', { file: path.basename(filePath), error: String(err) });
+      }
     })
     .on('error', (err: unknown) => log.error('Scope watcher error', { error: String(err) }));
 

package/server/wizard/config-editor.ts

@@ -0,0 +1,248 @@
+/**
+ * Interactive config editor — `orbital config`
+ */
+
+import fs from 'fs';
+import path from 'path';
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import { WORKFLOW_PRESETS } from './types.js';
+
+export async function runConfigEditor(projectRoot: string, packageVersion: string, args: string[]): Promise<void> {
+  const subcommand = args[0];
+
+  // Non-interactive: orbital config show
+  if (subcommand === 'show') {
+    const config = loadProjectConfig(projectRoot);
+    if (!config) {
+      console.error('No config found. Run `orbital` first.');
+      process.exit(1);
+    }
+    console.log(JSON.stringify(config, null, 2));
+    return;
+  }
+
+  // Non-interactive: orbital config set <key> <value>
+  if (subcommand === 'set') {
+    const key = args[1];
+    const value = args[2];
+    if (!key || value === undefined) {
+      console.error('Usage: orbital config set <key> <value>');
+      process.exit(1);
+    }
+    setConfigValue(projectRoot, key, value);
+    return;
+  }
+
+  // Interactive mode
+  const config = loadProjectConfig(projectRoot);
+  if (!config) {
+    p.log.error('No config found. Run `orbital` first.');
+    process.exit(1);
+  }
+
+  p.intro(`${pc.bgCyan(pc.black(' Orbital Config '))} ${pc.dim(`v${packageVersion}`)}`);
+
+  // If a section was specified, jump directly to it
+  if (subcommand === 'project') {
+    await editProjectSection(projectRoot, config);
+  } else if (subcommand === 'workflow') {
+    await editWorkflowSection(projectRoot);
+  } else if (subcommand === 'global') {
+    await editGlobalSection();
+  } else {
+    // Show interactive menu
+    const section = await p.select({
+      message: 'What would you like to configure?',
+      options: [
+        { value: 'project', label: 'Project', hint: 'name, ports, build commands' },
+        { value: 'workflow', label: 'Workflow', hint: 'switch preset, view lists' },
+        { value: 'global', label: 'Global', hint: 'registered projects' },
+      ],
+    });
+
+    if (p.isCancel(section)) {
+      p.cancel('Config cancelled.');
+      return;
+    }
+
+    if (section === 'project') await editProjectSection(projectRoot, config);
+    else if (section === 'workflow') await editWorkflowSection(projectRoot);
+    else if (section === 'global') await editGlobalSection();
+  }
+
+  p.outro('Configuration updated.');
+}
+
+// ─── Section Editors ────────────────────────────────────────────
+
+async function editProjectSection(projectRoot: string, config: Record<string, unknown>): Promise<void> {
+  const name = await p.text({
+    message: 'Project name',
+    defaultValue: (config.projectName as string) || '',
+    placeholder: (config.projectName as string) || '',
+  });
+  if (p.isCancel(name)) return;
+
+  const serverPort = await p.text({
+    message: 'Server port',
+    defaultValue: String(config.serverPort || 4444),
+    placeholder: String(config.serverPort || 4444),
+    validate: (val) => {
+      const n = Number(val);
+      if (isNaN(n) || n < 1 || n > 65535) return 'Must be a valid port (1-65535)';
+      return undefined;
+    },
+  });
+  if (p.isCancel(serverPort)) return;
+
+  const clientPort = await p.text({
+    message: 'Client port',
+    defaultValue: String(config.clientPort || 4445),
+    placeholder: String(config.clientPort || 4445),
+    validate: (val) => {
+      const n = Number(val);
+      if (isNaN(n) || n < 1 || n > 65535) return 'Must be a valid port (1-65535)';
+      return undefined;
+    },
+  });
+  if (p.isCancel(clientPort)) return;
+
+  config.projectName = name;
+  config.serverPort = Number(serverPort);
+  config.clientPort = Number(clientPort);
+  saveProjectConfig(projectRoot, config);
+  p.log.success('Project config saved.');
+}
+
+async function editWorkflowSection(projectRoot: string): Promise<void> {
+  const workflowPath = path.join(projectRoot, '.claude', 'config', 'workflow.json');
+  let currentPreset = 'unknown';
+
+  if (fs.existsSync(workflowPath)) {
+    try {
+      const wf = JSON.parse(fs.readFileSync(workflowPath, 'utf8'));
+      currentPreset = wf.name || 'Custom';
+      const lists = (wf.lists || []).map((l: Record<string, string>) => l.label).join(' → ');
+      p.note(`Current: ${pc.cyan(currentPreset)}\nLists:   ${lists}`, 'Active Workflow');
+    } catch { /* show selector anyway */ }
+  }
+
+  const switchPreset = await p.confirm({
+    message: 'Switch to a different preset?',
+    initialValue: false,
+  });
+  if (p.isCancel(switchPreset) || !switchPreset) return;
+
+  const preset = await p.select({
+    message: 'Choose a workflow preset',
+    options: WORKFLOW_PRESETS.map(wp => ({
+      value: wp.value,
+      label: wp.label,
+      hint: wp.hint,
+    })),
+  });
+  if (p.isCancel(preset)) return;
+
+  // Find and copy the preset
+  // Walk up to find templates dir
+  const templatesDir = findTemplatesDir();
+  if (!templatesDir) {
+    p.log.error('Could not locate templates directory.');
+    return;
+  }
+
+  const presetPath = path.join(templatesDir, 'presets', `${preset}.json`);
+  if (fs.existsSync(presetPath)) {
+    fs.copyFileSync(presetPath, workflowPath);
+    p.log.success(`Switched to ${preset} workflow.`);
+  } else {
+    p.log.error(`Preset file not found: ${preset}.json`);
+  }
+}
+
+async function editGlobalSection(): Promise<void> {
+  const homedir = process.env.HOME || process.env.USERPROFILE || '~';
+  const registryPath = path.join(homedir, '.orbital', 'config.json');
+
+  if (!fs.existsSync(registryPath)) {
+    p.log.info('No global registry found. Run `orbital` in a project first.');
+    return;
+  }
+
+  try {
+    const registry = JSON.parse(fs.readFileSync(registryPath, 'utf8'));
+    const projects = registry.projects || [];
+
+    if (projects.length === 0) {
+      p.log.info('No projects registered.');
+      return;
+    }
+
+    const rows = projects.map((proj: Record<string, unknown>) => {
+      const exists = fs.existsSync(proj.path as string);
+      const status = proj.enabled ? (exists ? pc.green('active') : pc.yellow('offline')) : pc.dim('disabled');
+      return `  ${pc.cyan(String(proj.id).padEnd(20))} ${status.padEnd(20)} ${proj.path}`;
+    });
+    p.note(rows.join('\n'), `Registered Projects (${projects.length})`);
+  } catch {
+    p.log.error('Could not read global registry.');
+  }
+}
+
+// ─── Helpers ────────────────────────────────────────────────────
+
+function loadProjectConfig(projectRoot: string): Record<string, unknown> | null {
+  const configPath = path.join(projectRoot, '.claude', 'orbital.config.json');
+  if (!fs.existsSync(configPath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function saveProjectConfig(projectRoot: string, config: Record<string, unknown>): void {
+  const configPath = path.join(projectRoot, '.claude', 'orbital.config.json');
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf8');
+}
+
+function setConfigValue(projectRoot: string, key: string, value: string): void {
+  const config = loadProjectConfig(projectRoot);
+  if (!config) {
+    console.error('No config found. Run `orbital` first.');
+    process.exit(1);
+  }
+
+  // Parse value: try number, then boolean, then string
+  let parsed: unknown = value;
+  if (value === 'true') parsed = true;
+  else if (value === 'false') parsed = false;
+  else if (value === 'null') parsed = null;
+  else if (!isNaN(Number(value)) && value !== '') parsed = Number(value);
+
+  // Support dot notation for nested keys
+  const keys = key.split('.');
+  let target: Record<string, unknown> = config;
+  for (let i = 0; i < keys.length - 1; i++) {
+    if (typeof target[keys[i]] !== 'object' || target[keys[i]] === null) {
+      target[keys[i]] = {};
+    }
+    target = target[keys[i]] as Record<string, unknown>;
+  }
+  target[keys[keys.length - 1]] = parsed;
+
+  saveProjectConfig(projectRoot, config);
+  console.log(`Set ${key} = ${JSON.stringify(parsed)}`);
+}
+
+function findTemplatesDir(): string | null {
+  // Walk up from this file to find templates/
+  let dir = path.dirname(new URL(import.meta.url).pathname);
+  for (let i = 0; i < 5; i++) {
+    const candidate = path.join(dir, 'templates');
+    if (fs.existsSync(candidate)) return candidate;
+    dir = path.resolve(dir, '..');
+  }
+  return null;
+}

package/server/wizard/detect.ts

@@ -0,0 +1,104 @@
+/**
+ * Environment and state detection for the wizard.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import type { SetupState, ProjectSetupState } 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'));
+}
+
+export function buildSetupState(packageVersion: string): SetupState {
+  return {
+    packageVersion,
+    isFirstTime: !isOrbitalSetupDone(),
+    linkedProjects: [],
+  };
+}
+
+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/doctor.ts

@@ -0,0 +1,114 @@
+/**
+ * Health diagnostics — `orbital doctor`
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { execFileSync } from 'child_process';
+import pc from 'picocolors';
+
+export async function runDoctor(projectRoot: string, packageVersion: string): Promise<void> {
+  console.log(`\n  ${pc.bold('Orbital Command')} ${pc.cyan(`v${packageVersion}`)}\n`);
+
+  const checks: { label: string; status: string }[] = [];
+
+  // 1. Check for latest version on npm
+  try {
+    const latest = execFileSync('npm', ['view', 'orbital-command', 'version'], {
+      encoding: 'utf8',
+      timeout: 5000,
+    }).trim();
+
+    if (latest && latest !== packageVersion) {
+      checks.push({ label: 'Latest', status: pc.yellow(`v${latest} available (run \`npm update -g orbital-command\`)`) });
+    } else {
+      checks.push({ label: 'Latest', status: pc.green(`v${packageVersion} (up to date)`) });
+    }
+  } catch {
+    checks.push({ label: 'Latest', status: pc.dim('could not check (npm unreachable)') });
+  }
+
+  // 2. Node version
+  const nodeVersion = process.version;
+  const major = parseInt(nodeVersion.slice(1), 10);
+  if (major >= 18) {
+    checks.push({ label: 'Node', status: pc.green(`${nodeVersion} (supported)`) });
+  } else {
+    checks.push({ label: 'Node', status: pc.red(`${nodeVersion} (requires Node 18+)`) });
+  }
+
+  // 3. Global registry
+  const homedir = process.env.HOME || process.env.USERPROFILE || '~';
+  const registryPath = path.join(homedir, '.orbital', 'config.json');
+  if (fs.existsSync(registryPath)) {
+    try {
+      const registry = JSON.parse(fs.readFileSync(registryPath, 'utf8'));
+      const count = (registry.projects || []).length;
+      checks.push({ label: 'Global', status: pc.green(`~/.orbital/ exists (${count} project${count !== 1 ? 's' : ''} registered)`) });
+    } catch {
+      checks.push({ label: 'Global', status: pc.yellow('~/.orbital/ exists (registry unreadable)') });
+    }
+  } else {
+    checks.push({ label: 'Global', status: pc.dim('~/.orbital/ not found (run `orbital` to create)') });
+  }
+
+  // 4. Project initialization
+  const configPath = path.join(projectRoot, '.claude', 'orbital.config.json');
+  if (fs.existsSync(configPath)) {
+    try {
+      const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+      const name = config.projectName || path.basename(projectRoot);
+      checks.push({ label: 'Project', status: pc.green(`initialized (${name})`) });
+    } catch {
+      checks.push({ label: 'Project', status: pc.yellow('config exists but unreadable') });
+    }
+  } else {
+    checks.push({ label: 'Project', status: pc.dim('not initialized (run `orbital`)') });
+  }
+
+  // 5. Workflow
+  const workflowPath = path.join(projectRoot, '.claude', 'config', 'workflow.json');
+  if (fs.existsSync(workflowPath)) {
+    try {
+      const wf = JSON.parse(fs.readFileSync(workflowPath, 'utf8'));
+      const listCount = (wf.lists || []).length;
+      const mode = wf.branchingMode || 'unknown';
+      checks.push({ label: 'Workflow', status: pc.green(`${wf.name || 'Custom'} (${listCount} lists, ${mode})`) });
+    } catch {
+      checks.push({ label: 'Workflow', status: pc.yellow('workflow.json exists but unreadable') });
+    }
+  } else {
+    checks.push({ label: 'Workflow', status: pc.dim('no workflow configured') });
+  }
+
+  // 6. Database
+  const dbPath = path.join(projectRoot, '.claude', 'orbital', 'orbital.db');
+  if (fs.existsSync(dbPath)) {
+    const stats = fs.statSync(dbPath);
+    const sizeMb = (stats.size / (1024 * 1024)).toFixed(1);
+    checks.push({ label: 'Database', status: pc.green(`${sizeMb} MB`) });
+  } else {
+    checks.push({ label: 'Database', status: pc.dim('not yet created (starts on first launch)') });
+  }
+
+  // 7. Template staleness
+  if (fs.existsSync(configPath)) {
+    try {
+      const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+      if (config.templateVersion && config.templateVersion !== packageVersion) {
+        checks.push({ label: 'Templates', status: pc.yellow(`outdated (v${config.templateVersion} → v${packageVersion}, run \`orbital update\`)`) });
+      } else if (config.templateVersion) {
+        checks.push({ label: 'Templates', status: pc.green('synced') });
+      } else {
+        checks.push({ label: 'Templates', status: pc.yellow('no version stamp (run `orbital update`)') });
+      }
+    } catch { /* skip */ }
+  }
+
+  // Print all checks
+  const maxLabel = Math.max(...checks.map(c => c.label.length));
+  for (const check of checks) {
+    console.log(`  ${pc.dim(check.label.padEnd(maxLabel + 2))} ${check.status}`);
+  }
+  console.log();
+}