@deimoscloud/coreai 0.1.0

package/src/adapters/native/github.ts

@@ -0,0 +1,627 @@
+/**
+ * Native GitHub Adapter
+ *
+ * Implements GitProviderAdapter using the GitHub CLI (gh).
+ * Requires the gh CLI to be installed and authenticated.
+ */
+
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import type { GitProviderAdapter } from '../interfaces.js';
+import type {
+  AdapterInfo,
+  PullRequest,
+  PullRequestQuery,
+  CreatePullRequestData,
+  Review,
+  CreateReviewData,
+  PullRequestStatus,
+  ReviewDecision,
+} from '../types.js';
+import { AdapterError } from '../types.js';
+
+const execFileAsync = promisify(execFile);
+
+/**
+ * Options for creating a GitHub adapter
+ */
+export interface GitHubAdapterOptions {
+  /**
+   * Repository in owner/repo format
+   */
+  repository: string;
+
+  /**
+   * Path to gh CLI (default: 'gh')
+   */
+  ghPath?: string;
+}
+
+/**
+ * Native GitHub adapter using gh CLI
+ */
+export class GitHubAdapter implements GitProviderAdapter {
+  private repository: string;
+  private ghPath: string;
+  private connected = false;
+  private owner: string;
+  private repo: string;
+
+  constructor(options: GitHubAdapterOptions) {
+    this.repository = options.repository;
+    this.ghPath = options.ghPath ?? 'gh';
+
+    const [owner, repo] = this.repository.split('/');
+    if (!owner || !repo) {
+      throw new AdapterError(
+        `Invalid repository format: ${this.repository}. Expected owner/repo`,
+        'invalid_config',
+        this.getInfo()
+      );
+    }
+    this.owner = owner;
+    this.repo = repo;
+  }
+
+  /**
+   * Get adapter info
+   */
+  getInfo(): AdapterInfo {
+    return {
+      type: 'git',
+      provider: 'github',
+      implementation: 'native',
+      connected: this.connected,
+    };
+  }
+
+  /**
+   * Check if connected
+   */
+  isConnected(): boolean {
+    return this.connected;
+  }
+
+  /**
+   * Connect (verify gh CLI is available and authenticated)
+   */
+  async connect(): Promise<void> {
+    try {
+      // Check gh is installed and authenticated
+      await this.gh(['auth', 'status']);
+
+      // Verify we can access the repository
+      await this.gh(['repo', 'view', this.repository, '--json', 'name']);
+
+      this.connected = true;
+    } catch (error) {
+      throw new AdapterError(
+        `Failed to connect to GitHub: ${error instanceof Error ? error.message : String(error)}`,
+        'connection_failed',
+        this.getInfo(),
+        error instanceof Error ? error : undefined
+      );
+    }
+  }
+
+  /**
+   * Disconnect
+   */
+  async disconnect(): Promise<void> {
+    this.connected = false;
+  }
+
+  /**
+   * Get a pull request by number
+   */
+  async getPullRequest(idOrNumber: string | number): Promise<PullRequest> {
+    this.ensureConnected();
+
+    try {
+      const result = await this.gh([
+        'pr',
+        'view',
+        String(idOrNumber),
+        '-R',
+        this.repository,
+        '--json',
+        'number,title,body,state,author,headRefName,baseRefName,createdAt,updatedAt,mergedAt,url,reviewRequests',
+      ]);
+
+      const data = JSON.parse(result);
+      return this.mapPullRequest(data);
+    } catch (error) {
+      if (this.isNotFoundError(error)) {
+        throw new AdapterError(
+          `Pull request #${idOrNumber} not found`,
+          'not_found',
+          this.getInfo()
+        );
+      }
+      throw this.wrapError(error, `Failed to get pull request #${idOrNumber}`);
+    }
+  }
+
+  /**
+   * List pull requests
+   */
+  async listPullRequests(query?: PullRequestQuery): Promise<PullRequest[]> {
+    this.ensureConnected();
+
+    try {
+      const args = [
+        'pr',
+        'list',
+        '-R',
+        this.repository,
+        '--json',
+        'number,title,body,state,author,headRefName,baseRefName,createdAt,updatedAt,url',
+      ];
+
+      // Map status to gh CLI state
+      if (query?.status) {
+        const states = Array.isArray(query.status) ? query.status : [query.status];
+        const ghStates = states
+          .map((s) => this.mapStatusToGh(s))
+          .filter((s): s is string => s !== undefined);
+        if (ghStates.length > 0 && ghStates[0]) {
+          args.push('--state', ghStates[0]);
+        }
+      }
+
+      if (query?.author) {
+        args.push('--author', query.author);
+      }
+
+      if (query?.limit) {
+        args.push('--limit', String(query.limit));
+      }
+
+      const result = await this.gh(args);
+      const data = JSON.parse(result) as unknown[];
+
+      return data.map((pr) => this.mapPullRequest(pr as Record<string, unknown>));
+    } catch (error) {
+      throw this.wrapError(error, 'Failed to list pull requests');
+    }
+  }
+
+  /**
+   * Create a pull request
+   */
+  async createPullRequest(data: CreatePullRequestData): Promise<PullRequest> {
+    this.ensureConnected();
+
+    try {
+      const args = [
+        'pr',
+        'create',
+        '-R',
+        this.repository,
+        '--head',
+        data.source_branch,
+        '--base',
+        data.target_branch,
+        '--title',
+        data.title,
+      ];
+
+      if (data.description) {
+        args.push('--body', data.description);
+      }
+
+      if (data.draft) {
+        args.push('--draft');
+      }
+
+      if (data.reviewers && data.reviewers.length > 0) {
+        args.push('--reviewer', data.reviewers.join(','));
+      }
+
+      // Create and get the PR details
+      const createResult = await this.gh(args);
+
+      // Parse the URL from the output to get the PR number
+      const urlMatch = createResult.match(/https:\/\/github\.com\/[^/]+\/[^/]+\/pull\/(\d+)/);
+      if (urlMatch?.[1]) {
+        return this.getPullRequest(parseInt(urlMatch[1], 10));
+      }
+
+      // Fallback: list to find the just-created PR
+      const prs = await this.listPullRequests({ limit: 1 });
+      const firstPr = prs[0];
+      if (firstPr) {
+        return firstPr;
+      }
+
+      throw new Error('Failed to retrieve created pull request');
+    } catch (error) {
+      throw this.wrapError(error, 'Failed to create pull request');
+    }
+  }
+
+  /**
+   * Update a pull request
+   */
+  async updatePullRequest(
+    idOrNumber: string | number,
+    data: Partial<CreatePullRequestData>
+  ): Promise<PullRequest> {
+    this.ensureConnected();
+
+    try {
+      const args = ['pr', 'edit', String(idOrNumber), '-R', this.repository];
+
+      if (data.title) {
+        args.push('--title', data.title);
+      }
+
+      if (data.description !== undefined) {
+        args.push('--body', data.description);
+      }
+
+      if (data.target_branch) {
+        args.push('--base', data.target_branch);
+      }
+
+      if (data.reviewers && data.reviewers.length > 0) {
+        args.push('--add-reviewer', data.reviewers.join(','));
+      }
+
+      await this.gh(args);
+
+      return this.getPullRequest(idOrNumber);
+    } catch (error) {
+      throw this.wrapError(error, `Failed to update pull request #${idOrNumber}`);
+    }
+  }
+
+  /**
+   * Merge a pull request
+   */
+  async mergePullRequest(
+    idOrNumber: string | number,
+    options?: { method?: 'merge' | 'squash' | 'rebase'; message?: string }
+  ): Promise<void> {
+    this.ensureConnected();
+
+    try {
+      const args = ['pr', 'merge', String(idOrNumber), '-R', this.repository];
+
+      const method = options?.method ?? 'merge';
+      args.push(`--${method}`);
+
+      if (options?.message) {
+        args.push('--body', options.message);
+      }
+
+      // Auto-confirm the merge
+      args.push('--delete-branch=false');
+
+      await this.gh(args);
+    } catch (error) {
+      throw this.wrapError(error, `Failed to merge pull request #${idOrNumber}`);
+    }
+  }
+
+  /**
+   * Close a pull request
+   */
+  async closePullRequest(idOrNumber: string | number): Promise<void> {
+    this.ensureConnected();
+
+    try {
+      await this.gh(['pr', 'close', String(idOrNumber), '-R', this.repository]);
+    } catch (error) {
+      throw this.wrapError(error, `Failed to close pull request #${idOrNumber}`);
+    }
+  }
+
+  /**
+   * Add a review to a pull request
+   */
+  async addReview(idOrNumber: string | number, review: CreateReviewData): Promise<Review> {
+    this.ensureConnected();
+
+    try {
+      const args = ['pr', 'review', String(idOrNumber), '-R', this.repository];
+
+      // Map decision to gh CLI flag
+      switch (review.decision) {
+        case 'approve':
+          args.push('--approve');
+          break;
+        case 'request_changes':
+          args.push('--request-changes');
+          break;
+        case 'comment':
+          args.push('--comment');
+          break;
+      }
+
+      if (review.body) {
+        args.push('--body', review.body);
+      }
+
+      await this.gh(args);
+
+      // Return the review data (gh doesn't return review ID)
+      const reviewResult: Review = {
+        id: `review-${Date.now()}`,
+        pull_request_id: String(idOrNumber),
+        author: 'current-user',
+        decision: review.decision,
+        body: review.body ?? '',
+        created_at: new Date().toISOString(),
+      };
+      return reviewResult;
+    } catch (error) {
+      throw this.wrapError(error, `Failed to add review to pull request #${idOrNumber}`);
+    }
+  }
+
+  /**
+   * Get reviews for a pull request
+   */
+  async getReviews(idOrNumber: string | number): Promise<Review[]> {
+    this.ensureConnected();
+
+    try {
+      const result = await this.gh([
+        'pr',
+        'view',
+        String(idOrNumber),
+        '-R',
+        this.repository,
+        '--json',
+        'reviews',
+      ]);
+
+      const data = JSON.parse(result);
+      const reviews = data.reviews || [];
+
+      return reviews.map((r: Record<string, unknown>) => ({
+        id: String(r.id || `review-${Date.now()}`),
+        pull_request_id: String(idOrNumber),
+        author: (r.author as { login?: string })?.login || 'unknown',
+        decision: this.mapGhStateToDecision(String(r.state || 'COMMENTED')),
+        body: String(r.body || ''),
+        created_at: String(r.submittedAt || new Date().toISOString()),
+      }));
+    } catch (error) {
+      throw this.wrapError(error, `Failed to get reviews for pull request #${idOrNumber}`);
+    }
+  }
+
+  /**
+   * Request reviewers for a pull request
+   */
+  async requestReviewers(idOrNumber: string | number, reviewers: string[]): Promise<void> {
+    this.ensureConnected();
+
+    try {
+      await this.gh([
+        'pr',
+        'edit',
+        String(idOrNumber),
+        '-R',
+        this.repository,
+        '--add-reviewer',
+        reviewers.join(','),
+      ]);
+    } catch (error) {
+      throw this.wrapError(error, `Failed to request reviewers for pull request #${idOrNumber}`);
+    }
+  }
+
+  /**
+   * Add a comment to a pull request
+   */
+  async addPullRequestComment(idOrNumber: string | number, comment: string): Promise<void> {
+    this.ensureConnected();
+
+    try {
+      await this.gh([
+        'pr',
+        'comment',
+        String(idOrNumber),
+        '-R',
+        this.repository,
+        '--body',
+        comment,
+      ]);
+    } catch (error) {
+      throw this.wrapError(error, `Failed to add comment to pull request #${idOrNumber}`);
+    }
+  }
+
+  /**
+   * Get the diff for a pull request
+   */
+  async getPullRequestDiff(idOrNumber: string | number): Promise<string> {
+    this.ensureConnected();
+
+    try {
+      return await this.gh(['pr', 'diff', String(idOrNumber), '-R', this.repository]);
+    } catch (error) {
+      throw this.wrapError(error, `Failed to get diff for pull request #${idOrNumber}`);
+    }
+  }
+
+  /**
+   * Get files changed in a pull request
+   */
+  async getPullRequestFiles(idOrNumber: string | number): Promise<string[]> {
+    this.ensureConnected();
+
+    try {
+      const result = await this.gh([
+        'pr',
+        'view',
+        String(idOrNumber),
+        '-R',
+        this.repository,
+        '--json',
+        'files',
+      ]);
+
+      const data = JSON.parse(result);
+      const files = data.files || [];
+
+      return files.map((f: { path?: string }) => f.path || '');
+    } catch (error) {
+      throw this.wrapError(error, `Failed to get files for pull request #${idOrNumber}`);
+    }
+  }
+
+  /**
+   * Execute gh CLI command
+   */
+  private async gh(args: string[]): Promise<string> {
+    try {
+      const { stdout } = await execFileAsync(this.ghPath, args, {
+        maxBuffer: 10 * 1024 * 1024, // 10MB
+      });
+      return stdout;
+    } catch (error) {
+      const execError = error as { stderr?: string; message?: string };
+      throw new Error(execError.stderr || execError.message || 'Unknown gh error');
+    }
+  }
+
+  /**
+   * Ensure adapter is connected
+   */
+  private ensureConnected(): void {
+    if (!this.connected) {
+      throw new AdapterError(
+        'GitHub adapter is not connected. Call connect() first.',
+        'not_connected',
+        this.getInfo()
+      );
+    }
+  }
+
+  /**
+   * Map gh PR data to PullRequest type
+   */
+  private mapPullRequest(data: Record<string, unknown>): PullRequest {
+    const pr: PullRequest = {
+      id: String(data.number),
+      number: Number(data.number),
+      title: String(data.title || ''),
+      source_branch: String(data.headRefName || ''),
+      target_branch: String(data.baseRefName || ''),
+      status: this.mapGhStateToPrStatus(String(data.state || 'OPEN')),
+    };
+
+    if (data.body) {
+      pr.description = String(data.body);
+    }
+
+    if (data.author && typeof data.author === 'object') {
+      const login = (data.author as { login?: string }).login;
+      if (login) {
+        pr.author = login;
+      }
+    }
+
+    if (data.createdAt) {
+      pr.created_at = String(data.createdAt);
+    }
+
+    if (data.updatedAt) {
+      pr.updated_at = String(data.updatedAt);
+    }
+
+    if (data.mergedAt) {
+      pr.merged_at = String(data.mergedAt);
+    }
+
+    if (data.url) {
+      pr.url = String(data.url);
+    }
+
+    if (data.reviewRequests && Array.isArray(data.reviewRequests)) {
+      pr.reviewers = data.reviewRequests
+        .map((r: { login?: string }) => r.login || '')
+        .filter(Boolean);
+    }
+
+    return pr;
+  }
+
+  /**
+   * Map gh state to PullRequestStatus
+   */
+  private mapGhStateToPrStatus(state: string): PullRequestStatus {
+    switch (state.toUpperCase()) {
+      case 'OPEN':
+        return 'open';
+      case 'CLOSED':
+        return 'closed';
+      case 'MERGED':
+        return 'merged';
+      default:
+        return 'open';
+    }
+  }
+
+  /**
+   * Map PullRequestStatus to gh CLI state
+   */
+  private mapStatusToGh(status: PullRequestStatus): string | undefined {
+    switch (status) {
+      case 'open':
+        return 'open';
+      case 'closed':
+        return 'closed';
+      case 'merged':
+        return 'merged';
+      default:
+        return undefined;
+    }
+  }
+
+  /**
+   * Map gh review state to ReviewDecision
+   */
+  private mapGhStateToDecision(state: string): ReviewDecision {
+    switch (state.toUpperCase()) {
+      case 'APPROVED':
+        return 'approve';
+      case 'CHANGES_REQUESTED':
+        return 'request_changes';
+      case 'COMMENTED':
+      default:
+        return 'comment';
+    }
+  }
+
+  /**
+   * Check if error is a not found error
+   */
+  private isNotFoundError(error: unknown): boolean {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.includes('Could not resolve') || message.includes('not found');
+  }
+
+  /**
+   * Wrap error in AdapterError
+   */
+  private wrapError(error: unknown, message: string): AdapterError {
+    return new AdapterError(
+      `${message}: ${error instanceof Error ? error.message : String(error)}`,
+      'operation_failed',
+      this.getInfo(),
+      error instanceof Error ? error : undefined
+    );
+  }
+}
+
+/**
+ * Create a GitHub adapter
+ */
+export function createGitHubAdapter(options: GitHubAdapterOptions): GitHubAdapter {
+  return new GitHubAdapter(options);
+}

package/src/adapters/native/index.ts

@@ -0,0 +1,22 @@
+/**
+ * Native Adapters
+ *
+ * Native implementations of adapter interfaces that don't require MCP servers.
+ * These serve as fallbacks when MCP servers are unavailable.
+ */
+
+// Filesystem adapter
+export type { FilesystemAdapterOptions } from './filesystem.js';
+export { FilesystemAdapter, createFilesystemAdapter } from './filesystem.js';
+
+// GitHub adapter
+export type { GitHubAdapterOptions } from './github.js';
+export { GitHubAdapter, createGitHubAdapter } from './github.js';
+
+// Selector
+export type { NativeAdapterSelectorOptions, NativeAdapterAvailability } from './selector.js';
+export {
+  registerNativeAdapters,
+  checkNativeAdapterAvailability,
+  parseGitHubRemote,
+} from './selector.js';