@deimoscloud/coreai 0.1.0

package/src/commands/registry.test.ts

@@ -0,0 +1,384 @@
+/**
+ * Command Registry Tests
+ */
+
+import type { CommandRegistry } from './registry.js';
+import { createCommandRegistry, getGlobalRegistry, resetGlobalRegistry } from './registry.js';
+import type { CommandDefinition, MarkdownCommand } from './types.js';
+
+describe('Command Registry', () => {
+  let registry: CommandRegistry;
+
+  beforeEach(() => {
+    registry = createCommandRegistry();
+    resetGlobalRegistry();
+  });
+
+  describe('createCommandRegistry', () => {
+    it('should create an empty registry', () => {
+      expect(registry.size).toBe(0);
+      expect(registry.getAll()).toHaveLength(0);
+    });
+  });
+
+  describe('register', () => {
+    it('should register a command definition', () => {
+      const cmd: CommandDefinition = {
+        name: 'test-cmd',
+        description: 'A test command',
+        category: 'core',
+        handler: async () => ({ success: true }),
+      };
+
+      registry.register(cmd);
+
+      expect(registry.has('test-cmd')).toBe(true);
+      expect(registry.size).toBe(1);
+    });
+
+    it('should register with dependencies', () => {
+      const cmd: CommandDefinition = {
+        name: 'jira-cmd',
+        description: 'Jira command',
+        category: 'optional',
+        dependencies: [{ type: 'issue_tracker', required: true, description: 'Needs Jira' }],
+        handler: async () => ({ success: true }),
+      };
+
+      registry.register(cmd);
+
+      const entry = registry.get('jira-cmd');
+      expect(entry?.metadata.dependencies).toHaveLength(1);
+      expect(entry?.metadata.dependencies[0].type).toBe('issue_tracker');
+    });
+
+    it('should mark command unavailable if required dep missing', () => {
+      const cmd: CommandDefinition = {
+        name: 'jira-cmd',
+        description: 'Jira command',
+        category: 'optional',
+        dependencies: [{ type: 'issue_tracker', required: true }],
+        handler: async () => ({ success: true }),
+      };
+
+      registry.register(cmd);
+
+      const entry = registry.get('jira-cmd');
+      // Without adapter factory, required deps are considered missing
+      expect(entry?.metadata.available).toBe(false);
+      expect(entry?.metadata.unavailableReason).toContain('issue_tracker');
+    });
+
+    it('should mark command available if only optional deps missing', () => {
+      const cmd: CommandDefinition = {
+        name: 'enhanced-cmd',
+        description: 'Enhanced command',
+        category: 'core',
+        dependencies: [{ type: 'documentation', required: false }],
+        handler: async () => ({ success: true }),
+      };
+
+      registry.register(cmd);
+
+      const entry = registry.get('enhanced-cmd');
+      expect(entry?.metadata.available).toBe(true);
+    });
+  });
+
+  describe('registerMarkdown', () => {
+    it('should register a markdown command', () => {
+      const cmd: MarkdownCommand = {
+        metadata: {
+          name: 'delegate',
+          description: 'Delegate work',
+          category: 'core',
+          dependencies: [],
+          sourcePath: '/path/to/delegate.md',
+          available: true,
+        },
+        content: '# Delegate\n\nInstructions here.',
+        sections: {
+          title: 'Delegate',
+        },
+      };
+
+      registry.registerMarkdown(cmd);
+
+      expect(registry.has('delegate')).toBe(true);
+      const entry = registry.get('delegate');
+      expect(entry?.source).toBe('markdown');
+      expect(entry?.markdownCommand).toBe(cmd);
+    });
+  });
+
+  describe('registerAll', () => {
+    it('should register multiple commands', () => {
+      const cmds: CommandDefinition[] = [
+        {
+          name: 'cmd1',
+          description: 'Cmd 1',
+          category: 'core',
+          handler: async () => ({ success: true }),
+        },
+        {
+          name: 'cmd2',
+          description: 'Cmd 2',
+          category: 'core',
+          handler: async () => ({ success: true }),
+        },
+        {
+          name: 'cmd3',
+          description: 'Cmd 3',
+          category: 'optional',
+          handler: async () => ({ success: true }),
+        },
+      ];
+
+      registry.registerAll(cmds);
+
+      expect(registry.size).toBe(3);
+      expect(registry.has('cmd1')).toBe(true);
+      expect(registry.has('cmd2')).toBe(true);
+      expect(registry.has('cmd3')).toBe(true);
+    });
+  });
+
+  describe('unregister', () => {
+    it('should unregister a command', () => {
+      const cmd: CommandDefinition = {
+        name: 'to-remove',
+        description: 'Will be removed',
+        category: 'core',
+        handler: async () => ({ success: true }),
+      };
+
+      registry.register(cmd);
+      expect(registry.has('to-remove')).toBe(true);
+
+      const result = registry.unregister('to-remove');
+
+      expect(result).toBe(true);
+      expect(registry.has('to-remove')).toBe(false);
+    });
+
+    it('should return false for non-existent command', () => {
+      const result = registry.unregister('non-existent');
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('get', () => {
+    it('should return command entry', () => {
+      const cmd: CommandDefinition = {
+        name: 'my-cmd',
+        description: 'My command',
+        category: 'core',
+        handler: async () => ({ success: true }),
+      };
+
+      registry.register(cmd);
+      const entry = registry.get('my-cmd');
+
+      expect(entry).toBeDefined();
+      expect(entry?.metadata.name).toBe('my-cmd');
+      expect(entry?.definition).toBe(cmd);
+    });
+
+    it('should return undefined for non-existent command', () => {
+      const entry = registry.get('non-existent');
+      expect(entry).toBeUndefined();
+    });
+  });
+
+  describe('getAll', () => {
+    it('should return all registered commands', () => {
+      registry.registerAll([
+        {
+          name: 'cmd1',
+          description: 'C1',
+          category: 'core',
+          handler: async () => ({ success: true }),
+        },
+        {
+          name: 'cmd2',
+          description: 'C2',
+          category: 'optional',
+          handler: async () => ({ success: true }),
+        },
+      ]);
+
+      const all = registry.getAll();
+
+      expect(all).toHaveLength(2);
+    });
+  });
+
+  describe('getAvailable / getUnavailable', () => {
+    it('should separate available and unavailable commands', () => {
+      registry.registerAll([
+        {
+          name: 'available',
+          description: 'Available',
+          category: 'core',
+          handler: async () => ({ success: true }),
+        },
+        {
+          name: 'unavailable',
+          description: 'Unavailable',
+          category: 'optional',
+          dependencies: [{ type: 'issue_tracker', required: true }],
+          handler: async () => ({ success: true }),
+        },
+      ]);
+
+      const available = registry.getAvailable();
+      const unavailable = registry.getUnavailable();
+
+      expect(available).toHaveLength(1);
+      expect(available[0].metadata.name).toBe('available');
+      expect(unavailable).toHaveLength(1);
+      expect(unavailable[0].metadata.name).toBe('unavailable');
+    });
+  });
+
+  describe('getByCategory', () => {
+    it('should filter by category', () => {
+      registry.registerAll([
+        {
+          name: 'core1',
+          description: 'C1',
+          category: 'core',
+          handler: async () => ({ success: true }),
+        },
+        {
+          name: 'core2',
+          description: 'C2',
+          category: 'core',
+          handler: async () => ({ success: true }),
+        },
+        {
+          name: 'opt1',
+          description: 'O1',
+          category: 'optional',
+          handler: async () => ({ success: true }),
+        },
+        {
+          name: 'custom1',
+          description: 'Cu1',
+          category: 'custom',
+          handler: async () => ({ success: true }),
+        },
+      ]);
+
+      const core = registry.getByCategory('core');
+      const optional = registry.getByCategory('optional');
+      const custom = registry.getByCategory('custom');
+
+      expect(core).toHaveLength(2);
+      expect(optional).toHaveLength(1);
+      expect(custom).toHaveLength(1);
+    });
+  });
+
+  describe('getNames', () => {
+    it('should return command names', () => {
+      registry.registerAll([
+        {
+          name: 'alpha',
+          description: 'A',
+          category: 'core',
+          handler: async () => ({ success: true }),
+        },
+        {
+          name: 'beta',
+          description: 'B',
+          category: 'core',
+          handler: async () => ({ success: true }),
+        },
+      ]);
+
+      const names = registry.getNames();
+
+      expect(names).toContain('alpha');
+      expect(names).toContain('beta');
+    });
+  });
+
+  describe('clear', () => {
+    it('should remove all commands', () => {
+      registry.registerAll([
+        {
+          name: 'cmd1',
+          description: 'C1',
+          category: 'core',
+          handler: async () => ({ success: true }),
+        },
+        {
+          name: 'cmd2',
+          description: 'C2',
+          category: 'core',
+          handler: async () => ({ success: true }),
+        },
+      ]);
+
+      expect(registry.size).toBe(2);
+
+      registry.clear();
+
+      expect(registry.size).toBe(0);
+    });
+  });
+
+  describe('getDependencyStatus', () => {
+    it('should return dependency status', () => {
+      registry.register({
+        name: 'cmd-with-deps',
+        description: 'Has deps',
+        category: 'optional',
+        dependencies: [
+          { type: 'issue_tracker', required: true },
+          { type: 'documentation', required: false },
+        ],
+        handler: async () => ({ success: true }),
+      });
+
+      const status = registry.getDependencyStatus('cmd-with-deps');
+
+      expect(status).not.toBeNull();
+      // Only required deps are counted as missing when no adapter factory
+      expect(status?.missing).toHaveLength(1);
+      expect(status?.missing[0].type).toBe('issue_tracker');
+      expect(status?.satisfied).toHaveLength(1); // Optional dep not counted as missing
+    });
+
+    it('should return null for non-existent command', () => {
+      const status = registry.getDependencyStatus('non-existent');
+      expect(status).toBeNull();
+    });
+  });
+
+  describe('Global Registry', () => {
+    it('should return same instance', () => {
+      const reg1 = getGlobalRegistry();
+      const reg2 = getGlobalRegistry();
+
+      expect(reg1).toBe(reg2);
+    });
+
+    it('should reset global registry', () => {
+      const reg1 = getGlobalRegistry();
+      reg1.register({
+        name: 'test',
+        description: 'Test',
+        category: 'core',
+        handler: async () => ({ success: true }),
+      });
+
+      resetGlobalRegistry();
+
+      const reg2 = getGlobalRegistry();
+      expect(reg2).not.toBe(reg1);
+      expect(reg2.size).toBe(0);
+    });
+  });
+});

package/src/commands/registry.ts

@@ -0,0 +1,248 @@
+/**
+ * Command Registry
+ *
+ * Central registry for command registration and discovery.
+ */
+
+import type {
+  CommandDefinition,
+  CommandMetadata,
+  MarkdownCommand,
+  RegistryEntry,
+  CommandCategory,
+  IntegrationDependency,
+} from './types.js';
+import type { AdapterFactory } from '../adapters/factory.js';
+
+/**
+ * Command Registry
+ *
+ * Manages registration and lookup of commands.
+ */
+export class CommandRegistry {
+  private commands = new Map<string, RegistryEntry>();
+  private adapterFactory: AdapterFactory | null = null;
+
+  /**
+   * Set the adapter factory for dependency checking
+   */
+  setAdapterFactory(factory: AdapterFactory | null): void {
+    this.adapterFactory = factory;
+    // Re-evaluate availability of all commands
+    this.updateAvailability();
+  }
+
+  /**
+   * Register a programmatic command
+   */
+  register(definition: CommandDefinition): void {
+    const metadata: CommandMetadata = {
+      name: definition.name,
+      description: definition.description,
+      category: definition.category,
+      dependencies: definition.dependencies ?? [],
+      sourcePath: '<programmatic>',
+      available: true,
+    };
+
+    // Check availability
+    this.checkAvailability(metadata);
+
+    this.commands.set(definition.name, {
+      metadata,
+      definition,
+      source: 'programmatic',
+    });
+  }
+
+  /**
+   * Register a markdown command
+   */
+  registerMarkdown(command: MarkdownCommand): void {
+    // Check availability
+    this.checkAvailability(command.metadata);
+
+    this.commands.set(command.metadata.name, {
+      metadata: command.metadata,
+      markdownCommand: command,
+      source: 'markdown',
+    });
+  }
+
+  /**
+   * Register multiple commands
+   */
+  registerAll(definitions: CommandDefinition[]): void {
+    for (const def of definitions) {
+      this.register(def);
+    }
+  }
+
+  /**
+   * Register multiple markdown commands
+   */
+  registerAllMarkdown(commands: MarkdownCommand[]): void {
+    for (const cmd of commands) {
+      this.registerMarkdown(cmd);
+    }
+  }
+
+  /**
+   * Unregister a command
+   */
+  unregister(name: string): boolean {
+    return this.commands.delete(name);
+  }
+
+  /**
+   * Get a command by name
+   */
+  get(name: string): RegistryEntry | undefined {
+    return this.commands.get(name);
+  }
+
+  /**
+   * Check if a command exists
+   */
+  has(name: string): boolean {
+    return this.commands.has(name);
+  }
+
+  /**
+   * Get all registered commands
+   */
+  getAll(): RegistryEntry[] {
+    return Array.from(this.commands.values());
+  }
+
+  /**
+   * Get available commands (dependencies satisfied)
+   */
+  getAvailable(): RegistryEntry[] {
+    return this.getAll().filter((entry) => entry.metadata.available);
+  }
+
+  /**
+   * Get unavailable commands
+   */
+  getUnavailable(): RegistryEntry[] {
+    return this.getAll().filter((entry) => !entry.metadata.available);
+  }
+
+  /**
+   * Get commands by category
+   */
+  getByCategory(category: CommandCategory): RegistryEntry[] {
+    return this.getAll().filter((entry) => entry.metadata.category === category);
+  }
+
+  /**
+   * Get command names
+   */
+  getNames(): string[] {
+    return Array.from(this.commands.keys());
+  }
+
+  /**
+   * Clear all registered commands
+   */
+  clear(): void {
+    this.commands.clear();
+  }
+
+  /**
+   * Get the number of registered commands
+   */
+  get size(): number {
+    return this.commands.size;
+  }
+
+  /**
+   * Check and update availability for a command metadata
+   */
+  private checkAvailability(metadata: CommandMetadata): void {
+    const missingDeps = this.getMissingDependencies(metadata.dependencies);
+
+    if (missingDeps.length > 0) {
+      const requiredMissing = missingDeps.filter((d) => d.required);
+      if (requiredMissing.length > 0) {
+        metadata.available = false;
+        metadata.unavailableReason = `Missing required integrations: ${requiredMissing.map((d) => d.type).join(', ')}`;
+      } else {
+        // Optional deps missing, still available but may degrade
+        metadata.available = true;
+      }
+    } else {
+      metadata.available = true;
+      delete metadata.unavailableReason;
+    }
+  }
+
+  /**
+   * Get missing dependencies
+   */
+  private getMissingDependencies(dependencies: IntegrationDependency[]): IntegrationDependency[] {
+    const factory = this.adapterFactory;
+    if (!factory) {
+      // No adapter factory, assume all required deps are missing
+      return dependencies.filter((d) => d.required);
+    }
+
+    return dependencies.filter((dep) => !factory.hasIntegration(dep.type));
+  }
+
+  /**
+   * Update availability for all commands
+   */
+  private updateAvailability(): void {
+    for (const entry of this.commands.values()) {
+      this.checkAvailability(entry.metadata);
+    }
+  }
+
+  /**
+   * Get dependency status for a command
+   */
+  getDependencyStatus(name: string): {
+    satisfied: IntegrationDependency[];
+    missing: IntegrationDependency[];
+  } | null {
+    const entry = this.commands.get(name);
+    if (!entry) return null;
+
+    const deps = entry.metadata.dependencies;
+    const missing = this.getMissingDependencies(deps);
+    const satisfied = deps.filter((d) => !missing.includes(d));
+
+    return { satisfied, missing };
+  }
+}
+
+/**
+ * Create a new command registry
+ */
+export function createCommandRegistry(): CommandRegistry {
+  return new CommandRegistry();
+}
+
+/**
+ * Global command registry instance
+ */
+let globalRegistry: CommandRegistry | null = null;
+
+/**
+ * Get or create the global command registry
+ */
+export function getGlobalRegistry(): CommandRegistry {
+  if (!globalRegistry) {
+    globalRegistry = new CommandRegistry();
+  }
+  return globalRegistry;
+}
+
+/**
+ * Reset the global registry (primarily for testing)
+ */
+export function resetGlobalRegistry(): void {
+  globalRegistry = null;
+}