@bretwardjames/ghp-cli 0.1.2 → 0.1.4

package/dist/github-api.js

@@ -1,35 +1,22 @@
-import { graphql } from '@octokit/graphql';
+/**
+ * CLI-specific GitHub API wrapper.
+ *
+ * This module wraps the core GitHubAPI class with CLI-specific behavior:
+ * - Token from `gh auth token` or environment variables
+ * - Chalk-colored error messages
+ * - process.exit on auth errors
+ */
 import { exec } from 'child_process';
 import { promisify } from 'util';
 import chalk from 'chalk';
+import { GitHubAPI as CoreGitHubAPI, } from '@bretwardjames/ghp-core';
 const execAsync = promisify(exec);
 /**
- * Check if an error is due to insufficient OAuth scopes
+ * CLI token provider that gets tokens from environment or gh CLI
  */
-function handleScopeError(error) {
-    if (error && typeof error === 'object' && 'errors' in error) {
-        const gqlError = error;
-        const scopeError = gqlError.errors?.find(e => e.type === 'INSUFFICIENT_SCOPES');
-        if (scopeError) {
-            console.error(chalk.red('\nError:'), 'Your GitHub token is missing required scopes.');
-            console.error(chalk.dim('GitHub Projects requires the'), chalk.cyan('read:project'), chalk.dim('scope.'));
-            console.error();
-            console.error('Run this command to add the required scope:');
-            console.error(chalk.cyan('  gh auth refresh -s read:project -s project'));
-            console.error();
-            process.exit(1);
-        }
-    }
-    throw error;
-}
-export class GitHubAPI {
-    graphqlWithAuth = null;
-    username = null;
-    /**
-     * Get token from gh CLI or environment variable
-     */
+const cliTokenProvider = {
     async getToken() {
-        // First try environment variable
+        // First try environment variables
         if (process.env.GITHUB_TOKEN) {
             return process.env.GITHUB_TOKEN;
         }
@@ -44,846 +31,43 @@ export class GitHubAPI {
         catch {
             return null;
         }
-    }
-    /**
-     * Authenticate with GitHub
-     */
-    async authenticate() {
-        const token = await this.getToken();
-        if (!token) {
-            return false;
-        }
-        this.graphqlWithAuth = graphql.defaults({
-            headers: {
-                authorization: `token ${token}`,
-            },
-        });
-        // Get current user
-        try {
-            const response = await this.graphqlWithAuth(`
-                query {
-                    viewer {
-                        login
-                    }
-                }
-            `);
-            this.username = response.viewer.login;
-            return true;
-        }
-        catch {
-            this.graphqlWithAuth = null;
-            return false;
-        }
-    }
-    get isAuthenticated() {
-        return this.graphqlWithAuth !== null;
-    }
-    /**
-     * Get projects linked to a repository
-     */
-    async getProjects(repo) {
-        if (!this.graphqlWithAuth)
-            throw new Error('Not authenticated');
-        try {
-            const response = await this.graphqlWithAuth(`
-                query($owner: String!, $name: String!) {
-                    repository(owner: $owner, name: $name) {
-                        projectsV2(first: 20) {
-                            nodes {
-                                id
-                                title
-                                number
-                                url
-                            }
-                        }
-                    }
-                }
-            `, {
-                owner: repo.owner,
-                name: repo.name,
-            });
-            return response.repository.projectsV2.nodes;
-        }
-        catch (error) {
-            handleScopeError(error);
-        }
-    }
-    /**
-     * Get items from a project
-     */
-    async getProjectItems(projectId, projectTitle) {
-        if (!this.graphqlWithAuth)
-            throw new Error('Not authenticated');
-        // First, get the status field to build a status order map
-        const statusField = await this.getStatusField(projectId);
-        const statusOrderMap = new Map();
-        if (statusField) {
-            statusField.options.forEach((opt, idx) => {
-                statusOrderMap.set(opt.name.toLowerCase(), idx);
-            });
-        }
-        const response = await this.graphqlWithAuth(`
-            query($projectId: ID!) {
-                node(id: $projectId) {
-                    ... on ProjectV2 {
-                        items(first: 100) {
-                            nodes {
-                                id
-                                fieldValues(first: 20) {
-                                    nodes {
-                                        __typename
-                                        ... on ProjectV2ItemFieldSingleSelectValue {
-                                            name
-                                            field { ... on ProjectV2SingleSelectField { name } }
-                                        }
-                                        ... on ProjectV2ItemFieldTextValue {
-                                            text
-                                            field { ... on ProjectV2Field { name } }
-                                        }
-                                        ... on ProjectV2ItemFieldNumberValue {
-                                            number
-                                            field { ... on ProjectV2Field { name } }
-                                        }
-                                        ... on ProjectV2ItemFieldDateValue {
-                                            date
-                                            field { ... on ProjectV2Field { name } }
-                                        }
-                                        ... on ProjectV2ItemFieldIterationValue {
-                                            title
-                                            field { ... on ProjectV2IterationField { name } }
-                                        }
-                                    }
-                                }
-                                content {
-                                    __typename
-                                    ... on Issue {
-                                        title
-                                        number
-                                        url
-                                        state
-                                        issueType { name }
-                                        assignees(first: 5) { nodes { login } }
-                                        labels(first: 10) { nodes { name color } }
-                                        repository { name }
-                                    }
-                                    ... on PullRequest {
-                                        title
-                                        number
-                                        url
-                                        state
-                                        merged
-                                        assignees(first: 5) { nodes { login } }
-                                        labels(first: 10) { nodes { name color } }
-                                        repository { name }
-                                    }
-                                    ... on DraftIssue {
-                                        title
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        `, { projectId });
-        return response.node.items.nodes
-            .filter(item => item.content)
-            .map(item => {
-            const content = item.content;
-            // Extract all field values into a map
-            const fields = {};
-            for (const fv of item.fieldValues.nodes) {
-                const fieldName = fv.field?.name;
-                if (!fieldName)
-                    continue;
-                if (fv.__typename === 'ProjectV2ItemFieldSingleSelectValue' && fv.name) {
-                    fields[fieldName] = fv.name;
-                }
-                else if (fv.__typename === 'ProjectV2ItemFieldTextValue' && fv.text) {
-                    fields[fieldName] = fv.text;
-                }
-                else if (fv.__typename === 'ProjectV2ItemFieldNumberValue' && fv.number !== undefined) {
-                    fields[fieldName] = fv.number.toString();
-                }
-                else if (fv.__typename === 'ProjectV2ItemFieldDateValue' && fv.date) {
-                    fields[fieldName] = fv.date;
-                }
-                else if (fv.__typename === 'ProjectV2ItemFieldIterationValue' && fv.title) {
-                    fields[fieldName] = fv.title;
-                }
-            }
-            let type = 'draft';
-            if (content.__typename === 'Issue')
-                type = 'issue';
-            else if (content.__typename === 'PullRequest')
-                type = 'pull_request';
-            const status = fields['Status'] || null;
-            const statusIndex = status
-                ? (statusOrderMap.get(status.toLowerCase()) ?? 999)
-                : 999;
-            // Determine issue/PR state
-            let state = null;
-            if (content.state) {
-                if (content.merged) {
-                    state = 'merged';
-                }
-                else if (content.state === 'OPEN') {
-                    state = 'open';
-                }
-                else {
-                    state = 'closed';
-                }
-            }
-            return {
-                id: item.id,
-                title: content.title || 'Untitled',
-                number: content.number || null,
-                type,
-                issueType: content.issueType?.name || null,
-                status,
-                statusIndex,
-                state,
-                assignees: content.assignees?.nodes.map(a => a.login) || [],
-                labels: content.labels?.nodes || [],
-                repository: content.repository?.name || null,
-                url: content.url || null,
-                projectId,
-                projectTitle,
-                fields,
-            };
+    },
+};
+/**
+ * CLI error handler that prints colored messages and exits
+ */
+function handleAuthError(error) {
+    if (error.type === 'INSUFFICIENT_SCOPES') {
+        console.error(chalk.red('\nError:'), 'Your GitHub token is missing required scopes.');
+        console.error(chalk.dim('GitHub Projects requires the'), chalk.cyan('read:project'), chalk.dim('scope.'));
+        console.error();
+        console.error('Run this command to add the required scope:');
+        console.error(chalk.cyan('  gh auth refresh -s read:project -s project'));
+        console.error();
+    }
+    else if (error.type === 'SSO_REQUIRED') {
+        console.error(chalk.red('\nError:'), 'SSO authentication required for this organization.');
+        console.error(chalk.dim('Please re-authenticate with SSO enabled.'));
+        console.error();
+    }
+    else {
+        console.error(chalk.red('\nError:'), error.message);
+    }
+    process.exit(1);
+}
+/**
+ * Extended GitHubAPI class for CLI with pre-configured token provider
+ */
+class CLIGitHubAPI extends CoreGitHubAPI {
+    constructor() {
+        super({
+            tokenProvider: cliTokenProvider,
+            onAuthError: handleAuthError,
         });
     }
-    /**
-     * Get the Status field info for a project
-     */
-    async getStatusField(projectId) {
-        if (!this.graphqlWithAuth)
-            throw new Error('Not authenticated');
-        const response = await this.graphqlWithAuth(`
-            query($projectId: ID!) {
-                node(id: $projectId) {
-                    ... on ProjectV2 {
-                        fields(first: 20) {
-                            nodes {
-                                __typename
-                                ... on ProjectV2SingleSelectField {
-                                    id
-                                    name
-                                    options { id name }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        `, { projectId });
-        const statusField = response.node.fields.nodes.find(f => f.__typename === 'ProjectV2SingleSelectField' && f.name === 'Status');
-        if (!statusField || !statusField.options)
-            return null;
-        return {
-            fieldId: statusField.id,
-            options: statusField.options,
-        };
-    }
-    /**
-     * Get project views
-     */
-    async getProjectViews(projectId) {
-        if (!this.graphqlWithAuth)
-            throw new Error('Not authenticated');
-        try {
-            const response = await this.graphqlWithAuth(`
-                query($projectId: ID!) {
-                    node(id: $projectId) {
-                        ... on ProjectV2 {
-                            views(first: 20) {
-                                nodes {
-                                    name
-                                    filter
-                                }
-                            }
-                        }
-                    }
-                }
-            `, { projectId });
-            return response.node.views.nodes;
-        }
-        catch (error) {
-            console.error('Error fetching project views:', error);
-            return [];
-        }
-    }
-    /**
-     * Update an item's status
-     */
-    async updateItemStatus(projectId, itemId, fieldId, optionId) {
-        if (!this.graphqlWithAuth)
-            throw new Error('Not authenticated');
-        try {
-            await this.graphqlWithAuth(`
-                mutation($projectId: ID!, $itemId: ID!, $fieldId: ID!, $optionId: String!) {
-                    updateProjectV2ItemFieldValue(input: {
-                        projectId: $projectId
-                        itemId: $itemId
-                        fieldId: $fieldId
-                        value: { singleSelectOptionId: $optionId }
-                    }) {
-                        projectV2Item { id }
-                    }
-                }
-            `, { projectId, itemId, fieldId, optionId });
-            return true;
-        }
-        catch (error) {
-            console.error('Failed to update status:', error);
-            return false;
-        }
-    }
-    /**
-     * Find an item by issue number across all projects for this repo
-     */
-    async findItemByNumber(repo, issueNumber) {
-        const projects = await this.getProjects(repo);
-        for (const project of projects) {
-            const items = await this.getProjectItems(project.id, project.title);
-            const item = items.find(i => i.number === issueNumber);
-            if (item)
-                return item;
-        }
-        return null;
-    }
-    /**
-     * Get all fields for a project
-     */
-    async getProjectFields(projectId) {
-        if (!this.graphqlWithAuth)
-            throw new Error('Not authenticated');
-        const response = await this.graphqlWithAuth(`
-            query($projectId: ID!) {
-                node(id: $projectId) {
-                    ... on ProjectV2 {
-                        fields(first: 30) {
-                            nodes {
-                                __typename
-                                ... on ProjectV2Field {
-                                    id
-                                    name
-                                }
-                                ... on ProjectV2SingleSelectField {
-                                    id
-                                    name
-                                    options { id name }
-                                }
-                                ... on ProjectV2IterationField {
-                                    id
-                                    name
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        `, { projectId });
-        return response.node.fields.nodes.map(f => ({
-            id: f.id,
-            name: f.name,
-            type: f.__typename.replace('ProjectV2', '').replace('Field', ''),
-            options: f.options,
-        }));
-    }
-    /**
-     * Set a field value on a project item
-     */
-    async setFieldValue(projectId, itemId, fieldId, value) {
-        if (!this.graphqlWithAuth)
-            throw new Error('Not authenticated');
-        try {
-            await this.graphqlWithAuth(`
-                mutation($projectId: ID!, $itemId: ID!, $fieldId: ID!, $value: ProjectV2FieldValue!) {
-                    updateProjectV2ItemFieldValue(input: {
-                        projectId: $projectId
-                        itemId: $itemId
-                        fieldId: $fieldId
-                        value: $value
-                    }) {
-                        projectV2Item { id }
-                    }
-                }
-            `, { projectId, itemId, fieldId, value });
-            return true;
-        }
-        catch (error) {
-            console.error('Failed to set field value:', error);
-            return false;
-        }
-    }
-    /**
-     * Create a new issue
-     */
-    async createIssue(repo, title, body) {
-        if (!this.graphqlWithAuth)
-            throw new Error('Not authenticated');
-        try {
-            // First get the repository ID
-            const repoResponse = await this.graphqlWithAuth(`
-                query($owner: String!, $name: String!) {
-                    repository(owner: $owner, name: $name) {
-                        id
-                    }
-                }
-            `, { owner: repo.owner, name: repo.name });
-            const response = await this.graphqlWithAuth(`
-                mutation($repositoryId: ID!, $title: String!, $body: String) {
-                    createIssue(input: {
-                        repositoryId: $repositoryId
-                        title: $title
-                        body: $body
-                    }) {
-                        issue {
-                            id
-                            number
-                        }
-                    }
-                }
-            `, {
-                repositoryId: repoResponse.repository.id,
-                title,
-                body: body || '',
-            });
-            return response.createIssue.issue;
-        }
-        catch (error) {
-            console.error('Failed to create issue:', error);
-            return null;
-        }
-    }
-    /**
-     * Add an issue to a project
-     */
-    async addToProject(projectId, contentId) {
-        if (!this.graphqlWithAuth)
-            throw new Error('Not authenticated');
-        try {
-            const response = await this.graphqlWithAuth(`
-                mutation($projectId: ID!, $contentId: ID!) {
-                    addProjectV2ItemById(input: {
-                        projectId: $projectId
-                        contentId: $contentId
-                    }) {
-                        item { id }
-                    }
-                }
-            `, { projectId, contentId });
-            return response.addProjectV2ItemById.item.id;
-        }
-        catch (error) {
-            console.error('Failed to add to project:', error);
-            return null;
-        }
-    }
-    /**
-     * Get full issue details including body and comments
-     */
-    async getIssueDetails(repo, issueNumber) {
-        if (!this.graphqlWithAuth)
-            throw new Error('Not authenticated');
-        try {
-            const response = await this.graphqlWithAuth(`
-                query($owner: String!, $name: String!, $number: Int!) {
-                    repository(owner: $owner, name: $name) {
-                        issueOrPullRequest(number: $number) {
-                            __typename
-                            ... on Issue {
-                                title
-                                body
-                                state
-                                createdAt
-                                author { login }
-                                labels(first: 10) { nodes { name color } }
-                                comments(first: 50) {
-                                    totalCount
-                                    nodes {
-                                        author { login }
-                                        body
-                                        createdAt
-                                    }
-                                }
-                            }
-                            ... on PullRequest {
-                                title
-                                body
-                                state
-                                createdAt
-                                author { login }
-                                labels(first: 10) { nodes { name color } }
-                                comments(first: 50) {
-                                    totalCount
-                                    nodes {
-                                        author { login }
-                                        body
-                                        createdAt
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            `, {
-                owner: repo.owner,
-                name: repo.name,
-                number: issueNumber,
-            });
-            const issue = response.repository.issueOrPullRequest;
-            if (!issue)
-                return null;
-            return {
-                title: issue.title,
-                body: issue.body,
-                state: issue.state,
-                type: issue.__typename === 'PullRequest' ? 'pull_request' : 'issue',
-                createdAt: issue.createdAt,
-                author: issue.author?.login || 'unknown',
-                labels: issue.labels.nodes,
-                comments: issue.comments.nodes.map(c => ({
-                    author: c.author?.login || 'unknown',
-                    body: c.body,
-                    createdAt: c.createdAt,
-                })),
-                totalComments: issue.comments.totalCount,
-            };
-        }
-        catch (error) {
-            console.error('Failed to get issue details:', error);
-            return null;
-        }
-    }
-    /**
-     * Add a comment to an issue or PR
-     */
-    async addComment(repo, issueNumber, body) {
-        if (!this.graphqlWithAuth)
-            throw new Error('Not authenticated');
-        try {
-            // First get the issue/PR node ID
-            const issueResponse = await this.graphqlWithAuth(`
-                query($owner: String!, $name: String!, $number: Int!) {
-                    repository(owner: $owner, name: $name) {
-                        issueOrPullRequest(number: $number) {
-                            ... on Issue { id }
-                            ... on PullRequest { id }
-                        }
-                    }
-                }
-            `, {
-                owner: repo.owner,
-                name: repo.name,
-                number: issueNumber,
-            });
-            const subjectId = issueResponse.repository.issueOrPullRequest?.id;
-            if (!subjectId) {
-                console.error('Issue not found');
-                return false;
-            }
-            await this.graphqlWithAuth(`
-                mutation($subjectId: ID!, $body: String!) {
-                    addComment(input: { subjectId: $subjectId, body: $body }) {
-                        commentEdge {
-                            node { id }
-                        }
-                    }
-                }
-            `, { subjectId, body });
-            return true;
-        }
-        catch (error) {
-            console.error('Failed to add comment:', error);
-            return false;
-        }
-    }
-    /**
-     * Get repository collaborators (for @ mention suggestions)
-     */
-    async getCollaborators(repo) {
-        if (!this.graphqlWithAuth)
-            throw new Error('Not authenticated');
-        try {
-            const response = await this.graphqlWithAuth(`
-                query($owner: String!, $name: String!) {
-                    repository(owner: $owner, name: $name) {
-                        collaborators(first: 50) {
-                            nodes { login name }
-                        }
-                        assignableUsers(first: 50) {
-                            nodes { login name }
-                        }
-                    }
-                }
-            `, { owner: repo.owner, name: repo.name });
-            // Use collaborators if available, fall back to assignable users
-            const users = response.repository.collaborators?.nodes
-                || response.repository.assignableUsers.nodes
-                || [];
-            return users.map(u => ({ login: u.login, name: u.name }));
-        }
-        catch {
-            // Collaborators might not be accessible, return empty
-            return [];
-        }
-    }
-    /**
-     * Get recent issues (for # reference suggestions)
-     */
-    async getRecentIssues(repo, limit = 20) {
-        if (!this.graphqlWithAuth)
-            throw new Error('Not authenticated');
-        try {
-            const response = await this.graphqlWithAuth(`
-                query($owner: String!, $name: String!, $limit: Int!) {
-                    repository(owner: $owner, name: $name) {
-                        issues(first: $limit, orderBy: { field: UPDATED_AT, direction: DESC }) {
-                            nodes {
-                                number
-                                title
-                                state
-                            }
-                        }
-                    }
-                }
-            `, { owner: repo.owner, name: repo.name, limit });
-            return response.repository.issues.nodes;
-        }
-        catch {
-            return [];
-        }
-    }
-    /**
-     * Get the active label name for a user
-     */
-    getActiveLabelName() {
-        return `@${this.username}:active`;
-    }
-    /**
-     * Ensure a label exists in the repository, create if it doesn't
-     */
-    async ensureLabel(repo, labelName, color = '1f883d') {
-        if (!this.graphqlWithAuth)
-            throw new Error('Not authenticated');
-        try {
-            // First check if label exists
-            const checkResponse = await this.graphqlWithAuth(`
-                query($owner: String!, $name: String!, $labelName: String!) {
-                    repository(owner: $owner, name: $name) {
-                        label(name: $labelName) {
-                            id
-                        }
-                    }
-                }
-            `, { owner: repo.owner, name: repo.name, labelName });
-            if (checkResponse.repository.label) {
-                return true; // Label already exists
-            }
-            // Create the label using REST API (GraphQL createLabel requires different permissions)
-            const token = await this.getToken();
-            const response = await fetch(`https://api.github.com/repos/${repo.owner}/${repo.name}/labels`, {
-                method: 'POST',
-                headers: {
-                    'Authorization': `token ${token}`,
-                    'Content-Type': 'application/json',
-                    'Accept': 'application/vnd.github.v3+json',
-                },
-                body: JSON.stringify({
-                    name: labelName,
-                    color: color,
-                    description: `Active working indicator for ${this.username}`,
-                }),
-            });
-            if (response.status === 201) {
-                return true;
-            }
-            else if (response.status === 422) {
-                // Label already exists (race condition)
-                return true;
-            }
-            else {
-                console.error('Failed to create label:', await response.text());
-                return false;
-            }
-        }
-        catch (error) {
-            console.error('Failed to ensure label:', error);
-            return false;
-        }
-    }
-    /**
-     * Add a label to an issue
-     */
-    async addLabelToIssue(repo, issueNumber, labelName) {
-        if (!this.graphqlWithAuth)
-            throw new Error('Not authenticated');
-        try {
-            // Get the issue node ID and label ID
-            const response = await this.graphqlWithAuth(`
-                query($owner: String!, $name: String!, $number: Int!, $labelName: String!) {
-                    repository(owner: $owner, name: $name) {
-                        issue(number: $number) {
-                            id
-                        }
-                        label(name: $labelName) {
-                            id
-                        }
-                    }
-                }
-            `, { owner: repo.owner, name: repo.name, number: issueNumber, labelName });
-            if (!response.repository.issue || !response.repository.label) {
-                return false;
-            }
-            await this.graphqlWithAuth(`
-                mutation($issueId: ID!, $labelIds: [ID!]!) {
-                    addLabelsToLabelable(input: { labelableId: $issueId, labelIds: $labelIds }) {
-                        clientMutationId
-                    }
-                }
-            `, {
-                issueId: response.repository.issue.id,
-                labelIds: [response.repository.label.id],
-            });
-            return true;
-        }
-        catch (error) {
-            console.error('Failed to add label:', error);
-            return false;
-        }
-    }
-    /**
-     * Remove a label from an issue
-     */
-    async removeLabelFromIssue(repo, issueNumber, labelName) {
-        if (!this.graphqlWithAuth)
-            throw new Error('Not authenticated');
-        try {
-            const response = await this.graphqlWithAuth(`
-                query($owner: String!, $name: String!, $number: Int!, $labelName: String!) {
-                    repository(owner: $owner, name: $name) {
-                        issue(number: $number) {
-                            id
-                        }
-                        label(name: $labelName) {
-                            id
-                        }
-                    }
-                }
-            `, { owner: repo.owner, name: repo.name, number: issueNumber, labelName });
-            if (!response.repository.issue || !response.repository.label) {
-                return false;
-            }
-            await this.graphqlWithAuth(`
-                mutation($issueId: ID!, $labelIds: [ID!]!) {
-                    removeLabelsFromLabelable(input: { labelableId: $issueId, labelIds: $labelIds }) {
-                        clientMutationId
-                    }
-                }
-            `, {
-                issueId: response.repository.issue.id,
-                labelIds: [response.repository.label.id],
-            });
-            return true;
-        }
-        catch (error) {
-            console.error('Failed to remove label:', error);
-            return false;
-        }
-    }
-    /**
-     * Find all issues with a specific label
-     */
-    async findIssuesWithLabel(repo, labelName) {
-        if (!this.graphqlWithAuth)
-            throw new Error('Not authenticated');
-        try {
-            const response = await this.graphqlWithAuth(`
-                query($owner: String!, $name: String!, $labels: [String!]) {
-                    repository(owner: $owner, name: $name) {
-                        issues(first: 10, labels: $labels, states: [OPEN]) {
-                            nodes {
-                                number
-                            }
-                        }
-                    }
-                }
-            `, { owner: repo.owner, name: repo.name, labels: [labelName] });
-            return response.repository.issues.nodes.map(i => i.number);
-        }
-        catch {
-            return [];
-        }
-    }
-    /**
-     * Get available issue types for a repository
-     */
-    async getIssueTypes(repo) {
-        if (!this.graphqlWithAuth)
-            throw new Error('Not authenticated');
-        try {
-            const response = await this.graphqlWithAuth(`
-                query($owner: String!, $name: String!) {
-                    repository(owner: $owner, name: $name) {
-                        issueTypes(first: 20) {
-                            nodes {
-                                id
-                                name
-                            }
-                        }
-                    }
-                }
-            `, { owner: repo.owner, name: repo.name });
-            return response.repository.issueTypes?.nodes || [];
-        }
-        catch (error) {
-            // Issue types may not be enabled for this repository
-            return [];
-        }
-    }
-    /**
-     * Set the issue type on an issue
-     */
-    async setIssueType(repo, issueNumber, issueTypeId) {
-        if (!this.graphqlWithAuth)
-            throw new Error('Not authenticated');
-        try {
-            // First get the issue's node ID
-            const issueResponse = await this.graphqlWithAuth(`
-                query($owner: String!, $name: String!, $number: Int!) {
-                    repository(owner: $owner, name: $name) {
-                        issue(number: $number) {
-                            id
-                        }
-                    }
-                }
-            `, { owner: repo.owner, name: repo.name, number: issueNumber });
-            if (!issueResponse.repository.issue) {
-                return false;
-            }
-            // Update the issue type
-            await this.graphqlWithAuth(`
-                mutation($issueId: ID!, $issueTypeId: ID!) {
-                    updateIssue(input: { id: $issueId, issueTypeId: $issueTypeId }) {
-                        issue {
-                            id
-                        }
-                    }
-                }
-            `, {
-                issueId: issueResponse.repository.issue.id,
-                issueTypeId,
-            });
-            return true;
-        }
-        catch (error) {
-            console.error('Failed to set issue type:', error);
-            return false;
-        }
-    }
 }
-// Singleton instance
-export const api = new GitHubAPI();
+// Singleton instance for CLI usage
+export const api = new CLIGitHubAPI();
+// Also export the class for testing
+export { CLIGitHubAPI as GitHubAPI };
 //# sourceMappingURL=github-api.js.map