@deimoscloud/coreai 0.1.9 → 0.1.10

package/src/commands/registry.test.ts

@@ -1,384 +0,0 @@
-/**
- * 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

@@ -1,248 +0,0 @@
-/**
- * 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;
-}