@deimoscloud/coreai 0.1.8 → 0.1.10

package/src/adapters/factory.test.ts

@@ -1,386 +0,0 @@
-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

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