@larkiny/astro-github-loader 0.11.2 → 0.12.0

package/src/github.assets.ts

@@ -0,0 +1,365 @@
+import { existsSync, promises as fs } from "node:fs";
+import { join, dirname, basename, extname } from "node:path";
+import { Octokit } from "octokit";
+import { shouldIncludeFile } from "./github.paths.js";
+import type { Logger } from "./github.logger.js";
+import type { ImportOptions } from "./github.types.js";
+
+/**
+ * Default asset patterns for common image and media file types
+ * @internal
+ */
+const DEFAULT_ASSET_PATTERNS = [
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".svg",
+  ".webp",
+  ".ico",
+  ".bmp",
+];
+
+/**
+ * Resolves the effective asset configuration for an import.
+ *
+ * If `assetsPath` and `assetsBaseUrl` are explicitly provided, uses them (existing behavior).
+ * If omitted, derives co-located defaults from the matched include pattern's basePath:
+ * - assetsPath: `{basePath}/assets/` (physical directory on disk)
+ * - assetsBaseUrl: `./assets` (relative reference in markdown)
+ *
+ * @param options - Import options that may or may not have explicit asset config
+ * @param filePath - The file being processed (used to find the matched include pattern)
+ * @returns Resolved assetsPath and assetsBaseUrl, or null if assets should not be processed
+ * @internal
+ */
+export function resolveAssetConfig(
+  options: ImportOptions,
+  filePath: string,
+): { assetsPath: string; assetsBaseUrl: string } | null {
+  // Explicit config takes precedence
+  if (options.assetsPath && options.assetsBaseUrl) {
+    return {
+      assetsPath: options.assetsPath,
+      assetsBaseUrl: options.assetsBaseUrl,
+    };
+  }
+
+  // If only one is set, that's a misconfiguration — skip
+  if (options.assetsPath || options.assetsBaseUrl) {
+    return null;
+  }
+
+  // Derive co-located defaults from the matched include pattern's basePath
+  const includeResult = shouldIncludeFile(filePath, options);
+  if (includeResult.included && includeResult.matchedPattern) {
+    const basePath = includeResult.matchedPattern.basePath;
+    return {
+      assetsPath: join(basePath, "assets"),
+      assetsBaseUrl: "./assets",
+    };
+  }
+
+  return null;
+}
+
+/**
+ * Detects asset references in markdown content using regex patterns
+ * @param content - The markdown content to parse
+ * @param assetPatterns - File extensions to treat as assets
+ * @returns Array of detected asset paths
+ * @internal
+ */
+export function detectAssets(
+  content: string,
+  assetPatterns: string[] = DEFAULT_ASSET_PATTERNS,
+): string[] {
+  const assets: string[] = [];
+  const patterns = assetPatterns.map((ext) => ext.toLowerCase());
+
+  // Match markdown images: ![alt](path)
+  const imageRegex = /!\[[^\]]*\]\(([^)]+)\)/g;
+  let match;
+
+  while ((match = imageRegex.exec(content)) !== null) {
+    const assetPath = match[1];
+    // Only include relative paths and assets matching our patterns
+    if (
+      assetPath.startsWith("./") ||
+      assetPath.startsWith("../") ||
+      !assetPath.includes("://")
+    ) {
+      const ext = extname(assetPath).toLowerCase();
+      if (patterns.includes(ext)) {
+        assets.push(assetPath);
+      }
+    }
+  }
+
+  // Match HTML img tags: <img src="path">
+  const htmlImgRegex = /<img[^>]+src\s*=\s*["']([^"']+)["'][^>]*>/gi;
+  while ((match = htmlImgRegex.exec(content)) !== null) {
+    const assetPath = match[1];
+    if (
+      assetPath.startsWith("./") ||
+      assetPath.startsWith("../") ||
+      !assetPath.includes("://")
+    ) {
+      const ext = extname(assetPath).toLowerCase();
+      if (patterns.includes(ext)) {
+        assets.push(assetPath);
+      }
+    }
+  }
+
+  return [...new Set(assets)]; // Remove duplicates
+}
+
+/**
+ * Downloads an asset from GitHub and saves it locally
+ * @param octokit - GitHub API client
+ * @param owner - Repository owner
+ * @param repo - Repository name
+ * @param ref - Git reference
+ * @param assetPath - Path to the asset in the repository
+ * @param localPath - Local path where the asset should be saved
+ * @param signal - Abort signal for cancellation
+ * @returns Promise that resolves when the asset is downloaded
+ * @internal
+ */
+export async function downloadAsset(
+  octokit: Octokit,
+  owner: string,
+  repo: string,
+  ref: string,
+  assetPath: string,
+  localPath: string,
+  signal?: AbortSignal,
+): Promise<void> {
+  try {
+    const { data } = await octokit.rest.repos.getContent({
+      owner,
+      repo,
+      path: assetPath,
+      ref,
+      request: { signal },
+    });
+
+    if (Array.isArray(data)) {
+      throw new Error(`Asset ${assetPath} is a directory, not a file`);
+    }
+    if (data.type !== "file" || !data.download_url) {
+      throw new Error(
+        `Asset ${assetPath} is not a valid file (type: ${data.type}, downloadUrl: ${data.download_url})`,
+      );
+    }
+
+    const response = await fetch(data.download_url, { signal });
+    if (!response.ok) {
+      throw new Error(
+        `Failed to download asset: ${response.status} ${response.statusText}`,
+      );
+    }
+
+    const buffer = await response.arrayBuffer();
+    const dir = dirname(localPath);
+
+    if (!existsSync(dir)) {
+      await fs.mkdir(dir, { recursive: true });
+    }
+
+    await fs.writeFile(localPath, new Uint8Array(buffer));
+  } catch (error: unknown) {
+    if (
+      typeof error === "object" &&
+      error !== null &&
+      "status" in error &&
+      (error as { status: number }).status === 404
+    ) {
+      throw new Error(`Asset not found: ${assetPath}`);
+    }
+    throw error;
+  }
+}
+
+/**
+ * Transforms asset references in markdown content to use local paths
+ * @param content - The markdown content to transform
+ * @param assetMap - Map of original asset paths to new local paths
+ * @returns Transformed content with updated asset references
+ * @internal
+ */
+export function transformAssetReferences(
+  content: string,
+  assetMap: Map<string, string>,
+): string {
+  let transformedContent = content;
+
+  for (const [originalPath, newPath] of assetMap) {
+    // Transform markdown images
+    const imageRegex = new RegExp(
+      `(!)\\[([^\\]]*)\\]\\(\\s*${escapeRegExp(originalPath)}\\s*\\)`,
+      "g",
+    );
+    transformedContent = transformedContent.replace(
+      imageRegex,
+      `$1[$2](${newPath})`,
+    );
+
+    // Transform HTML img tags
+    const htmlRegex = new RegExp(
+      `(<img[^>]+src\\s*=\\s*["'])${escapeRegExp(originalPath)}(["'][^>]*>)`,
+      "gi",
+    );
+    transformedContent = transformedContent.replace(
+      htmlRegex,
+      `$1${newPath}$2`,
+    );
+  }
+
+  return transformedContent;
+}
+
+/**
+ * Escapes special regex characters in a string
+ * @internal
+ */
+function escapeRegExp(string: string): string {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/**
+ * Resolves an asset path relative to a base path
+ * @internal
+ */
+export function resolveAssetPath(basePath: string, assetPath: string): string {
+  if (assetPath.startsWith("./")) {
+    return join(dirname(basePath), assetPath.slice(2));
+  } else if (assetPath.startsWith("../")) {
+    return join(dirname(basePath), assetPath);
+  }
+  return assetPath;
+}
+
+/**
+ * Processes assets in markdown content by detecting, downloading, and transforming references
+ * @param content - The markdown content to process
+ * @param filePath - The file path of the markdown file being processed
+ * @param options - Configuration options including asset settings
+ * @param octokit - GitHub API client
+ * @param logger - Logger instance for output
+ * @param signal - Abort signal for cancellation
+ * @returns Promise that resolves to transformed content
+ * @internal
+ */
+export async function processAssets(
+  content: string,
+  filePath: string,
+  options: ImportOptions,
+  octokit: Octokit,
+  logger: Logger,
+  signal?: AbortSignal,
+): Promise<{
+  content: string;
+  assetsDownloaded: number;
+  assetsCached: number;
+}> {
+  const {
+    owner,
+    repo,
+    ref = "main",
+    assetsPath,
+    assetsBaseUrl,
+    assetPatterns,
+  } = options;
+
+  logger.verbose(`🖼️  Processing assets for ${filePath}`);
+  logger.debug(`    assetsPath: ${assetsPath}`);
+  logger.debug(`    assetsBaseUrl: ${assetsBaseUrl}`);
+
+  if (!assetsPath || !assetsBaseUrl) {
+    logger.verbose(
+      `    ⏭️  Skipping asset processing - missing assetsPath or assetsBaseUrl`,
+    );
+    return { content, assetsDownloaded: 0, assetsCached: 0 };
+  }
+
+  // Detect assets in the content
+  const detectedAssets = detectAssets(content, assetPatterns);
+  logger.verbose(`    📸 Detected ${detectedAssets.length} assets`);
+  if (detectedAssets.length > 0) {
+    logger.debug(`    Assets: ${detectedAssets.join(", ")}`);
+  }
+
+  if (detectedAssets.length === 0) {
+    return { content, assetsDownloaded: 0, assetsCached: 0 };
+  }
+
+  const assetMap = new Map<string, string>();
+  let assetsDownloaded = 0;
+  let assetsCached = 0;
+
+  // Process each detected asset
+  await Promise.all(
+    detectedAssets.map(async (assetPath) => {
+      logger.logAssetProcessing("Processing", assetPath);
+      try {
+        // Resolve the asset path relative to the current markdown file
+        const resolvedAssetPath = resolveAssetPath(filePath, assetPath);
+        logger.debug(`    🔗 Resolved path: ${resolvedAssetPath}`);
+
+        // Generate unique filename to avoid conflicts
+        const originalFilename = basename(assetPath);
+        const ext = extname(originalFilename);
+        const nameWithoutExt = basename(originalFilename, ext);
+        const uniqueFilename = `${nameWithoutExt}-${Date.now()}${ext}`;
+        const localPath = join(assetsPath, uniqueFilename);
+        logger.debug(`    💾 Local path: ${localPath}`);
+
+        // Check if asset already exists (simple cache check)
+        if (existsSync(localPath)) {
+          logger.logAssetProcessing("Cached", assetPath);
+          assetsCached++;
+        } else {
+          // Download the asset
+          logger.logAssetProcessing(
+            "Downloading",
+            assetPath,
+            `from ${owner}/${repo}@${ref}:${resolvedAssetPath}`,
+          );
+          await downloadAsset(
+            octokit,
+            owner,
+            repo,
+            ref,
+            resolvedAssetPath,
+            localPath,
+            signal,
+          );
+          logger.logAssetProcessing("Downloaded", assetPath);
+          assetsDownloaded++;
+        }
+
+        // Generate URL for the transformed reference
+        const assetUrl = `${assetsBaseUrl}/${uniqueFilename}`.replace(
+          /\/+/g,
+          "/",
+        );
+        logger.debug(`    🔄 Transform: ${assetPath} -> ${assetUrl}`);
+
+        // Map the transformation
+        assetMap.set(assetPath, assetUrl);
+      } catch (error) {
+        logger.warn(`    ❌ Failed to process asset ${assetPath}: ${error}`);
+      }
+    }),
+  );
+
+  logger.verbose(
+    `    🗺️  Processed ${assetMap.size} assets: ${assetsDownloaded} downloaded, ${assetsCached} cached`,
+  );
+
+  // Transform the content with new asset references
+  const transformedContent = transformAssetReferences(content, assetMap);
+  return { content: transformedContent, assetsDownloaded, assetsCached };
+}

package/src/github.auth.spec.ts

@@ -0,0 +1,245 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { Octokit } from "octokit";
+import {
+  createAuthenticatedOctokit,
+  createOctokitFromEnv,
+  type GitHubAppAuthConfig,
+  type GitHubPATAuthConfig,
+} from "./github.auth";
+
+describe("github.auth", () => {
+  afterEach(() => {
+    vi.unstubAllEnvs();
+    vi.restoreAllMocks();
+  });
+
+  describe("createAuthenticatedOctokit", () => {
+    describe("with PAT config", () => {
+      it("should create Octokit instance with PAT authentication", () => {
+        const config: GitHubPATAuthConfig = {
+          token: "ghp_testtoken123",
+        };
+
+        const octokit = createAuthenticatedOctokit(config);
+
+        expect(octokit).toBeInstanceOf(Octokit);
+      });
+
+      it("should accept token from config", () => {
+        const config: GitHubPATAuthConfig = {
+          token: "ghp_anothertesttoken456",
+        };
+
+        expect(() => createAuthenticatedOctokit(config)).not.toThrow();
+      });
+
+      it("should create different instances for different tokens", () => {
+        const config1: GitHubPATAuthConfig = { token: "ghp_token1" };
+        const config2: GitHubPATAuthConfig = { token: "ghp_token2" };
+
+        const octokit1 = createAuthenticatedOctokit(config1);
+        const octokit2 = createAuthenticatedOctokit(config2);
+
+        expect(octokit1).not.toBe(octokit2);
+      });
+    });
+
+    describe("with GitHub App config", () => {
+      it("should create Octokit instance with GitHub App authentication", () => {
+        const config: GitHubAppAuthConfig = {
+          appId: "12345",
+          privateKey: "-----BEGIN RSA PRIVATE KEY-----\ntest\n-----END RSA PRIVATE KEY-----",
+          installationId: "67890",
+        };
+
+        const octokit = createAuthenticatedOctokit(config);
+
+        expect(octokit).toBeInstanceOf(Octokit);
+      });
+
+      it("should accept numeric appId and installationId", () => {
+        const config: GitHubAppAuthConfig = {
+          appId: 12345,
+          privateKey: "-----BEGIN PRIVATE KEY-----\ntest\n-----END PRIVATE KEY-----",
+          installationId: 67890,
+        };
+
+        expect(() => createAuthenticatedOctokit(config)).not.toThrow();
+      });
+
+      it("should accept string appId and installationId", () => {
+        const config: GitHubAppAuthConfig = {
+          appId: "12345",
+          privateKey: "-----BEGIN RSA PRIVATE KEY-----\ntest\n-----END RSA PRIVATE KEY-----",
+          installationId: "67890",
+        };
+
+        expect(() => createAuthenticatedOctokit(config)).not.toThrow();
+      });
+
+      it("should handle RSA PRIVATE KEY format", () => {
+        const config: GitHubAppAuthConfig = {
+          appId: "12345",
+          privateKey: "-----BEGIN RSA PRIVATE KEY-----\nMIIEpAIBAAKCAQEA...\n-----END RSA PRIVATE KEY-----",
+          installationId: "67890",
+        };
+
+        const octokit = createAuthenticatedOctokit(config);
+
+        expect(octokit).toBeInstanceOf(Octokit);
+      });
+
+      it("should handle PRIVATE KEY format", () => {
+        const config: GitHubAppAuthConfig = {
+          appId: "12345",
+          privateKey: "-----BEGIN PRIVATE KEY-----\nMIIEvQIBADANBgkqhkiG9w0BAQE...\n-----END PRIVATE KEY-----",
+          installationId: "67890",
+        };
+
+        const octokit = createAuthenticatedOctokit(config);
+
+        expect(octokit).toBeInstanceOf(Octokit);
+      });
+    });
+  });
+
+  describe("createOctokitFromEnv", () => {
+    describe("with GITHUB_TOKEN", () => {
+      it("should create Octokit from GITHUB_TOKEN environment variable", () => {
+        vi.stubEnv("GITHUB_TOKEN", "ghp_envtoken123");
+        const consoleSpy = vi.spyOn(console, "log");
+
+        const octokit = createOctokitFromEnv();
+
+        expect(octokit).toBeInstanceOf(Octokit);
+        expect(consoleSpy).toHaveBeenCalledWith(
+          "✓ Using Personal Access Token authentication (5,000 requests/hour)",
+        );
+        expect(consoleSpy).toHaveBeenCalledWith(
+          "💡 Consider switching to GitHub App for 3x higher rate limits",
+        );
+      });
+
+      it("should use PAT when only GITHUB_TOKEN is set", () => {
+        vi.stubEnv("GITHUB_TOKEN", "ghp_token");
+
+        expect(() => createOctokitFromEnv()).not.toThrow();
+      });
+    });
+
+    describe("with GitHub App credentials", () => {
+      it("should create Octokit from GitHub App environment variables", () => {
+        vi.stubEnv("GITHUB_APP_ID", "12345");
+        vi.stubEnv("GITHUB_APP_PRIVATE_KEY", "-----BEGIN RSA PRIVATE KEY-----\ntest\n-----END RSA PRIVATE KEY-----");
+        vi.stubEnv("GITHUB_APP_INSTALLATION_ID", "67890");
+        const consoleSpy = vi.spyOn(console, "log");
+
+        const octokit = createOctokitFromEnv();
+
+        expect(octokit).toBeInstanceOf(Octokit);
+        expect(consoleSpy).toHaveBeenCalledWith(
+          "✓ Using GitHub App authentication (15,000 requests/hour)",
+        );
+      });
+
+      it("should prioritize GitHub App over PAT when both are set", () => {
+        vi.stubEnv("GITHUB_APP_ID", "12345");
+        vi.stubEnv("GITHUB_APP_PRIVATE_KEY", "-----BEGIN RSA PRIVATE KEY-----\ntest\n-----END RSA PRIVATE KEY-----");
+        vi.stubEnv("GITHUB_APP_INSTALLATION_ID", "67890");
+        vi.stubEnv("GITHUB_TOKEN", "ghp_token");
+        const consoleSpy = vi.spyOn(console, "log");
+
+        createOctokitFromEnv();
+
+        expect(consoleSpy).toHaveBeenCalledWith(
+          "✓ Using GitHub App authentication (15,000 requests/hour)",
+        );
+        expect(consoleSpy).not.toHaveBeenCalledWith(
+          expect.stringContaining("Personal Access Token"),
+        );
+      });
+
+      it("should decode base64-encoded private key", () => {
+        const privateKey = "-----BEGIN RSA PRIVATE KEY-----\ntest\n-----END RSA PRIVATE KEY-----";
+        const base64Key = Buffer.from(privateKey).toString("base64");
+
+        vi.stubEnv("GITHUB_APP_ID", "12345");
+        vi.stubEnv("GITHUB_APP_PRIVATE_KEY", base64Key);
+        vi.stubEnv("GITHUB_APP_INSTALLATION_ID", "67890");
+
+        expect(() => createOctokitFromEnv()).not.toThrow();
+      });
+
+      it("should use private key as-is if it contains BEGIN RSA PRIVATE KEY", () => {
+        const privateKey = "-----BEGIN RSA PRIVATE KEY-----\nMIIEpAIBAAKCAQEA...\n-----END RSA PRIVATE KEY-----";
+
+        vi.stubEnv("GITHUB_APP_ID", "12345");
+        vi.stubEnv("GITHUB_APP_PRIVATE_KEY", privateKey);
+        vi.stubEnv("GITHUB_APP_INSTALLATION_ID", "67890");
+
+        expect(() => createOctokitFromEnv()).not.toThrow();
+      });
+
+      it("should use private key as-is if it contains BEGIN PRIVATE KEY", () => {
+        const privateKey = "-----BEGIN PRIVATE KEY-----\nMIIEvQIBADANBgkqhkiG9w0BAQE...\n-----END PRIVATE KEY-----";
+
+        vi.stubEnv("GITHUB_APP_ID", "12345");
+        vi.stubEnv("GITHUB_APP_PRIVATE_KEY", privateKey);
+        vi.stubEnv("GITHUB_APP_INSTALLATION_ID", "67890");
+
+        expect(() => createOctokitFromEnv()).not.toThrow();
+      });
+
+      it("should handle decode failure gracefully and use key as-is", () => {
+        const invalidBase64 = "not-valid-base64-or-pem!!!";
+
+        vi.stubEnv("GITHUB_APP_ID", "12345");
+        vi.stubEnv("GITHUB_APP_PRIVATE_KEY", invalidBase64);
+        vi.stubEnv("GITHUB_APP_INSTALLATION_ID", "67890");
+
+        // Should not throw during key processing
+        expect(() => createOctokitFromEnv()).not.toThrow();
+      });
+
+      it("should not use GitHub App if only appId is set", () => {
+        vi.stubEnv("GITHUB_APP_ID", "12345");
+
+        expect(() => createOctokitFromEnv()).toThrow();
+      });
+
+      it("should not use GitHub App if only privateKey is set", () => {
+        vi.stubEnv("GITHUB_APP_PRIVATE_KEY", "-----BEGIN RSA PRIVATE KEY-----\ntest\n-----END RSA PRIVATE KEY-----");
+
+        expect(() => createOctokitFromEnv()).toThrow();
+      });
+
+      it("should not use GitHub App if only installationId is set", () => {
+        vi.stubEnv("GITHUB_APP_INSTALLATION_ID", "67890");
+
+        expect(() => createOctokitFromEnv()).toThrow();
+      });
+
+      it("should not use GitHub App if missing installationId", () => {
+        vi.stubEnv("GITHUB_APP_ID", "12345");
+        vi.stubEnv("GITHUB_APP_PRIVATE_KEY", "-----BEGIN RSA PRIVATE KEY-----\ntest\n-----END RSA PRIVATE KEY-----");
+
+        expect(() => createOctokitFromEnv()).toThrow();
+      });
+    });
+
+    describe("error cases", () => {
+      it("should throw error when no credentials are set", () => {
+        expect(() => createOctokitFromEnv()).toThrow(
+          "No GitHub authentication credentials found",
+        );
+      });
+
+      it("should include helpful error message with credential options", () => {
+        expect(() => createOctokitFromEnv()).toThrow(/GITHUB_TOKEN/);
+        expect(() => createOctokitFromEnv()).toThrow(/GITHUB_APP_ID/);
+        expect(() => createOctokitFromEnv()).toThrow(/GITHUB_APP_PRIVATE_KEY/);
+        expect(() => createOctokitFromEnv()).toThrow(/GITHUB_APP_INSTALLATION_ID/);
+      });
+    });
+  });
+});

package/src/github.auth.ts

@@ -29,8 +29,12 @@ export type GitHubAuthConfig = GitHubAppAuthConfig | GitHubPATAuthConfig;
 /**
  * Type guard to check if config is GitHub App authentication
  */
-function isGitHubAppAuth(config: GitHubAuthConfig): config is GitHubAppAuthConfig {
-  return 'appId' in config && 'privateKey' in config && 'installationId' in config;
+function isGitHubAppAuth(
+  config: GitHubAuthConfig,
+): config is GitHubAppAuthConfig {
+  return (
+    "appId" in config && "privateKey" in config && "installationId" in config
+  );
 }
 
 /**
@@ -119,15 +123,19 @@ export function createOctokitFromEnv(): Octokit {
   if (appId && privateKey && installationId) {
     // Decode private key if it's base64 encoded (for easier .env storage)
     let decodedPrivateKey = privateKey;
-    if (!privateKey.includes('BEGIN RSA PRIVATE KEY') && !privateKey.includes('BEGIN PRIVATE KEY')) {
+    if (
+      !privateKey.includes("BEGIN RSA PRIVATE KEY") &&
+      !privateKey.includes("BEGIN PRIVATE KEY")
+    ) {
       try {
-        decodedPrivateKey = Buffer.from(privateKey, 'base64').toString('utf-8');
+        decodedPrivateKey = Buffer.from(privateKey, "base64").toString("utf-8");
       } catch {
         // If decoding fails, use as-is (might already be plaintext)
       }
     }
 
-    console.log('✓ Using GitHub App authentication (15,000 requests/hour)');
+    // eslint-disable-next-line no-console -- startup message before logger exists
+    console.log("✓ Using GitHub App authentication (15,000 requests/hour)");
     return createAuthenticatedOctokit({
       appId,
       privateKey: decodedPrivateKey,
@@ -138,14 +146,20 @@ export function createOctokitFromEnv(): Octokit {
   // Fallback to Personal Access Token
   const token = process.env.GITHUB_TOKEN;
   if (token) {
-    console.log('✓ Using Personal Access Token authentication (5,000 requests/hour)');
-    console.log('💡 Consider switching to GitHub App for 3x higher rate limits');
+    // eslint-disable-next-line no-console -- startup message before logger exists
+    console.log(
+      "✓ Using Personal Access Token authentication (5,000 requests/hour)",
+    );
+    // eslint-disable-next-line no-console -- startup message before logger exists
+    console.log(
+      "💡 Consider switching to GitHub App for 3x higher rate limits",
+    );
     return createAuthenticatedOctokit({ token });
   }
 
   throw new Error(
-    'No GitHub authentication credentials found. Please set either:\n' +
-    '  - GITHUB_TOKEN (for PAT authentication)\n' +
-    '  - GITHUB_APP_ID, GITHUB_APP_PRIVATE_KEY, GITHUB_APP_INSTALLATION_ID (for GitHub App authentication)'
+    "No GitHub authentication credentials found. Please set either:\n" +
+      "  - GITHUB_TOKEN (for PAT authentication)\n" +
+      "  - GITHUB_APP_ID, GITHUB_APP_PRIVATE_KEY, GITHUB_APP_INSTALLATION_ID (for GitHub App authentication)",
   );
 }