orbital-command 0.2.0 → 1.0.0

package/dist/server/server/settings-sync.js

@@ -0,0 +1,284 @@
+/**
+ * Bidirectional settings hook sync.
+ *
+ * Replaces the old additive-only mergeSettingsHooks(). The key improvement:
+ * when a hook is removed from the template between versions, it's also
+ * removed from settings.local.json — preventing stale registrations
+ * pointing to deleted scripts.
+ */
+import fs from 'fs';
+import path from 'path';
+import { hashFile } from './manifest.js';
+import { createLogger } from './utils/logger.js';
+const log = createLogger('sync');
+// ─── Public API ─────────────────────────────────────────────
+/**
+ * Sync settings.local.json hooks with the current settings-hooks.json template.
+ *
+ * - Adds new _orbital hooks from the template
+ * - Removes _orbital hooks that are no longer in the template
+ * - Updates _orbital hooks that have changed (e.g., renamed command paths)
+ * - Never touches user hooks (those without _orbital: true)
+ *
+ * @param settingsPath - Path to .claude/settings.local.json
+ * @param templatePath - Path to templates/settings-hooks.json
+ * @param previousChecksum - Hash of the template last time sync was run (from manifest)
+ * @param renameMap - Optional map of old command paths to new ones
+ * @returns Sync result with counts of changes made
+ */
+export function syncSettingsHooks(settingsPath, templatePath, previousChecksum, renameMap) {
+    if (!fs.existsSync(templatePath)) {
+        return { added: 0, removed: 0, updated: 0, skipped: true };
+    }
+    // Check if template has changed since last sync
+    const currentChecksum = hashFile(templatePath);
+    if (currentChecksum === previousChecksum) {
+        return { added: 0, removed: 0, updated: 0, skipped: true };
+    }
+    // Load current settings
+    let settings = {};
+    if (fs.existsSync(settingsPath)) {
+        try {
+            settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+        }
+        catch {
+            log.warn('Malformed settings file, starting fresh', { path: settingsPath });
+            settings = {};
+        }
+    }
+    // Load template
+    const template = JSON.parse(fs.readFileSync(templatePath, 'utf-8'));
+    const templateHooks = template.hooks || {};
+    // Collect all _orbital commands currently in settings
+    const currentOrbitalCommands = collectOrbitalCommands(settings.hooks || {});
+    // Collect all commands from the template
+    const templateCommands = collectAllCommands(templateHooks);
+    // Build rename map for command paths (from file rename map)
+    const commandRenameMap = buildCommandRenameMap(renameMap);
+    let added = 0;
+    let removed = 0;
+    let updated = 0;
+    // Phase 1: Handle renames in existing _orbital hooks
+    if (settings.hooks && commandRenameMap.size > 0) {
+        updated += applyCommandRenames(settings.hooks, commandRenameMap);
+    }
+    // Phase 2: Remove _orbital hooks that are no longer in the template
+    if (settings.hooks) {
+        removed += removeStaleHooks(settings.hooks, templateCommands);
+    }
+    // Phase 3: Add new hooks from the template
+    if (!settings.hooks)
+        settings.hooks = {};
+    added += addNewHooks(settings.hooks, templateHooks, currentOrbitalCommands);
+    // Phase 4: Clean up empty groups and events
+    cleanupEmptyEntries(settings.hooks);
+    if (Object.keys(settings.hooks).length === 0) {
+        delete settings.hooks;
+    }
+    // Write back
+    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+    return { added, removed, updated, skipped: false };
+}
+/**
+ * Remove all _orbital hooks from settings.local.json.
+ * Used during uninstall.
+ */
+export function removeAllOrbitalHooks(settingsPath) {
+    if (!fs.existsSync(settingsPath))
+        return 0;
+    let settings;
+    try {
+        settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+    }
+    catch {
+        log.debug('Settings unreadable during cleanup', { path: settingsPath });
+        return 0;
+    }
+    if (!settings.hooks)
+        return 0;
+    let removed = 0;
+    for (const groups of Object.values(settings.hooks)) {
+        for (const group of groups) {
+            if (!group.hooks)
+                continue;
+            const before = group.hooks.length;
+            group.hooks = group.hooks.filter(h => !h._orbital);
+            removed += before - group.hooks.length;
+        }
+    }
+    cleanupEmptyEntries(settings.hooks);
+    if (Object.keys(settings.hooks).length === 0) {
+        delete settings.hooks;
+    }
+    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+    return removed;
+}
+/**
+ * Get the current checksum of the settings-hooks.json template.
+ */
+export function getTemplateChecksum(templatePath) {
+    if (!fs.existsSync(templatePath))
+        return '';
+    return hashFile(templatePath);
+}
+/**
+ * Validate that every _orbital hook in settings.local.json points to a file
+ * that exists on disk. Returns list of broken command paths.
+ */
+export function validateHookPaths(settingsPath, projectRoot) {
+    if (!fs.existsSync(settingsPath))
+        return [];
+    let settings;
+    try {
+        settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+    }
+    catch {
+        return [];
+    }
+    if (!settings.hooks)
+        return [];
+    const broken = [];
+    for (const groups of Object.values(settings.hooks)) {
+        for (const group of groups) {
+            for (const hook of group.hooks || []) {
+                if (!hook._orbital)
+                    continue;
+                // Resolve command path — handle $CLAUDE_PROJECT_DIR variable
+                const commandPath = hook.command
+                    .replace(/^"?\$CLAUDE_PROJECT_DIR"?\//, '')
+                    .replace(/^"/, '')
+                    .replace(/"$/, '');
+                const absPath = path.join(projectRoot, commandPath);
+                if (!fs.existsSync(absPath)) {
+                    broken.push(hook.command);
+                }
+            }
+        }
+    }
+    return broken;
+}
+// ─── Internal Helpers ───────────────────────────────────────
+/** Collect all command strings from _orbital hooks in settings. */
+function collectOrbitalCommands(hooks) {
+    const commands = new Set();
+    for (const groups of Object.values(hooks)) {
+        for (const group of groups) {
+            for (const hook of group.hooks || []) {
+                if (hook._orbital)
+                    commands.add(hook.command);
+            }
+        }
+    }
+    return commands;
+}
+/** Collect all command strings from a hooks template. */
+function collectAllCommands(hooks) {
+    const commands = new Set();
+    for (const groups of Object.values(hooks)) {
+        for (const group of groups) {
+            for (const hook of group.hooks || []) {
+                if (hook.command)
+                    commands.add(hook.command);
+            }
+        }
+    }
+    return commands;
+}
+/** Build a command-level rename map from a file-level rename map. */
+function buildCommandRenameMap(fileRenameMap) {
+    const commandMap = new Map();
+    if (!fileRenameMap)
+        return commandMap;
+    for (const [oldFile, newFile] of fileRenameMap) {
+        // Hook commands use paths like: "$CLAUDE_PROJECT_DIR"/.claude/hooks/foo.sh
+        // We need to detect when oldFile appears in a command and replace with newFile
+        if (oldFile.startsWith('hooks/') || oldFile.startsWith('skills/')) {
+            const oldSuffix = `.claude/${oldFile}`;
+            const newSuffix = `.claude/${newFile}`;
+            commandMap.set(oldSuffix, newSuffix);
+        }
+    }
+    return commandMap;
+}
+/** Apply command path renames to existing _orbital hooks. Returns count of updates. */
+function applyCommandRenames(hooks, commandRenameMap) {
+    let updated = 0;
+    for (const groups of Object.values(hooks)) {
+        for (const group of groups) {
+            for (const hook of group.hooks || []) {
+                if (!hook._orbital)
+                    continue;
+                for (const [oldSuffix, newSuffix] of commandRenameMap) {
+                    if (hook.command.includes(oldSuffix)) {
+                        hook.command = hook.command.replace(oldSuffix, newSuffix);
+                        updated++;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    return updated;
+}
+/** Remove _orbital hooks whose commands are not in the template. Returns count removed. */
+function removeStaleHooks(hooks, templateCommands) {
+    let removed = 0;
+    for (const groups of Object.values(hooks)) {
+        for (const group of groups) {
+            if (!group.hooks)
+                continue;
+            const before = group.hooks.length;
+            group.hooks = group.hooks.filter(hook => {
+                if (!hook._orbital)
+                    return true; // Keep user hooks
+                return templateCommands.has(hook.command); // Keep if still in template
+            });
+            removed += before - group.hooks.length;
+        }
+    }
+    return removed;
+}
+/** Add hooks from template that aren't already in settings. Returns count added. */
+function addNewHooks(settingsHooks, templateHooks, existingOrbitalCommands) {
+    let added = 0;
+    for (const [event, templateGroups] of Object.entries(templateHooks)) {
+        if (!settingsHooks[event]) {
+            settingsHooks[event] = [];
+        }
+        for (const templateGroup of templateGroups) {
+            const matcher = templateGroup.matcher || '__none__';
+            // Find matching group in settings
+            let targetGroup = settingsHooks[event].find(g => (g.matcher || '__none__') === matcher);
+            if (!targetGroup) {
+                // Create the group with all hooks tagged
+                targetGroup = {
+                    ...(templateGroup.matcher ? { matcher: templateGroup.matcher } : {}),
+                    hooks: [],
+                };
+                settingsHooks[event].push(targetGroup);
+            }
+            if (!targetGroup.hooks)
+                targetGroup.hooks = [];
+            for (const hook of templateGroup.hooks || []) {
+                if (existingOrbitalCommands.has(hook.command))
+                    continue;
+                // Also check if command already exists (de-dup)
+                const alreadyPresent = targetGroup.hooks.some(h => h.command === hook.command);
+                if (alreadyPresent)
+                    continue;
+                targetGroup.hooks.push({ ...hook, _orbital: true });
+                added++;
+            }
+        }
+    }
+    return added;
+}
+/** Remove empty hook groups and empty event entries. */
+function cleanupEmptyEntries(hooks) {
+    for (const [event, groups] of Object.entries(hooks)) {
+        hooks[event] = groups.filter(g => g.hooks && g.hooks.length > 0);
+        if (hooks[event].length === 0) {
+            delete hooks[event];
+        }
+    }
+}

package/dist/server/server/uninstall.js

@@ -0,0 +1,195 @@
+/**
+ * Uninstall logic — extracted from init.ts for focused maintainability.
+ */
+import fs from 'fs';
+import path from 'path';
+import { loadManifest } from './manifest.js';
+import { removeAllOrbitalHooks } from './settings-sync.js';
+import { unregisterProject } from './global-config.js';
+import { TEMPLATES_DIR, cleanEmptyDirs, listTemplateFiles, } from './init.js';
+export function runUninstall(projectRoot, options = {}) {
+    const { dryRun = false, keepConfig = false } = options;
+    const claudeDir = path.join(projectRoot, '.claude');
+    console.log(`\nOrbital Command — uninstall${dryRun ? ' (dry run)' : ''}`);
+    console.log(`Project root: ${projectRoot}\n`);
+    const manifest = loadManifest(projectRoot);
+    // Fall back to legacy uninstall if no manifest
+    if (!manifest) {
+        console.log('  No manifest found — falling back to legacy uninstall.');
+        runLegacyUninstall(projectRoot);
+        return;
+    }
+    // Compute what to remove vs preserve
+    const toRemove = [];
+    const toPreserve = [];
+    for (const [filePath, record] of Object.entries(manifest.files)) {
+        if (record.origin === 'user') {
+            toPreserve.push(filePath);
+        }
+        else if (record.status === 'modified' || record.status === 'outdated') {
+            toPreserve.push(filePath);
+        }
+        else {
+            toRemove.push(filePath);
+        }
+    }
+    if (dryRun) {
+        console.log('  Files to REMOVE:');
+        for (const f of toRemove)
+            console.log(`    ${f}`);
+        if (toPreserve.length > 0) {
+            console.log('  Files to PRESERVE:');
+            for (const f of toPreserve)
+                console.log(`    ${f} (${manifest.files[f].origin}/${manifest.files[f].status})`);
+        }
+        console.log(`\n  Would also remove: settings hooks, generated artifacts, config files, gitignore entries`);
+        console.log(`  No changes made. Run without --dry-run to apply.`);
+        return;
+    }
+    // 1. Remove _orbital hooks from settings.local.json
+    const settingsPath = path.join(claudeDir, 'settings.local.json');
+    const removedHooks = removeAllOrbitalHooks(settingsPath);
+    console.log(`  Removed  ${removedHooks} orbital hook registrations`);
+    // 2. Delete template files (synced + pinned, not modified or user-owned)
+    let filesRemoved = 0;
+    for (const filePath of toRemove) {
+        const absPath = path.join(claudeDir, filePath);
+        if (fs.existsSync(absPath)) {
+            fs.unlinkSync(absPath);
+            filesRemoved++;
+        }
+    }
+    console.log(`  Removed  ${filesRemoved} template files`);
+    if (toPreserve.length > 0) {
+        console.log(`  Preserved ${toPreserve.length} user/modified files`);
+    }
+    // 3. Clean up empty directories
+    for (const dir of ['hooks', 'skills', 'agents', 'config/workflows', 'quick', 'anti-patterns']) {
+        const dirPath = path.join(claudeDir, dir);
+        if (fs.existsSync(dirPath))
+            cleanEmptyDirs(dirPath);
+    }
+    // 4. Remove generated artifacts
+    for (const artifact of manifest.generatedArtifacts) {
+        const artifactPath = path.join(claudeDir, artifact);
+        if (fs.existsSync(artifactPath)) {
+            fs.unlinkSync(artifactPath);
+            console.log(`  Removed  .claude/${artifact}`);
+        }
+    }
+    // 5. Remove template-sourced config files
+    const configFiles = [
+        'config/agent-triggers.json',
+        'config/workflow.json',
+        'lessons-learned.md',
+    ];
+    for (const file of configFiles) {
+        const filePath = path.join(claudeDir, file);
+        if (fs.existsSync(filePath)) {
+            fs.unlinkSync(filePath);
+            console.log(`  Removed  .claude/${file}`);
+        }
+    }
+    // Remove config/workflows/ directory entirely
+    const workflowsDir = path.join(claudeDir, 'config', 'workflows');
+    if (fs.existsSync(workflowsDir)) {
+        fs.rmSync(workflowsDir, { recursive: true, force: true });
+        console.log(`  Removed  .claude/config/workflows/`);
+    }
+    // 6. Remove gitignore entries
+    removeGitignoreEntries(projectRoot, manifest.gitignoreEntries);
+    console.log(`  Cleaned  .gitignore`);
+    // 7. Deregister from global registry
+    if (unregisterProject(projectRoot)) {
+        console.log(`  Removed  project from ~/.orbital/config.json`);
+    }
+    // 8. Remove orbital config and manifest (unless --keep-config)
+    if (!keepConfig) {
+        const toClean = ['orbital.config.json', 'orbital-manifest.json', 'orbital-sync.json'];
+        for (const file of toClean) {
+            const filePath = path.join(claudeDir, file);
+            if (fs.existsSync(filePath))
+                fs.unlinkSync(filePath);
+        }
+        // Remove backups directory
+        const backupsDir = path.join(claudeDir, '.orbital-backups');
+        if (fs.existsSync(backupsDir))
+            fs.rmSync(backupsDir, { recursive: true, force: true });
+        console.log(`  Removed  orbital config and manifest`);
+    }
+    else {
+        // Still remove the manifest — it's invalid after uninstall
+        const manifestPath = path.join(claudeDir, 'orbital-manifest.json');
+        if (fs.existsSync(manifestPath))
+            fs.unlinkSync(manifestPath);
+        console.log(`  Kept     orbital.config.json (--keep-config)`);
+    }
+    // Clean up remaining empty directories
+    for (const dir of ['config', 'quick', 'anti-patterns', 'review-verdicts']) {
+        const dirPath = path.join(claudeDir, dir);
+        if (fs.existsSync(dirPath))
+            cleanEmptyDirs(dirPath);
+    }
+    const total = removedHooks + filesRemoved;
+    console.log(`\nUninstall complete. ${total} items removed.`);
+    if (toPreserve.length > 0) {
+        console.log(`Note: ${toPreserve.length} user/modified files were preserved.`);
+    }
+    console.log(`Note: scopes/ and .claude/orbital-events/ were preserved.\n`);
+}
+// ─── Helpers ────────────────────────────────────────────────
+/** Legacy uninstall for projects without a manifest (backward compat). */
+function runLegacyUninstall(projectRoot) {
+    const claudeDir = path.join(projectRoot, '.claude');
+    // Remove orbital hooks from settings.local.json
+    const settingsPath = path.join(claudeDir, 'settings.local.json');
+    const removedHooks = removeAllOrbitalHooks(settingsPath);
+    console.log(`  Removed  ${removedHooks} orbital hook registrations`);
+    // Delete hooks/skills/agents that match template files
+    for (const dir of ['hooks', 'skills', 'agents']) {
+        const templateDir = listTemplateFiles(path.join(TEMPLATES_DIR, dir), path.join(claudeDir, dir));
+        let removed = 0;
+        for (const f of templateDir) {
+            if (fs.existsSync(f)) {
+                fs.unlinkSync(f);
+                removed++;
+            }
+        }
+        const dirPath = path.join(claudeDir, dir);
+        if (fs.existsSync(dirPath))
+            cleanEmptyDirs(dirPath);
+        console.log(`  Removed  ${removed} ${dir} files`);
+    }
+    console.log(`\nLegacy uninstall complete.`);
+    console.log(`Note: scopes/ and .claude/orbital-events/ were preserved.\n`);
+}
+/** Remove Orbital-added entries from .gitignore. */
+function removeGitignoreEntries(projectRoot, entries) {
+    const gitignorePath = path.join(projectRoot, '.gitignore');
+    if (!fs.existsSync(gitignorePath))
+        return;
+    let content = fs.readFileSync(gitignorePath, 'utf-8');
+    const marker = '# Orbital Command';
+    const markerIdx = content.indexOf(marker);
+    if (markerIdx !== -1) {
+        const before = content.slice(0, markerIdx).replace(/\n+$/, '');
+        const after = content.slice(markerIdx);
+        const lines = after.split('\n');
+        let endIdx = 0;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i].trim();
+            if (i === 0) {
+                endIdx = i + 1;
+                continue;
+            }
+            if (line === '' || entries.includes(line)) {
+                endIdx = i + 1;
+                continue;
+            }
+            break;
+        }
+        const remaining = lines.slice(endIdx).join('\n');
+        content = before + (remaining ? '\n' + remaining : '') + '\n';
+        fs.writeFileSync(gitignorePath, content, 'utf-8');
+    }
+}