orbital-command 0.2.0 → 1.0.0

package/dist/server/server/watchers/global-watcher.js

@@ -0,0 +1,63 @@
+import chokidar from 'chokidar';
+import path from 'path';
+import fs from 'fs';
+import { GLOBAL_PRIMITIVES_DIR } from '../global-config.js';
+import { createLogger } from '../utils/logger.js';
+const log = createLogger('global-watcher');
+/**
+ * Watch ~/.orbital/primitives/ for changes and propagate to synced projects.
+ *
+ * On file change: copies to all synced projects' .claude/ directories.
+ * On file create: copies to projects with auto-sync policy.
+ * On file delete: removes from synced projects, preserves overrides.
+ */
+export function startGlobalWatcher(syncService, io) {
+    if (!fs.existsSync(GLOBAL_PRIMITIVES_DIR)) {
+        log.info('Global primitives directory does not exist, skipping watcher');
+        return null;
+    }
+    const watcher = chokidar.watch(GLOBAL_PRIMITIVES_DIR, {
+        ignored: [/(^|[/\\])\../, /\.tmp$/, /\.sync-tmp$/],
+        persistent: true,
+        ignoreInitial: true,
+        depth: 10,
+        awaitWriteFinish: { stabilityThreshold: 300, pollInterval: 100 },
+    });
+    function relativePath(absPath) {
+        return path.relative(GLOBAL_PRIMITIVES_DIR, absPath);
+    }
+    watcher.on('change', (filePath) => {
+        const rel = relativePath(filePath);
+        log.info('Global primitive changed', { file: rel });
+        const result = syncService.propagateGlobalChange(rel);
+        io.to('all-projects').emit('sync:file:updated', {
+            relativePath: rel,
+            projects: result.updated,
+        });
+    });
+    watcher.on('add', (filePath) => {
+        const rel = relativePath(filePath);
+        log.info('Global primitive added', { file: rel });
+        const result = syncService.handleNewGlobalFile(rel);
+        io.to('all-projects').emit('sync:file:created', {
+            relativePath: rel,
+            autoSynced: result.updated,
+            pending: result.skipped,
+        });
+    });
+    watcher.on('unlink', (filePath) => {
+        const rel = relativePath(filePath);
+        log.info('Global primitive deleted', { file: rel });
+        const result = syncService.handleGlobalFileDeletion(rel);
+        io.to('all-projects').emit('sync:file:deleted', {
+            relativePath: rel,
+            removed: result.removed,
+            preserved: result.preserved,
+        });
+    });
+    watcher.on('error', (err) => {
+        log.error('Global watcher error', { error: String(err) });
+    });
+    log.info('Global primitives watcher started', { dir: GLOBAL_PRIMITIVES_DIR });
+    return watcher;
+}

package/dist/server/server/watchers/scope-watcher.js

@@ -11,22 +11,37 @@ export function startScopeWatcher(scopesDir, scopeService) {
     });
     watcher
         .on('add', (filePath) => {
-        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) => {
-        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) => {
-        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) => log.error('Scope watcher error', { error: String(err) }));
     return watcher;

package/dist/server/server/wizard/config-editor.js

@@ -0,0 +1,237 @@
+/**
+ * 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, packageVersion, args) {
+    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, config) {
+    const name = await p.text({
+        message: 'Project name',
+        defaultValue: config.projectName || '',
+        placeholder: config.projectName || '',
+    });
+    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) {
+    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) => 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() {
+    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) => {
+            const exists = fs.existsSync(proj.path);
+            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) {
+    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, config) {
+    const configPath = path.join(projectRoot, '.claude', 'orbital.config.json');
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf8');
+}
+function setConfigValue(projectRoot, key, value) {
+    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 = 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 = 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]];
+    }
+    target[keys[keys.length - 1]] = parsed;
+    saveProjectConfig(projectRoot, config);
+    console.log(`Set ${key} = ${JSON.stringify(parsed)}`);
+}
+function findTemplatesDir() {
+    // 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/dist/server/server/wizard/detect.js

@@ -0,0 +1,96 @@
+/**
+ * Environment and state detection for the wizard.
+ */
+import fs from 'fs';
+import path from 'path';
+const ORBITAL_HOME = path.join(process.env.HOME || process.env.USERPROFILE || '~', '.orbital');
+export { ORBITAL_HOME };
+export function isInteractiveTerminal() {
+    return !!(process.stdout.isTTY && !process.env.CI);
+}
+export function isOrbitalSetupDone() {
+    return fs.existsSync(path.join(ORBITAL_HOME, 'config.json'));
+}
+export function buildSetupState(packageVersion) {
+    return {
+        packageVersion,
+        isFirstTime: !isOrbitalSetupDone(),
+        linkedProjects: [],
+    };
+}
+export function buildProjectState(projectRoot, packageVersion) {
+    const projectConfigExists = fs.existsSync(path.join(projectRoot, '.claude', 'orbital.config.json'));
+    return {
+        projectRoot,
+        isProjectInitialized: projectConfigExists,
+        packageVersion,
+    };
+}
+export function detectProjectName(projectRoot) {
+    return path.basename(projectRoot)
+        .replace(/[-_]+/g, ' ')
+        .replace(/\b\w/g, c => c.toUpperCase());
+}
+export function detectCommands(projectRoot) {
+    const commands = {
+        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) {
+    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) {
+    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) {
+    if (p.startsWith('~')) {
+        return path.join(process.env.HOME || process.env.USERPROFILE || '~', p.slice(1));
+    }
+    return path.resolve(p);
+}

package/dist/server/server/wizard/doctor.js

@@ -0,0 +1,115 @@
+/**
+ * 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, packageVersion) {
+    console.log(`\n  ${pc.bold('Orbital Command')} ${pc.cyan(`v${packageVersion}`)}\n`);
+    const checks = [];
+    // 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();
+}