@deimoscloud/coreai 0.1.0

package/src/adapters/native/selector.test.ts

@@ -0,0 +1,224 @@
+/**
+ * Native Adapter Selector Tests
+ */
+
+import type { CoreAIConfig } from '../../config/types.js';
+import { AdapterFactory } from '../factory.js';
+import { FilesystemAdapter } from './filesystem.js';
+import {
+  registerNativeAdapters,
+  checkNativeAdapterAvailability,
+  parseGitHubRemote,
+} from './selector.js';
+
+describe('registerNativeAdapters', () => {
+  it('should register state adapter creator', async () => {
+    const config: CoreAIConfig = {
+      project: { root: '/tmp/test' },
+    };
+    const factory = new AdapterFactory(config);
+
+    registerNativeAdapters(factory, { statePath: '/tmp/test' });
+
+    // Verify the creator was registered by trying to get the adapter
+    // We can't directly access the creators, but we can test the factory behavior
+    expect(factory).toBeDefined();
+  });
+
+  it('should register git adapter creator', () => {
+    const config: CoreAIConfig = {
+      project: { root: '/tmp/test' },
+      integrations: {
+        git: {
+          provider: 'github',
+          owner: 'test-owner',
+          repo: 'test-repo',
+        },
+      },
+    };
+    const factory = new AdapterFactory(config);
+
+    registerNativeAdapters(factory, { githubRepository: 'owner/repo' });
+
+    expect(factory).toBeDefined();
+  });
+
+  it('should use options for state path', () => {
+    const config: CoreAIConfig = {
+      project: { root: '/original' },
+    };
+    const factory = new AdapterFactory(config);
+
+    registerNativeAdapters(factory, {
+      statePath: '/custom/path',
+    });
+
+    expect(factory).toBeDefined();
+  });
+
+  it('should use options for github repository', () => {
+    const config: CoreAIConfig = {};
+    const factory = new AdapterFactory(config);
+
+    registerNativeAdapters(factory, {
+      githubRepository: 'custom/repo',
+    });
+
+    expect(factory).toBeDefined();
+  });
+});
+
+describe('checkNativeAdapterAvailability', () => {
+  it('should return state as available with valid config', () => {
+    const config: CoreAIConfig = {
+      project: { root: '/tmp/test' },
+    };
+
+    const availability = checkNativeAdapterAvailability(config);
+
+    expect(availability.state).toBe(true);
+    expect(availability.stateReason).toBeUndefined();
+  });
+
+  it('should return git as available when configured', () => {
+    const config: CoreAIConfig = {
+      integrations: {
+        git: {
+          provider: 'github',
+          config: {
+            owner: 'test-owner',
+            repo: 'test-repo',
+          },
+        },
+      },
+    };
+
+    const availability = checkNativeAdapterAvailability(config);
+
+    expect(availability.git).toBe(true);
+    expect(availability.gitReason).toBeUndefined();
+  });
+
+  it('should return git as unavailable without configuration', () => {
+    const config: CoreAIConfig = {};
+
+    const availability = checkNativeAdapterAvailability(config);
+
+    expect(availability.git).toBe(false);
+    expect(availability.gitReason).toBe('GitHub repository not configured');
+  });
+
+  it('should use options to override config for git', () => {
+    const config: CoreAIConfig = {};
+    const options = { githubRepository: 'owner/repo' };
+
+    const availability = checkNativeAdapterAvailability(config, options);
+
+    expect(availability.git).toBe(true);
+  });
+
+  it('should use options to override config for state', () => {
+    const config: CoreAIConfig = {};
+    const options = { statePath: '/custom/path' };
+
+    const availability = checkNativeAdapterAvailability(config, options);
+
+    expect(availability.state).toBe(true);
+  });
+
+  it('should check git provider is github', () => {
+    const config: CoreAIConfig = {
+      integrations: {
+        git: {
+          provider: 'gitlab', // Not github
+          owner: 'test-owner',
+          repo: 'test-repo',
+        },
+      },
+    };
+
+    const availability = checkNativeAdapterAvailability(config);
+
+    expect(availability.git).toBe(false);
+  });
+});
+
+describe('parseGitHubRemote', () => {
+  it('should parse HTTPS URL', () => {
+    const url = 'https://github.com/owner/repo.git';
+    const result = parseGitHubRemote(url);
+    expect(result).toBe('owner/repo');
+  });
+
+  it('should parse HTTPS URL without .git suffix', () => {
+    const url = 'https://github.com/owner/repo';
+    const result = parseGitHubRemote(url);
+    expect(result).toBe('owner/repo');
+  });
+
+  it('should parse SSH URL', () => {
+    const url = 'git@github.com:owner/repo.git';
+    const result = parseGitHubRemote(url);
+    expect(result).toBe('owner/repo');
+  });
+
+  it('should parse SSH URL without .git suffix', () => {
+    const url = 'git@github.com:owner/repo';
+    const result = parseGitHubRemote(url);
+    expect(result).toBe('owner/repo');
+  });
+
+  it('should return null for non-GitHub URL', () => {
+    const url = 'https://gitlab.com/owner/repo.git';
+    const result = parseGitHubRemote(url);
+    expect(result).toBeNull();
+  });
+
+  it('should return null for invalid URL', () => {
+    const url = 'not-a-url';
+    const result = parseGitHubRemote(url);
+    expect(result).toBeNull();
+  });
+
+  it('should handle complex repo names', () => {
+    const url = 'https://github.com/my-org/my-cool-repo.git';
+    const result = parseGitHubRemote(url);
+    expect(result).toBe('my-org/my-cool-repo');
+  });
+
+  it('should handle underscores in names', () => {
+    const url = 'git@github.com:my_org/my_repo.git';
+    const result = parseGitHubRemote(url);
+    expect(result).toBe('my_org/my_repo');
+  });
+});
+
+describe('Integration tests', () => {
+  it('should create filesystem adapter through factory', async () => {
+    const config: CoreAIConfig = {
+      project: { root: '/tmp/test' },
+    };
+    const factory = new AdapterFactory(config);
+
+    registerNativeAdapters(factory, { statePath: '/tmp' });
+
+    // The factory will try to create and connect, which may fail
+    // but we can test that the creator is properly registered
+    try {
+      const adapter = await factory.getStateProvider({ strategy: 'native' });
+      expect(adapter).toBeInstanceOf(FilesystemAdapter);
+      await adapter.disconnect();
+    } catch {
+      // Connect may fail in test environment, that's ok
+    }
+  });
+
+  it('should throw when getting git adapter without config', async () => {
+    const config: CoreAIConfig = {};
+    const factory = new AdapterFactory(config);
+
+    registerNativeAdapters(factory);
+
+    await expect(factory.getGitProvider({ strategy: 'native' })).rejects.toThrow();
+  });
+});

package/src/adapters/native/selector.ts

@@ -0,0 +1,150 @@
+/**
+ * Native Adapter Selector
+ *
+ * Registers native adapters with the adapter factory and provides
+ * helper functions for adapter selection.
+ */
+
+import type { CoreAIConfig } from '../../config/types.js';
+import type { AdapterFactory } from '../factory.js';
+import { FilesystemAdapter } from './filesystem.js';
+import { GitHubAdapter } from './github.js';
+
+/**
+ * Options for the native adapter selector
+ */
+export interface NativeAdapterSelectorOptions {
+  /**
+   * Base path for filesystem adapter (defaults to .coreai in project root)
+   */
+  statePath?: string;
+
+  /**
+   * GitHub repository in owner/repo format (auto-detected if not provided)
+   */
+  githubRepository?: string;
+
+  /**
+   * Path to gh CLI (defaults to 'gh')
+   */
+  ghPath?: string;
+}
+
+/**
+ * Register native adapters with a factory
+ *
+ * This function registers the native adapters (filesystem, github) with the
+ * adapter factory. The factory will use these as fallbacks when MCP adapters
+ * are not available.
+ */
+export function registerNativeAdapters(
+  factory: AdapterFactory,
+  options?: NativeAdapterSelectorOptions
+): void {
+  // Register state provider (filesystem)
+  factory.registerCreator('state', 'native', async (config: CoreAIConfig) => {
+    const basePath = options?.statePath ?? config.project?.root ?? process.cwd();
+    const adapter = new FilesystemAdapter({
+      basePath,
+      defaultEncoding: 'utf-8',
+    });
+    return adapter;
+  });
+
+  // Register git provider (github)
+  factory.registerCreator('git', 'native', async (config: CoreAIConfig) => {
+    // Try to get repository from options or config
+    let repository = options?.githubRepository;
+
+    if (!repository) {
+      // Try to get from git integration config
+      const gitConfig = config.integrations?.git;
+      if (gitConfig?.provider === 'github' && gitConfig.config?.owner && gitConfig.config?.repo) {
+        repository = `${gitConfig.config.owner}/${gitConfig.config.repo}`;
+      }
+    }
+
+    if (!repository) {
+      throw new Error(
+        'GitHub repository not configured. Set integrations.git.owner and integrations.git.repo in config.'
+      );
+    }
+
+    const adapterOptions: { repository: string; ghPath?: string } = { repository };
+    if (options?.ghPath) {
+      adapterOptions.ghPath = options.ghPath;
+    }
+    const adapter = new GitHubAdapter(adapterOptions);
+    return adapter;
+  });
+}
+
+/**
+ * Check if native adapters are available for the current environment
+ */
+export interface NativeAdapterAvailability {
+  state: boolean;
+  git: boolean;
+  stateReason?: string;
+  gitReason?: string;
+}
+
+/**
+ * Check which native adapters are available
+ */
+export function checkNativeAdapterAvailability(
+  config: CoreAIConfig,
+  options?: NativeAdapterSelectorOptions
+): NativeAdapterAvailability {
+  const result: NativeAdapterAvailability = {
+    state: true,
+    git: false,
+  };
+
+  // State adapter is always available (filesystem)
+  // Just needs a valid base path
+  const basePath = options?.statePath ?? config.project?.root ?? process.cwd();
+  if (!basePath) {
+    result.state = false;
+    result.stateReason = 'No base path configured';
+  }
+
+  // Git adapter needs repository configuration
+  let repository = options?.githubRepository;
+  if (!repository) {
+    const gitConfig = config.integrations?.git;
+    if (gitConfig?.provider === 'github' && gitConfig.config?.owner && gitConfig.config?.repo) {
+      repository = `${gitConfig.config.owner}/${gitConfig.config.repo}`;
+    }
+  }
+
+  if (repository) {
+    result.git = true;
+  } else {
+    result.gitReason = 'GitHub repository not configured';
+  }
+
+  return result;
+}
+
+/**
+ * Auto-detect GitHub repository from git remote
+ *
+ * Parses the git remote URL to extract owner/repo.
+ * Supports both HTTPS and SSH URL formats.
+ */
+export function parseGitHubRemote(remoteUrl: string): string | null {
+  // HTTPS format: https://github.com/owner/repo.git
+  const httpsMatch = remoteUrl.match(/https:\/\/github\.com\/([^/]+)\/([^/.]+)/);
+  if (httpsMatch) {
+    return `${httpsMatch[1]}/${httpsMatch[2]}`;
+  }
+
+  // SSH format: git@github.com:owner/repo.git
+  const sshMatch = remoteUrl.match(/git@github\.com:([^/]+)\/([^/.]+)/);
+  if (sshMatch) {
+    return `${sshMatch[1]}/${sshMatch[2]}`;
+  }
+
+  return null;
+}

package/src/adapters/types.ts

@@ -0,0 +1,270 @@
+/**
+ * Adapter Types
+ *
+ * Common types used across all adapters.
+ */
+
+/**
+ * The type of adapter
+ */
+export type AdapterType = 'issue_tracker' | 'git' | 'documentation' | 'state';
+
+/**
+ * How the adapter connects to the service
+ */
+export type AdapterImplementation = 'mcp' | 'native' | 'mock';
+
+/**
+ * Base metadata for all adapters
+ */
+export interface AdapterInfo {
+  /**
+   * Type of adapter
+   */
+  type: AdapterType;
+
+  /**
+   * Provider name (e.g., 'github', 'jira', 'confluence')
+   */
+  provider: string;
+
+  /**
+   * How this adapter is implemented
+   */
+  implementation: AdapterImplementation;
+
+  /**
+   * Whether the adapter is currently connected/available
+   */
+  connected: boolean;
+}
+
+/**
+ * Common issue status values
+ */
+export type IssueStatus =
+  | 'backlog'
+  | 'todo'
+  | 'in_progress'
+  | 'in_review'
+  | 'done'
+  | 'closed'
+  | string;
+
+/**
+ * Common pull request status values
+ */
+export type PullRequestStatus = 'open' | 'merged' | 'closed' | 'draft';
+
+/**
+ * Common review decision values
+ */
+export type ReviewDecision = 'approve' | 'request_changes' | 'comment';
+
+/**
+ * Issue data structure
+ */
+export interface Issue {
+  id: string;
+  key: string;
+  title: string;
+  description?: string;
+  status: IssueStatus;
+  assignee?: string;
+  reporter?: string;
+  labels?: string[];
+  priority?: string;
+  created_at?: string;
+  updated_at?: string;
+  url?: string;
+}
+
+/**
+ * Data for creating an issue
+ */
+export interface CreateIssueData {
+  title: string;
+  description?: string;
+  assignee?: string;
+  labels?: string[];
+  priority?: string;
+  type?: string;
+}
+
+/**
+ * Data for updating an issue
+ */
+export interface UpdateIssueData {
+  title?: string;
+  description?: string;
+  assignee?: string;
+  labels?: string[];
+  priority?: string;
+  status?: IssueStatus;
+}
+
+/**
+ * Query parameters for listing issues
+ */
+export interface IssueQuery {
+  assignee?: string;
+  status?: IssueStatus | IssueStatus[];
+  labels?: string[];
+  limit?: number;
+  offset?: number;
+}
+
+/**
+ * Pull request data structure
+ */
+export interface PullRequest {
+  id: string;
+  number: number;
+  title: string;
+  description?: string;
+  status: PullRequestStatus;
+  author?: string;
+  source_branch: string;
+  target_branch: string;
+  created_at?: string;
+  updated_at?: string;
+  merged_at?: string;
+  url?: string;
+  reviewers?: string[];
+}
+
+/**
+ * Data for creating a pull request
+ */
+export interface CreatePullRequestData {
+  title: string;
+  description?: string;
+  source_branch: string;
+  target_branch: string;
+  draft?: boolean;
+  reviewers?: string[];
+}
+
+/**
+ * Query parameters for listing pull requests
+ */
+export interface PullRequestQuery {
+  status?: PullRequestStatus | PullRequestStatus[];
+  author?: string;
+  limit?: number;
+  offset?: number;
+}
+
+/**
+ * Review data for a pull request
+ */
+export interface Review {
+  id: string;
+  pull_request_id: string;
+  author: string;
+  decision: ReviewDecision;
+  body?: string;
+  created_at?: string;
+}
+
+/**
+ * Data for creating a review
+ */
+export interface CreateReviewData {
+  decision: ReviewDecision;
+  body?: string;
+  comments?: ReviewComment[];
+}
+
+/**
+ * Comment on a specific line in a review
+ */
+export interface ReviewComment {
+  path: string;
+  line: number;
+  body: string;
+}
+
+/**
+ * Documentation page data structure
+ */
+export interface DocumentationPage {
+  id: string;
+  title: string;
+  content?: string;
+  path?: string;
+  url?: string;
+  parent_id?: string;
+  created_at?: string;
+  updated_at?: string;
+}
+
+/**
+ * Query parameters for searching documentation
+ */
+export interface DocumentationQuery {
+  query: string;
+  space?: string;
+  limit?: number;
+}
+
+/**
+ * File/directory entry for state provider
+ */
+export interface StateEntry {
+  path: string;
+  name: string;
+  type: 'file' | 'directory';
+  size?: number;
+  modified_at?: string;
+}
+
+/**
+ * Options for state operations
+ */
+export interface StateOptions {
+  /**
+   * Create parent directories if they don't exist
+   */
+  recursive?: boolean;
+
+  /**
+   * Encoding for text content
+   */
+  encoding?: BufferEncoding;
+}
+
+/**
+ * Adapter error with context
+ */
+export class AdapterError extends Error {
+  public readonly code: AdapterErrorCode;
+  public readonly adapter?: AdapterInfo;
+
+  constructor(message: string, code: AdapterErrorCode, adapter?: AdapterInfo, cause?: Error) {
+    super(message, { cause });
+    this.name = 'AdapterError';
+    this.code = code;
+    if (adapter) {
+      this.adapter = adapter;
+    }
+  }
+}
+
+/**
+ * Error codes for adapter operations
+ */
+export type AdapterErrorCode =
+  | 'not_found'
+  | 'unauthorized'
+  | 'forbidden'
+  | 'rate_limited'
+  | 'network_error'
+  | 'invalid_request'
+  | 'not_implemented'
+  | 'connection_failed'
+  | 'provider_error'
+  | 'operation_failed'
+  | 'invalid_operation'
+  | 'not_connected'
+  | 'invalid_config';