@hasna/connectors 1.3.31 → 1.3.33

package/connectors/{connect-googledocs → connect-github}/bin/index.js

@@ -2378,210 +2378,31 @@ var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
 var source_default = chalk;
 
 // src/types/index.ts
-class GoogleDocsApiError extends Error {
+class GitHubApiError extends Error {
   statusCode;
   errors;
-  constructor(message, statusCode, errors) {
+  documentationUrl;
+  constructor(message, statusCode, errors, documentationUrl) {
     super(message);
-    this.name = "GoogleDocsApiError";
+    this.name = "GitHubApiError";
     this.statusCode = statusCode;
     this.errors = errors;
+    this.documentationUrl = documentationUrl;
   }
 }
 
-// src/utils/config.ts
-import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, rmSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-var CONNECTOR_NAME = "connect-googledocs";
-var DEFAULT_PROFILE = "default";
-var profileOverride;
-var CONFIG_DIR = join(homedir(), ".hasna", "connectors", CONNECTOR_NAME);
-var PROFILES_DIR = join(CONFIG_DIR, "profiles");
-var CURRENT_PROFILE_FILE = join(CONFIG_DIR, "current_profile");
-function setProfileOverride(profile) {
-  profileOverride = profile;
-}
-function ensureConfigDir() {
-  if (!existsSync(CONFIG_DIR)) {
-    mkdirSync(CONFIG_DIR, { recursive: true });
-  }
-  if (!existsSync(PROFILES_DIR)) {
-    mkdirSync(PROFILES_DIR, { recursive: true });
-  }
-}
-function getProfilePath(profile) {
-  return join(PROFILES_DIR, `${profile}.json`);
-}
-function getCurrentProfile() {
-  if (profileOverride) {
-    return profileOverride;
-  }
-  ensureConfigDir();
-  if (existsSync(CURRENT_PROFILE_FILE)) {
-    try {
-      const profile = readFileSync(CURRENT_PROFILE_FILE, "utf-8").trim();
-      if (profile && profileExists(profile)) {
-        return profile;
-      }
-    } catch {}
-  }
-  return DEFAULT_PROFILE;
-}
-function setCurrentProfile(profile) {
-  ensureConfigDir();
-  if (!profileExists(profile) && profile !== DEFAULT_PROFILE) {
-    throw new Error(`Profile "${profile}" does not exist`);
-  }
-  writeFileSync(CURRENT_PROFILE_FILE, profile);
-}
-function profileExists(profile) {
-  return existsSync(getProfilePath(profile));
-}
-function listProfiles() {
-  ensureConfigDir();
-  if (!existsSync(PROFILES_DIR)) {
-    return [];
-  }
-  return readdirSync(PROFILES_DIR).filter((f) => f.endsWith(".json")).map((f) => f.replace(".json", "")).sort();
-}
-function createProfile(profile, config = {}) {
-  ensureConfigDir();
-  if (profileExists(profile)) {
-    return false;
-  }
-  if (!/^[a-zA-Z0-9_-]+$/.test(profile)) {
-    throw new Error("Profile name can only contain letters, numbers, hyphens, and underscores");
-  }
-  writeFileSync(getProfilePath(profile), JSON.stringify(config, null, 2));
-  return true;
-}
-function deleteProfile(profile) {
-  if (profile === DEFAULT_PROFILE) {
-    return false;
-  }
-  if (!profileExists(profile)) {
-    return false;
-  }
-  if (getCurrentProfile() === profile) {
-    setCurrentProfile(DEFAULT_PROFILE);
-  }
-  rmSync(getProfilePath(profile));
-  return true;
-}
-function loadProfile(profile) {
-  ensureConfigDir();
-  const profileName = profile || getCurrentProfile();
-  const profilePath = getProfilePath(profileName);
-  if (!existsSync(profilePath)) {
-    return {};
-  }
-  try {
-    return JSON.parse(readFileSync(profilePath, "utf-8"));
-  } catch {
-    return {};
-  }
-}
-function saveProfile(config, profile) {
-  ensureConfigDir();
-  const profileName = profile || getCurrentProfile();
-  writeFileSync(getProfilePath(profileName), JSON.stringify(config, null, 2));
-}
-function getApiKey() {
-  return process.env.GOOGLE_API_KEY || loadProfile().apiKey;
-}
-function setApiKey(apiKey) {
-  const config = loadProfile();
-  config.apiKey = apiKey;
-  saveProfile(config);
-}
-function getAccessToken() {
-  return process.env.GOOGLE_ACCESS_TOKEN || loadProfile().accessToken;
-}
-function setAccessToken(accessToken) {
-  const config = loadProfile();
-  config.accessToken = accessToken;
-  saveProfile(config);
-}
-var GOOGLE_TOKEN_URL = "https://oauth2.googleapis.com/token";
-function getRefreshToken() {
-  return process.env.GOOGLE_REFRESH_TOKEN || loadProfile().refreshToken;
-}
-async function refreshAccessToken() {
-  const profile = loadProfile();
-  const clientId = process.env.GOOGLE_CLIENT_ID || profile.clientId;
-  const clientSecret = process.env.GOOGLE_CLIENT_SECRET || profile.clientSecret;
-  const refreshToken = process.env.GOOGLE_REFRESH_TOKEN || profile.refreshToken;
-  if (!clientId || !clientSecret) {
-    throw new Error("OAuth client credentials not configured. Set clientId/clientSecret in profile or GOOGLE_CLIENT_ID/GOOGLE_CLIENT_SECRET env vars.");
-  }
-  if (!refreshToken) {
-    throw new Error("No refresh token available. Please re-authenticate.");
-  }
-  const response = await fetch(GOOGLE_TOKEN_URL, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/x-www-form-urlencoded"
-    },
-    body: new URLSearchParams({
-      client_id: clientId,
-      client_secret: clientSecret,
-      refresh_token: refreshToken,
-      grant_type: "refresh_token"
-    })
-  });
-  if (!response.ok) {
-    const error = await response.json();
-    throw new Error(`Token refresh failed: ${error.error_description || error.error}`);
-  }
-  const data = await response.json();
-  const updatedProfile = {
-    ...profile,
-    accessToken: data.access_token,
-    refreshToken,
-    expiresAt: Date.now() + data.expires_in * 1000
-  };
-  saveProfile(updatedProfile);
-  return updatedProfile;
-}
-async function getValidAccessToken() {
-  if (process.env.GOOGLE_ACCESS_TOKEN) {
-    return process.env.GOOGLE_ACCESS_TOKEN;
-  }
-  const profile = loadProfile();
-  if (!profile.accessToken) {
-    throw new Error('Not authenticated. Run "connect-googledocs config set-token <token>" or set GOOGLE_ACCESS_TOKEN.');
-  }
-  if (profile.expiresAt && profile.refreshToken) {
-    if (Date.now() >= profile.expiresAt - 5 * 60 * 1000) {
-      const updated = await refreshAccessToken();
-      return updated.accessToken;
-    }
-  }
-  return profile.accessToken;
-}
-function clearConfig() {
-  saveProfile({});
-}
-function getConfigDir() {
-  return CONFIG_DIR;
-}
-
 // src/api/client.ts
-var DEFAULT_BASE_URL = "https://docs.googleapis.com/v1";
+var DEFAULT_BASE_URL = "https://api.github.com";
+var API_VERSION = "2022-11-28";
 
-class GoogleDocsClient {
-  apiKey;
-  accessToken;
+class GitHubClient {
+  token;
   baseUrl;
-  useAutoRefresh;
   constructor(config) {
-    if (!config.apiKey && !config.accessToken) {
-      throw new Error("Either API key or access token is required");
+    if (!config.token) {
+      throw new Error("GitHub token is required");
     }
-    this.apiKey = config.apiKey;
-    this.accessToken = config.accessToken;
-    this.useAutoRefresh = config.autoRefresh !== false;
+    this.token = config.token;
     this.baseUrl = config.baseUrl || DEFAULT_BASE_URL;
   }
   buildUrl(path, params) {
@@ -2593,26 +2414,17 @@ class GoogleDocsClient {
         }
       });
     }
-    if (this.apiKey && !this.accessToken) {
-      url.searchParams.append("key", this.apiKey);
-    }
     return url.toString();
   }
   async request(path, options = {}) {
     const { method = "GET", params, body, headers = {} } = options;
-    if (this.accessToken && this.useAutoRefresh) {
-      try {
-        this.accessToken = await getValidAccessToken();
-      } catch {}
-    }
     const url = this.buildUrl(path, params);
     const requestHeaders = {
-      Accept: "application/json",
+      Authorization: `Bearer ${this.token}`,
+      Accept: "application/vnd.github+json",
+      "X-GitHub-Api-Version": API_VERSION,
       ...headers
     };
-    if (this.accessToken) {
-      requestHeaders["Authorization"] = `Bearer ${this.accessToken}`;
-    }
     if (body && ["POST", "PUT", "PATCH"].includes(method)) {
       requestHeaders["Content-Type"] = "application/json";
     }
@@ -2629,7 +2441,7 @@ class GoogleDocsClient {
     }
     let data;
     const contentType = response.headers.get("content-type") || "";
-    if (contentType.includes("application/json")) {
+    if (contentType.includes("application/json") || contentType.includes("application/vnd.github")) {
       const text = await response.text();
       if (text) {
         try {
@@ -2642,8 +2454,9 @@ class GoogleDocsClient {
       data = await response.text();
     }
     if (!response.ok) {
-      const errorMessage = typeof data === "object" && data !== null ? JSON.stringify(data) : String(data || response.statusText);
-      throw new GoogleDocsApiError(errorMessage, response.status);
+      const errorData = data;
+      const errorMessage = errorData?.message || response.statusText;
+      throw new GitHubApiError(errorMessage, response.status, errorData?.errors, errorData?.documentation_url);
     }
     return data;
   }
@@ -2662,464 +2475,406 @@ class GoogleDocsClient {
   async delete(path, params) {
     return this.request(path, { method: "DELETE", params });
   }
-  getCredentialsPreview() {
-    if (this.accessToken) {
-      if (this.accessToken.length > 10) {
-        return `Bearer ${this.accessToken.substring(0, 6)}...${this.accessToken.substring(this.accessToken.length - 4)}`;
-      }
-      return "Bearer ***";
+  getTokenPreview() {
+    if (this.token.length > 10) {
+      return `${this.token.substring(0, 6)}...${this.token.substring(this.token.length - 4)}`;
     }
-    if (this.apiKey) {
-      if (this.apiKey.length > 10) {
-        return `API Key ${this.apiKey.substring(0, 6)}...${this.apiKey.substring(this.apiKey.length - 4)}`;
-      }
-      return "API Key ***";
-    }
-    return "No credentials";
-  }
-  hasWriteAccess() {
-    return !!this.accessToken;
+    return "***";
   }
 }
 
-// src/api/documents.ts
-class DocumentsApi {
+// src/api/repos.ts
+class ReposApi {
   client;
   constructor(client) {
     this.client = client;
   }
-  async get(documentId, suggestionsViewMode) {
-    const params = {};
-    if (suggestionsViewMode) {
-      params.suggestionsViewMode = suggestionsViewMode;
-    }
-    return this.client.get(`/documents/${documentId}`, params);
+  async get(owner, repo) {
+    return this.client.get(`/repos/${owner}/${repo}`);
   }
-  async create(title) {
-    return this.client.post("/documents", { title });
+  async list(username, options) {
+    return this.client.get(`/users/${username}/repos`, options);
   }
-  async batchUpdate(documentId, requests, writeControl) {
-    const body = { requests };
-    if (writeControl) {
-      body.writeControl = writeControl;
-    }
-    return this.client.post(`/documents/${documentId}:batchUpdate`, body);
+  async listOrg(org, options) {
+    return this.client.get(`/orgs/${org}/repos`, options);
+  }
+  async listForAuthenticatedUser(options) {
+    return this.client.get("/user/repos", options);
+  }
+  async create(name, options) {
+    return this.client.post("/user/repos", {
+      name,
+      ...options
+    });
+  }
+  async createInOrg(org, name, options) {
+    return this.client.post(`/orgs/${org}/repos`, {
+      name,
+      ...options
+    });
+  }
+  async delete(owner, repo) {
+    await this.client.delete(`/repos/${owner}/${repo}`);
+  }
+  async getContent(owner, repo, path, options) {
+    return this.client.get(`/repos/${owner}/${repo}/contents/${path}`, options);
+  }
+  async createOrUpdateFile(owner, repo, path, options) {
+    return this.client.put(`/repos/${owner}/${repo}/contents/${path}`, options);
+  }
+  async deleteFile(owner, repo, path, options) {
+    return this.client.delete(`/repos/${owner}/${repo}/contents/${path}`, options);
+  }
+  async listCommits(owner, repo, options) {
+    return this.client.get(`/repos/${owner}/${repo}/commits`, options);
+  }
+  async getCommit(owner, repo, ref) {
+    return this.client.get(`/repos/${owner}/${repo}/commits/${ref}`);
+  }
+  async listBranches(owner, repo, options) {
+    return this.client.get(`/repos/${owner}/${repo}/branches`, options);
+  }
+  async listTopics(owner, repo) {
+    return this.client.get(`/repos/${owner}/${repo}/topics`);
+  }
+  async replaceTopics(owner, repo, names) {
+    return this.client.put(`/repos/${owner}/${repo}/topics`, { names });
   }
 }
 
-// src/api/content.ts
-class ContentApi {
+// src/api/issues.ts
+class IssuesApi {
   client;
   constructor(client) {
     this.client = client;
   }
-  async insertText(documentId, text, index) {
-    const requests = [
-      {
-        insertText: {
-          text,
-          location: { index }
-        }
-      }
-    ];
-    return this.batchUpdate(documentId, requests);
+  async list(owner, repo, options) {
+    return this.client.get(`/repos/${owner}/${repo}/issues`, options);
   }
-  async appendText(documentId, text) {
-    const requests = [
-      {
-        insertText: {
-          text,
-          endOfSegmentLocation: {}
-        }
-      }
-    ];
-    return this.batchUpdate(documentId, requests);
+  async get(owner, repo, issueNumber) {
+    return this.client.get(`/repos/${owner}/${repo}/issues/${issueNumber}`);
   }
-  async deleteRange(documentId, startIndex, endIndex) {
-    const requests = [
-      {
-        deleteContentRange: {
-          range: { startIndex, endIndex }
-        }
-      }
-    ];
-    return this.batchUpdate(documentId, requests);
+  async create(owner, repo, title, body, options) {
+    return this.client.post(`/repos/${owner}/${repo}/issues`, {
+      title,
+      body,
+      ...options
+    });
   }
-  async replaceText(documentId, find, replace, matchCase = false) {
-    const requests = [
-      {
-        replaceAllText: {
-          containsText: {
-            text: find,
-            matchCase
-          },
-          replaceText: replace
-        }
-      }
-    ];
-    return this.batchUpdate(documentId, requests);
+  async update(owner, repo, issueNumber, options) {
+    return this.client.patch(`/repos/${owner}/${repo}/issues/${issueNumber}`, options);
   }
-  async insertImage(documentId, uri, index, objectSize) {
-    const requests = [
-      {
-        insertInlineImage: {
-          uri,
-          location: { index },
-          ...objectSize && { objectSize }
-        }
-      }
-    ];
-    return this.batchUpdate(documentId, requests);
+  async lock(owner, repo, issueNumber, lockReason) {
+    await this.client.put(`/repos/${owner}/${repo}/issues/${issueNumber}/lock`, {
+      lock_reason: lockReason
+    });
   }
-  async appendImage(documentId, uri, objectSize) {
-    const requests = [
-      {
-        insertInlineImage: {
-          uri,
-          endOfSegmentLocation: {},
-          ...objectSize && { objectSize }
-        }
-      }
-    ];
-    return this.batchUpdate(documentId, requests);
+  async unlock(owner, repo, issueNumber) {
+    await this.client.delete(`/repos/${owner}/${repo}/issues/${issueNumber}/lock`);
   }
-  async insertPageBreak(documentId, index) {
-    const requests = [
-      {
-        insertPageBreak: {
-          location: { index }
-        }
-      }
-    ];
-    return this.batchUpdate(documentId, requests);
+  async listComments(owner, repo, issueNumber, options) {
+    return this.client.get(`/repos/${owner}/${repo}/issues/${issueNumber}/comments`, options);
   }
-  async insertTable(documentId, rows, columns, index) {
-    const requests = [
-      {
-        insertTable: {
-          rows,
-          columns,
-          location: { index }
-        }
-      }
-    ];
-    return this.batchUpdate(documentId, requests);
+  async getComment(owner, repo, commentId) {
+    return this.client.get(`/repos/${owner}/${repo}/issues/comments/${commentId}`);
   }
-  async createNamedRange(documentId, name, startIndex, endIndex) {
-    const requests = [
-      {
-        createNamedRange: {
-          name,
-          range: { startIndex, endIndex }
-        }
-      }
-    ];
-    return this.batchUpdate(documentId, requests);
+  async createComment(owner, repo, issueNumber, body) {
+    return this.client.post(`/repos/${owner}/${repo}/issues/${issueNumber}/comments`, { body });
   }
-  async deleteNamedRange(documentId, name) {
-    const requests = [
-      {
-        deleteNamedRange: { name }
-      }
-    ];
-    return this.batchUpdate(documentId, requests);
+  async updateComment(owner, repo, commentId, body) {
+    return this.client.patch(`/repos/${owner}/${repo}/issues/comments/${commentId}`, { body });
+  }
+  async deleteComment(owner, repo, commentId) {
+    await this.client.delete(`/repos/${owner}/${repo}/issues/comments/${commentId}`);
   }
-  async batchUpdate(documentId, requests) {
-    return this.client.post(`/documents/${documentId}:batchUpdate`, { requests });
+  async addLabels(owner, repo, issueNumber, labels) {
+    await this.client.post(`/repos/${owner}/${repo}/issues/${issueNumber}/labels`, { labels });
+  }
+  async removeLabel(owner, repo, issueNumber, label) {
+    await this.client.delete(`/repos/${owner}/${repo}/issues/${issueNumber}/labels/${label}`);
+  }
+  async addAssignees(owner, repo, issueNumber, assignees) {
+    return this.client.post(`/repos/${owner}/${repo}/issues/${issueNumber}/assignees`, { assignees });
+  }
+  async removeAssignees(owner, repo, issueNumber, assignees) {
+    return this.client.request(`/repos/${owner}/${repo}/issues/${issueNumber}/assignees`, { method: "DELETE", body: { assignees } });
   }
 }
 
-// src/api/styles.ts
-class StylesApi {
+// src/api/pulls.ts
+class PullsApi {
   client;
   constructor(client) {
     this.client = client;
   }
-  async updateTextStyle(documentId, range, style, fields) {
-    const requests = [
-      {
-        updateTextStyle: {
-          range,
-          textStyle: style,
-          fields
-        }
-      }
-    ];
-    return this.batchUpdate(documentId, requests);
-  }
-  async updateParagraphStyle(documentId, range, style, fields) {
-    const requests = [
-      {
-        updateParagraphStyle: {
-          range,
-          paragraphStyle: style,
-          fields
-        }
-      }
-    ];
-    return this.batchUpdate(documentId, requests);
+  async list(owner, repo, options) {
+    return this.client.get(`/repos/${owner}/${repo}/pulls`, options);
   }
-  async setBold(documentId, startIndex, endIndex) {
-    return this.updateTextStyle(documentId, { startIndex, endIndex }, { bold: true }, "bold");
+  async get(owner, repo, prNumber) {
+    return this.client.get(`/repos/${owner}/${repo}/pulls/${prNumber}`);
   }
-  async setItalic(documentId, startIndex, endIndex) {
-    return this.updateTextStyle(documentId, { startIndex, endIndex }, { italic: true }, "italic");
+  async create(owner, repo, title, head, base, body, options) {
+    return this.client.post(`/repos/${owner}/${repo}/pulls`, {
+      title,
+      head,
+      base,
+      body,
+      ...options
+    });
   }
-  async setUnderline(documentId, startIndex, endIndex) {
-    return this.updateTextStyle(documentId, { startIndex, endIndex }, { underline: true }, "underline");
+  async update(owner, repo, prNumber, options) {
+    return this.client.patch(`/repos/${owner}/${repo}/pulls/${prNumber}`, options);
   }
-  async setStrikethrough(documentId, startIndex, endIndex) {
-    return this.updateTextStyle(documentId, { startIndex, endIndex }, { strikethrough: true }, "strikethrough");
+  async merge(owner, repo, prNumber, options) {
+    return this.client.put(`/repos/${owner}/${repo}/pulls/${prNumber}/merge`, options || {});
   }
-  async setFontSize(documentId, startIndex, endIndex, sizePt) {
-    return this.updateTextStyle(documentId, { startIndex, endIndex }, { fontSize: { magnitude: sizePt, unit: "PT" } }, "fontSize");
+  async isMerged(owner, repo, prNumber) {
+    try {
+      await this.client.get(`/repos/${owner}/${repo}/pulls/${prNumber}/merge`);
+      return true;
+    } catch {
+      return false;
+    }
   }
-  async setFontFamily(documentId, startIndex, endIndex, fontFamily) {
-    return this.updateTextStyle(documentId, { startIndex, endIndex }, { weightedFontFamily: { fontFamily } }, "weightedFontFamily");
+  async listCommits(owner, repo, prNumber, options) {
+    return this.client.get(`/repos/${owner}/${repo}/pulls/${prNumber}/commits`, options);
   }
-  async setTextColor(documentId, startIndex, endIndex, red, green, blue) {
-    return this.updateTextStyle(documentId, { startIndex, endIndex }, {
-      foregroundColor: {
-        color: { rgbColor: { red, green, blue } }
-      }
-    }, "foregroundColor");
+  async listFiles(owner, repo, prNumber, options) {
+    return this.client.get(`/repos/${owner}/${repo}/pulls/${prNumber}/files`, options);
   }
-  async setHighlightColor(documentId, startIndex, endIndex, red, green, blue) {
-    return this.updateTextStyle(documentId, { startIndex, endIndex }, {
-      backgroundColor: {
-        color: { rgbColor: { red, green, blue } }
-      }
-    }, "backgroundColor");
+  async listReviews(owner, repo, prNumber, options) {
+    return this.client.get(`/repos/${owner}/${repo}/pulls/${prNumber}/reviews`, options);
   }
-  async setLink(documentId, startIndex, endIndex, url) {
-    return this.updateTextStyle(documentId, { startIndex, endIndex }, { link: { url } }, "link");
+  async getReview(owner, repo, prNumber, reviewId) {
+    return this.client.get(`/repos/${owner}/${repo}/pulls/${prNumber}/reviews/${reviewId}`);
   }
-  async setAlignment(documentId, startIndex, endIndex, alignment) {
-    return this.updateParagraphStyle(documentId, { startIndex, endIndex }, { alignment }, "alignment");
+  async createReview(owner, repo, prNumber, body, event, options) {
+    return this.client.post(`/repos/${owner}/${repo}/pulls/${prNumber}/reviews`, {
+      body,
+      event,
+      ...options
+    });
   }
-  async setLineSpacing(documentId, startIndex, endIndex, lineSpacing) {
-    return this.updateParagraphStyle(documentId, { startIndex, endIndex }, { lineSpacing }, "lineSpacing");
+  async submitReview(owner, repo, prNumber, reviewId, event, body) {
+    return this.client.post(`/repos/${owner}/${repo}/pulls/${prNumber}/reviews/${reviewId}/events`, { event, body });
   }
-  async setNamedStyle(documentId, startIndex, endIndex, namedStyleType) {
-    return this.updateParagraphStyle(documentId, { startIndex, endIndex }, { namedStyleType }, "namedStyleType");
+  async dismissReview(owner, repo, prNumber, reviewId, message) {
+    return this.client.put(`/repos/${owner}/${repo}/pulls/${prNumber}/reviews/${reviewId}/dismissals`, { message });
   }
-  async setSpacing(documentId, startIndex, endIndex, spaceAbovePt, spaceBelowPt) {
-    return this.updateParagraphStyle(documentId, { startIndex, endIndex }, {
-      spaceAbove: { magnitude: spaceAbovePt, unit: "PT" },
-      spaceBelow: { magnitude: spaceBelowPt, unit: "PT" }
-    }, "spaceAbove,spaceBelow");
+  async listReviewComments(owner, repo, prNumber, options) {
+    return this.client.get(`/repos/${owner}/${repo}/pulls/${prNumber}/comments`, options);
   }
-  async setIndentation(documentId, startIndex, endIndex, firstLinePt, startPt, endPt) {
-    const style = {};
-    const fields = [];
-    if (firstLinePt !== undefined) {
-      style.indentFirstLine = { magnitude: firstLinePt, unit: "PT" };
-      fields.push("indentFirstLine");
-    }
-    if (startPt !== undefined) {
-      style.indentStart = { magnitude: startPt, unit: "PT" };
-      fields.push("indentStart");
-    }
-    if (endPt !== undefined) {
-      style.indentEnd = { magnitude: endPt, unit: "PT" };
-      fields.push("indentEnd");
-    }
-    return this.updateParagraphStyle(documentId, { startIndex, endIndex }, style, fields.join(","));
+  async requestReviewers(owner, repo, prNumber, reviewers, teamReviewers) {
+    return this.client.post(`/repos/${owner}/${repo}/pulls/${prNumber}/requested_reviewers`, {
+      reviewers,
+      team_reviewers: teamReviewers
+    });
   }
-  async batchUpdate(documentId, requests) {
-    return this.client.post(`/documents/${documentId}:batchUpdate`, { requests });
+  async removeRequestedReviewers(owner, repo, prNumber, reviewers, teamReviewers) {
+    await this.client.request(`/repos/${owner}/${repo}/pulls/${prNumber}/requested_reviewers`, { method: "DELETE", body: { reviewers, team_reviewers: teamReviewers } });
   }
 }
 
-// src/api/bulk.ts
-class BulkApi {
+// src/api/users.ts
+class UsersApi {
   client;
   constructor(client) {
     this.client = client;
   }
-  async createDocuments(options) {
-    const { titles, concurrency = 10, dryRun = false, onProgress, onError } = options;
-    const result = {
-      total: titles.length,
-      success: 0,
-      failed: 0,
-      errors: [],
-      createdDocuments: []
-    };
-    if (titles.length === 0)
-      return result;
-    const chunks = this.chunkArray(titles, concurrency);
-    for (const chunk of chunks) {
-      await Promise.all(chunk.map(async (title) => {
-        try {
-          if (dryRun) {
-            result.success++;
-          } else {
-            const doc = await this.client.post("/documents", { title });
-            result.success++;
-            result.createdDocuments.push({
-              documentId: doc.documentId,
-              title: doc.title
-            });
-          }
-          if (onProgress)
-            onProgress(result.success + result.failed, result.total, title);
-        } catch (err) {
-          result.failed++;
-          const errorMessage = err instanceof Error ? err.message : String(err);
-          result.errors.push({ title, error: errorMessage });
-          if (onError)
-            onError(err instanceof Error ? err : new Error(errorMessage), title);
-        }
-      }));
-    }
-    return result;
-  }
-  async findReplace(options) {
-    const { entries, concurrency = 10, dryRun = false, onProgress, onError } = options;
-    const result = {
-      total: entries.length,
-      success: 0,
-      failed: 0,
-      errors: [],
-      results: []
-    };
-    if (entries.length === 0)
-      return result;
-    const chunks = this.chunkArray(entries, concurrency);
-    for (const chunk of chunks) {
-      await Promise.all(chunk.map(async (entry) => {
-        try {
-          if (dryRun) {
-            result.success++;
-            result.results.push({
-              documentId: entry.documentId,
-              occurrencesChanged: 0,
-              find: entry.find,
-              replace: entry.replace
-            });
-          } else {
-            const requests = [
-              {
-                replaceAllText: {
-                  containsText: {
-                    text: entry.find,
-                    matchCase: entry.matchCase || false
-                  },
-                  replaceText: entry.replace
-                }
-              }
-            ];
-            const response = await this.client.post(`/documents/${entry.documentId}:batchUpdate`, { requests });
-            const occurrencesChanged = response.replies?.find((r) => r.replaceAllText)?.replaceAllText?.occurrencesChanged || 0;
-            result.success++;
-            result.results.push({
-              documentId: entry.documentId,
-              occurrencesChanged,
-              find: entry.find,
-              replace: entry.replace
-            });
-          }
-          if (onProgress)
-            onProgress(result.success + result.failed, result.total, entry);
-        } catch (err) {
-          result.failed++;
-          const errorMessage = err instanceof Error ? err.message : String(err);
-          result.errors.push({
-            documentId: entry.documentId,
-            find: entry.find,
-            error: errorMessage
-          });
-          if (onError)
-            onError(err instanceof Error ? err : new Error(errorMessage), entry);
-        }
-      }));
-    }
-    return result;
+  async getAuthenticated() {
+    return this.client.get("/user");
   }
-  async batchUpdate(options) {
-    const { entries, concurrency = 10, dryRun = false, onProgress, onError } = options;
-    const result = {
-      total: entries.length,
-      success: 0,
-      failed: 0,
-      errors: [],
-      results: []
-    };
-    if (entries.length === 0)
-      return result;
-    const chunks = this.chunkArray(entries, concurrency);
-    for (const chunk of chunks) {
-      await Promise.all(chunk.map(async (entry) => {
-        try {
-          if (dryRun) {
-            result.success++;
-          } else {
-            const response = await this.client.post(`/documents/${entry.documentId}:batchUpdate`, { requests: entry.requests });
-            result.success++;
-            result.results.push({
-              documentId: entry.documentId,
-              response
-            });
-          }
-          if (onProgress)
-            onProgress(result.success + result.failed, result.total, entry);
-        } catch (err) {
-          result.failed++;
-          const errorMessage = err instanceof Error ? err.message : String(err);
-          result.errors.push({
-            documentId: entry.documentId,
-            error: errorMessage
-          });
-          if (onError)
-            onError(err instanceof Error ? err : new Error(errorMessage), entry);
-        }
-      }));
+  async get(username) {
+    return this.client.get(`/users/${username}`);
+  }
+  async listFollowers(username, options) {
+    return this.client.get(`/users/${username}/followers`, options);
+  }
+  async listFollowing(username, options) {
+    return this.client.get(`/users/${username}/following`, options);
+  }
+  async listMyFollowers(options) {
+    return this.client.get("/user/followers", options);
+  }
+  async listMyFollowing(options) {
+    return this.client.get("/user/following", options);
+  }
+  async isFollowing(username) {
+    try {
+      await this.client.get(`/user/following/${username}`);
+      return true;
+    } catch {
+      return false;
     }
-    return result;
   }
-  chunkArray(array, size) {
-    const chunks = [];
-    for (let i = 0;i < array.length; i += size) {
-      chunks.push(array.slice(i, i + size));
+  async checkFollowing(username, targetUser) {
+    try {
+      await this.client.get(`/users/${username}/following/${targetUser}`);
+      return true;
+    } catch {
+      return false;
     }
-    return chunks;
+  }
+  async follow(username) {
+    await this.client.put(`/user/following/${username}`, {});
+  }
+  async unfollow(username) {
+    await this.client.delete(`/user/following/${username}`);
+  }
+  async listEmails(options) {
+    return this.client.get("/user/emails", options);
+  }
+  async listPublicEmails(options) {
+    return this.client.get("/user/public_emails", options);
+  }
+  async update(options) {
+    return this.client.patch("/user", options);
   }
 }
 
 // src/api/index.ts
-class GoogleDocs {
+class GitHub {
   client;
-  documents;
-  content;
-  styles;
-  bulk;
+  repos;
+  issues;
+  pulls;
+  users;
   constructor(config) {
-    this.client = new GoogleDocsClient(config);
-    this.documents = new DocumentsApi(this.client);
-    this.content = new ContentApi(this.client);
-    this.styles = new StylesApi(this.client);
-    this.bulk = new BulkApi(this.client);
+    this.client = new GitHubClient(config);
+    this.repos = new ReposApi(this.client);
+    this.issues = new IssuesApi(this.client);
+    this.pulls = new PullsApi(this.client);
+    this.users = new UsersApi(this.client);
   }
   static fromEnv() {
-    const accessToken = process.env.GOOGLE_ACCESS_TOKEN;
-    const apiKey = process.env.GOOGLE_API_KEY;
-    if (!accessToken && !apiKey) {
-      throw new Error("GOOGLE_ACCESS_TOKEN or GOOGLE_API_KEY environment variable is required");
+    const token = process.env.GITHUB_TOKEN;
+    if (!token) {
+      throw new Error("GITHUB_TOKEN environment variable is required");
     }
-    return new GoogleDocs({ accessToken, apiKey });
+    const baseUrl = process.env.GITHUB_BASE_URL;
+    return new GitHub({ token, baseUrl });
   }
-  getCredentialsPreview() {
-    return this.client.getCredentialsPreview();
-  }
-  hasWriteAccess() {
-    return this.client.hasWriteAccess();
+  getTokenPreview() {
+    return this.client.getTokenPreview();
   }
   getClient() {
     return this.client;
   }
 }
 
+// src/utils/config.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, rmSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var CONNECTOR_NAME = "connect-github";
+var DEFAULT_PROFILE = "default";
+var profileOverride;
+var CONFIG_DIR = join(homedir(), ".connect", CONNECTOR_NAME);
+var PROFILES_DIR = join(CONFIG_DIR, "profiles");
+var CURRENT_PROFILE_FILE = join(CONFIG_DIR, "current_profile");
+function setProfileOverride(profile) {
+  profileOverride = profile;
+}
+function ensureConfigDir() {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  if (!existsSync(PROFILES_DIR)) {
+    mkdirSync(PROFILES_DIR, { recursive: true });
+  }
+}
+function getProfilePath(profile) {
+  return join(PROFILES_DIR, `${profile}.json`);
+}
+function getCurrentProfile() {
+  if (profileOverride) {
+    return profileOverride;
+  }
+  ensureConfigDir();
+  if (existsSync(CURRENT_PROFILE_FILE)) {
+    try {
+      const profile = readFileSync(CURRENT_PROFILE_FILE, "utf-8").trim();
+      if (profile && profileExists(profile)) {
+        return profile;
+      }
+    } catch {}
+  }
+  return DEFAULT_PROFILE;
+}
+function setCurrentProfile(profile) {
+  ensureConfigDir();
+  if (!profileExists(profile) && profile !== DEFAULT_PROFILE) {
+    throw new Error(`Profile "${profile}" does not exist`);
+  }
+  writeFileSync(CURRENT_PROFILE_FILE, profile);
+}
+function profileExists(profile) {
+  return existsSync(getProfilePath(profile));
+}
+function listProfiles() {
+  ensureConfigDir();
+  if (!existsSync(PROFILES_DIR)) {
+    return [];
+  }
+  return readdirSync(PROFILES_DIR).filter((f) => f.endsWith(".json")).map((f) => f.replace(".json", "")).sort();
+}
+function createProfile(profile, config = {}) {
+  ensureConfigDir();
+  if (profileExists(profile)) {
+    return false;
+  }
+  if (!/^[a-zA-Z0-9_-]+$/.test(profile)) {
+    throw new Error("Profile name can only contain letters, numbers, hyphens, and underscores");
+  }
+  writeFileSync(getProfilePath(profile), JSON.stringify(config, null, 2));
+  return true;
+}
+function deleteProfile(profile) {
+  if (profile === DEFAULT_PROFILE) {
+    return false;
+  }
+  if (!profileExists(profile)) {
+    return false;
+  }
+  if (getCurrentProfile() === profile) {
+    setCurrentProfile(DEFAULT_PROFILE);
+  }
+  rmSync(getProfilePath(profile));
+  return true;
+}
+function loadProfile(profile) {
+  ensureConfigDir();
+  const profileName = profile || getCurrentProfile();
+  const profilePath = getProfilePath(profileName);
+  if (!existsSync(profilePath)) {
+    return {};
+  }
+  try {
+    return JSON.parse(readFileSync(profilePath, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function saveProfile(config, profile) {
+  ensureConfigDir();
+  const profileName = profile || getCurrentProfile();
+  writeFileSync(getProfilePath(profileName), JSON.stringify(config, null, 2));
+}
+function getToken() {
+  return process.env.GITHUB_TOKEN || loadProfile().token;
+}
+function setToken(token) {
+  const config = loadProfile();
+  config.token = token;
+  saveProfile(config);
+}
+function clearConfig() {
+  saveProfile({});
+}
+function getConfigDir() {
+  return CONFIG_DIR;
+}
+
 // src/utils/output.ts
 function formatOutput(data, format = "pretty") {
   switch (format) {
@@ -3213,10 +2968,10 @@ function print(data, format = "pretty") {
 }
 
 // src/cli/index.ts
-var CONNECTOR_NAME2 = "connect-googledocs";
+var CONNECTOR_NAME2 = "connect-github";
 var VERSION = "0.0.1";
 var program2 = new Command;
-program2.name(CONNECTOR_NAME2).description("Google Docs API v1 connector - Create, read, and edit Google Docs").version(VERSION).option("-t, --token <token>", "OAuth access token (overrides config)").option("-k, --api-key <key>", "API key for read-only access (overrides config)").option("-f, --format <format>", "Output format (json, pretty)", "pretty").option("-p, --profile <profile>", "Use a specific profile").hook("preAction", (thisCommand) => {
+program2.name(CONNECTOR_NAME2).description("GitHub API connector CLI").version(VERSION).option("-t, --token <token>", "GitHub token (overrides config)").option("-f, --format <format>", "Output format (json, pretty)", "pretty").option("-p, --profile <profile>", "Use a specific profile").hook("preAction", (thisCommand) => {
   const opts = thisCommand.opts();
   if (opts.profile) {
     if (!profileExists(opts.profile)) {
@@ -3226,32 +2981,20 @@ program2.name(CONNECTOR_NAME2).description("Google Docs API v1 connector - Creat
     setProfileOverride(opts.profile);
   }
   if (opts.token) {
-    process.env.GOOGLE_ACCESS_TOKEN = opts.token;
-  }
-  if (opts.apiKey) {
-    process.env.GOOGLE_API_KEY = opts.apiKey;
+    process.env.GITHUB_TOKEN = opts.token;
   }
 });
 function getFormat(cmd) {
   const parent = cmd.parent;
   return parent?.opts().format || "pretty";
 }
-async function getClient() {
-  let accessToken = getAccessToken();
-  const apiKey = getApiKey();
-  if (!accessToken && !apiKey) {
-    const refreshToken = getRefreshToken();
-    if (refreshToken) {
-      try {
-        accessToken = await getValidAccessToken();
-      } catch {}
-    }
-    if (!accessToken) {
-      error(`No credentials configured. Run "${CONNECTOR_NAME2} config set-token <token>" or set GOOGLE_ACCESS_TOKEN environment variable.`);
-      process.exit(1);
-    }
+function getClient() {
+  const token = getToken();
+  if (!token) {
+    error(`No GitHub token configured. Run "${CONNECTOR_NAME2} config set-token <token>" or set GITHUB_TOKEN environment variable.`);
+    process.exit(1);
   }
-  return new GoogleDocs({ accessToken, apiKey });
+  return new GitHub({ token });
 }
 var profileCmd = program2.command("profile").description("Manage configuration profiles");
 profileCmd.command("list").description("List all profiles").action(() => {
@@ -3275,14 +3018,13 @@ profileCmd.command("use <name>").description("Switch to a profile").action((name
   setCurrentProfile(name);
   success(`Switched to profile: ${name}`);
 });
-profileCmd.command("create <name>").description("Create a new profile").option("--token <token>", "OAuth access token").option("--api-key <key>", "API key").option("--use", "Switch to this profile after creation").action((name, opts) => {
+profileCmd.command("create <name>").description("Create a new profile").option("--token <token>", "GitHub token").option("--use", "Switch to this profile after creation").action((name, opts) => {
   if (profileExists(name)) {
     error(`Profile "${name}" already exists`);
     process.exit(1);
   }
   createProfile(name, {
-    accessToken: opts.token,
-    apiKey: opts.apiKey
+    token: opts.token
   });
   success(`Profile "${name}" created`);
   if (opts.use) {
@@ -3307,291 +3049,467 @@ profileCmd.command("show [name]").description("Show profile configuration").acti
   const config = loadProfile(profileName);
   const active = getCurrentProfile();
   console.log(source_default.bold(`Profile: ${profileName}${profileName === active ? source_default.green(" (active)") : ""}`));
-  info(`Access Token: ${config.accessToken ? `${config.accessToken.substring(0, 8)}...` : source_default.gray("not set")}`);
-  info(`API Key: ${config.apiKey ? `${config.apiKey.substring(0, 8)}...` : source_default.gray("not set")}`);
+  info(`Token: ${config.token ? `${config.token.substring(0, 8)}...` : source_default.gray("not set")}`);
 });
 var configCmd = program2.command("config").description("Manage CLI configuration (for active profile)");
-configCmd.command("set-token <token>").description("Set OAuth access token").action((token) => {
-  setAccessToken(token);
-  success(`Access token saved to profile: ${getCurrentProfile()}`);
-});
-configCmd.command("set-key <apiKey>").description("Set API key (read-only access)").action((apiKey) => {
-  setApiKey(apiKey);
-  success(`API key saved to profile: ${getCurrentProfile()}`);
+configCmd.command("set-token <token>").description("Set GitHub token").action((token) => {
+  setToken(token);
+  success(`Token saved to profile: ${getCurrentProfile()}`);
 });
 configCmd.command("show").description("Show current configuration").action(() => {
   const profileName = getCurrentProfile();
-  const accessToken = getAccessToken();
-  const apiKey = getApiKey();
+  const token = getToken();
   console.log(source_default.bold(`Active Profile: ${profileName}`));
   info(`Config directory: ${getConfigDir()}`);
-  info(`Access Token: ${accessToken ? `${accessToken.substring(0, 8)}...` : source_default.gray("not set")}`);
-  info(`API Key: ${apiKey ? `${apiKey.substring(0, 8)}...` : source_default.gray("not set")}`);
+  info(`Token: ${token ? `${token.substring(0, 8)}...` : source_default.gray("not set")}`);
 });
 configCmd.command("clear").description("Clear configuration for active profile").action(() => {
   clearConfig();
   success(`Configuration cleared for profile: ${getCurrentProfile()}`);
 });
-program2.command("get <documentId>").description("Get a document by ID").action(async (documentId) => {
+var repoCmd = program2.command("repo").description("Manage repositories");
+repoCmd.command("list [owner]").description("List repositories for a user/org (defaults to authenticated user)").option("--org", "Treat owner as an organization").option("-n, --per-page <number>", "Results per page", "30").option("--page <number>", "Page number", "1").option("--sort <sort>", "Sort by: created, updated, pushed, full_name", "updated").action(async (owner, opts) => {
   try {
-    const client = await getClient();
-    const result = await client.documents.get(documentId);
-    print(result, getFormat(program2));
+    const client = getClient();
+    let repos;
+    if (!owner) {
+      repos = await client.repos.listForAuthenticatedUser({
+        per_page: parseInt(opts.perPage),
+        page: parseInt(opts.page),
+        sort: opts.sort
+      });
+    } else if (opts.org) {
+      repos = await client.repos.listOrg(owner, {
+        per_page: parseInt(opts.perPage),
+        page: parseInt(opts.page),
+        sort: opts.sort
+      });
+    } else {
+      repos = await client.repos.list(owner, {
+        per_page: parseInt(opts.perPage),
+        page: parseInt(opts.page),
+        sort: opts.sort
+      });
+    }
+    if (getFormat(repoCmd) === "json") {
+      print(repos, "json");
+    } else {
+      if (repos.length === 0) {
+        info("No repositories found");
+        return;
+      }
+      repos.forEach((repo) => {
+        const visibility = repo.private ? source_default.yellow("private") : source_default.green("public");
+        const stars = repo.stargazers_count > 0 ? source_default.yellow(`* ${repo.stargazers_count}`) : "";
+        console.log(`${source_default.cyan(repo.full_name)} ${visibility} ${stars}`);
+        if (repo.description) {
+          console.log(`  ${source_default.gray(repo.description)}`);
+        }
+      });
+    }
   } catch (err) {
     error(String(err));
     process.exit(1);
   }
 });
-program2.command("create <title>").description("Create a new document (requires OAuth token)").action(async (title) => {
+repoCmd.command("get <owner> <repo>").description("Get repository information").action(async (owner, repo) => {
   try {
-    const client = await getClient();
-    if (!client.hasWriteAccess()) {
-      error("Creating documents requires an OAuth access token. API key provides read-only access.");
-      process.exit(1);
-    }
-    const result = await client.documents.create(title);
-    success(`Document created: ${result.documentId}`);
-    print(result, getFormat(program2));
+    const client = getClient();
+    const result = await client.repos.get(owner, repo);
+    print(result, getFormat(repoCmd));
   } catch (err) {
     error(String(err));
     process.exit(1);
   }
 });
-program2.command("append <documentId> <text>").description("Append text to the end of a document (requires OAuth token)").action(async (documentId, text) => {
+repoCmd.command("create <name>").description("Create a new repository").option("-d, --description <description>", "Repository description").option("--private", "Create as private repository").option("--org <org>", "Create in an organization").option("--auto-init", "Initialize with README").action(async (name, opts) => {
   try {
-    const client = await getClient();
-    if (!client.hasWriteAccess()) {
-      error("Modifying documents requires an OAuth access token. API key provides read-only access.");
-      process.exit(1);
+    const client = getClient();
+    let result;
+    const options = {
+      description: opts.description,
+      private: opts.private,
+      auto_init: opts.autoInit
+    };
+    if (opts.org) {
+      result = await client.repos.createInOrg(opts.org, name, options);
+    } else {
+      result = await client.repos.create(name, options);
     }
-    const result = await client.content.appendText(documentId, text);
-    success("Text appended successfully");
-    print(result, getFormat(program2));
+    success(`Repository created: ${result.html_url}`);
+    print(result, getFormat(repoCmd));
   } catch (err) {
     error(String(err));
     process.exit(1);
   }
 });
-var bulkCmd = program2.command("bulk").description("Bulk operations on documents");
-bulkCmd.command("create").description("Bulk create documents from titles").requiredOption("--titles <titles>", "Comma-separated list of document titles").option("--concurrency <number>", "Max concurrent requests", "10").option("--dry-run", "Preview without making changes").action(async (opts) => {
+repoCmd.command("delete <owner> <repo>").description("Delete a repository").action(async (owner, repo) => {
   try {
-    const client = await getClient();
-    if (!client.hasWriteAccess()) {
-      error("Creating documents requires an OAuth access token.");
-      process.exit(1);
-    }
-    const titles = opts.titles.split(",").map((t) => t.trim()).filter(Boolean);
-    const concurrency = parseInt(opts.concurrency, 10);
-    if (titles.length === 0) {
-      error("No titles provided");
-      process.exit(1);
-    }
-    info(`Creating ${titles.length} document(s) (concurrency: ${concurrency})...`);
-    if (opts.dryRun)
-      info("(dry run)");
-    const result = await client.bulk.createDocuments({
-      titles,
-      concurrency,
-      dryRun: opts.dryRun,
-      onProgress: (current, total) => {
-        process.stdout.write(`\rProgress: ${current}/${total}`);
-      },
-      onError: (err, title) => {
-        warn(`
-  Failed: ${title} - ${err.message}`);
+    const client = getClient();
+    await client.repos.delete(owner, repo);
+    success(`Repository ${owner}/${repo} deleted`);
+  } catch (err) {
+    error(String(err));
+    process.exit(1);
+  }
+});
+repoCmd.command("content <owner> <repo> <path>").description("Get file or directory content").option("--ref <ref>", "Git ref (branch, tag, commit)").action(async (owner, repo, path, opts) => {
+  try {
+    const client = getClient();
+    const result = await client.repos.getContent(owner, repo, path, { ref: opts.ref });
+    if (!Array.isArray(result) && result.type === "file" && result.content) {
+      if (getFormat(repoCmd) === "json") {
+        print(result, "json");
+      } else {
+        const content = Buffer.from(result.content, "base64").toString("utf-8");
+        console.log(content);
       }
+    } else {
+      print(result, getFormat(repoCmd));
+    }
+  } catch (err) {
+    error(String(err));
+    process.exit(1);
+  }
+});
+repoCmd.command("commits <owner> <repo>").description("List commits on a repository").option("--sha <sha>", "SHA or branch to start listing from").option("--path <path>", "Only commits containing this file path").option("--author <author>", "GitHub login or email to filter by").option("--since <since>", "Only commits after this date (ISO 8601)").option("--until <until>", "Only commits before this date (ISO 8601)").option("--limit <number>", "Maximum results", "10").action(async (owner, repo, opts) => {
+  try {
+    const client = getClient();
+    const commits = await client.repos.listCommits(owner, repo, {
+      sha: opts.sha,
+      path: opts.path,
+      author: opts.author,
+      since: opts.since,
+      until: opts.until,
+      per_page: parseInt(opts.limit, 10) || 10
     });
-    console.log();
-    success(`Done: ${result.success} created, ${result.failed} failed`);
-    if (result.errors.length > 0) {
-      warn("Errors:");
-      for (const e of result.errors) {
-        console.log(`  - ${e.title}: ${e.error}`);
+    if (getFormat(repoCmd) === "json") {
+      print(commits, "json");
+    } else {
+      if (commits.length === 0) {
+        info("No commits found.");
+        return;
       }
-    }
-    if (result.createdDocuments.length > 0) {
-      print(result.createdDocuments, getFormat(program2));
+      for (const c of commits) {
+        const date = c.commit.author?.date ? new Date(c.commit.author.date).toLocaleDateString() : "";
+        const author = c.commit.author?.name || c.author?.login || "unknown";
+        const msg = c.commit.message.split(`
+`)[0];
+        console.log(`${source_default.yellow(c.sha.slice(0, 7))} ${source_default.gray(date)} ${source_default.cyan(author)} ${msg}`);
+      }
+      info(`${commits.length} commit(s)`);
     }
   } catch (err) {
     error(String(err));
     process.exit(1);
   }
 });
-bulkCmd.command("find-replace").description("Bulk find and replace across documents").requiredOption("--entries <entries>", "JSON array of {documentId, find, replace, matchCase?}").option("--concurrency <number>", "Max concurrent requests", "10").option("--dry-run", "Preview without making changes").action(async (opts) => {
+repoCmd.command("commit <owner> <repo> <ref>").description("Get a single commit by SHA or ref").action(async (owner, repo, ref) => {
   try {
-    const client = await getClient();
-    if (!client.hasWriteAccess()) {
-      error("Modifying documents requires an OAuth access token.");
-      process.exit(1);
-    }
-    let entries;
-    try {
-      entries = JSON.parse(opts.entries);
-    } catch {
-      error("Invalid JSON for --entries");
-      process.exit(1);
-    }
-    const concurrency = parseInt(opts.concurrency, 10);
-    if (entries.length === 0) {
-      error("No entries provided");
-      process.exit(1);
-    }
-    info(`Processing ${entries.length} find/replace operation(s)...`);
-    if (opts.dryRun)
-      info("(dry run)");
-    const result = await client.bulk.findReplace({
-      entries,
-      concurrency,
-      dryRun: opts.dryRun,
-      onProgress: (current, total) => {
-        process.stdout.write(`\rProgress: ${current}/${total}`);
-      },
-      onError: (err, entry) => {
-        const e = entry;
-        warn(`
-  Failed: ${e.documentId} - ${err.message}`);
+    const client = getClient();
+    const commit = await client.repos.getCommit(owner, repo, ref);
+    if (getFormat(repoCmd) === "json") {
+      print(commit, "json");
+    } else {
+      const msg = commit.commit.message.split(`
+`)[0];
+      const author = commit.commit.author?.name || "unknown";
+      const date = commit.commit.author?.date || "";
+      console.log(`${source_default.yellow("Commit:")} ${commit.sha}`);
+      console.log(`${source_default.cyan("Author:")} ${author}`);
+      console.log(`${source_default.gray("Date:")}   ${date}`);
+      console.log(`${source_default.white("Message:")} ${msg}`);
+      if (commit.parents.length > 0) {
+        console.log(`${source_default.gray("Parents:")} ${commit.parents.map((p) => p.sha.slice(0, 7)).join(", ")}`);
       }
+    }
+  } catch (err) {
+    error(String(err));
+    process.exit(1);
+  }
+});
+repoCmd.command("branches <owner> <repo>").description("List branches for a repository").option("--protected", "Only show protected branches").option("--limit <number>", "Maximum results", "30").action(async (owner, repo, opts) => {
+  try {
+    const client = getClient();
+    const branches = await client.repos.listBranches(owner, repo, {
+      protected: opts.protected,
+      per_page: parseInt(opts.limit, 10) || 30
     });
-    console.log();
-    success(`Done: ${result.success} succeeded, ${result.failed} failed`);
-    if (result.errors.length > 0) {
-      warn("Errors:");
-      for (const e of result.errors) {
-        console.log(`  - ${e.documentId} ("${e.find}"): ${e.error}`);
+    if (getFormat(repoCmd) === "json") {
+      print(branches, "json");
+    } else {
+      if (branches.length === 0) {
+        info("No branches found.");
+        return;
       }
-    }
-    if (result.results.length > 0 && !opts.dryRun) {
-      info("Results:");
-      for (const r of result.results) {
-        console.log(`  ${r.documentId}: ${r.occurrencesChanged} occurrence(s) of "${r.find}" replaced with "${r.replace}"`);
+      for (const b of branches) {
+        const prot = b.protected ? source_default.yellow(" [protected]") : "";
+        console.log(`${source_default.cyan(b.name)}${prot} ${source_default.gray(b.commit.sha.slice(0, 7))}`);
       }
+      info(`${branches.length} branch(es)`);
     }
   } catch (err) {
     error(String(err));
     process.exit(1);
   }
 });
-bulkCmd.command("batch-update").description("Bulk batch updates across documents").requiredOption("--entries <entries>", "JSON array of {documentId, requests: [...]}").option("--concurrency <number>", "Max concurrent requests", "10").option("--dry-run", "Preview without making changes").action(async (opts) => {
+var issueCmd = program2.command("issue").description("Manage issues");
+issueCmd.command("list <owner> <repo>").description("List issues in a repository").option("--state <state>", "Filter by state: open, closed, all", "open").option("--labels <labels>", "Filter by labels (comma-separated)").option("-n, --per-page <number>", "Results per page", "30").option("--page <number>", "Page number", "1").action(async (owner, repo, opts) => {
   try {
-    const client = await getClient();
-    if (!client.hasWriteAccess()) {
-      error("Modifying documents requires an OAuth access token.");
-      process.exit(1);
-    }
-    let entries;
-    try {
-      entries = JSON.parse(opts.entries);
-    } catch {
-      error("Invalid JSON for --entries");
-      process.exit(1);
-    }
-    const concurrency = parseInt(opts.concurrency, 10);
-    if (entries.length === 0) {
-      error("No entries provided");
-      process.exit(1);
-    }
-    info(`Processing ${entries.length} batch update(s)...`);
-    if (opts.dryRun)
-      info("(dry run)");
-    const result = await client.bulk.batchUpdate({
-      entries,
-      concurrency,
-      dryRun: opts.dryRun,
-      onProgress: (current, total) => {
-        process.stdout.write(`\rProgress: ${current}/${total}`);
-      },
-      onError: (err, entry) => {
-        const e = entry;
-        warn(`
-  Failed: ${e.documentId} - ${err.message}`);
-      }
+    const client = getClient();
+    const issues = await client.issues.list(owner, repo, {
+      state: opts.state,
+      labels: opts.labels,
+      per_page: parseInt(opts.perPage),
+      page: parseInt(opts.page)
     });
-    console.log();
-    success(`Done: ${result.success} succeeded, ${result.failed} failed`);
-    if (result.errors.length > 0) {
-      warn("Errors:");
-      for (const e of result.errors) {
-        console.log(`  - ${e.documentId}: ${e.error}`);
+    if (getFormat(issueCmd) === "json") {
+      print(issues, "json");
+    } else {
+      if (issues.length === 0) {
+        info("No issues found");
+        return;
       }
+      issues.forEach((issue) => {
+        const state = issue.state === "open" ? source_default.green("open") : source_default.red("closed");
+        const labels = issue.labels.map((l) => source_default.cyan(l.name)).join(", ");
+        console.log(`#${issue.number} ${state} ${source_default.bold(issue.title)}`);
+        if (labels)
+          console.log(`  Labels: ${labels}`);
+        if (issue.assignee)
+          console.log(`  Assignee: ${source_default.yellow(issue.assignee.login)}`);
+      });
     }
   } catch (err) {
     error(String(err));
     process.exit(1);
   }
 });
-program2.command("replace <documentId> <find> <replace>").description("Find and replace text in a document (requires OAuth token)").option("--match-case", "Match case when finding text").action(async (documentId, find, replace, opts) => {
+issueCmd.command("get <owner> <repo> <number>").description("Get an issue").action(async (owner, repo, number) => {
   try {
-    const client = await getClient();
-    if (!client.hasWriteAccess()) {
-      error("Modifying documents requires an OAuth access token. API key provides read-only access.");
-      process.exit(1);
-    }
-    const result = await client.content.replaceText(documentId, find, replace, opts.matchCase);
-    const replaceReply = result.replies?.find((r) => r.replaceAllText);
-    const count = replaceReply?.replaceAllText?.occurrencesChanged || 0;
-    success(`Replaced ${count} occurrence(s)`);
-    print(result, getFormat(program2));
+    const client = getClient();
+    const result = await client.issues.get(owner, repo, parseInt(number));
+    print(result, getFormat(issueCmd));
   } catch (err) {
     error(String(err));
     process.exit(1);
   }
 });
-program2.command("insert <documentId> <text> <index>").description("Insert text at a specific position (requires OAuth token)").action(async (documentId, text, index) => {
+issueCmd.command("create <owner> <repo>").description("Create an issue").requiredOption("-t, --title <title>", "Issue title").option("-b, --body <body>", "Issue body").option("--labels <labels>", "Labels (comma-separated)").option("--assignees <assignees>", "Assignees (comma-separated)").action(async (owner, repo, opts) => {
   try {
-    const client = await getClient();
-    if (!client.hasWriteAccess()) {
-      error("Modifying documents requires an OAuth access token. API key provides read-only access.");
-      process.exit(1);
+    const client = getClient();
+    const result = await client.issues.create(owner, repo, opts.title, opts.body, {
+      labels: opts.labels?.split(",").map((l) => l.trim()),
+      assignees: opts.assignees?.split(",").map((a) => a.trim())
+    });
+    success(`Issue created: ${result.html_url}`);
+    print(result, getFormat(issueCmd));
+  } catch (err) {
+    error(String(err));
+    process.exit(1);
+  }
+});
+issueCmd.command("close <owner> <repo> <number>").description("Close an issue").option("--reason <reason>", "Close reason: completed, not_planned", "completed").action(async (owner, repo, number, opts) => {
+  try {
+    const client = getClient();
+    await client.issues.update(owner, repo, parseInt(number), {
+      state: "closed",
+      state_reason: opts.reason
+    });
+    success(`Issue #${number} closed`);
+  } catch (err) {
+    error(String(err));
+    process.exit(1);
+  }
+});
+issueCmd.command("comment <owner> <repo> <number>").description("Add a comment to an issue").requiredOption("-b, --body <body>", "Comment body").action(async (owner, repo, number, opts) => {
+  try {
+    const client = getClient();
+    const result = await client.issues.createComment(owner, repo, parseInt(number), opts.body);
+    success(`Comment added: ${result.html_url}`);
+  } catch (err) {
+    error(String(err));
+    process.exit(1);
+  }
+});
+issueCmd.command("comments <owner> <repo> <number>").description("List comments on an issue").action(async (owner, repo, number) => {
+  try {
+    const client = getClient();
+    const comments = await client.issues.listComments(owner, repo, parseInt(number));
+    if (getFormat(issueCmd) === "json") {
+      print(comments, "json");
+    } else {
+      if (comments.length === 0) {
+        info("No comments");
+        return;
+      }
+      comments.forEach((comment) => {
+        console.log(`${source_default.cyan(comment.user.login)} ${source_default.gray(comment.created_at)}`);
+        console.log(`  ${comment.body}`);
+        console.log();
+      });
     }
-    const idx = parseInt(index, 10);
-    if (isNaN(idx) || idx < 1) {
-      error("Index must be a positive integer (1 or greater)");
-      process.exit(1);
+  } catch (err) {
+    error(String(err));
+    process.exit(1);
+  }
+});
+var prCmd = program2.command("pr").description("Manage pull requests");
+prCmd.command("list <owner> <repo>").description("List pull requests").option("--state <state>", "Filter by state: open, closed, all", "open").option("--base <base>", "Filter by base branch").option("--head <head>", "Filter by head branch").option("-n, --per-page <number>", "Results per page", "30").option("--page <number>", "Page number", "1").action(async (owner, repo, opts) => {
+  try {
+    const client = getClient();
+    const prs = await client.pulls.list(owner, repo, {
+      state: opts.state,
+      base: opts.base,
+      head: opts.head,
+      per_page: parseInt(opts.perPage),
+      page: parseInt(opts.page)
+    });
+    if (getFormat(prCmd) === "json") {
+      print(prs, "json");
+    } else {
+      if (prs.length === 0) {
+        info("No pull requests found");
+        return;
+      }
+      prs.forEach((pr) => {
+        const state = pr.state === "open" ? source_default.green("open") : source_default.red("closed");
+        const merged = pr.merged ? source_default.magenta(" [merged]") : "";
+        const draft = pr.draft ? source_default.gray(" [draft]") : "";
+        console.log(`#${pr.number} ${state}${merged}${draft} ${source_default.bold(pr.title)}`);
+        console.log(`  ${source_default.cyan(pr.head.ref)} -> ${source_default.cyan(pr.base.ref)}`);
+        if (pr.user)
+          console.log(`  Author: ${source_default.yellow(pr.user.login)}`);
+      });
     }
-    const result = await client.content.insertText(documentId, text, idx);
-    success("Text inserted successfully");
-    print(result, getFormat(program2));
   } catch (err) {
     error(String(err));
     process.exit(1);
   }
 });
-program2.command("delete-range <documentId> <startIndex> <endIndex>").description("Delete content within a range (requires OAuth token)").action(async (documentId, startIndex, endIndex) => {
+prCmd.command("get <owner> <repo> <number>").description("Get a pull request").action(async (owner, repo, number) => {
   try {
-    const client = await getClient();
-    if (!client.hasWriteAccess()) {
-      error("Modifying documents requires an OAuth access token. API key provides read-only access.");
-      process.exit(1);
+    const client = getClient();
+    const result = await client.pulls.get(owner, repo, parseInt(number));
+    print(result, getFormat(prCmd));
+  } catch (err) {
+    error(String(err));
+    process.exit(1);
+  }
+});
+prCmd.command("create <owner> <repo>").description("Create a pull request").requiredOption("-t, --title <title>", "PR title").requiredOption("--head <head>", "Head branch").requiredOption("--base <base>", "Base branch").option("-b, --body <body>", "PR body").option("--draft", "Create as draft").action(async (owner, repo, opts) => {
+  try {
+    const client = getClient();
+    const result = await client.pulls.create(owner, repo, opts.title, opts.head, opts.base, opts.body, { draft: opts.draft });
+    success(`Pull request created: ${result.html_url}`);
+    print(result, getFormat(prCmd));
+  } catch (err) {
+    error(String(err));
+    process.exit(1);
+  }
+});
+prCmd.command("merge <owner> <repo> <number>").description("Merge a pull request").option("--method <method>", "Merge method: merge, squash, rebase", "merge").option("--title <title>", "Commit title").option("--message <message>", "Commit message").action(async (owner, repo, number, opts) => {
+  try {
+    const client = getClient();
+    const result = await client.pulls.merge(owner, repo, parseInt(number), {
+      merge_method: opts.method,
+      commit_title: opts.title,
+      commit_message: opts.message
+    });
+    if (result.merged) {
+      success(`Pull request #${number} merged`);
+    } else {
+      warn(`Merge result: ${result.message}`);
     }
-    const start = parseInt(startIndex, 10);
-    const end = parseInt(endIndex, 10);
-    if (isNaN(start) || isNaN(end) || start < 1 || end <= start) {
-      error("Invalid range. Start must be >= 1 and end must be > start.");
-      process.exit(1);
+  } catch (err) {
+    error(String(err));
+    process.exit(1);
+  }
+});
+prCmd.command("reviews <owner> <repo> <number>").description("List reviews on a pull request").action(async (owner, repo, number) => {
+  try {
+    const client = getClient();
+    const reviews = await client.pulls.listReviews(owner, repo, parseInt(number));
+    if (getFormat(prCmd) === "json") {
+      print(reviews, "json");
+    } else {
+      if (reviews.length === 0) {
+        info("No reviews");
+        return;
+      }
+      reviews.forEach((review) => {
+        const stateColor = review.state === "APPROVED" ? source_default.green : review.state === "CHANGES_REQUESTED" ? source_default.red : source_default.gray;
+        console.log(`${source_default.cyan(review.user.login)} ${stateColor(review.state)}`);
+        if (review.body)
+          console.log(`  ${review.body}`);
+      });
     }
-    const result = await client.content.deleteRange(documentId, start, end);
-    success("Content deleted successfully");
-    print(result, getFormat(program2));
   } catch (err) {
     error(String(err));
     process.exit(1);
   }
 });
-program2.command("insert-image <documentId> <uri> <index>").description("Insert an image at a specific position (requires OAuth token)").action(async (documentId, uri, index) => {
+prCmd.command("review <owner> <repo> <number>").description("Create a review on a pull request").option("-b, --body <body>", "Review body").option("--approve", "Approve the PR").option("--request-changes", "Request changes").option("--comment", "Just comment (no approval)").action(async (owner, repo, number, opts) => {
   try {
-    const client = await getClient();
-    if (!client.hasWriteAccess()) {
-      error("Modifying documents requires an OAuth access token. API key provides read-only access.");
-      process.exit(1);
+    const client = getClient();
+    let event = "COMMENT";
+    if (opts.approve)
+      event = "APPROVE";
+    if (opts.requestChanges)
+      event = "REQUEST_CHANGES";
+    const result = await client.pulls.createReview(owner, repo, parseInt(number), opts.body, event);
+    success(`Review submitted: ${result.state}`);
+  } catch (err) {
+    error(String(err));
+    process.exit(1);
+  }
+});
+var userCmd = program2.command("user").description("User information");
+userCmd.command("info [username]").description("Get user information (defaults to authenticated user)").action(async (username) => {
+  try {
+    const client = getClient();
+    const result = username ? await client.users.get(username) : await client.users.getAuthenticated();
+    print(result, getFormat(userCmd));
+  } catch (err) {
+    error(String(err));
+    process.exit(1);
+  }
+});
+userCmd.command("followers [username]").description("List followers").option("-n, --per-page <number>", "Results per page", "30").action(async (username, opts) => {
+  try {
+    const client = getClient();
+    const followers = username ? await client.users.listFollowers(username, { per_page: parseInt(opts.perPage) }) : await client.users.listMyFollowers({ per_page: parseInt(opts.perPage) });
+    if (getFormat(userCmd) === "json") {
+      print(followers, "json");
+    } else {
+      if (followers.length === 0) {
+        info("No followers");
+        return;
+      }
+      followers.forEach((user) => {
+        console.log(`${source_default.cyan(user.login)}`);
+      });
     }
-    const idx = parseInt(index, 10);
-    if (isNaN(idx) || idx < 1) {
-      error("Index must be a positive integer (1 or greater)");
-      process.exit(1);
+  } catch (err) {
+    error(String(err));
+    process.exit(1);
+  }
+});
+userCmd.command("following [username]").description("List users being followed").option("-n, --per-page <number>", "Results per page", "30").action(async (username, opts) => {
+  try {
+    const client = getClient();
+    const following = username ? await client.users.listFollowing(username, { per_page: parseInt(opts.perPage) }) : await client.users.listMyFollowing({ per_page: parseInt(opts.perPage) });
+    if (getFormat(userCmd) === "json") {
+      print(following, "json");
+    } else {
+      if (following.length === 0) {
+        info("Not following anyone");
+        return;
+      }
+      following.forEach((user) => {
+        console.log(`${source_default.cyan(user.login)}`);
+      });
     }
-    const result = await client.content.insertImage(documentId, uri, idx);
-    success("Image inserted successfully");
-    print(result, getFormat(program2));
   } catch (err) {
     error(String(err));
     process.exit(1);