orbital-command 0.2.0 → 1.0.0

package/server/services/workflow-service.test.ts

@@ -0,0 +1,190 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { WorkflowService } from './workflow-service.js';
+import { WorkflowEngine } from '../../shared/workflow-engine.js';
+import { DEFAULT_CONFIG, MINIMAL_CONFIG } from '../../shared/__fixtures__/workflow-configs.js';
+import { createMockEmitter } from '../__tests__/helpers/mock-emitter.js';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+describe('WorkflowService', () => {
+  let tmpDir: string;
+  let configDir: string;
+  let scopesDir: string;
+  let defaultConfigPath: string;
+  let engine: WorkflowEngine;
+  let service: WorkflowService;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'workflow-svc-test-'));
+    configDir = path.join(tmpDir, 'config');
+    scopesDir = path.join(tmpDir, 'scopes');
+    defaultConfigPath = path.join(tmpDir, 'default-workflow.json');
+
+    fs.mkdirSync(configDir, { recursive: true });
+    fs.mkdirSync(scopesDir, { recursive: true });
+
+    // Write the default workflow config that the constructor reads
+    fs.writeFileSync(defaultConfigPath, JSON.stringify(DEFAULT_CONFIG));
+
+    // Create scope directories for the default workflow
+    for (const list of DEFAULT_CONFIG.lists) {
+      if (list.hasDirectory) {
+        fs.mkdirSync(path.join(scopesDir, list.id), { recursive: true });
+      }
+    }
+
+    engine = new WorkflowEngine(DEFAULT_CONFIG);
+    service = new WorkflowService(configDir, engine, scopesDir, defaultConfigPath);
+    service.setSocketServer(createMockEmitter() as any);
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  // ─── validate() ──────────────────────────────────────────
+
+  describe('validate()', () => {
+    it('passes for valid config', () => {
+      const result = service.validate(DEFAULT_CONFIG);
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it('fails for invalid config shape', () => {
+      const result = service.validate({ version: 2 } as any);
+      expect(result.valid).toBe(false);
+      expect(result.errors.length).toBeGreaterThan(0);
+    });
+
+    it('fails for duplicate list IDs', () => {
+      const config = {
+        ...MINIMAL_CONFIG,
+        lists: [
+          ...MINIMAL_CONFIG.lists,
+          { ...MINIMAL_CONFIG.lists[0] }, // duplicate 'todo'
+        ],
+      };
+      const result = service.validate(config);
+      expect(result.valid).toBe(false);
+      expect(result.errors.some(e => e.toLowerCase().includes('duplicate'))).toBe(true);
+    });
+
+    it('fails for edges referencing non-existent lists', () => {
+      const config = {
+        ...MINIMAL_CONFIG,
+        edges: [
+          { from: 'todo', to: 'nonexistent', direction: 'forward' as const, command: null, confirmLevel: 'quick' as const, label: 'X', description: 'X' },
+        ],
+      };
+      const result = service.validate(config);
+      expect(result.valid).toBe(false);
+    });
+
+    it('fails for zero entry points', () => {
+      const config = {
+        ...MINIMAL_CONFIG,
+        lists: MINIMAL_CONFIG.lists.map(l => ({ ...l, isEntryPoint: false })),
+      };
+      const result = service.validate(config);
+      expect(result.valid).toBe(false);
+    });
+  });
+
+  // ─── getActive() / updateActive() ────────────────────────
+
+  describe('getActive()', () => {
+    it('returns active workflow config', () => {
+      const config = service.getActive();
+      expect(config.name).toBe(DEFAULT_CONFIG.name);
+      expect(config.version).toBe(1);
+    });
+
+    it('strips _defaultDigest from returned config', () => {
+      const config = service.getActive() as any;
+      expect(config._defaultDigest).toBeUndefined();
+    });
+  });
+
+  describe('updateActive()', () => {
+    it('updates config and returns valid result', () => {
+      const result = service.updateActive(DEFAULT_CONFIG);
+      expect(result.valid).toBe(true);
+    });
+
+    it('rejects invalid config', () => {
+      const result = service.updateActive({ version: 1, name: 'Bad', lists: [], edges: [] } as any);
+      expect(result.valid).toBe(false);
+    });
+  });
+
+  // ─── Presets ──────────────────────────────────────────────
+
+  describe('presets', () => {
+    it('savePreset() creates a preset file', () => {
+      service.savePreset('test-preset');
+      const presets = service.listPresets();
+      expect(presets.some(p => p.name === 'test-preset')).toBe(true);
+    });
+
+    it('listPresets() returns all saved presets', () => {
+      service.savePreset('preset-a');
+      service.savePreset('preset-b');
+      const presets = service.listPresets();
+      expect(presets.length).toBeGreaterThanOrEqual(2);
+    });
+
+    it('getPreset() loads preset by name', () => {
+      service.savePreset('loadable');
+      const config = service.getPreset('loadable');
+      expect(config.version).toBe(1);
+    });
+
+    it('getPreset() throws for non-existent preset', () => {
+      expect(() => service.getPreset('nonexistent')).toThrow();
+    });
+
+    it('deletePreset() removes preset file', () => {
+      service.savePreset('to-delete');
+      service.deletePreset('to-delete');
+      expect(() => service.getPreset('to-delete')).toThrow();
+    });
+
+    it('deletePreset() blocks deletion of "default"', () => {
+      expect(() => service.deletePreset('default')).toThrow();
+    });
+  });
+
+  // ─── previewMigration() ──────────────────────────────────
+
+  describe('previewMigration()', () => {
+    it('detects removed lists', () => {
+      // Preview migrating from DEFAULT_CONFIG (7 lists) to MINIMAL_CONFIG (2 lists)
+      const plan = service.previewMigration(MINIMAL_CONFIG);
+      expect(plan.removedLists.length).toBeGreaterThan(0);
+    });
+
+    it('returns no-op plan when configs have same lists', () => {
+      const plan = service.previewMigration(DEFAULT_CONFIG);
+      expect(plan.valid).toBe(true);
+      expect(plan.removedLists).toHaveLength(0);
+      expect(plan.orphanedScopes).toHaveLength(0);
+    });
+
+    it('returns valid: false for invalid config', () => {
+      const plan = service.previewMigration({ version: 1, name: 'Bad', lists: [], edges: [] } as any);
+      expect(plan.valid).toBe(false);
+    });
+  });
+
+  // ─── getEngine() ─────────────────────────────────────────
+
+  describe('getEngine()', () => {
+    it('returns the active workflow engine', () => {
+      const e = service.getEngine();
+      expect(e).toBeDefined();
+      expect(e.getLists().length).toBeGreaterThan(0);
+    });
+  });
+});

package/server/services/workflow-service.ts

@@ -1,7 +1,7 @@
 import crypto from 'crypto';
 import fs from 'fs';
 import path from 'path';
-import type { Server } from 'socket.io';
+import type { Emitter } from '../project-emitter.js';
 import type { WorkflowConfig } from '../../shared/workflow-config.js';
 import { createLogger } from '../utils/logger.js';
 
@@ -53,7 +53,7 @@ export class WorkflowService {
   private engine: WorkflowEngine;
   private defaultConfigPath: string;
   private manifestPath: string;
-  private io: Server | null = null;
+  private io: Emitter | null = null;
 
   constructor(configDir: string, engine: WorkflowEngine, scopesDir: string, defaultConfigPath: string) {
     this.presetsDir = path.join(configDir, 'workflows');
@@ -81,13 +81,19 @@ export class WorkflowService {
       this.engine.reload(defaultConfig);
       fs.writeFileSync(this.manifestPath, this.engine.generateShellManifest(), 'utf-8');
     } else {
-      const active = JSON.parse(fs.readFileSync(this.activeConfigPath, 'utf-8')) as WorkflowConfig & { _defaultDigest?: string };
+      const active = JSON.parse(fs.readFileSync(this.activeConfigPath, 'utf-8')) as WorkflowConfig & { _defaultDigest?: string; _customized?: boolean };
       if (!active._defaultDigest) {
-        // Legacy file without digest marker. If content matches current default, stamp it.
-        // If different, it's user-customized — leave it alone.
         if (configDigest(active) === currentDigest) {
+          // Exact content match — just stamp it with the digest
           this.writeWithDigest(this.activeConfigPath, defaultConfig, currentDigest);
+        } else if (this.isLikelyOldDefault(active, defaultConfig)) {
+          // Same list structure but different edges — old default that needs updating
+          log.info('Upgrading legacy workflow config to current default');
+          this.writeWithDigest(this.activeConfigPath, defaultConfig, currentDigest);
+          this.engine.reload(defaultConfig);
+          fs.writeFileSync(this.manifestPath, this.engine.generateShellManifest(), 'utf-8');
         }
+        // else: genuinely user-customized (different list structure), leave alone
       } else if (active._defaultDigest !== currentDigest) {
         // Bundled default changed since last sync — refresh + regenerate manifest
         this.writeWithDigest(this.activeConfigPath, defaultConfig, currentDigest);
@@ -96,13 +102,17 @@ export class WorkflowService {
       }
     }
 
-    // Always keep the "default" preset in sync with the bundled default
+    // Always keep the "default" preset in sync with the bundled default.
+    // Copy the raw template bytes to preserve formatting (avoid hash drift from re-serialization).
     const defaultPresetPath = path.join(this.presetsDir, 'default.json');
-    const preset = { _preset: { name: 'default', savedAt: new Date().toISOString(), savedFrom: 'bundled' }, ...defaultConfig };
-    fs.writeFileSync(defaultPresetPath, JSON.stringify(preset, null, 2));
+    const templateBytes = fs.readFileSync(this.defaultConfigPath, 'utf-8');
+    const existing = fs.existsSync(defaultPresetPath) ? fs.readFileSync(defaultPresetPath, 'utf-8') : '';
+    if (existing !== templateBytes) {
+      fs.writeFileSync(defaultPresetPath, templateBytes);
+    }
   }
 
-  setSocketServer(io: Server): void {
+  setSocketServer(io: Emitter): void {
     this.io = io;
   }
 
@@ -110,6 +120,16 @@ export class WorkflowService {
     return this.engine;
   }
 
+  /** Check if a legacy config (no digest) is structurally an old default rather than
+   *  a user customization. If it has the same list IDs in the same order, it was
+   *  almost certainly seeded from an older version of the bundled default. */
+  private isLikelyOldDefault(active: WorkflowConfig, currentDefault: WorkflowConfig): boolean {
+    if (active.name !== currentDefault.name) return false;
+    const activeListIds = active.lists.map(l => l.id).join(',');
+    const defaultListIds = currentDefault.lists.map(l => l.id).join(',');
+    return activeListIds === defaultListIds;
+  }
+
   // ─── Validation ──────────────────────────────────────
 
   validate(config: WorkflowConfig): ValidationResult {

package/server/settings-sync.ts

@@ -0,0 +1,359 @@
+/**
+ * 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';
+import type { SettingsHooks } from './manifest-types.js';
+
+const log = createLogger('sync');
+
+// ─── Types ──────────────────────────────────────────────────
+
+interface SettingsFile {
+  hooks?: SettingsHooks;
+  [key: string]: unknown;
+}
+
+export interface SettingsSyncResult {
+  added: number;
+  removed: number;
+  updated: number;
+  skipped: boolean;
+}
+
+// ─── 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: string,
+  templatePath: string,
+  previousChecksum: string,
+  renameMap?: Map<string, string>,
+): SettingsSyncResult {
+  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: SettingsFile = {};
+  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: SettingsFile = 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: string): number {
+  if (!fs.existsSync(settingsPath)) return 0;
+
+  let settings: SettingsFile;
+  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: string): string {
+  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: string,
+  projectRoot: string,
+): string[] {
+  if (!fs.existsSync(settingsPath)) return [];
+
+  let settings: SettingsFile;
+  try {
+    settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+  } catch {
+    return [];
+  }
+
+  if (!settings.hooks) return [];
+
+  const broken: string[] = [];
+
+  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: SettingsHooks): Set<string> {
+  const commands = new Set<string>();
+  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: SettingsHooks): Set<string> {
+  const commands = new Set<string>();
+  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?: Map<string, string>,
+): Map<string, string> {
+  const commandMap = new Map<string, string>();
+  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: SettingsHooks,
+  commandRenameMap: Map<string, string>,
+): number {
+  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: SettingsHooks,
+  templateCommands: Set<string>,
+): number {
+  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: SettingsHooks,
+  templateHooks: SettingsHooks,
+  existingOrbitalCommands: Set<string>,
+): number {
+  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: SettingsHooks): void {
+  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];
+    }
+  }
+}