@happyvertical/repos 0.74.8

package/dist/index.js

@@ -0,0 +1,714 @@
+import { GraphQLClient } from "@happyvertical/graphql";
+import { readFile } from "node:fs/promises";
+import yaml from "js-yaml";
+var RepositoryErrorCode = /* @__PURE__ */ ((RepositoryErrorCode2) => {
+  RepositoryErrorCode2["NOT_FOUND"] = "NOT_FOUND";
+  RepositoryErrorCode2["UNAUTHORIZED"] = "UNAUTHORIZED";
+  RepositoryErrorCode2["FORBIDDEN"] = "FORBIDDEN";
+  RepositoryErrorCode2["RATE_LIMITED"] = "RATE_LIMITED";
+  RepositoryErrorCode2["VALIDATION_ERROR"] = "VALIDATION_ERROR";
+  RepositoryErrorCode2["NETWORK_ERROR"] = "NETWORK_ERROR";
+  RepositoryErrorCode2["UNKNOWN"] = "UNKNOWN";
+  return RepositoryErrorCode2;
+})(RepositoryErrorCode || {});
+class RepositoryError extends Error {
+  constructor(message, code, statusCode, response) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.response = response;
+    this.name = "RepositoryError";
+    Error.captureStackTrace(this, this.constructor);
+  }
+  static fromHTTPStatus(statusCode, message, response) {
+    let code;
+    switch (statusCode) {
+      case 404:
+        code = "NOT_FOUND";
+        break;
+      case 401:
+        code = "UNAUTHORIZED";
+        break;
+      case 403:
+        code = "FORBIDDEN";
+        break;
+      case 429:
+        code = "RATE_LIMITED";
+        break;
+      case 422:
+        code = "VALIDATION_ERROR";
+        break;
+      default:
+        code = "UNKNOWN";
+    }
+    return new RepositoryError(message, code, statusCode, response);
+  }
+  static networkError(message, cause) {
+    return new RepositoryError(
+      message,
+      "NETWORK_ERROR",
+      void 0,
+      cause
+    );
+  }
+  isRetryable() {
+    return this.code === "RATE_LIMITED" || this.code === "NETWORK_ERROR";
+  }
+}
+function isRepositoryInstance(value) {
+  return value !== null && typeof value === "object" && "getIssue" in value && "createIssue" in value && "addLabels" in value && typeof value.getIssue === "function";
+}
+async function getRepository(options) {
+  if (isRepositoryInstance(options)) {
+    return options;
+  }
+  if (!options.type) {
+    throw new RepositoryError(
+      "Repository type is required",
+      RepositoryErrorCode.VALIDATION_ERROR
+    );
+  }
+  if (!options.owner || !options.repo) {
+    throw new RepositoryError(
+      "Repository owner and repo are required",
+      RepositoryErrorCode.VALIDATION_ERROR
+    );
+  }
+  if (!options.token) {
+    throw new RepositoryError(
+      "Authentication token is required",
+      RepositoryErrorCode.UNAUTHORIZED
+    );
+  }
+  switch (options.type) {
+    case "github": {
+      const { GitHubRepository: GitHubRepository2 } = await Promise.resolve().then(() => index);
+      return new GitHubRepository2(options);
+    }
+    case "gitlab":
+      throw new RepositoryError(
+        "GitLab support not yet implemented",
+        RepositoryErrorCode.UNKNOWN
+      );
+    case "bitbucket":
+      throw new RepositoryError(
+        "Bitbucket support not yet implemented",
+        RepositoryErrorCode.UNKNOWN
+      );
+    case "azure":
+      throw new RepositoryError(
+        "Azure DevOps support not yet implemented",
+        RepositoryErrorCode.UNKNOWN
+      );
+    default:
+      throw new RepositoryError(
+        `Unsupported repository type: ${options.type}`,
+        RepositoryErrorCode.VALIDATION_ERROR
+      );
+  }
+}
+class GitHubRest {
+  token;
+  baseUrl;
+  constructor(config) {
+    this.token = config.token;
+    this.baseUrl = config.baseUrl || "https://api.github.com";
+  }
+  /**
+   * Make a REST API request
+   */
+  async request(method, path, body) {
+    const url = `${this.baseUrl}${path}`;
+    const headers = {
+      Authorization: `Bearer ${this.token}`,
+      Accept: "application/vnd.github+json",
+      "X-GitHub-Api-Version": "2022-11-28",
+      "Content-Type": "application/json"
+    };
+    const response = await fetch(url, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw RepositoryError.fromHTTPStatus(
+        response.status,
+        `GitHub API error: ${response.statusText}
+${error}`,
+        error
+      );
+    }
+    return response.json();
+  }
+  /**
+   * GET request
+   */
+  async get(path) {
+    return this.request("GET", path);
+  }
+  /**
+   * POST request
+   */
+  async post(path, body) {
+    return this.request("POST", path, body);
+  }
+  /**
+   * PATCH request
+   */
+  async patch(path, body) {
+    return this.request("PATCH", path, body);
+  }
+  /**
+   * PUT request
+   */
+  async put(path, body) {
+    return this.request("PUT", path, body);
+  }
+  /**
+   * DELETE request
+   */
+  async delete(path) {
+    await this.request("DELETE", path);
+  }
+}
+class GitHubRepository {
+  rest;
+  graphql;
+  owner;
+  repo;
+  constructor(config) {
+    if (config.type !== "github") {
+      throw new Error("Invalid config type for GitHubRepository");
+    }
+    this.owner = config.owner;
+    this.repo = config.repo;
+    this.rest = new GitHubRest({
+      token: config.token,
+      baseUrl: config.baseUrl
+    });
+    this.graphql = new GraphQLClient({
+      endpoint: config.baseUrl ? `${config.baseUrl}/graphql` : "https://api.github.com/graphql",
+      token: config.token
+    });
+  }
+  // Repository Info
+  async getRepository() {
+    const data = await this.rest.get(`/repos/${this.owner}/${this.repo}`);
+    return {
+      owner: data.owner.login,
+      name: data.name,
+      description: data.description,
+      defaultBranch: data.default_branch,
+      url: data.html_url,
+      isPrivate: data.private
+    };
+  }
+  // Issues
+  async getIssue(number) {
+    const data = await this.rest.get(
+      `/repos/${this.owner}/${this.repo}/issues/${number}`
+    );
+    return {
+      number: data.number,
+      id: data.node_id,
+      title: data.title,
+      body: data.body || "",
+      state: data.state === "open" ? "open" : "closed",
+      labels: data.labels.map((l) => ({
+        name: l.name,
+        color: l.color,
+        description: l.description
+      })),
+      assignees: data.assignees.map((a) => ({
+        login: a.login,
+        id: String(a.id),
+        type: a.type === "Bot" ? "Bot" : "User"
+      })),
+      author: {
+        login: data.user.login,
+        id: String(data.user.id),
+        type: data.user.type === "Bot" ? "Bot" : "User"
+      },
+      createdAt: new Date(data.created_at),
+      updatedAt: new Date(data.updated_at),
+      closedAt: data.closed_at ? new Date(data.closed_at) : void 0,
+      url: data.html_url,
+      commentsCount: data.comments
+    };
+  }
+  async createIssue(data) {
+    const result = await this.rest.post(
+      `/repos/${this.owner}/${this.repo}/issues`,
+      data
+    );
+    return this.getIssue(result.number);
+  }
+  async updateIssue(number, data) {
+    await this.rest.patch(
+      `/repos/${this.owner}/${this.repo}/issues/${number}`,
+      data
+    );
+    return this.getIssue(number);
+  }
+  async closeIssue(number) {
+    await this.updateIssue(number, { state: "closed" });
+  }
+  // Labels
+  async addLabels(issueNumber, labels) {
+    await this.rest.post(
+      `/repos/${this.owner}/${this.repo}/issues/${issueNumber}/labels`,
+      { labels }
+    );
+  }
+  async removeLabel(issueNumber, label) {
+    const encodedLabel = encodeURIComponent(label);
+    await this.rest.delete(
+      `/repos/${this.owner}/${this.repo}/issues/${issueNumber}/labels/${encodedLabel}`
+    );
+  }
+  async createLabel(label) {
+    await this.rest.post(`/repos/${this.owner}/${this.repo}/labels`, label);
+  }
+  async updateLabel(name, label) {
+    await this.rest.patch(
+      `/repos/${this.owner}/${this.repo}/labels/${encodeURIComponent(name)}`,
+      label
+    );
+  }
+  async listLabels() {
+    const data = await this.rest.get(
+      `/repos/${this.owner}/${this.repo}/labels`
+    );
+    return data.map((l) => ({
+      name: l.name,
+      color: l.color,
+      description: l.description
+    }));
+  }
+  // Comments
+  async addComment(issueNumber, body) {
+    const data = await this.rest.post(
+      `/repos/${this.owner}/${this.repo}/issues/${issueNumber}/comments`,
+      { body }
+    );
+    return {
+      id: String(data.id),
+      body: data.body,
+      author: {
+        login: data.user.login,
+        id: String(data.user.id),
+        type: data.user.type === "Bot" ? "Bot" : "User"
+      },
+      createdAt: new Date(data.created_at),
+      updatedAt: new Date(data.updated_at),
+      url: data.html_url
+    };
+  }
+  async updateComment(commentId, body) {
+    const data = await this.rest.patch(
+      `/repos/${this.owner}/${this.repo}/issues/comments/${commentId}`,
+      { body }
+    );
+    return data;
+  }
+  async deleteComment(commentId) {
+    await this.rest.delete(
+      `/repos/${this.owner}/${this.repo}/issues/comments/${commentId}`
+    );
+  }
+  async listComments(issueNumber) {
+    const data = await this.rest.get(
+      `/repos/${this.owner}/${this.repo}/issues/${issueNumber}/comments`
+    );
+    return data.map((c) => ({
+      id: String(c.id),
+      body: c.body,
+      author: {
+        login: c.user.login,
+        id: String(c.user.id),
+        type: c.user.type === "Bot" ? "Bot" : "User"
+      },
+      createdAt: new Date(c.created_at),
+      updatedAt: new Date(c.updated_at),
+      url: c.html_url
+    }));
+  }
+  // Assignments
+  async assignIssue(issueNumber, assignees) {
+    await this.rest.post(
+      `/repos/${this.owner}/${this.repo}/issues/${issueNumber}/assignees`,
+      { assignees }
+    );
+  }
+  async unassignIssue(issueNumber, assignees) {
+    await this.rest.delete(
+      `/repos/${this.owner}/${this.repo}/issues/${issueNumber}/assignees`
+    );
+  }
+  // Pull Requests
+  async getPullRequest(number) {
+    const issue = await this.getIssue(number);
+    const data = await this.rest.get(
+      `/repos/${this.owner}/${this.repo}/pulls/${number}`
+    );
+    return {
+      ...issue,
+      headRef: data.head.ref,
+      baseRef: data.base.ref,
+      merged: data.merged,
+      mergedAt: data.merged_at ? new Date(data.merged_at) : void 0,
+      mergeable: data.mergeable,
+      draft: data.draft
+    };
+  }
+  async createPullRequest(data) {
+    const result = await this.rest.post(
+      `/repos/${this.owner}/${this.repo}/pulls`,
+      {
+        title: data.title,
+        body: data.body,
+        head: data.headRef,
+        base: data.baseRef,
+        draft: data.draft
+      }
+    );
+    return this.getPullRequest(result.number);
+  }
+  async mergePullRequest(number, method) {
+    await this.rest.put(
+      `/repos/${this.owner}/${this.repo}/pulls/${number}/merge`,
+      {
+        merge_method: method || "merge"
+      }
+    );
+  }
+  // Search
+  async searchIssues(query, filters) {
+    let searchQuery = `${query} repo:${this.owner}/${this.repo}`;
+    if (filters?.state) {
+      searchQuery += ` state:${filters.state}`;
+    }
+    if (filters?.labels) {
+      searchQuery += ` ${filters.labels.map((l) => `label:"${l}"`).join(" ")}`;
+    }
+    if (filters?.author) {
+      searchQuery += ` author:${filters.author}`;
+    }
+    if (filters?.assignee) {
+      searchQuery += ` assignee:${filters.assignee}`;
+    }
+    const params = new URLSearchParams({
+      q: searchQuery,
+      sort: filters?.sort || "created",
+      order: filters?.order || "desc",
+      per_page: String(filters?.limit || 30)
+    });
+    const data = await this.rest.get(`/search/issues?${params}`);
+    return Promise.all(data.items.map((item) => this.getIssue(item.number)));
+  }
+  // Node ID resolution
+  async getIssueNodeId(issueNumber) {
+    const issue = await this.getIssue(issueNumber);
+    return issue.id;
+  }
+  async getPRNodeId(prNumber) {
+    const pr = await this.getPullRequest(prNumber);
+    return pr.id;
+  }
+  // Branch Management
+  async createBranch(name, fromRef) {
+    const refData = await this.rest.get(
+      `/repos/${this.owner}/${this.repo}/git/ref/heads/${fromRef}`
+    );
+    await this.rest.post(`/repos/${this.owner}/${this.repo}/git/refs`, {
+      ref: `refs/heads/${name}`,
+      sha: refData.object.sha
+    });
+    return {
+      name,
+      sha: refData.object.sha,
+      protected: false
+    };
+  }
+  async deleteBranch(name) {
+    await this.rest.delete(
+      `/repos/${this.owner}/${this.repo}/git/refs/heads/${name}`
+    );
+  }
+  async getBranch(name) {
+    try {
+      const data = await this.rest.get(
+        `/repos/${this.owner}/${this.repo}/branches/${encodeURIComponent(name)}`
+      );
+      return {
+        name: data.name,
+        sha: data.commit.sha,
+        protected: data.protected
+      };
+    } catch (error) {
+      if (error instanceof Error && "code" in error && error.code === "NOT_FOUND") {
+        return null;
+      }
+      throw error;
+    }
+  }
+  // PR Draft/Review
+  async markPRReady(prNumber) {
+    const pr = await this.getPullRequest(prNumber);
+    const mutation = `
+      mutation($pullRequestId: ID!) {
+        markPullRequestReadyForReview(input: {
+          pullRequestId: $pullRequestId
+        }) {
+          pullRequest {
+            id
+          }
+        }
+      }
+    `;
+    await this.graphql.mutate(mutation, { pullRequestId: pr.id });
+  }
+  async convertPRToDraft(prNumber) {
+    const pr = await this.getPullRequest(prNumber);
+    const mutation = `
+      mutation($pullRequestId: ID!) {
+        convertPullRequestToDraft(input: {
+          pullRequestId: $pullRequestId
+        }) {
+          pullRequest {
+            id
+          }
+        }
+      }
+    `;
+    await this.graphql.mutate(mutation, { pullRequestId: pr.id });
+  }
+  async requestReview(prNumber, reviewers) {
+    await this.rest.post(
+      `/repos/${this.owner}/${this.repo}/pulls/${prNumber}/requested_reviewers`,
+      { reviewers }
+    );
+  }
+  // Workflow
+  async triggerWorkflow(workflowId, ref, inputs) {
+    await this.rest.post(
+      `/repos/${this.owner}/${this.repo}/actions/workflows/${workflowId}/dispatches`,
+      { ref, inputs: inputs || {} }
+    );
+  }
+  // Linking
+  async findPRsForIssue(issueNumber) {
+    const keywords = ["closes", "fixes", "resolves"];
+    const searchTerms = keywords.map((k) => `${k} #${issueNumber}`).join(" OR ");
+    const query = `is:pr repo:${this.owner}/${this.repo} ${searchTerms}`;
+    const data = await this.rest.get(
+      `/search/issues?q=${encodeURIComponent(query)}`
+    );
+    return Promise.all(
+      data.items.map((item) => this.getPullRequest(item.number))
+    );
+  }
+  async findIssueForPR(prNumber) {
+    const pr = await this.getPullRequest(prNumber);
+    const closingPattern = /(?:closes?|fixes?|resolves?)\s+#(\d+)/gi;
+    const matches = [...pr.body.matchAll(closingPattern)];
+    if (matches.length === 0) {
+      return null;
+    }
+    const issueNumber = Number.parseInt(matches[0][1], 10);
+    try {
+      return await this.getIssue(issueNumber);
+    } catch {
+      return null;
+    }
+  }
+  // File Content
+  async getFileContent(path, ref) {
+    try {
+      const url = `/repos/${this.owner}/${this.repo}/contents/${path}${ref ? `?ref=${ref}` : ""}`;
+      const data = await this.rest.get(url);
+      if (data.type !== "file" || !data.content) {
+        return null;
+      }
+      if (data.encoding === "base64") {
+        return Buffer.from(data.content, "base64").toString("utf-8");
+      }
+      return data.content;
+    } catch {
+      return null;
+    }
+  }
+  async listDirectoryFiles(path, ref) {
+    try {
+      const url = `/repos/${this.owner}/${this.repo}/contents/${path}${ref ? `?ref=${ref}` : ""}`;
+      const data = await this.rest.get(url);
+      if (!Array.isArray(data)) {
+        return [];
+      }
+      return data.filter((item) => item.type === "file").map((item) => item.name);
+    } catch {
+      return [];
+    }
+  }
+  // Repository Creation from Template
+  /**
+   * Create a new repository from this repository as a template.
+   *
+   * Uses the GitHub "Generate" API: POST /repos/{template_owner}/{template_repo}/generate
+   * The current repository (this.owner/this.repo) is used as the template.
+   */
+  async createRepositoryFromTemplate(options) {
+    const data = await this.rest.post(
+      `/repos/${this.owner}/${this.repo}/generate`,
+      {
+        owner: options.owner,
+        name: options.name,
+        description: options.description || "",
+        private: options.isPrivate ?? true,
+        include_all_branches: options.includeAllBranches ?? false
+      }
+    );
+    return {
+      owner: data.owner.login,
+      name: data.name,
+      description: data.description || "",
+      defaultBranch: data.default_branch,
+      url: data.html_url,
+      isPrivate: data.private
+    };
+  }
+}
+const index = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  GitHubRepository
+}, Symbol.toStringTag, { value: "Module" }));
+async function loadIssueTemplate(yamlPath) {
+  const content = await readFile(yamlPath, "utf-8");
+  return parseIssueTemplate(content);
+}
+function parseIssueTemplate(yamlContent) {
+  const parsed = yaml.load(yamlContent);
+  if (!parsed.name) {
+    throw new Error("Issue template must have a name");
+  }
+  if (!parsed.body || !Array.isArray(parsed.body)) {
+    throw new Error("Issue template must have a body array");
+  }
+  return parsed;
+}
+function parseIssueBody(body, template) {
+  const sections = parseSections(body);
+  if (!template) {
+    return sections;
+  }
+  const labelToId = /* @__PURE__ */ new Map();
+  for (const field of template.body) {
+    if (field.id && field.attributes?.label) {
+      labelToId.set(field.attributes.label, field.id);
+    }
+  }
+  const result = {};
+  for (const [label, content] of Object.entries(sections)) {
+    const id = labelToId.get(label);
+    if (id) {
+      result[id] = content;
+    } else {
+      result[label] = content;
+    }
+  }
+  return result;
+}
+function parseSections(body) {
+  const result = {};
+  const sectionRegex = /^### (.+?)\r?\n\r?\n([\s\S]*?)(?=\r?\n### |\r?\n---|\s*$)/gm;
+  for (const match of body.matchAll(sectionRegex)) {
+    const label = match[1].trim();
+    const content = match[2].trim();
+    result[label] = content;
+  }
+  return result;
+}
+function renderIssueBody(fields, template) {
+  const sections = [];
+  if (!template) {
+    for (const [label, content] of Object.entries(fields)) {
+      sections.push(`### ${label}
+
+${content}`);
+    }
+  } else {
+    const idToContent = new Map(Object.entries(fields));
+    for (const field of template.body) {
+      if (!field.id || field.type === "markdown") {
+        continue;
+      }
+      const label = field.attributes?.label || field.id;
+      const content = idToContent.get(field.id);
+      if (content !== void 0) {
+        sections.push(`### ${label}
+
+${content}`);
+      }
+    }
+  }
+  return sections.join("\n\n");
+}
+function getIssueField(body, fieldIdOrLabel, template) {
+  const fields = parseIssueBody(body, template);
+  return fields[fieldIdOrLabel];
+}
+function updateIssueField(body, fieldIdOrLabel, value, template) {
+  const fields = parseIssueBody(body, template);
+  fields[fieldIdOrLabel] = value;
+  return renderIssueBody(fields, template);
+}
+async function fetchIssueTemplates(repo) {
+  const templatePath = ".github/ISSUE_TEMPLATE";
+  const files = await repo.listDirectoryFiles(templatePath);
+  const templates = [];
+  for (const file of files) {
+    if (file.endsWith(".yml") || file.endsWith(".yaml")) {
+      const content = await repo.getFileContent(`${templatePath}/${file}`);
+      if (content) {
+        try {
+          templates.push(parseIssueTemplate(content));
+        } catch (e) {
+          console.warn(`[repos] Failed to parse template ${file}:`, e);
+        }
+      }
+    }
+  }
+  return templates;
+}
+function detectTemplateFromLabels(labels, templates) {
+  const labelSet = new Set(labels.map((l) => l.toLowerCase()));
+  let bestMatch;
+  let bestScore = 0;
+  for (const template of templates) {
+    if (!template.labels || template.labels.length === 0) continue;
+    const matchCount = template.labels.filter(
+      (l) => labelSet.has(l.toLowerCase())
+    ).length;
+    if (matchCount > 0 && matchCount > bestScore) {
+      bestScore = matchCount;
+      bestMatch = template;
+    }
+  }
+  return bestMatch;
+}
+export {
+  GitHubRepository,
+  RepositoryError,
+  RepositoryErrorCode,
+  detectTemplateFromLabels,
+  fetchIssueTemplates,
+  getIssueField,
+  getRepository,
+  loadIssueTemplate,
+  parseIssueBody,
+  parseIssueTemplate,
+  renderIssueBody,
+  updateIssueField
+};
+//# sourceMappingURL=index.js.map