@bretwardjames/ghp-core 0.1.0

package/dist/index.js

@@ -0,0 +1,1230 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/github-api.ts
+import { graphql } from "@octokit/graphql";
+
+// src/queries.ts
+var queries_exports = {};
+__export(queries_exports, {
+  ADD_COMMENT_MUTATION: () => ADD_COMMENT_MUTATION,
+  ADD_LABELS_MUTATION: () => ADD_LABELS_MUTATION,
+  ADD_TO_PROJECT_MUTATION: () => ADD_TO_PROJECT_MUTATION,
+  COLLABORATORS_QUERY: () => COLLABORATORS_QUERY,
+  CREATE_ISSUE_MUTATION: () => CREATE_ISSUE_MUTATION,
+  ISSUES_WITH_LABEL_QUERY: () => ISSUES_WITH_LABEL_QUERY,
+  ISSUE_AND_LABEL_QUERY: () => ISSUE_AND_LABEL_QUERY,
+  ISSUE_DETAILS_QUERY: () => ISSUE_DETAILS_QUERY,
+  ISSUE_FOR_UPDATE_QUERY: () => ISSUE_FOR_UPDATE_QUERY,
+  ISSUE_NODE_ID_QUERY: () => ISSUE_NODE_ID_QUERY,
+  ISSUE_TYPES_QUERY: () => ISSUE_TYPES_QUERY,
+  LABEL_EXISTS_QUERY: () => LABEL_EXISTS_QUERY,
+  PROJECT_FIELDS_QUERY: () => PROJECT_FIELDS_QUERY,
+  PROJECT_ITEMS_QUERY: () => PROJECT_ITEMS_QUERY,
+  PROJECT_VIEWS_QUERY: () => PROJECT_VIEWS_QUERY,
+  RECENT_ISSUES_QUERY: () => RECENT_ISSUES_QUERY,
+  REMOVE_LABELS_MUTATION: () => REMOVE_LABELS_MUTATION,
+  REPOSITORY_ID_QUERY: () => REPOSITORY_ID_QUERY,
+  REPOSITORY_PROJECTS_QUERY: () => REPOSITORY_PROJECTS_QUERY,
+  UPDATE_ISSUE_TYPE_MUTATION: () => UPDATE_ISSUE_TYPE_MUTATION,
+  UPDATE_ITEM_FIELD_MUTATION: () => UPDATE_ITEM_FIELD_MUTATION,
+  UPDATE_ITEM_STATUS_MUTATION: () => UPDATE_ITEM_STATUS_MUTATION,
+  VIEWER_QUERY: () => VIEWER_QUERY
+});
+var VIEWER_QUERY = `
+    query {
+        viewer {
+            login
+        }
+    }
+`;
+var REPOSITORY_PROJECTS_QUERY = `
+    query($owner: String!, $name: String!) {
+        repository(owner: $owner, name: $name) {
+            projectsV2(first: 20) {
+                nodes {
+                    id
+                    title
+                    number
+                    url
+                }
+            }
+        }
+    }
+`;
+var REPOSITORY_ID_QUERY = `
+    query($owner: String!, $name: String!) {
+        repository(owner: $owner, name: $name) {
+            id
+        }
+    }
+`;
+var PROJECT_ITEMS_QUERY = `
+    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
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+`;
+var PROJECT_FIELDS_QUERY = `
+    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
+                        }
+                    }
+                }
+            }
+        }
+    }
+`;
+var PROJECT_VIEWS_QUERY = `
+    query($projectId: ID!) {
+        node(id: $projectId) {
+            ... on ProjectV2 {
+                views(first: 20) {
+                    nodes {
+                        name
+                        filter
+                    }
+                }
+            }
+        }
+    }
+`;
+var UPDATE_ITEM_FIELD_MUTATION = `
+    mutation($projectId: ID!, $itemId: ID!, $fieldId: ID!, $value: ProjectV2FieldValue!) {
+        updateProjectV2ItemFieldValue(input: {
+            projectId: $projectId
+            itemId: $itemId
+            fieldId: $fieldId
+            value: $value
+        }) {
+            projectV2Item { id }
+        }
+    }
+`;
+var UPDATE_ITEM_STATUS_MUTATION = `
+    mutation($projectId: ID!, $itemId: ID!, $fieldId: ID!, $optionId: String!) {
+        updateProjectV2ItemFieldValue(input: {
+            projectId: $projectId
+            itemId: $itemId
+            fieldId: $fieldId
+            value: { singleSelectOptionId: $optionId }
+        }) {
+            projectV2Item { id }
+        }
+    }
+`;
+var CREATE_ISSUE_MUTATION = `
+    mutation($repositoryId: ID!, $title: String!, $body: String) {
+        createIssue(input: {
+            repositoryId: $repositoryId
+            title: $title
+            body: $body
+        }) {
+            issue {
+                id
+                number
+            }
+        }
+    }
+`;
+var ADD_TO_PROJECT_MUTATION = `
+    mutation($projectId: ID!, $contentId: ID!) {
+        addProjectV2ItemById(input: {
+            projectId: $projectId
+            contentId: $contentId
+        }) {
+            item { id }
+        }
+    }
+`;
+var ISSUE_DETAILS_QUERY = `
+    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
+                        }
+                    }
+                }
+            }
+        }
+    }
+`;
+var ISSUE_NODE_ID_QUERY = `
+    query($owner: String!, $name: String!, $number: Int!) {
+        repository(owner: $owner, name: $name) {
+            issueOrPullRequest(number: $number) {
+                ... on Issue { id }
+                ... on PullRequest { id }
+            }
+        }
+    }
+`;
+var ADD_COMMENT_MUTATION = `
+    mutation($subjectId: ID!, $body: String!) {
+        addComment(input: { subjectId: $subjectId, body: $body }) {
+            commentEdge {
+                node { id }
+            }
+        }
+    }
+`;
+var COLLABORATORS_QUERY = `
+    query($owner: String!, $name: String!) {
+        repository(owner: $owner, name: $name) {
+            collaborators(first: 50) {
+                nodes { login name }
+            }
+            assignableUsers(first: 50) {
+                nodes { login name }
+            }
+        }
+    }
+`;
+var RECENT_ISSUES_QUERY = `
+    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
+                }
+            }
+        }
+    }
+`;
+var LABEL_EXISTS_QUERY = `
+    query($owner: String!, $name: String!, $labelName: String!) {
+        repository(owner: $owner, name: $name) {
+            label(name: $labelName) {
+                id
+            }
+        }
+    }
+`;
+var ISSUE_AND_LABEL_QUERY = `
+    query($owner: String!, $name: String!, $number: Int!, $labelName: String!) {
+        repository(owner: $owner, name: $name) {
+            issue(number: $number) {
+                id
+            }
+            label(name: $labelName) {
+                id
+            }
+        }
+    }
+`;
+var ADD_LABELS_MUTATION = `
+    mutation($issueId: ID!, $labelIds: [ID!]!) {
+        addLabelsToLabelable(input: { labelableId: $issueId, labelIds: $labelIds }) {
+            clientMutationId
+        }
+    }
+`;
+var REMOVE_LABELS_MUTATION = `
+    mutation($issueId: ID!, $labelIds: [ID!]!) {
+        removeLabelsFromLabelable(input: { labelableId: $issueId, labelIds: $labelIds }) {
+            clientMutationId
+        }
+    }
+`;
+var ISSUES_WITH_LABEL_QUERY = `
+    query($owner: String!, $name: String!, $labels: [String!]) {
+        repository(owner: $owner, name: $name) {
+            issues(first: 10, labels: $labels, states: [OPEN]) {
+                nodes {
+                    number
+                }
+            }
+        }
+    }
+`;
+var ISSUE_TYPES_QUERY = `
+    query($owner: String!, $name: String!) {
+        repository(owner: $owner, name: $name) {
+            issueTypes(first: 20) {
+                nodes {
+                    id
+                    name
+                }
+            }
+        }
+    }
+`;
+var ISSUE_FOR_UPDATE_QUERY = `
+    query($owner: String!, $name: String!, $number: Int!) {
+        repository(owner: $owner, name: $name) {
+            issue(number: $number) {
+                id
+            }
+        }
+    }
+`;
+var UPDATE_ISSUE_TYPE_MUTATION = `
+    mutation($issueId: ID!, $issueTypeId: ID!) {
+        updateIssue(input: { id: $issueId, issueTypeId: $issueTypeId }) {
+            issue {
+                id
+            }
+        }
+    }
+`;
+
+// src/github-api.ts
+function createAuthError(message, type, details) {
+  const error = new Error(message);
+  error.type = type;
+  error.requiredScopes = details?.requiredScopes;
+  error.ssoUrl = details?.ssoUrl;
+  return error;
+}
+function checkAuthError(error) {
+  if (error && typeof error === "object" && "errors" in error) {
+    const gqlError = error;
+    const scopeError = gqlError.errors?.find((e) => e.type === "INSUFFICIENT_SCOPES");
+    if (scopeError) {
+      return createAuthError(
+        "Your GitHub token is missing required scopes. GitHub Projects requires the read:project scope.",
+        "INSUFFICIENT_SCOPES",
+        { requiredScopes: ["read:project", "project"] }
+      );
+    }
+    const ssoError = gqlError.errors?.find(
+      (e) => e.message?.includes("SSO") || e.message?.includes("SAML")
+    );
+    if (ssoError) {
+      return createAuthError(
+        "SSO authentication required for this organization.",
+        "SSO_REQUIRED"
+      );
+    }
+  }
+  return null;
+}
+var GitHubAPI = class {
+  graphqlWithAuth = null;
+  tokenProvider;
+  onAuthError;
+  username = null;
+  constructor(options) {
+    this.tokenProvider = options.tokenProvider;
+    this.onAuthError = options.onAuthError;
+  }
+  /**
+   * Handle authentication errors by calling the error handler or throwing
+   */
+  handleAuthError(error) {
+    const authError = checkAuthError(error);
+    if (authError) {
+      if (this.onAuthError) {
+        this.onAuthError(authError);
+      }
+      throw authError;
+    }
+    throw error;
+  }
+  /**
+   * Authenticate with GitHub using the token provider
+   */
+  async authenticate() {
+    const token = await this.tokenProvider.getToken();
+    if (!token) {
+      return false;
+    }
+    this.graphqlWithAuth = graphql.defaults({
+      headers: {
+        authorization: `token ${token}`
+      }
+    });
+    try {
+      const response = await this.graphqlWithAuth(VIEWER_QUERY);
+      this.username = response.viewer.login;
+      return true;
+    } catch {
+      this.graphqlWithAuth = null;
+      return false;
+    }
+  }
+  get isAuthenticated() {
+    return this.graphqlWithAuth !== null;
+  }
+  /**
+   * Get the current token (for REST API calls)
+   */
+  async getToken() {
+    return this.tokenProvider.getToken();
+  }
+  /**
+   * Get projects linked to a repository
+   */
+  async getProjects(repo) {
+    if (!this.graphqlWithAuth) throw new Error("Not authenticated");
+    try {
+      const response = await this.graphqlWithAuth(REPOSITORY_PROJECTS_QUERY, {
+        owner: repo.owner,
+        name: repo.name
+      });
+      return response.repository.projectsV2.nodes;
+    } catch (error) {
+      this.handleAuthError(error);
+    }
+  }
+  /**
+   * Get items from a project
+   */
+  async getProjectItems(projectId, projectTitle) {
+    if (!this.graphqlWithAuth) throw new Error("Not authenticated");
+    const statusField = await this.getStatusField(projectId);
+    const statusOrderMap = /* @__PURE__ */ new Map();
+    if (statusField) {
+      statusField.options.forEach((opt, idx) => {
+        statusOrderMap.set(opt.name.toLowerCase(), idx);
+      });
+    }
+    const response = await this.graphqlWithAuth(PROJECT_ITEMS_QUERY, { projectId });
+    return response.node.items.nodes.filter((item) => item.content).map((item) => {
+      const content = item.content;
+      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 !== void 0) {
+          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;
+      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
+      };
+    });
+  }
+  /**
+   * Get the Status field info for a project
+   */
+  async getStatusField(projectId) {
+    if (!this.graphqlWithAuth) throw new Error("Not authenticated");
+    const response = await this.graphqlWithAuth(PROJECT_FIELDS_QUERY, { 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(PROJECT_VIEWS_QUERY, { projectId });
+      return response.node.views.nodes;
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Update an item's status
+   */
+  async updateItemStatus(projectId, itemId, fieldId, optionId) {
+    if (!this.graphqlWithAuth) throw new Error("Not authenticated");
+    try {
+      await this.graphqlWithAuth(UPDATE_ITEM_STATUS_MUTATION, {
+        projectId,
+        itemId,
+        fieldId,
+        optionId
+      });
+      return true;
+    } catch {
+      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(PROJECT_FIELDS_QUERY, { 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(UPDATE_ITEM_FIELD_MUTATION, {
+        projectId,
+        itemId,
+        fieldId,
+        value
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Create a new issue
+   */
+  async createIssue(repo, title, body) {
+    if (!this.graphqlWithAuth) throw new Error("Not authenticated");
+    try {
+      const repoResponse = await this.graphqlWithAuth(REPOSITORY_ID_QUERY, {
+        owner: repo.owner,
+        name: repo.name
+      });
+      const response = await this.graphqlWithAuth(CREATE_ISSUE_MUTATION, {
+        repositoryId: repoResponse.repository.id,
+        title,
+        body: body || ""
+      });
+      return response.createIssue.issue;
+    } catch {
+      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(ADD_TO_PROJECT_MUTATION, {
+        projectId,
+        contentId
+      });
+      return response.addProjectV2ItemById.item.id;
+    } catch {
+      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(ISSUE_DETAILS_QUERY, {
+        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 {
+      return null;
+    }
+  }
+  /**
+   * Add a comment to an issue or PR
+   */
+  async addComment(repo, issueNumber, body) {
+    if (!this.graphqlWithAuth) throw new Error("Not authenticated");
+    try {
+      const issueResponse = await this.graphqlWithAuth(ISSUE_NODE_ID_QUERY, {
+        owner: repo.owner,
+        name: repo.name,
+        number: issueNumber
+      });
+      const subjectId = issueResponse.repository.issueOrPullRequest?.id;
+      if (!subjectId) {
+        return false;
+      }
+      await this.graphqlWithAuth(ADD_COMMENT_MUTATION, { subjectId, body });
+      return true;
+    } catch {
+      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(COLLABORATORS_QUERY, {
+        owner: repo.owner,
+        name: repo.name
+      });
+      const users = response.repository.collaborators?.nodes || response.repository.assignableUsers.nodes || [];
+      return users.map((u) => ({ login: u.login, name: u.name }));
+    } catch {
+      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(RECENT_ISSUES_QUERY, {
+        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 {
+      const checkResponse = await this.graphqlWithAuth(LABEL_EXISTS_QUERY, {
+        owner: repo.owner,
+        name: repo.name,
+        labelName
+      });
+      if (checkResponse.repository.label) {
+        return true;
+      }
+      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,
+            description: `Active working indicator for ${this.username}`
+          })
+        }
+      );
+      return response.status === 201 || response.status === 422;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Add a label to an issue
+   */
+  async addLabelToIssue(repo, issueNumber, labelName) {
+    if (!this.graphqlWithAuth) throw new Error("Not authenticated");
+    try {
+      const response = await this.graphqlWithAuth(ISSUE_AND_LABEL_QUERY, {
+        owner: repo.owner,
+        name: repo.name,
+        number: issueNumber,
+        labelName
+      });
+      if (!response.repository.issue || !response.repository.label) {
+        return false;
+      }
+      await this.graphqlWithAuth(ADD_LABELS_MUTATION, {
+        issueId: response.repository.issue.id,
+        labelIds: [response.repository.label.id]
+      });
+      return true;
+    } catch {
+      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(ISSUE_AND_LABEL_QUERY, {
+        owner: repo.owner,
+        name: repo.name,
+        number: issueNumber,
+        labelName
+      });
+      if (!response.repository.issue || !response.repository.label) {
+        return false;
+      }
+      await this.graphqlWithAuth(REMOVE_LABELS_MUTATION, {
+        issueId: response.repository.issue.id,
+        labelIds: [response.repository.label.id]
+      });
+      return true;
+    } catch {
+      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(ISSUES_WITH_LABEL_QUERY, {
+        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(ISSUE_TYPES_QUERY, {
+        owner: repo.owner,
+        name: repo.name
+      });
+      return response.repository.issueTypes?.nodes || [];
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Set the issue type on an issue
+   */
+  async setIssueType(repo, issueNumber, issueTypeId) {
+    if (!this.graphqlWithAuth) throw new Error("Not authenticated");
+    try {
+      const issueResponse = await this.graphqlWithAuth(ISSUE_FOR_UPDATE_QUERY, {
+        owner: repo.owner,
+        name: repo.name,
+        number: issueNumber
+      });
+      if (!issueResponse.repository.issue) {
+        return false;
+      }
+      await this.graphqlWithAuth(UPDATE_ISSUE_TYPE_MUTATION, {
+        issueId: issueResponse.repository.issue.id,
+        issueTypeId
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/branch-linker.ts
+var BranchLinker = class {
+  storage;
+  constructor(storage) {
+    this.storage = storage;
+  }
+  /**
+   * Load links from storage (handles both sync and async adapters)
+   */
+  async loadLinks() {
+    const result = this.storage.load();
+    return result instanceof Promise ? await result : result;
+  }
+  /**
+   * Save links to storage (handles both sync and async adapters)
+   */
+  async saveLinks(links) {
+    const result = this.storage.save(links);
+    if (result instanceof Promise) {
+      await result;
+    }
+  }
+  /**
+   * Create a link between a branch and an issue.
+   * If a link already exists for this branch or issue in this repo, it will be replaced.
+   */
+  async link(branch, issueNumber, issueTitle, itemId, repo) {
+    const links = await this.loadLinks();
+    const filtered = links.filter(
+      (l) => !(l.repo === repo && (l.branch === branch || l.issueNumber === issueNumber))
+    );
+    filtered.push({
+      branch,
+      issueNumber,
+      issueTitle,
+      itemId,
+      repo,
+      linkedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    await this.saveLinks(filtered);
+  }
+  /**
+   * Remove the link for an issue.
+   * @returns true if a link was removed, false if no link existed
+   */
+  async unlink(repo, issueNumber) {
+    const links = await this.loadLinks();
+    const filtered = links.filter(
+      (l) => !(l.repo === repo && l.issueNumber === issueNumber)
+    );
+    if (filtered.length === links.length) {
+      return false;
+    }
+    await this.saveLinks(filtered);
+    return true;
+  }
+  /**
+   * Remove the link for a branch.
+   * @returns true if a link was removed, false if no link existed
+   */
+  async unlinkBranch(repo, branch) {
+    const links = await this.loadLinks();
+    const filtered = links.filter(
+      (l) => !(l.repo === repo && l.branch === branch)
+    );
+    if (filtered.length === links.length) {
+      return false;
+    }
+    await this.saveLinks(filtered);
+    return true;
+  }
+  /**
+   * Get the branch linked to an issue.
+   */
+  async getBranchForIssue(repo, issueNumber) {
+    const links = await this.loadLinks();
+    const link = links.find((l) => l.repo === repo && l.issueNumber === issueNumber);
+    return link?.branch || null;
+  }
+  /**
+   * Get the full link info for a branch.
+   */
+  async getLinkForBranch(repo, branch) {
+    const links = await this.loadLinks();
+    return links.find((l) => l.repo === repo && l.branch === branch) || null;
+  }
+  /**
+   * Get the full link info for an issue.
+   */
+  async getLinkForIssue(repo, issueNumber) {
+    const links = await this.loadLinks();
+    return links.find((l) => l.repo === repo && l.issueNumber === issueNumber) || null;
+  }
+  /**
+   * Get all links for a repository.
+   */
+  async getLinksForRepo(repo) {
+    const links = await this.loadLinks();
+    return links.filter((l) => l.repo === repo);
+  }
+  /**
+   * Get all links.
+   */
+  async getAllLinks() {
+    return this.loadLinks();
+  }
+  /**
+   * Check if a branch has a link.
+   */
+  async hasLinkForBranch(repo, branch) {
+    const link = await this.getLinkForBranch(repo, branch);
+    return link !== null;
+  }
+  /**
+   * Check if an issue has a link.
+   */
+  async hasLinkForIssue(repo, issueNumber) {
+    const link = await this.getLinkForIssue(repo, issueNumber);
+    return link !== null;
+  }
+};
+function createInMemoryAdapter() {
+  const adapter = {
+    links: [],
+    load() {
+      return [...this.links];
+    },
+    save(links) {
+      this.links = [...links];
+    }
+  };
+  return adapter;
+}
+
+// src/git-utils.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+
+// src/url-parser.ts
+function parseGitHubUrl(url) {
+  const sshMatch = url.match(/git@github\.com:([^/]+)\/(.+?)(?:\.git)?$/);
+  if (sshMatch) {
+    return {
+      owner: sshMatch[1],
+      name: sshMatch[2],
+      fullName: `${sshMatch[1]}/${sshMatch[2]}`
+    };
+  }
+  const httpsMatch = url.match(/https:\/\/github\.com\/([^/]+)\/(.+?)(?:\.git)?$/);
+  if (httpsMatch) {
+    return {
+      owner: httpsMatch[1],
+      name: httpsMatch[2],
+      fullName: `${httpsMatch[1]}/${httpsMatch[2]}`
+    };
+  }
+  return null;
+}
+function parseIssueUrl(url) {
+  const match = url.match(
+    /https:\/\/github\.com\/([^/]+)\/([^/]+)\/(issues|pull)\/(\d+)/
+  );
+  if (match) {
+    return {
+      owner: match[1],
+      repo: match[2],
+      number: parseInt(match[4], 10),
+      type: match[3] === "pull" ? "pull" : "issue"
+    };
+  }
+  return null;
+}
+function buildIssueUrl(owner, repo, number) {
+  return `https://github.com/${owner}/${repo}/issues/${number}`;
+}
+function buildPullRequestUrl(owner, repo, number) {
+  return `https://github.com/${owner}/${repo}/pull/${number}`;
+}
+function buildRepoUrl(owner, repo) {
+  return `https://github.com/${owner}/${repo}`;
+}
+function buildProjectUrl(owner, projectNumber) {
+  return `https://github.com/users/${owner}/projects/${projectNumber}`;
+}
+function buildOrgProjectUrl(org, projectNumber) {
+  return `https://github.com/orgs/${org}/projects/${projectNumber}`;
+}
+
+// src/git-utils.ts
+var execAsync = promisify(exec);
+async function execGit(command, options = {}) {
+  const cwd = options.cwd || process.cwd();
+  return execAsync(command, { cwd });
+}
+async function detectRepository(options = {}) {
+  try {
+    const { stdout } = await execGit("git remote get-url origin", options);
+    const url = stdout.trim();
+    return parseGitHubUrl(url);
+  } catch {
+    return null;
+  }
+}
+async function getCurrentBranch(options = {}) {
+  try {
+    const { stdout } = await execGit("git branch --show-current", options);
+    return stdout.trim() || null;
+  } catch {
+    return null;
+  }
+}
+async function hasUncommittedChanges(options = {}) {
+  try {
+    const { stdout } = await execGit("git status --porcelain", options);
+    return stdout.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+async function branchExists(branchName, options = {}) {
+  try {
+    await execGit(`git show-ref --verify --quiet refs/heads/${branchName}`, options);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function createBranch(branchName, options = {}) {
+  await execGit(`git checkout -b "${branchName}"`, options);
+}
+async function checkoutBranch(branchName, options = {}) {
+  await execGit(`git checkout "${branchName}"`, options);
+}
+async function pullLatest(options = {}) {
+  await execGit("git pull", options);
+}
+async function fetchOrigin(options = {}) {
+  await execGit("git fetch origin", options);
+}
+async function getCommitsBehind(branch, options = {}) {
+  try {
+    await fetchOrigin(options);
+    const { stdout } = await execGit(
+      `git rev-list --count ${branch}..origin/${branch}`,
+      options
+    );
+    return parseInt(stdout.trim(), 10) || 0;
+  } catch {
+    return 0;
+  }
+}
+async function getCommitsAhead(branch, options = {}) {
+  try {
+    await fetchOrigin(options);
+    const { stdout } = await execGit(
+      `git rev-list --count origin/${branch}..${branch}`,
+      options
+    );
+    return parseInt(stdout.trim(), 10) || 0;
+  } catch {
+    return 0;
+  }
+}
+async function isGitRepository(options = {}) {
+  try {
+    await execGit("git rev-parse --git-dir", options);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getRepositoryRoot(options = {}) {
+  try {
+    const { stdout } = await execGit("git rev-parse --show-toplevel", options);
+    return stdout.trim();
+  } catch {
+    return null;
+  }
+}
+function sanitizeForBranchName(str) {
+  return str.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").substring(0, 50);
+}
+function generateBranchName(pattern, vars, maxLength = 60) {
+  const sanitizedTitle = sanitizeForBranchName(vars.title);
+  let branch = pattern.replace("{user}", vars.user).replace("{number}", vars.number?.toString() || "draft").replace("{title}", sanitizedTitle).replace("{repo}", vars.repo);
+  if (branch.length > maxLength) {
+    branch = branch.substring(0, maxLength).replace(/-$/, "");
+  }
+  return branch;
+}
+async function getDefaultBranch(options = {}) {
+  try {
+    const { stdout } = await execGit(
+      "git symbolic-ref refs/remotes/origin/HEAD",
+      options
+    );
+    const ref = stdout.trim();
+    const match = ref.match(/refs\/remotes\/origin\/(.+)/);
+    if (match) {
+      return match[1];
+    }
+  } catch {
+  }
+  if (await branchExists("main", options)) {
+    return "main";
+  }
+  return "master";
+}
+export {
+  BranchLinker,
+  GitHubAPI,
+  branchExists,
+  buildIssueUrl,
+  buildOrgProjectUrl,
+  buildProjectUrl,
+  buildPullRequestUrl,
+  buildRepoUrl,
+  checkoutBranch,
+  createBranch,
+  createInMemoryAdapter,
+  detectRepository,
+  fetchOrigin,
+  generateBranchName,
+  getCommitsAhead,
+  getCommitsBehind,
+  getCurrentBranch,
+  getDefaultBranch,
+  getRepositoryRoot,
+  hasUncommittedChanges,
+  isGitRepository,
+  parseGitHubUrl,
+  parseIssueUrl,
+  pullLatest,
+  queries_exports as queries,
+  sanitizeForBranchName
+};