@auto-engineer/pipeline 0.0.1

package/src/plugins/handler-adapter.specs.ts

@@ -0,0 +1,164 @@
+import { describe, expect, it, vi } from 'vitest';
+import { adaptHandler, adaptHandlers } from './handler-adapter';
+import type { CommandHandlerMetadata } from './plugin-loader';
+
+describe('handler-adapter', () => {
+  describe('adaptHandler', () => {
+    it('should preserve name from source handler', () => {
+      const source: CommandHandlerMetadata = {
+        name: 'CheckTests',
+        handle: vi.fn().mockResolvedValue({ type: 'TestsCheckPassed', data: {} }),
+      };
+
+      const adapted = adaptHandler(source);
+
+      expect(adapted.name).toBe('CheckTests');
+    });
+
+    it('should preserve alias from source handler', () => {
+      const source: CommandHandlerMetadata = {
+        name: 'CheckTests',
+        alias: 'check:tests',
+        handle: vi.fn().mockResolvedValue({ type: 'TestsCheckPassed', data: {} }),
+      };
+
+      const adapted = adaptHandler(source);
+
+      expect(adapted.alias).toBe('check:tests');
+    });
+
+    it('should preserve description from source handler', () => {
+      const source: CommandHandlerMetadata = {
+        name: 'CheckTypes',
+        description: 'Runs TypeScript type checking',
+        handle: vi.fn().mockResolvedValue({ type: 'TypeCheckPassed', data: {} }),
+      };
+
+      const adapted = adaptHandler(source);
+
+      expect(adapted.description).toBe('Runs TypeScript type checking');
+    });
+
+    it('should preserve events from source handler', () => {
+      const source: CommandHandlerMetadata = {
+        name: 'CheckTests',
+        events: ['TestsCheckPassed', 'TestsCheckFailed'],
+        handle: vi.fn().mockResolvedValue({ type: 'TestsCheckPassed', data: {} }),
+      };
+
+      const adapted = adaptHandler(source);
+
+      expect(adapted.events).toEqual(['TestsCheckPassed', 'TestsCheckFailed']);
+    });
+
+    it('should preserve fields from source handler', () => {
+      const source: CommandHandlerMetadata = {
+        name: 'CheckTests',
+        fields: { targetDirectory: { type: 'string', required: true } },
+        handle: vi.fn().mockResolvedValue({ type: 'TestsCheckPassed', data: {} }),
+      };
+
+      const adapted = adaptHandler(source);
+
+      expect(adapted.fields).toEqual({ targetDirectory: { type: 'string', required: true } });
+    });
+
+    it('should call source handle function with command', async () => {
+      const mockHandle = vi.fn().mockResolvedValue({ type: 'TestsCheckPassed', data: {} });
+      const source: CommandHandlerMetadata = {
+        name: 'CheckTests',
+        handle: mockHandle,
+      };
+
+      const adapted = adaptHandler(source);
+      const command = { type: 'CheckTests', data: { targetDirectory: './src' } };
+      await adapted.handle(command);
+
+      expect(mockHandle).toHaveBeenCalledWith(command);
+    });
+
+    it('should return single event from handle', async () => {
+      const source: CommandHandlerMetadata = {
+        name: 'CheckTests',
+        handle: vi.fn().mockResolvedValue({ type: 'TestsCheckPassed', data: { passed: true } }),
+      };
+
+      const adapted = adaptHandler(source);
+      const result = await adapted.handle({ type: 'CheckTests', data: {} });
+
+      expect(result).toEqual({ type: 'TestsCheckPassed', data: { passed: true } });
+    });
+
+    it('should return array of events from handle', async () => {
+      const events = [
+        { type: 'SliceGenerated', data: { slicePath: './slice1' } },
+        { type: 'ServerGenerated', data: {} },
+      ];
+      const source: CommandHandlerMetadata = {
+        name: 'GenerateServer',
+        handle: vi.fn().mockResolvedValue(events),
+      };
+
+      const adapted = adaptHandler(source);
+      const result = await adapted.handle({ type: 'GenerateServer', data: {} });
+
+      expect(result).toEqual(events);
+    });
+
+    it('should handle undefined optional fields', () => {
+      const source: CommandHandlerMetadata = {
+        name: 'SimpleHandler',
+        handle: vi.fn().mockResolvedValue({ type: 'Done', data: {} }),
+      };
+
+      const adapted = adaptHandler(source);
+
+      expect(adapted.alias).toBeUndefined();
+      expect(adapted.description).toBeUndefined();
+      expect(adapted.events).toBeUndefined();
+      expect(adapted.fields).toBeUndefined();
+    });
+  });
+
+  describe('adaptHandlers', () => {
+    it('should adapt multiple handlers', () => {
+      const sources: CommandHandlerMetadata[] = [
+        { name: 'CheckTests', handle: vi.fn().mockResolvedValue({ type: 'TestsCheckPassed', data: {} }) },
+        { name: 'CheckTypes', handle: vi.fn().mockResolvedValue({ type: 'TypeCheckPassed', data: {} }) },
+        { name: 'CheckLint', handle: vi.fn().mockResolvedValue({ type: 'LintCheckPassed', data: {} }) },
+      ];
+
+      const adapted = adaptHandlers(sources);
+
+      expect(adapted).toHaveLength(3);
+      expect(adapted.map((h) => h.name)).toEqual(['CheckTests', 'CheckTypes', 'CheckLint']);
+    });
+
+    it('should return empty array for empty input', () => {
+      const adapted = adaptHandlers([]);
+
+      expect(adapted).toEqual([]);
+    });
+
+    it('should preserve all metadata on adapted handlers', () => {
+      const sources: CommandHandlerMetadata[] = [
+        {
+          name: 'CheckTests',
+          alias: 'check:tests',
+          description: 'Run tests',
+          events: ['TestsCheckPassed', 'TestsCheckFailed'],
+          fields: { scope: { type: 'string' } },
+          handle: vi.fn().mockResolvedValue({ type: 'TestsCheckPassed', data: {} }),
+        },
+      ];
+
+      const adapted = adaptHandlers(sources);
+
+      expect(adapted[0].name).toBe('CheckTests');
+      expect(adapted[0].alias).toBe('check:tests');
+      expect(adapted[0].description).toBe('Run tests');
+      expect(adapted[0].events).toEqual(['TestsCheckPassed', 'TestsCheckFailed']);
+      expect(adapted[0].fields).toEqual({ scope: { type: 'string' } });
+    });
+  });
+});

package/src/plugins/handler-adapter.ts

@@ -0,0 +1,21 @@
+import type { Command, Event } from '@auto-engineer/message-bus';
+import type { CommandHandlerWithMetadata } from '../server/pipeline-server';
+import type { CommandHandlerMetadata } from './plugin-loader';
+
+export function adaptHandler(source: CommandHandlerMetadata): CommandHandlerWithMetadata {
+  return {
+    name: source.name,
+    alias: source.alias,
+    description: source.description,
+    events: source.events,
+    fields: source.fields,
+    handle: async (command: Command): Promise<Event | Event[]> => {
+      const result = await source.handle(command);
+      return result as Event | Event[];
+    },
+  };
+}
+
+export function adaptHandlers(sources: CommandHandlerMetadata[]): CommandHandlerWithMetadata[] {
+  return sources.map(adaptHandler);
+}

package/src/plugins/plugin-loader.specs.ts

@@ -0,0 +1,295 @@
+import { describe, expect, it, vi } from 'vitest';
+import { PluginLoader, type PluginLoaderDeps } from './plugin-loader';
+
+function createMockDeps(overrides?: Partial<PluginLoaderDeps>): PluginLoaderDeps {
+  return {
+    existsSync: vi.fn().mockReturnValue(false),
+    importModule: vi.fn().mockResolvedValue(null),
+    ...overrides,
+  };
+}
+
+function createMockHandler(name: string, events?: string[]) {
+  return {
+    name,
+    alias: `${name.toLowerCase()}:cmd`,
+    description: `${name} handler`,
+    events: events ?? [`${name}Done`],
+    fields: { field1: { type: 'string' } },
+    handle: vi.fn().mockResolvedValue({ type: `${name}Done`, data: {} }),
+  };
+}
+
+describe('PluginLoader', () => {
+  describe('loadPlugin', () => {
+    it('should load COMMANDS from workspace package', async () => {
+      const mockHandler = createMockHandler('CheckTests', ['TestsCheckPassed', 'TestsCheckFailed']);
+      const deps = createMockDeps({
+        existsSync: vi.fn().mockImplementation((path: string) => path.includes('packages/server-checks')),
+        importModule: vi.fn().mockResolvedValue({ COMMANDS: [mockHandler] }),
+      });
+
+      const loader = new PluginLoader('/workspace', deps);
+      const handlers = await loader.loadPlugin('@auto-engineer/server-checks');
+
+      expect(handlers).toHaveLength(1);
+      expect(handlers[0].name).toBe('CheckTests');
+      expect(handlers[0].events).toEqual(['TestsCheckPassed', 'TestsCheckFailed']);
+    });
+
+    it('should load COMMANDS from node_modules when workspace not found', async () => {
+      const mockHandler = createMockHandler('GenerateServer');
+      const deps = createMockDeps({
+        existsSync: vi.fn().mockImplementation((path: string) => path.includes('node_modules')),
+        importModule: vi.fn().mockResolvedValue({ COMMANDS: [mockHandler] }),
+      });
+
+      const loader = new PluginLoader('/workspace', deps);
+      const handlers = await loader.loadPlugin('@auto-engineer/server-generator');
+
+      expect(handlers).toHaveLength(1);
+      expect(handlers[0].name).toBe('GenerateServer');
+      expect(deps.existsSync).toHaveBeenCalled();
+    });
+
+    it('should fallback to direct import when neither workspace nor node_modules found', async () => {
+      const mockHandler = createMockHandler('DirectImport');
+      const deps = createMockDeps({
+        existsSync: vi.fn().mockReturnValue(false),
+        importModule: vi.fn().mockResolvedValue({ COMMANDS: [mockHandler] }),
+      });
+
+      const loader = new PluginLoader('/workspace', deps);
+      const handlers = await loader.loadPlugin('some-package');
+
+      expect(handlers).toHaveLength(1);
+      expect(handlers[0].name).toBe('DirectImport');
+      expect(deps.importModule).toHaveBeenCalledWith('some-package');
+    });
+
+    it('should return empty array when import fails', async () => {
+      const deps = createMockDeps({
+        existsSync: vi.fn().mockReturnValue(false),
+        importModule: vi.fn().mockRejectedValue(new Error('Module not found')),
+      });
+
+      const loader = new PluginLoader('/workspace', deps);
+      const handlers = await loader.loadPlugin('@auto-engineer/nonexistent');
+
+      expect(handlers).toEqual([]);
+    });
+
+    it('should extract handler metadata', async () => {
+      const mockHandler = {
+        name: 'CheckTypes',
+        alias: 'check:types',
+        description: 'Type checking',
+        events: ['TypeCheckPassed', 'TypeCheckFailed'],
+        fields: { targetDir: { type: 'string', required: true } },
+        handle: vi.fn(),
+      };
+      const deps = createMockDeps({
+        existsSync: vi.fn().mockReturnValue(true),
+        importModule: vi.fn().mockResolvedValue({ COMMANDS: [mockHandler] }),
+      });
+
+      const loader = new PluginLoader('/workspace', deps);
+      const handlers = await loader.loadPlugin('@auto-engineer/server-checks');
+
+      expect(handlers[0]).toEqual({
+        name: 'CheckTypes',
+        alias: 'check:types',
+        description: 'Type checking',
+        events: ['TypeCheckPassed', 'TypeCheckFailed'],
+        fields: { targetDir: { type: 'string', required: true } },
+        handle: mockHandler.handle,
+      });
+    });
+
+    it('should skip invalid handlers in COMMANDS array', async () => {
+      const validHandler = createMockHandler('Valid');
+      const deps = createMockDeps({
+        existsSync: vi.fn().mockReturnValue(true),
+        importModule: vi.fn().mockResolvedValue({
+          COMMANDS: [validHandler, { notAHandler: true }, null, 'string', { name: 'NoHandle' }],
+        }),
+      });
+
+      const loader = new PluginLoader('/workspace', deps);
+      const handlers = await loader.loadPlugin('@auto-engineer/test');
+
+      expect(handlers).toHaveLength(1);
+      expect(handlers[0].name).toBe('Valid');
+    });
+
+    it('should handle module that is not an object', async () => {
+      const deps = createMockDeps({
+        existsSync: vi.fn().mockReturnValue(true),
+        importModule: vi.fn().mockResolvedValue('not an object'),
+      });
+
+      const loader = new PluginLoader('/workspace', deps);
+      const handlers = await loader.loadPlugin('@auto-engineer/test');
+
+      expect(handlers).toEqual([]);
+    });
+
+    it('should handle null module', async () => {
+      const deps = createMockDeps({
+        existsSync: vi.fn().mockReturnValue(true),
+        importModule: vi.fn().mockResolvedValue(null),
+      });
+
+      const loader = new PluginLoader('/workspace', deps);
+      const handlers = await loader.loadPlugin('@auto-engineer/test');
+
+      expect(handlers).toEqual([]);
+    });
+
+    it('should extract COMMANDS from default export', async () => {
+      const mockHandler = createMockHandler('FromDefault');
+      const deps = createMockDeps({
+        existsSync: vi.fn().mockReturnValue(true),
+        importModule: vi.fn().mockResolvedValue({
+          default: { COMMANDS: [mockHandler] },
+        }),
+      });
+
+      const loader = new PluginLoader('/workspace', deps);
+      const handlers = await loader.loadPlugin('@auto-engineer/test');
+
+      expect(handlers).toHaveLength(1);
+      expect(handlers[0].name).toBe('FromDefault');
+    });
+
+    it('should return empty when default export has no COMMANDS', async () => {
+      const deps = createMockDeps({
+        existsSync: vi.fn().mockReturnValue(true),
+        importModule: vi.fn().mockResolvedValue({
+          default: { somethingElse: true },
+        }),
+      });
+
+      const loader = new PluginLoader('/workspace', deps);
+      const handlers = await loader.loadPlugin('@auto-engineer/test');
+
+      expect(handlers).toEqual([]);
+    });
+
+    it('should return empty when default export is not an object', async () => {
+      const deps = createMockDeps({
+        existsSync: vi.fn().mockReturnValue(true),
+        importModule: vi.fn().mockResolvedValue({
+          default: 'not an object',
+        }),
+      });
+
+      const loader = new PluginLoader('/workspace', deps);
+      const handlers = await loader.loadPlugin('@auto-engineer/test');
+
+      expect(handlers).toEqual([]);
+    });
+
+    it('should return empty when extractCommands throws', async () => {
+      const deps = createMockDeps({
+        existsSync: vi.fn().mockReturnValue(true),
+        importModule: vi.fn().mockImplementation(() => {
+          throw new Error('Unexpected error');
+        }),
+      });
+
+      const loader = new PluginLoader('/workspace', deps);
+      const handlers = await loader.loadPlugin('@auto-engineer/test');
+
+      expect(handlers).toEqual([]);
+    });
+  });
+
+  describe('loadPlugins', () => {
+    it('should load handlers from multiple packages', async () => {
+      const handler1 = createMockHandler('Handler1');
+      const handler2 = createMockHandler('Handler2');
+      const deps = createMockDeps({
+        existsSync: vi.fn().mockReturnValue(true),
+        importModule: vi
+          .fn()
+          .mockResolvedValueOnce({ COMMANDS: [handler1] })
+          .mockResolvedValueOnce({ COMMANDS: [handler2] }),
+      });
+
+      const loader = new PluginLoader('/workspace', deps);
+      const handlers = await loader.loadPlugins(['@auto-engineer/pkg1', '@auto-engineer/pkg2']);
+
+      expect(handlers).toHaveLength(2);
+      expect(handlers.map((h) => h.name)).toEqual(['Handler1', 'Handler2']);
+    });
+
+    it('should continue loading even if one package fails', async () => {
+      const handler = createMockHandler('Handler');
+      const deps = createMockDeps({
+        existsSync: vi.fn().mockReturnValue(true),
+        importModule: vi
+          .fn()
+          .mockRejectedValueOnce(new Error('Failed'))
+          .mockResolvedValueOnce({ COMMANDS: [handler] }),
+      });
+
+      const loader = new PluginLoader('/workspace', deps);
+      const handlers = await loader.loadPlugins(['@auto-engineer/failing', '@auto-engineer/working']);
+
+      expect(handlers).toHaveLength(1);
+      expect(handlers[0].name).toBe('Handler');
+    });
+  });
+
+  describe('constructor', () => {
+    it('should use default workspace root when not provided', () => {
+      const loader = new PluginLoader();
+      expect(loader).toBeDefined();
+    });
+
+    it('should use custom workspace root when provided', () => {
+      const loader = new PluginLoader('/custom/workspace');
+      expect(loader).toBeDefined();
+    });
+  });
+
+  describe('integration', { timeout: 30000 }, () => {
+    it('should load real package using default deps', async () => {
+      const loader = new PluginLoader();
+      const handlers = await loader.loadPlugin('@auto-engineer/server-checks');
+      const handlerNames = handlers.map((h) => h.name);
+      expect(handlerNames).toContain('CheckTests');
+      expect(handlerNames).toContain('CheckTypes');
+      expect(handlerNames).toContain('CheckLint');
+    });
+
+    it('should load handlers from multiple real packages', async () => {
+      const loader = new PluginLoader();
+      const handlers = await loader.loadPlugins([
+        '@auto-engineer/server-checks',
+        '@auto-engineer/server-generator-apollo-emmett',
+      ]);
+      const handlerNames = handlers.map((h) => h.name);
+      expect(handlerNames).toContain('CheckTests');
+      expect(handlerNames).toContain('CheckTypes');
+      expect(handlerNames).toContain('CheckLint');
+      expect(handlerNames).toContain('GenerateServer');
+      expect(handlers.length).toBeGreaterThan(3);
+    });
+
+    it('should load ExportSchema from narrative package node entry', async () => {
+      const loader = new PluginLoader();
+      const handlers = await loader.loadPlugin('@auto-engineer/narrative');
+      const handlerNames = handlers.map((h) => h.name);
+      expect(handlerNames).toContain('ExportSchema');
+    });
+
+    it('should load GenerateClient from frontend-generator package', async () => {
+      const loader = new PluginLoader();
+      const handlers = await loader.loadPlugin('@auto-engineer/frontend-generator-react-graphql');
+      const handlerNames = handlers.map((h) => h.name);
+      expect(handlerNames).toContain('GenerateClient');
+    });
+  });
+});

package/src/plugins/plugin-loader.ts

@@ -0,0 +1,202 @@
+import { existsSync as fsExistsSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export interface CommandHandlerMetadata {
+  name: string;
+  alias?: string;
+  description?: string;
+  events?: string[];
+  fields?: Record<string, unknown>;
+  handle: (command: unknown) => Promise<unknown>;
+}
+
+interface UnifiedCommandHandler {
+  name: string;
+  alias?: string;
+  description?: string;
+  events?: string[];
+  fields?: Record<string, unknown>;
+  handle: (command: unknown) => Promise<unknown>;
+}
+
+function isValidHandler(obj: unknown): obj is UnifiedCommandHandler {
+  return (
+    typeof obj === 'object' &&
+    obj !== null &&
+    'name' in obj &&
+    typeof (obj as UnifiedCommandHandler).name === 'string' &&
+    'handle' in obj &&
+    typeof (obj as UnifiedCommandHandler).handle === 'function'
+  );
+}
+
+function isHandlerExportKey(key: string): boolean {
+  return key.endsWith('CommandHandler') || key.endsWith('commandHandler');
+}
+
+function isHandlerObject(value: unknown): boolean {
+  return typeof value === 'object' && value !== null && 'name' in value && 'handle' in value;
+}
+
+function hasCommandsArray(obj: Record<string, unknown>): boolean {
+  return 'COMMANDS' in obj && Array.isArray(obj.COMMANDS);
+}
+
+function getDefaultExport(obj: Record<string, unknown>): Record<string, unknown> | null {
+  if ('default' in obj && typeof obj.default === 'object' && obj.default !== null) {
+    return obj.default as Record<string, unknown>;
+  }
+  return null;
+}
+
+export interface PluginLoaderDeps {
+  existsSync: (path: string) => boolean;
+  importModule: (path: string) => Promise<unknown>;
+}
+
+const defaultDeps: PluginLoaderDeps = {
+  existsSync: fsExistsSync,
+  importModule: (path: string) => import(path),
+};
+
+export class PluginLoader {
+  private readonly workspaceRoot: string;
+  private readonly deps: PluginLoaderDeps;
+
+  constructor(workspaceRoot?: string, deps?: PluginLoaderDeps) {
+    const currentDir = dirname(fileURLToPath(import.meta.url));
+    this.workspaceRoot = workspaceRoot ?? resolve(currentDir, '../../../../');
+    this.deps = deps ?? defaultDeps;
+  }
+
+  async loadPlugin(packageName: string): Promise<CommandHandlerMetadata[]> {
+    const handlers: CommandHandlerMetadata[] = [];
+
+    try {
+      const module = await this.tryLoadModule(packageName);
+      if (module === null) {
+        return [];
+      }
+
+      const commands = this.extractCommands(module);
+      for (const cmd of commands) {
+        if (isValidHandler(cmd)) {
+          handlers.push({
+            name: cmd.name,
+            alias: cmd.alias,
+            description: cmd.description,
+            events: cmd.events,
+            fields: cmd.fields,
+            handle: cmd.handle,
+          });
+        }
+      }
+    } catch {
+      return [];
+    }
+
+    return handlers;
+  }
+
+  async loadPlugins(packageNames: string[]): Promise<CommandHandlerMetadata[]> {
+    const allHandlers: CommandHandlerMetadata[] = [];
+    for (const packageName of packageNames) {
+      const handlers = await this.loadPlugin(packageName);
+      allHandlers.push(...handlers);
+    }
+    return allHandlers;
+  }
+
+  private async tryLoadModule(packageName: string): Promise<unknown> {
+    const shortName = packageName.replace('@auto-engineer/', '');
+    const distPaths = ['dist', 'dist/src'];
+    const entryPoints = ['index.js', 'node.js'];
+
+    for (const distPath of distPaths) {
+      for (const entry of entryPoints) {
+        const workspacePath = resolve(this.workspaceRoot, 'packages', shortName, distPath, entry);
+        if (this.deps.existsSync(workspacePath)) {
+          const mod = await this.deps.importModule(workspacePath);
+          if (this.hasCommands(mod)) {
+            return mod;
+          }
+        }
+      }
+    }
+
+    for (const distPath of distPaths) {
+      for (const entry of entryPoints) {
+        const nodeModulesPath = resolve(this.workspaceRoot, 'node_modules', packageName, distPath, entry);
+        if (this.deps.existsSync(nodeModulesPath)) {
+          const mod = await this.deps.importModule(nodeModulesPath);
+          if (this.hasCommands(mod)) {
+            return mod;
+          }
+        }
+      }
+    }
+
+    try {
+      return await this.deps.importModule(packageName);
+    } catch {
+      return null;
+    }
+  }
+
+  private hasCommands(mod: unknown): boolean {
+    if (typeof mod !== 'object' || mod === null) {
+      return false;
+    }
+    const obj = mod as Record<string, unknown>;
+
+    if (hasCommandsArray(obj)) {
+      return true;
+    }
+
+    const defaultMod = getDefaultExport(obj);
+    if (defaultMod !== null && hasCommandsArray(defaultMod)) {
+      return true;
+    }
+
+    return this.hasNamedHandlerExports(obj);
+  }
+
+  private hasNamedHandlerExports(obj: Record<string, unknown>): boolean {
+    for (const key of Object.keys(obj)) {
+      if (isHandlerExportKey(key) && isHandlerObject(obj[key])) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  private extractCommands(module: unknown): unknown[] {
+    if (typeof module !== 'object' || module === null) {
+      return [];
+    }
+
+    const mod = module as Record<string, unknown>;
+
+    if (hasCommandsArray(mod)) {
+      return mod.COMMANDS as unknown[];
+    }
+
+    const defaultMod = getDefaultExport(mod);
+    if (defaultMod !== null && hasCommandsArray(defaultMod)) {
+      return defaultMod.COMMANDS as unknown[];
+    }
+
+    return this.extractNamedHandlers(mod);
+  }
+
+  private extractNamedHandlers(mod: Record<string, unknown>): unknown[] {
+    const handlers: unknown[] = [];
+    for (const [key, value] of Object.entries(mod)) {
+      if (isHandlerExportKey(key) && isHandlerObject(value)) {
+        handlers.push(value);
+      }
+    }
+    return handlers;
+  }
+}