claude-flow-novice 2.0.3 → 2.0.4

package/dist/src/cli/simple-commands/github/github-api.js

@@ -4,621 +4,582 @@
  * Provides authentication, rate limiting, and API wrappers for GitHub workflow commands
  *
  * Enhanced with GitHub CLI Safety Wrapper for secure command execution
- */
-
-import { printSuccess, printError, printWarning, printInfo } from '../utils.js';
-import { githubCli, GitHubCliSafe } from '../../utils/github-cli-safety-wrapper.js';
-
+ */ import { printSuccess, printError, printWarning, printInfo } from "../utils.js";
+import { GitHubCliSafe } from "../../utils/github-cli-safety-wrapper.js";
 // GitHub API Configuration
 const GITHUB_API_BASE = 'https://api.github.com';
 const GITHUB_RATE_LIMIT = 5000; // API calls per hour
 const GITHUB_WEBHOOK_SECRET = process.env.GITHUB_WEBHOOK_SECRET;
-
-class GitHubAPIClient {
-  constructor(token = null) {
-    this.token = token || process.env.GITHUB_TOKEN;
-    this.rateLimitRemaining = GITHUB_RATE_LIMIT;
-    this.rateLimitResetTime = null;
-    this.lastRequestTime = 0;
-    this.requestQueue = [];
-    this.isProcessingQueue = false;
-
-    // Initialize GitHub CLI safety wrapper
-    this.cliSafe = new GitHubCliSafe({
-      timeout: 60000, // 1 minute timeout for CLI operations
-      maxRetries: 3,
-      enableRateLimit: true,
-      enableLogging: false, // Can be enabled for debugging
-    });
-  }
-
-  /**
+let GitHubAPIClient = class GitHubAPIClient {
+    /**
    * Authentication Methods
-   */
-  async authenticate(token = null) {
-    if (token) {
-      this.token = token;
-    }
-
-    if (!this.token) {
-      printError('GitHub token not found. Set GITHUB_TOKEN environment variable or provide token.');
-      return false;
-    }
-
-    try {
-      const response = await this.request('/user');
-      if (response.success) {
-        printSuccess(`Authenticated as ${response.data.login}`);
-        return true;
-      }
-      return false;
-    } catch (error) {
-      printError(`Authentication failed: ${error.message}`);
-      return false;
-    }
-  }
-
-  /**
+   */ async authenticate(token = null) {
+        if (token) {
+            this.token = token;
+        }
+        if (!this.token) {
+            printError('GitHub token not found. Set GITHUB_TOKEN environment variable or provide token.');
+            return false;
+        }
+        try {
+            const response = await this.request('/user');
+            if (response.success) {
+                printSuccess(`Authenticated as ${response.data.login}`);
+                return true;
+            }
+            return false;
+        } catch (error) {
+            printError(`Authentication failed: ${error.message}`);
+            return false;
+        }
+    }
+    /**
    * Rate Limiting Management
-   */
-  async checkRateLimit() {
-    if (this.rateLimitRemaining <= 1) {
-      const resetTime = new Date(this.rateLimitResetTime);
-      const now = new Date();
-      const waitTime = resetTime.getTime() - now.getTime();
-
-      if (waitTime > 0) {
-        printWarning(`Rate limit exceeded. Waiting ${Math.ceil(waitTime / 1000)}s...`);
-        await this.sleep(waitTime);
-      }
-    }
-  }
-
-  updateRateLimitInfo(headers) {
-    this.rateLimitRemaining = parseInt(headers['x-ratelimit-remaining'] || '0');
-    this.rateLimitResetTime = new Date((parseInt(headers['x-ratelimit-reset']) || 0) * 1000);
-  }
-
-  /**
+   */ async checkRateLimit() {
+        if (this.rateLimitRemaining <= 1) {
+            const resetTime = new Date(this.rateLimitResetTime);
+            const now = new Date();
+            const waitTime = resetTime.getTime() - now.getTime();
+            if (waitTime > 0) {
+                printWarning(`Rate limit exceeded. Waiting ${Math.ceil(waitTime / 1000)}s...`);
+                await this.sleep(waitTime);
+            }
+        }
+    }
+    updateRateLimitInfo(headers) {
+        this.rateLimitRemaining = parseInt(headers['x-ratelimit-remaining'] || '0');
+        this.rateLimitResetTime = new Date((parseInt(headers['x-ratelimit-reset']) || 0) * 1000);
+    }
+    /**
    * Core API Request Method
-   */
-  async request(endpoint, options = {}) {
-    await this.checkRateLimit();
-
-    const url = endpoint.startsWith('http') ? endpoint : `${GITHUB_API_BASE}${endpoint}`;
-    const headers = {
-      Authorization: `token ${this.token}`,
-      Accept: 'application/vnd.github.v3+json',
-      'User-Agent': 'Claude-Flow-GitHub-Integration',
-      ...options.headers,
-    };
-
-    const requestOptions = {
-      method: options.method || 'GET',
-      headers,
-      ...options,
-    };
-
-    if (options.body) {
-      requestOptions.body = JSON.stringify(options.body);
-      headers['Content-Type'] = 'application/json';
-    }
-
-    try {
-      const response = await fetch(url, requestOptions);
-      this.updateRateLimitInfo(response.headers);
-
-      const data = await response.json();
-
-      if (!response.ok) {
-        throw new Error(`GitHub API error: ${data.message || response.statusText}`);
-      }
-
-      return {
-        success: true,
-        data,
-        headers: response.headers,
-        status: response.status,
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error.message,
-        status: error.status || 500,
-      };
-    }
-  }
-
-  /**
+   */ async request(endpoint, options = {}) {
+        await this.checkRateLimit();
+        const url = endpoint.startsWith('http') ? endpoint : `${GITHUB_API_BASE}${endpoint}`;
+        const headers = {
+            Authorization: `token ${this.token}`,
+            Accept: 'application/vnd.github.v3+json',
+            'User-Agent': 'Claude-Flow-GitHub-Integration',
+            ...options.headers
+        };
+        const requestOptions = {
+            method: options.method || 'GET',
+            headers,
+            ...options
+        };
+        if (options.body) {
+            requestOptions.body = JSON.stringify(options.body);
+            headers['Content-Type'] = 'application/json';
+        }
+        try {
+            const response = await fetch(url, requestOptions);
+            this.updateRateLimitInfo(response.headers);
+            const data = await response.json();
+            if (!response.ok) {
+                throw new Error(`GitHub API error: ${data.message || response.statusText}`);
+            }
+            return {
+                success: true,
+                data,
+                headers: response.headers,
+                status: response.status
+            };
+        } catch (error) {
+            return {
+                success: false,
+                error: error.message,
+                status: error.status || 500
+            };
+        }
+    }
+    /**
    * Repository Operations
-   */
-  async getRepository(owner, repo) {
-    return await this.request(`/repos/${owner}/${repo}`);
-  }
-
-  async listRepositories(options = {}) {
-    const params = new URLSearchParams({
-      sort: options.sort || 'updated',
-      direction: options.direction || 'desc',
-      per_page: options.perPage || 30,
-      page: options.page || 1,
-    });
-
-    return await this.request(`/user/repos?${params}`);
-  }
-
-  async createRepository(repoData) {
-    return await this.request('/user/repos', {
-      method: 'POST',
-      body: repoData,
-    });
-  }
-
-  /**
+   */ async getRepository(owner, repo) {
+        return await this.request(`/repos/${owner}/${repo}`);
+    }
+    async listRepositories(options = {}) {
+        const params = new URLSearchParams({
+            sort: options.sort || 'updated',
+            direction: options.direction || 'desc',
+            per_page: options.perPage || 30,
+            page: options.page || 1
+        });
+        return await this.request(`/user/repos?${params}`);
+    }
+    async createRepository(repoData) {
+        return await this.request('/user/repos', {
+            method: 'POST',
+            body: repoData
+        });
+    }
+    /**
    * Pull Request Operations
-   */
-  async listPullRequests(owner, repo, options = {}) {
-    const params = new URLSearchParams({
-      state: options.state || 'open',
-      sort: options.sort || 'created',
-      direction: options.direction || 'desc',
-      per_page: options.perPage || 30,
-      page: options.page || 1,
-    });
-
-    return await this.request(`/repos/${owner}/${repo}/pulls?${params}`);
-  }
-
-  async createPullRequest(owner, repo, prData) {
-    return await this.request(`/repos/${owner}/${repo}/pulls`, {
-      method: 'POST',
-      body: prData,
-    });
-  }
-
-  async updatePullRequest(owner, repo, prNumber, prData) {
-    return await this.request(`/repos/${owner}/${repo}/pulls/${prNumber}`, {
-      method: 'PATCH',
-      body: prData,
-    });
-  }
-
-  async mergePullRequest(owner, repo, prNumber, mergeData) {
-    return await this.request(`/repos/${owner}/${repo}/pulls/${prNumber}/merge`, {
-      method: 'PUT',
-      body: mergeData,
-    });
-  }
-
-  async requestPullRequestReview(owner, repo, prNumber, reviewData) {
-    return await this.request(`/repos/${owner}/${repo}/pulls/${prNumber}/requested_reviewers`, {
-      method: 'POST',
-      body: reviewData,
-    });
-  }
-
-  /**
+   */ async listPullRequests(owner, repo, options = {}) {
+        const params = new URLSearchParams({
+            state: options.state || 'open',
+            sort: options.sort || 'created',
+            direction: options.direction || 'desc',
+            per_page: options.perPage || 30,
+            page: options.page || 1
+        });
+        return await this.request(`/repos/${owner}/${repo}/pulls?${params}`);
+    }
+    async createPullRequest(owner, repo, prData) {
+        return await this.request(`/repos/${owner}/${repo}/pulls`, {
+            method: 'POST',
+            body: prData
+        });
+    }
+    async updatePullRequest(owner, repo, prNumber, prData) {
+        return await this.request(`/repos/${owner}/${repo}/pulls/${prNumber}`, {
+            method: 'PATCH',
+            body: prData
+        });
+    }
+    async mergePullRequest(owner, repo, prNumber, mergeData) {
+        return await this.request(`/repos/${owner}/${repo}/pulls/${prNumber}/merge`, {
+            method: 'PUT',
+            body: mergeData
+        });
+    }
+    async requestPullRequestReview(owner, repo, prNumber, reviewData) {
+        return await this.request(`/repos/${owner}/${repo}/pulls/${prNumber}/requested_reviewers`, {
+            method: 'POST',
+            body: reviewData
+        });
+    }
+    /**
    * Issue Operations
-   */
-  async listIssues(owner, repo, options = {}) {
-    const params = new URLSearchParams({
-      state: options.state || 'open',
-      sort: options.sort || 'created',
-      direction: options.direction || 'desc',
-      per_page: options.perPage || 30,
-      page: options.page || 1,
-    });
-
-    if (options.labels) {
-      params.append('labels', options.labels);
-    }
-
-    return await this.request(`/repos/${owner}/${repo}/issues?${params}`);
-  }
-
-  async createIssue(owner, repo, issueData) {
-    return await this.request(`/repos/${owner}/${repo}/issues`, {
-      method: 'POST',
-      body: issueData,
-    });
-  }
-
-  async updateIssue(owner, repo, issueNumber, issueData) {
-    return await this.request(`/repos/${owner}/${repo}/issues/${issueNumber}`, {
-      method: 'PATCH',
-      body: issueData,
-    });
-  }
-
-  async addIssueLabels(owner, repo, issueNumber, labels) {
-    return await this.request(`/repos/${owner}/${repo}/issues/${issueNumber}/labels`, {
-      method: 'POST',
-      body: { labels },
-    });
-  }
-
-  async assignIssue(owner, repo, issueNumber, assignees) {
-    return await this.request(`/repos/${owner}/${repo}/issues/${issueNumber}/assignees`, {
-      method: 'POST',
-      body: { assignees },
-    });
-  }
-
-  /**
+   */ async listIssues(owner, repo, options = {}) {
+        const params = new URLSearchParams({
+            state: options.state || 'open',
+            sort: options.sort || 'created',
+            direction: options.direction || 'desc',
+            per_page: options.perPage || 30,
+            page: options.page || 1
+        });
+        if (options.labels) {
+            params.append('labels', options.labels);
+        }
+        return await this.request(`/repos/${owner}/${repo}/issues?${params}`);
+    }
+    async createIssue(owner, repo, issueData) {
+        return await this.request(`/repos/${owner}/${repo}/issues`, {
+            method: 'POST',
+            body: issueData
+        });
+    }
+    async updateIssue(owner, repo, issueNumber, issueData) {
+        return await this.request(`/repos/${owner}/${repo}/issues/${issueNumber}`, {
+            method: 'PATCH',
+            body: issueData
+        });
+    }
+    async addIssueLabels(owner, repo, issueNumber, labels) {
+        return await this.request(`/repos/${owner}/${repo}/issues/${issueNumber}/labels`, {
+            method: 'POST',
+            body: {
+                labels
+            }
+        });
+    }
+    async assignIssue(owner, repo, issueNumber, assignees) {
+        return await this.request(`/repos/${owner}/${repo}/issues/${issueNumber}/assignees`, {
+            method: 'POST',
+            body: {
+                assignees
+            }
+        });
+    }
+    /**
    * Release Operations
-   */
-  async listReleases(owner, repo, options = {}) {
-    const params = new URLSearchParams({
-      per_page: options.perPage || 30,
-      page: options.page || 1,
-    });
-
-    return await this.request(`/repos/${owner}/${repo}/releases?${params}`);
-  }
-
-  async createRelease(owner, repo, releaseData) {
-    return await this.request(`/repos/${owner}/${repo}/releases`, {
-      method: 'POST',
-      body: releaseData,
-    });
-  }
-
-  async updateRelease(owner, repo, releaseId, releaseData) {
-    return await this.request(`/repos/${owner}/${repo}/releases/${releaseId}`, {
-      method: 'PATCH',
-      body: releaseData,
-    });
-  }
-
-  async deleteRelease(owner, repo, releaseId) {
-    return await this.request(`/repos/${owner}/${repo}/releases/${releaseId}`, {
-      method: 'DELETE',
-    });
-  }
-
-  /**
+   */ async listReleases(owner, repo, options = {}) {
+        const params = new URLSearchParams({
+            per_page: options.perPage || 30,
+            page: options.page || 1
+        });
+        return await this.request(`/repos/${owner}/${repo}/releases?${params}`);
+    }
+    async createRelease(owner, repo, releaseData) {
+        return await this.request(`/repos/${owner}/${repo}/releases`, {
+            method: 'POST',
+            body: releaseData
+        });
+    }
+    async updateRelease(owner, repo, releaseId, releaseData) {
+        return await this.request(`/repos/${owner}/${repo}/releases/${releaseId}`, {
+            method: 'PATCH',
+            body: releaseData
+        });
+    }
+    async deleteRelease(owner, repo, releaseId) {
+        return await this.request(`/repos/${owner}/${repo}/releases/${releaseId}`, {
+            method: 'DELETE'
+        });
+    }
+    /**
    * Workflow Operations
-   */
-  async listWorkflows(owner, repo) {
-    return await this.request(`/repos/${owner}/${repo}/actions/workflows`);
-  }
-
-  async triggerWorkflow(owner, repo, workflowId, ref = 'main', inputs = {}) {
-    return await this.request(
-      `/repos/${owner}/${repo}/actions/workflows/${workflowId}/dispatches`,
-      {
-        method: 'POST',
-        body: { ref, inputs },
-      },
-    );
-  }
-
-  async listWorkflowRuns(owner, repo, options = {}) {
-    const params = new URLSearchParams({
-      per_page: options.perPage || 30,
-      page: options.page || 1,
-    });
-
-    if (options.status) {
-      params.append('status', options.status);
-    }
-
-    return await this.request(`/repos/${owner}/${repo}/actions/runs?${params}`);
-  }
-
-  /**
+   */ async listWorkflows(owner, repo) {
+        return await this.request(`/repos/${owner}/${repo}/actions/workflows`);
+    }
+    async triggerWorkflow(owner, repo, workflowId, ref = 'main', inputs = {}) {
+        return await this.request(`/repos/${owner}/${repo}/actions/workflows/${workflowId}/dispatches`, {
+            method: 'POST',
+            body: {
+                ref,
+                inputs
+            }
+        });
+    }
+    async listWorkflowRuns(owner, repo, options = {}) {
+        const params = new URLSearchParams({
+            per_page: options.perPage || 30,
+            page: options.page || 1
+        });
+        if (options.status) {
+            params.append('status', options.status);
+        }
+        return await this.request(`/repos/${owner}/${repo}/actions/runs?${params}`);
+    }
+    /**
    * Branch Operations
-   */
-  async listBranches(owner, repo) {
-    return await this.request(`/repos/${owner}/${repo}/branches`);
-  }
-
-  async createBranch(owner, repo, branchName, sha) {
-    return await this.request(`/repos/${owner}/${repo}/git/refs`, {
-      method: 'POST',
-      body: {
-        ref: `refs/heads/${branchName}`,
-        sha,
-      },
-    });
-  }
-
-  async getBranchProtection(owner, repo, branch) {
-    return await this.request(`/repos/${owner}/${repo}/branches/${branch}/protection`);
-  }
-
-  async updateBranchProtection(owner, repo, branch, protection) {
-    return await this.request(`/repos/${owner}/${repo}/branches/${branch}/protection`, {
-      method: 'PUT',
-      body: protection,
-    });
-  }
-
-  /**
+   */ async listBranches(owner, repo) {
+        return await this.request(`/repos/${owner}/${repo}/branches`);
+    }
+    async createBranch(owner, repo, branchName, sha) {
+        return await this.request(`/repos/${owner}/${repo}/git/refs`, {
+            method: 'POST',
+            body: {
+                ref: `refs/heads/${branchName}`,
+                sha
+            }
+        });
+    }
+    async getBranchProtection(owner, repo, branch) {
+        return await this.request(`/repos/${owner}/${repo}/branches/${branch}/protection`);
+    }
+    async updateBranchProtection(owner, repo, branch, protection) {
+        return await this.request(`/repos/${owner}/${repo}/branches/${branch}/protection`, {
+            method: 'PUT',
+            body: protection
+        });
+    }
+    /**
    * Webhook Operations
-   */
-  async listWebhooks(owner, repo) {
-    return await this.request(`/repos/${owner}/${repo}/hooks`);
-  }
-
-  async createWebhook(owner, repo, webhookData) {
-    return await this.request(`/repos/${owner}/${repo}/hooks`, {
-      method: 'POST',
-      body: webhookData,
-    });
-  }
-
-  async updateWebhook(owner, repo, hookId, webhookData) {
-    return await this.request(`/repos/${owner}/${repo}/hooks/${hookId}`, {
-      method: 'PATCH',
-      body: webhookData,
-    });
-  }
-
-  async deleteWebhook(owner, repo, hookId) {
-    return await this.request(`/repos/${owner}/${repo}/hooks/${hookId}`, {
-      method: 'DELETE',
-    });
-  }
-
-  /**
+   */ async listWebhooks(owner, repo) {
+        return await this.request(`/repos/${owner}/${repo}/hooks`);
+    }
+    async createWebhook(owner, repo, webhookData) {
+        return await this.request(`/repos/${owner}/${repo}/hooks`, {
+            method: 'POST',
+            body: webhookData
+        });
+    }
+    async updateWebhook(owner, repo, hookId, webhookData) {
+        return await this.request(`/repos/${owner}/${repo}/hooks/${hookId}`, {
+            method: 'PATCH',
+            body: webhookData
+        });
+    }
+    async deleteWebhook(owner, repo, hookId) {
+        return await this.request(`/repos/${owner}/${repo}/hooks/${hookId}`, {
+            method: 'DELETE'
+        });
+    }
+    /**
    * Event Processing
-   */
-  async processWebhookEvent(event, signature, payload) {
-    if (!this.verifyWebhookSignature(signature, payload)) {
-      throw new Error('Invalid webhook signature');
-    }
-
-    const eventData = JSON.parse(payload);
-
-    switch (event) {
-      case 'push':
-        return this.handlePushEvent(eventData);
-      case 'pull_request':
-        return this.handlePullRequestEvent(eventData);
-      case 'issues':
-        return this.handleIssuesEvent(eventData);
-      case 'release':
-        return this.handleReleaseEvent(eventData);
-      case 'workflow_run':
-        return this.handleWorkflowRunEvent(eventData);
-      default:
-        printInfo(`Unhandled event type: ${event}`);
-        return { handled: false, event };
-    }
-  }
-
-  verifyWebhookSignature(signature, payload) {
-    if (!GITHUB_WEBHOOK_SECRET) {
-      printWarning('GITHUB_WEBHOOK_SECRET not set. Skipping signature verification.');
-      return true;
-    }
-
-    const crypto = require('crypto');
-    const hmac = crypto.createHmac('sha256', GITHUB_WEBHOOK_SECRET);
-    hmac.update(payload);
-    const expectedSignature = `sha256=${hmac.digest('hex')}`;
-
-    return crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expectedSignature));
-  }
-
-  /**
+   */ async processWebhookEvent(event, signature, payload) {
+        if (!this.verifyWebhookSignature(signature, payload)) {
+            throw new Error('Invalid webhook signature');
+        }
+        const eventData = JSON.parse(payload);
+        switch(event){
+            case 'push':
+                return this.handlePushEvent(eventData);
+            case 'pull_request':
+                return this.handlePullRequestEvent(eventData);
+            case 'issues':
+                return this.handleIssuesEvent(eventData);
+            case 'release':
+                return this.handleReleaseEvent(eventData);
+            case 'workflow_run':
+                return this.handleWorkflowRunEvent(eventData);
+            default:
+                printInfo(`Unhandled event type: ${event}`);
+                return {
+                    handled: false,
+                    event
+                };
+        }
+    }
+    verifyWebhookSignature(signature, payload) {
+        if (!GITHUB_WEBHOOK_SECRET) {
+            printWarning('GITHUB_WEBHOOK_SECRET not set. Skipping signature verification.');
+            return true;
+        }
+        const crypto = require('crypto');
+        const hmac = crypto.createHmac('sha256', GITHUB_WEBHOOK_SECRET);
+        hmac.update(payload);
+        const expectedSignature = `sha256=${hmac.digest('hex')}`;
+        return crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expectedSignature));
+    }
+    /**
    * Event Handlers
-   */
-  async handlePushEvent(eventData) {
-    printInfo(`Push event: ${eventData.commits.length} commits to ${eventData.ref}`);
-    return { handled: true, event: 'push', data: eventData };
-  }
-
-  async handlePullRequestEvent(eventData) {
-    const action = eventData.action;
-    const pr = eventData.pull_request;
-    printInfo(`Pull request ${action}: #${pr.number} - ${pr.title}`);
-    return { handled: true, event: 'pull_request', action, data: eventData };
-  }
-
-  async handleIssuesEvent(eventData) {
-    const action = eventData.action;
-    const issue = eventData.issue;
-    printInfo(`Issue ${action}: #${issue.number} - ${issue.title}`);
-    return { handled: true, event: 'issues', action, data: eventData };
-  }
-
-  async handleReleaseEvent(eventData) {
-    const action = eventData.action;
-    const release = eventData.release;
-    printInfo(`Release ${action}: ${release.tag_name} - ${release.name}`);
-    return { handled: true, event: 'release', action, data: eventData };
-  }
-
-  async handleWorkflowRunEvent(eventData) {
-    const action = eventData.action;
-    const workflowRun = eventData.workflow_run;
-    printInfo(`Workflow run ${action}: ${workflowRun.name} - ${workflowRun.conclusion}`);
-    return { handled: true, event: 'workflow_run', action, data: eventData };
-  }
-
-  /**
+   */ async handlePushEvent(eventData) {
+        printInfo(`Push event: ${eventData.commits.length} commits to ${eventData.ref}`);
+        return {
+            handled: true,
+            event: 'push',
+            data: eventData
+        };
+    }
+    async handlePullRequestEvent(eventData) {
+        const action = eventData.action;
+        const pr = eventData.pull_request;
+        printInfo(`Pull request ${action}: #${pr.number} - ${pr.title}`);
+        return {
+            handled: true,
+            event: 'pull_request',
+            action,
+            data: eventData
+        };
+    }
+    async handleIssuesEvent(eventData) {
+        const action = eventData.action;
+        const issue = eventData.issue;
+        printInfo(`Issue ${action}: #${issue.number} - ${issue.title}`);
+        return {
+            handled: true,
+            event: 'issues',
+            action,
+            data: eventData
+        };
+    }
+    async handleReleaseEvent(eventData) {
+        const action = eventData.action;
+        const release = eventData.release;
+        printInfo(`Release ${action}: ${release.tag_name} - ${release.name}`);
+        return {
+            handled: true,
+            event: 'release',
+            action,
+            data: eventData
+        };
+    }
+    async handleWorkflowRunEvent(eventData) {
+        const action = eventData.action;
+        const workflowRun = eventData.workflow_run;
+        printInfo(`Workflow run ${action}: ${workflowRun.name} - ${workflowRun.conclusion}`);
+        return {
+            handled: true,
+            event: 'workflow_run',
+            action,
+            data: eventData
+        };
+    }
+    /**
    * Utility Methods
-   */
-  async sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-
-  parseRepository(repoString) {
-    const match = repoString.match(/^([^/]+)\/([^/]+)$/);
-    if (!match) {
-      throw new Error('Invalid repository format. Use: owner/repo');
-    }
-    return { owner: match[1], repo: match[2] };
-  }
-
-  formatDate(dateString) {
-    return new Date(dateString).toLocaleString();
-  }
-
-  formatFileSize(bytes) {
-    const units = ['B', 'KB', 'MB', 'GB'];
-    let size = bytes;
-    let unitIndex = 0;
-
-    while (size >= 1024 && unitIndex < units.length - 1) {
-      size /= 1024;
-      unitIndex++;
-    }
-
-    return `${size.toFixed(2)} ${units[unitIndex]}`;
-  }
-
-  /**
+   */ async sleep(ms) {
+        return new Promise((resolve)=>setTimeout(resolve, ms));
+    }
+    parseRepository(repoString) {
+        const match = repoString.match(/^([^/]+)\/([^/]+)$/);
+        if (!match) {
+            throw new Error('Invalid repository format. Use: owner/repo');
+        }
+        return {
+            owner: match[1],
+            repo: match[2]
+        };
+    }
+    formatDate(dateString) {
+        return new Date(dateString).toLocaleString();
+    }
+    formatFileSize(bytes) {
+        const units = [
+            'B',
+            'KB',
+            'MB',
+            'GB'
+        ];
+        let size = bytes;
+        let unitIndex = 0;
+        while(size >= 1024 && unitIndex < units.length - 1){
+            size /= 1024;
+            unitIndex++;
+        }
+        return `${size.toFixed(2)} ${units[unitIndex]}`;
+    }
+    /**
    * Safe GitHub CLI Methods
    * These methods use the GitHubCliSafe wrapper for secure command execution
-   */
-
-  /**
+   */ /**
    * Create issue using GitHub CLI (safe alternative to createIssue API method)
    * @param {Object} issueData - Issue data
    * @returns {Promise<Object>} - CLI execution result
-   */
-  async createIssueCLI(issueData) {
-    try {
-      const result = await this.cliSafe.createIssue({
-        title: issueData.title,
-        body: issueData.body,
-        labels: issueData.labels || [],
-        assignees: issueData.assignees || [],
-      });
-
-      printSuccess(`Issue created via CLI: ${issueData.title}`);
-      return { success: true, data: result };
-    } catch (error) {
-      printError(`Failed to create issue via CLI: ${error.message}`);
-      return { success: false, error: error.message };
-    }
-  }
-
-  /**
+   */ async createIssueCLI(issueData) {
+        try {
+            const result = await this.cliSafe.createIssue({
+                title: issueData.title,
+                body: issueData.body,
+                labels: issueData.labels || [],
+                assignees: issueData.assignees || []
+            });
+            printSuccess(`Issue created via CLI: ${issueData.title}`);
+            return {
+                success: true,
+                data: result
+            };
+        } catch (error) {
+            printError(`Failed to create issue via CLI: ${error.message}`);
+            return {
+                success: false,
+                error: error.message
+            };
+        }
+    }
+    /**
    * Create PR using GitHub CLI (safe alternative to createPullRequest API method)
    * @param {Object} prData - PR data
    * @returns {Promise<Object>} - CLI execution result
-   */
-  async createPullRequestCLI(prData) {
-    try {
-      const result = await this.cliSafe.createPR({
-        title: prData.title,
-        body: prData.body,
-        base: prData.base || 'main',
-        head: prData.head,
-        draft: prData.draft || false,
-      });
-
-      printSuccess(`PR created via CLI: ${prData.title}`);
-      return { success: true, data: result };
-    } catch (error) {
-      printError(`Failed to create PR via CLI: ${error.message}`);
-      return { success: false, error: error.message };
-    }
-  }
-
-  /**
+   */ async createPullRequestCLI(prData) {
+        try {
+            const result = await this.cliSafe.createPR({
+                title: prData.title,
+                body: prData.body,
+                base: prData.base || 'main',
+                head: prData.head,
+                draft: prData.draft || false
+            });
+            printSuccess(`PR created via CLI: ${prData.title}`);
+            return {
+                success: true,
+                data: result
+            };
+        } catch (error) {
+            printError(`Failed to create PR via CLI: ${error.message}`);
+            return {
+                success: false,
+                error: error.message
+            };
+        }
+    }
+    /**
    * Add issue comment using GitHub CLI
    * @param {number} issueNumber - Issue number
    * @param {string} body - Comment body
    * @returns {Promise<Object>} - CLI execution result
-   */
-  async addIssueCommentCLI(issueNumber, body) {
-    try {
-      const result = await this.cliSafe.addIssueComment(issueNumber, body);
-      printSuccess(`Comment added to issue #${issueNumber}`);
-      return { success: true, data: result };
-    } catch (error) {
-      printError(`Failed to add comment to issue #${issueNumber}: ${error.message}`);
-      return { success: false, error: error.message };
-    }
-  }
-
-  /**
+   */ async addIssueCommentCLI(issueNumber, body) {
+        try {
+            const result = await this.cliSafe.addIssueComment(issueNumber, body);
+            printSuccess(`Comment added to issue #${issueNumber}`);
+            return {
+                success: true,
+                data: result
+            };
+        } catch (error) {
+            printError(`Failed to add comment to issue #${issueNumber}: ${error.message}`);
+            return {
+                success: false,
+                error: error.message
+            };
+        }
+    }
+    /**
    * Add PR comment using GitHub CLI
    * @param {number} prNumber - PR number
    * @param {string} body - Comment body
    * @returns {Promise<Object>} - CLI execution result
-   */
-  async addPRCommentCLI(prNumber, body) {
-    try {
-      const result = await this.cliSafe.addPRComment(prNumber, body);
-      printSuccess(`Comment added to PR #${prNumber}`);
-      return { success: true, data: result };
-    } catch (error) {
-      printError(`Failed to add comment to PR #${prNumber}: ${error.message}`);
-      return { success: false, error: error.message };
-    }
-  }
-
-  /**
+   */ async addPRCommentCLI(prNumber, body) {
+        try {
+            const result = await this.cliSafe.addPRComment(prNumber, body);
+            printSuccess(`Comment added to PR #${prNumber}`);
+            return {
+                success: true,
+                data: result
+            };
+        } catch (error) {
+            printError(`Failed to add comment to PR #${prNumber}: ${error.message}`);
+            return {
+                success: false,
+                error: error.message
+            };
+        }
+    }
+    /**
    * Create release using GitHub CLI
    * @param {Object} releaseData - Release data
    * @returns {Promise<Object>} - CLI execution result
-   */
-  async createReleaseCLI(releaseData) {
-    try {
-      const result = await this.cliSafe.createRelease({
-        tag: releaseData.tag_name,
-        title: releaseData.name,
-        body: releaseData.body,
-        prerelease: releaseData.prerelease || false,
-        draft: releaseData.draft || false,
-      });
-
-      printSuccess(`Release created via CLI: ${releaseData.tag_name}`);
-      return { success: true, data: result };
-    } catch (error) {
-      printError(`Failed to create release via CLI: ${error.message}`);
-      return { success: false, error: error.message };
-    }
-  }
-
-  /**
+   */ async createReleaseCLI(releaseData) {
+        try {
+            const result = await this.cliSafe.createRelease({
+                tag: releaseData.tag_name,
+                title: releaseData.name,
+                body: releaseData.body,
+                prerelease: releaseData.prerelease || false,
+                draft: releaseData.draft || false
+            });
+            printSuccess(`Release created via CLI: ${releaseData.tag_name}`);
+            return {
+                success: true,
+                data: result
+            };
+        } catch (error) {
+            printError(`Failed to create release via CLI: ${error.message}`);
+            return {
+                success: false,
+                error: error.message
+            };
+        }
+    }
+    /**
    * Check GitHub CLI authentication and availability
    * @returns {Promise<boolean>} - True if CLI is ready to use
-   */
-  async checkCLIStatus() {
-    try {
-      const isAvailable = await this.cliSafe.checkGitHubCli();
-      if (!isAvailable) {
-        printWarning('GitHub CLI is not installed or not in PATH');
-        return false;
-      }
-
-      const isAuthenticated = await this.cliSafe.checkAuthentication();
-      if (!isAuthenticated) {
-        printWarning('GitHub CLI is not authenticated. Run: gh auth login');
-        return false;
-      }
-
-      printSuccess('GitHub CLI is ready for use');
-      return true;
-    } catch (error) {
-      printError(`GitHub CLI status check failed: ${error.message}`);
-      return false;
-    }
-  }
-
-  /**
+   */ async checkCLIStatus() {
+        try {
+            const isAvailable = await this.cliSafe.checkGitHubCli();
+            if (!isAvailable) {
+                printWarning('GitHub CLI is not installed or not in PATH');
+                return false;
+            }
+            const isAuthenticated = await this.cliSafe.checkAuthentication();
+            if (!isAuthenticated) {
+                printWarning('GitHub CLI is not authenticated. Run: gh auth login');
+                return false;
+            }
+            printSuccess('GitHub CLI is ready for use');
+            return true;
+        } catch (error) {
+            printError(`GitHub CLI status check failed: ${error.message}`);
+            return false;
+        }
+    }
+    /**
    * Get GitHub CLI wrapper statistics
    * @returns {Object} - Usage statistics
-   */
-  getCLIStats() {
-    return this.cliSafe.getStats();
-  }
-
-  /**
+   */ getCLIStats() {
+        return this.cliSafe.getStats();
+    }
+    /**
    * Cleanup CLI resources (call before shutdown)
-   */
-  async cleanupCLI() {
-    await this.cliSafe.cleanup();
-  }
-}
-
+   */ async cleanupCLI() {
+        await this.cliSafe.cleanup();
+    }
+    constructor(token = null){
+        this.token = token || process.env.GITHUB_TOKEN;
+        this.rateLimitRemaining = GITHUB_RATE_LIMIT;
+        this.rateLimitResetTime = null;
+        this.lastRequestTime = 0;
+        this.requestQueue = [];
+        this.isProcessingQueue = false;
+        // Initialize GitHub CLI safety wrapper
+        this.cliSafe = new GitHubCliSafe({
+            timeout: 60000,
+            maxRetries: 3,
+            enableRateLimit: true,
+            enableLogging: false
+        });
+    }
+};
 // Export singleton instance
 export const githubAPI = new GitHubAPIClient();
 export default GitHubAPIClient;