@deimoscloud/coreai 0.1.0

package/src/adapters/factory.test.ts

@@ -0,0 +1,386 @@
+import { AdapterFactory, createAdapterFactory, createAdapterInfo } from './factory.js';
+import { AdapterError } from './types.js';
+import type { CoreAIConfig } from '../config/types.js';
+import type { IssueTrackerAdapter, StateProviderAdapter } from './interfaces.js';
+import type {
+  AdapterInfo,
+  Issue,
+  IssueQuery,
+  CreateIssueData,
+  UpdateIssueData,
+  IssueStatus,
+  StateEntry,
+  StateOptions,
+} from './types.js';
+
+// Mock adapter implementations for testing
+function createMockIssueTrackerAdapter(
+  provider: string,
+  implementation: 'mcp' | 'native' | 'mock'
+): IssueTrackerAdapter {
+  const info: AdapterInfo = {
+    type: 'issue_tracker',
+    provider,
+    implementation,
+    connected: false,
+  };
+
+  return {
+    getInfo: () => info,
+    isConnected: () => info.connected,
+    connect: async () => {
+      info.connected = true;
+    },
+    disconnect: async () => {
+      info.connected = false;
+    },
+    getIssue: async (id: string): Promise<Issue> => ({
+      id,
+      key: `MOCK-${id}`,
+      title: 'Mock Issue',
+      status: 'todo',
+    }),
+    listIssues: async (_query?: IssueQuery): Promise<Issue[]> => [],
+    createIssue: async (data: CreateIssueData): Promise<Issue> => ({
+      id: '1',
+      key: 'MOCK-1',
+      title: data.title,
+      status: 'todo',
+    }),
+    updateIssue: async (id: string, data: UpdateIssueData): Promise<Issue> => ({
+      id,
+      key: `MOCK-${id}`,
+      title: data.title ?? 'Updated',
+      status: data.status ?? 'todo',
+    }),
+    transitionIssue: async (id: string, status: IssueStatus): Promise<Issue> => ({
+      id,
+      key: `MOCK-${id}`,
+      title: 'Mock Issue',
+      status,
+    }),
+    addComment: async (): Promise<void> => {
+      // No-op for mock
+    },
+  };
+}
+
+function createMockStateAdapter(
+  provider: string,
+  implementation: 'mcp' | 'native' | 'mock'
+): StateProviderAdapter {
+  const info: AdapterInfo = {
+    type: 'state',
+    provider,
+    implementation,
+    connected: false,
+  };
+
+  const storage = new Map<string, string>();
+
+  return {
+    getInfo: () => info,
+    isConnected: () => info.connected,
+    connect: async () => {
+      info.connected = true;
+    },
+    disconnect: async () => {
+      info.connected = false;
+    },
+    read: async (path: string): Promise<string> => {
+      const content = storage.get(path);
+      if (!content) throw new Error('Not found');
+      return content;
+    },
+    write: async (path: string, content: string): Promise<void> => {
+      storage.set(path, content);
+    },
+    exists: async (path: string): Promise<boolean> => storage.has(path),
+    list: async (_path: string): Promise<StateEntry[]> => [],
+    delete: async (path: string, _options?: StateOptions): Promise<void> => {
+      storage.delete(path);
+    },
+  };
+}
+
+const mockConfig: CoreAIConfig = {
+  version: '1.0',
+  project: {
+    name: 'test-project',
+  },
+  integrations: {
+    issue_tracker: {
+      provider: 'jira',
+      config: {
+        project_key: 'TEST',
+        base_url: 'https://jira.example.com',
+      },
+      strategy: 'auto',
+    },
+    git: {
+      provider: 'github',
+      config: {
+        repo: 'org/repo',
+      },
+      strategy: 'native',
+    },
+    state: {
+      provider: 'local',
+      config: {
+        base_path: './KnowledgeLibrary',
+      },
+    },
+  },
+};
+
+describe('AdapterFactory', () => {
+  describe('createAdapterFactory', () => {
+    it('should create a factory from config', () => {
+      const factory = createAdapterFactory(mockConfig);
+      expect(factory).toBeInstanceOf(AdapterFactory);
+    });
+  });
+
+  describe('createAdapterInfo', () => {
+    it('should create adapter info with defaults', () => {
+      const info = createAdapterInfo('issue_tracker', 'jira', 'mcp');
+      expect(info).toEqual({
+        type: 'issue_tracker',
+        provider: 'jira',
+        implementation: 'mcp',
+        connected: false,
+      });
+    });
+
+    it('should create adapter info with connected state', () => {
+      const info = createAdapterInfo('git', 'github', 'native', true);
+      expect(info.connected).toBe(true);
+    });
+  });
+
+  describe('hasIntegration', () => {
+    it('should return true for configured integrations', () => {
+      const factory = createAdapterFactory(mockConfig);
+      expect(factory.hasIntegration('issue_tracker')).toBe(true);
+      expect(factory.hasIntegration('git')).toBe(true);
+      expect(factory.hasIntegration('state')).toBe(true);
+    });
+
+    it('should return false for unconfigured integrations', () => {
+      const factory = createAdapterFactory(mockConfig);
+      expect(factory.hasIntegration('documentation')).toBe(false);
+    });
+
+    it('should return false when no integrations configured', () => {
+      const factory = createAdapterFactory({
+        version: '1.0',
+        project: { name: 'test' },
+      });
+      expect(factory.hasIntegration('issue_tracker')).toBe(false);
+    });
+  });
+
+  describe('getIntegrationInfo', () => {
+    it('should return provider and strategy for configured integration', () => {
+      const factory = createAdapterFactory(mockConfig);
+      const info = factory.getIntegrationInfo('issue_tracker');
+      expect(info).toEqual({
+        provider: 'jira',
+        strategy: 'auto',
+      });
+    });
+
+    it('should return strategy from config', () => {
+      const factory = createAdapterFactory(mockConfig);
+      const info = factory.getIntegrationInfo('git');
+      expect(info?.strategy).toBe('native');
+    });
+
+    it('should default strategy to auto', () => {
+      const factory = createAdapterFactory(mockConfig);
+      const info = factory.getIntegrationInfo('state');
+      expect(info?.strategy).toBe('auto');
+    });
+
+    it('should return null for unconfigured integration', () => {
+      const factory = createAdapterFactory(mockConfig);
+      expect(factory.getIntegrationInfo('documentation')).toBeNull();
+    });
+  });
+
+  describe('registerCreator', () => {
+    it('should register and use MCP creator', async () => {
+      const factory = createAdapterFactory(mockConfig);
+
+      factory.registerCreator('issue_tracker', 'mcp', async () =>
+        createMockIssueTrackerAdapter('jira', 'mcp')
+      );
+
+      const adapter = await factory.getIssueTracker({ implementation: 'mcp' });
+      const info = adapter.getInfo();
+
+      expect(info.type).toBe('issue_tracker');
+      expect(info.provider).toBe('jira');
+      expect(info.implementation).toBe('mcp');
+      expect(adapter.isConnected()).toBe(true);
+    });
+
+    it('should register and use native creator', async () => {
+      const factory = createAdapterFactory(mockConfig);
+
+      factory.registerCreator('issue_tracker', 'native', async () =>
+        createMockIssueTrackerAdapter('jira', 'native')
+      );
+
+      const adapter = await factory.getIssueTracker({ implementation: 'native' });
+      expect(adapter.getInfo().implementation).toBe('native');
+    });
+  });
+
+  describe('getAdapter', () => {
+    it('should cache adapters', async () => {
+      const factory = createAdapterFactory(mockConfig);
+
+      let callCount = 0;
+      factory.registerCreator('issue_tracker', 'mcp', async () => {
+        callCount++;
+        return createMockIssueTrackerAdapter('jira', 'mcp');
+      });
+
+      const adapter1 = await factory.getIssueTracker();
+      const adapter2 = await factory.getIssueTracker();
+
+      expect(adapter1).toBe(adapter2);
+      expect(callCount).toBe(1);
+    });
+
+    it('should throw for missing implementation', async () => {
+      const factory = createAdapterFactory(mockConfig);
+
+      await expect(factory.getIssueTracker()).rejects.toThrow(AdapterError);
+    });
+
+    it('should select MCP over native in auto mode', async () => {
+      const factory = createAdapterFactory(mockConfig);
+
+      factory.registerCreator('issue_tracker', 'mcp', async () =>
+        createMockIssueTrackerAdapter('jira', 'mcp')
+      );
+      factory.registerCreator('issue_tracker', 'native', async () =>
+        createMockIssueTrackerAdapter('jira', 'native')
+      );
+
+      const adapter = await factory.getIssueTracker();
+      expect(adapter.getInfo().implementation).toBe('mcp');
+    });
+
+    it('should fall back to native when MCP unavailable', async () => {
+      const factory = createAdapterFactory(mockConfig);
+
+      factory.registerCreator('issue_tracker', 'native', async () =>
+        createMockIssueTrackerAdapter('jira', 'native')
+      );
+
+      const adapter = await factory.getIssueTracker();
+      expect(adapter.getInfo().implementation).toBe('native');
+    });
+
+    it('should respect strategy override in options', async () => {
+      const factory = createAdapterFactory(mockConfig);
+
+      factory.registerCreator('issue_tracker', 'mcp', async () =>
+        createMockIssueTrackerAdapter('jira', 'mcp')
+      );
+      factory.registerCreator('issue_tracker', 'native', async () =>
+        createMockIssueTrackerAdapter('jira', 'native')
+      );
+
+      const adapter = await factory.getIssueTracker({ strategy: 'native' });
+      expect(adapter.getInfo().implementation).toBe('native');
+    });
+
+    it('should throw when requested strategy is unavailable', async () => {
+      const factory = createAdapterFactory(mockConfig);
+
+      factory.registerCreator('issue_tracker', 'native', async () =>
+        createMockIssueTrackerAdapter('jira', 'native')
+      );
+
+      await expect(factory.getIssueTracker({ strategy: 'mcp' })).rejects.toThrow(
+        'MCP adapter not available'
+      );
+    });
+  });
+
+  describe('typed adapter getters', () => {
+    it('should get issue tracker adapter', async () => {
+      const factory = createAdapterFactory(mockConfig);
+      factory.registerCreator('issue_tracker', 'mock', async () =>
+        createMockIssueTrackerAdapter('jira', 'mock')
+      );
+
+      const adapter = await factory.getIssueTracker();
+      expect(adapter.getInfo().type).toBe('issue_tracker');
+
+      // Test that interface methods exist
+      const issue = await adapter.getIssue('123');
+      expect(issue.key).toBe('MOCK-123');
+    });
+
+    it('should get state provider adapter', async () => {
+      const factory = createAdapterFactory(mockConfig);
+      factory.registerCreator('state', 'mock', async () => createMockStateAdapter('local', 'mock'));
+
+      const adapter = await factory.getStateProvider();
+      expect(adapter.getInfo().type).toBe('state');
+
+      // Test that interface methods work
+      await adapter.write('/test.txt', 'hello');
+      const content = await adapter.read('/test.txt');
+      expect(content).toBe('hello');
+    });
+  });
+
+  describe('disconnectAll', () => {
+    it('should disconnect all cached adapters', async () => {
+      const factory = createAdapterFactory(mockConfig);
+
+      factory.registerCreator('issue_tracker', 'mock', async () =>
+        createMockIssueTrackerAdapter('jira', 'mock')
+      );
+      factory.registerCreator('state', 'mock', async () => createMockStateAdapter('local', 'mock'));
+
+      const issueTracker = await factory.getIssueTracker();
+      const stateProvider = await factory.getStateProvider();
+
+      expect(issueTracker.isConnected()).toBe(true);
+      expect(stateProvider.isConnected()).toBe(true);
+
+      await factory.disconnectAll();
+
+      expect(issueTracker.isConnected()).toBe(false);
+      expect(stateProvider.isConnected()).toBe(false);
+    });
+  });
+});
+
+describe('AdapterError', () => {
+  it('should create error with message and code', () => {
+    const error = new AdapterError('Something went wrong', 'network_error');
+    expect(error.message).toBe('Something went wrong');
+    expect(error.code).toBe('network_error');
+    expect(error.name).toBe('AdapterError');
+  });
+
+  it('should include adapter info', () => {
+    const info = createAdapterInfo('git', 'github', 'native', true);
+    const error = new AdapterError('Failed', 'provider_error', info);
+    expect(error.adapter).toEqual(info);
+  });
+
+  it('should include cause', () => {
+    const cause = new Error('Original error');
+    const error = new AdapterError('Wrapped error', 'network_error', undefined, cause);
+    expect(error.cause).toBe(cause);
+  });
+});

package/src/adapters/factory.ts

@@ -0,0 +1,305 @@
+/**
+ * Adapter Factory
+ *
+ * Creates and manages adapter instances based on configuration.
+ */
+
+import type { CoreAIConfig, AdapterStrategy } from '../config/types.js';
+import type { AdapterType, AdapterInfo, AdapterImplementation } from './types.js';
+import { AdapterError } from './types.js';
+import type {
+  IssueTrackerAdapter,
+  GitProviderAdapter,
+  DocumentationProviderAdapter,
+  StateProviderAdapter,
+  Adapter,
+} from './interfaces.js';
+
+/**
+ * Options for creating an adapter
+ */
+export interface AdapterFactoryOptions {
+  /**
+   * Override the strategy from config
+   */
+  strategy?: AdapterStrategy;
+
+  /**
+   * Force a specific implementation
+   */
+  implementation?: AdapterImplementation;
+}
+
+/**
+ * Registry of adapter creators
+ */
+interface AdapterCreator<T extends Adapter> {
+  mcp?: (config: CoreAIConfig) => Promise<T>;
+  native?: (config: CoreAIConfig) => Promise<T>;
+  mock?: (config: CoreAIConfig) => Promise<T>;
+}
+
+/**
+ * Adapter Factory
+ *
+ * Creates adapter instances based on configuration and available implementations.
+ */
+export class AdapterFactory {
+  private config: CoreAIConfig;
+  private adapters = new Map<AdapterType, Adapter>();
+
+  /**
+   * Registry of adapter creators by type
+   */
+  private creators: {
+    issue_tracker: AdapterCreator<IssueTrackerAdapter>;
+    git: AdapterCreator<GitProviderAdapter>;
+    documentation: AdapterCreator<DocumentationProviderAdapter>;
+    state: AdapterCreator<StateProviderAdapter>;
+  } = {
+    issue_tracker: {},
+    git: {},
+    documentation: {},
+    state: {},
+  };
+
+  constructor(config: CoreAIConfig) {
+    this.config = config;
+  }
+
+  /**
+   * Register an adapter creator
+   */
+  registerCreator<T extends AdapterType>(
+    type: T,
+    implementation: AdapterImplementation,
+    creator: (config: CoreAIConfig) => Promise<Adapter>
+  ): void {
+    const typeCreators = this.creators[type] as AdapterCreator<Adapter>;
+    typeCreators[implementation] = creator;
+  }
+
+  /**
+   * Get an issue tracker adapter
+   */
+  async getIssueTracker(options?: AdapterFactoryOptions): Promise<IssueTrackerAdapter> {
+    return this.getAdapter('issue_tracker', options) as Promise<IssueTrackerAdapter>;
+  }
+
+  /**
+   * Get a git provider adapter
+   */
+  async getGitProvider(options?: AdapterFactoryOptions): Promise<GitProviderAdapter> {
+    return this.getAdapter('git', options) as Promise<GitProviderAdapter>;
+  }
+
+  /**
+   * Get a documentation provider adapter
+   */
+  async getDocumentationProvider(
+    options?: AdapterFactoryOptions
+  ): Promise<DocumentationProviderAdapter> {
+    return this.getAdapter('documentation', options) as Promise<DocumentationProviderAdapter>;
+  }
+
+  /**
+   * Get a state provider adapter
+   */
+  async getStateProvider(options?: AdapterFactoryOptions): Promise<StateProviderAdapter> {
+    return this.getAdapter('state', options) as Promise<StateProviderAdapter>;
+  }
+
+  /**
+   * Get an adapter by type
+   */
+  async getAdapter(type: AdapterType, options?: AdapterFactoryOptions): Promise<Adapter> {
+    // Check if we already have this adapter cached
+    const cached = this.adapters.get(type);
+    if (cached && cached.isConnected()) {
+      return cached;
+    }
+
+    // Determine the strategy
+    const strategy = this.getStrategy(type, options);
+
+    // Get the implementation to use
+    const implementation = options?.implementation ?? this.selectImplementation(type, strategy);
+
+    // Create the adapter
+    const adapter = await this.createAdapter(type, implementation);
+
+    // Cache it
+    this.adapters.set(type, adapter);
+
+    return adapter;
+  }
+
+  /**
+   * Check if an adapter type is configured
+   */
+  hasIntegration(type: AdapterType): boolean {
+    const integrations = this.config.integrations;
+    if (!integrations) return false;
+
+    switch (type) {
+      case 'issue_tracker':
+        return !!integrations.issue_tracker?.provider;
+      case 'git':
+        return !!integrations.git?.provider;
+      case 'documentation':
+        return !!integrations.documentation?.provider;
+      case 'state':
+        return !!integrations.state?.provider;
+      default:
+        return false;
+    }
+  }
+
+  /**
+   * Get information about a configured integration
+   */
+  getIntegrationInfo(type: AdapterType): { provider: string; strategy: AdapterStrategy } | null {
+    const integrations = this.config.integrations;
+    if (!integrations) return null;
+
+    let integration;
+    switch (type) {
+      case 'issue_tracker':
+        integration = integrations.issue_tracker;
+        break;
+      case 'git':
+        integration = integrations.git;
+        break;
+      case 'documentation':
+        integration = integrations.documentation;
+        break;
+      case 'state':
+        integration = integrations.state;
+        break;
+    }
+
+    if (!integration?.provider) return null;
+
+    return {
+      provider: integration.provider,
+      strategy: integration.strategy ?? 'auto',
+    };
+  }
+
+  /**
+   * Disconnect and clear all cached adapters
+   */
+  async disconnectAll(): Promise<void> {
+    const disconnects: Promise<void>[] = [];
+
+    for (const adapter of this.adapters.values()) {
+      if (adapter.isConnected()) {
+        disconnects.push(adapter.disconnect());
+      }
+    }
+
+    await Promise.all(disconnects);
+    this.adapters.clear();
+  }
+
+  /**
+   * Get the strategy for an adapter type
+   */
+  private getStrategy(type: AdapterType, options?: AdapterFactoryOptions): AdapterStrategy {
+    if (options?.strategy) {
+      return options.strategy;
+    }
+
+    const info = this.getIntegrationInfo(type);
+    return info?.strategy ?? 'auto';
+  }
+
+  /**
+   * Select the implementation based on strategy and availability
+   */
+  private selectImplementation(
+    type: AdapterType,
+    strategy: AdapterStrategy
+  ): AdapterImplementation {
+    const creators = this.creators[type];
+
+    switch (strategy) {
+      case 'mcp':
+        if (creators.mcp) return 'mcp';
+        throw new AdapterError(
+          `MCP adapter not available for ${type}`,
+          'not_implemented',
+          undefined
+        );
+
+      case 'native':
+        if (creators.native) return 'native';
+        throw new AdapterError(
+          `Native adapter not available for ${type}`,
+          'not_implemented',
+          undefined
+        );
+
+      case 'auto':
+      default:
+        // Prefer MCP, fall back to native
+        if (creators.mcp) return 'mcp';
+        if (creators.native) return 'native';
+        if (creators.mock) return 'mock';
+
+        throw new AdapterError(
+          `No adapter implementation available for ${type}`,
+          'not_implemented',
+          undefined
+        );
+    }
+  }
+
+  /**
+   * Create an adapter instance
+   */
+  private async createAdapter(
+    type: AdapterType,
+    implementation: AdapterImplementation
+  ): Promise<Adapter> {
+    const creators = this.creators[type];
+    const creator = creators[implementation];
+
+    if (!creator) {
+      throw new AdapterError(
+        `No ${implementation} adapter creator registered for ${type}`,
+        'not_implemented',
+        undefined
+      );
+    }
+
+    const adapter = await creator(this.config);
+    await adapter.connect();
+
+    return adapter;
+  }
+}
+
+/**
+ * Create an adapter factory from configuration
+ */
+export function createAdapterFactory(config: CoreAIConfig): AdapterFactory {
+  return new AdapterFactory(config);
+}
+
+/**
+ * Create adapter info helper
+ */
+export function createAdapterInfo(
+  type: AdapterType,
+  provider: string,
+  implementation: AdapterImplementation,
+  connected = false
+): AdapterInfo {
+  return {
+    type,
+    provider,
+    implementation,
+    connected,
+  };
+}