@larkiny/astro-github-loader 0.11.2 → 0.12.0

package/dist/github.loader.js

@@ -1,33 +1,7 @@
 import { toCollectionEntry } from "./github.content.js";
 import { performSelectiveCleanup } from "./github.cleanup.js";
-import { performDryRun, displayDryRunResults, updateImportState, loadImportState, createConfigId, getLatestCommitInfo } from "./github.dryrun.js";
-import { createLogger } from "./github.logger.js";
-/**
- * Performs selective cleanup for configurations with basePath
- * @param configs - Array of configuration objects
- * @param context - Loader context
- * @param octokit - GitHub API client
- * @internal
- */
-async function performSelectiveCleanups(configs, context, octokit) {
-    const results = [];
-    // Process each config sequentially to avoid overwhelming Astro's file watcher
-    for (const config of configs) {
-        if (config.enabled === false) {
-            context.logger.debug(`Skipping disabled config: ${config.name || `${config.owner}/${config.repo}`}`);
-            continue;
-        }
-        try {
-            const stats = await performSelectiveCleanup(config, context, octokit);
-            results.push(stats);
-        }
-        catch (error) {
-            context.logger.error(`Selective cleanup failed for ${config.name || `${config.owner}/${config.repo}`}: ${error}`);
-            // Continue with other configs even if one fails
-        }
-    }
-    return results;
-}
+import { performDryRun, displayDryRunResults, updateImportState, loadImportState, createConfigId, getLatestCommitInfo, } from "./github.dryrun.js";
+import { createLogger, } from "./github.logger.js";
 /**
  * Loads data from GitHub repositories based on the provided configurations and options.
  *
@@ -44,9 +18,8 @@ export function githubLoader({ octokit, configs, fetchOptions = {}, clear = fals
     return {
         name: "github-loader",
         load: async (context) => {
-            const { store } = context;
             // Create global logger with specified level or default
-            const globalLogger = createLogger(logLevel || 'default');
+            const globalLogger = createLogger(logLevel || "default");
             if (dryRun) {
                 globalLogger.info("🔍 Dry run mode enabled - checking for changes only");
                 try {
@@ -57,16 +30,16 @@ export function githubLoader({ octokit, configs, fetchOptions = {}, clear = fals
                     return; // Exit without importing
                 }
                 catch (error) {
-                    globalLogger.error(`Dry run failed: ${error.message}`);
+                    globalLogger.error(`Dry run failed: ${error instanceof Error ? error.message : String(error)}`);
                     throw error;
                 }
             }
             globalLogger.debug(`Loading data from ${configs.length} sources`);
-            // Always use standard processing - no file deletions to avoid Astro issues
-            globalLogger.info(clear ? "Processing with content store clear" : "Processing without content store clear");
-            if (clear) {
-                store.clear();
-            }
+            // Log clear mode status - actual clearing happens per-entry in toCollectionEntry
+            // to avoid breaking Astro's content collection by emptying the store all at once
+            globalLogger.info(clear
+                ? "Processing with selective entry replacement"
+                : "Processing without entry replacement");
             // Process each config sequentially to avoid overwhelming GitHub API/CDN
             for (let i = 0; i < configs.length; i++) {
                 const config = configs[i];
@@ -76,12 +49,15 @@ export function githubLoader({ octokit, configs, fetchOptions = {}, clear = fals
                 }
                 // Add small delay between configs to be gentler on GitHub's CDN
                 if (i > 0) {
-                    await new Promise(resolve => setTimeout(resolve, 1000));
+                    await new Promise((resolve) => setTimeout(resolve, 1000));
                 }
                 // Determine the effective log level for this config
-                const effectiveLogLevel = logLevel || config.logLevel || 'default';
+                const effectiveLogLevel = logLevel || config.logLevel || "default";
                 const configLogger = createLogger(effectiveLogLevel);
-                const configName = config.name || `${config.owner}/${config.repo}`;
+                const langSuffix = config.language ? ` (${config.language})` : "";
+                const configName = config.name
+                    ? `${config.name}${langSuffix}`
+                    : `${config.owner}/${config.repo}${langSuffix}`;
                 const repository = `${config.owner}/${config.repo}`;
                 let summary = {
                     configName,
@@ -91,7 +67,7 @@ export function githubLoader({ octokit, configs, fetchOptions = {}, clear = fals
                     filesUpdated: 0,
                     filesUnchanged: 0,
                     duration: 0,
-                    status: 'error',
+                    status: "error",
                 };
                 const startTime = Date.now();
                 try {
@@ -99,24 +75,25 @@ export function githubLoader({ octokit, configs, fetchOptions = {}, clear = fals
                     const configId = createConfigId(config);
                     if (!force) {
                         try {
-                            const state = await loadImportState(process.cwd());
+                            const state = await loadImportState(process.cwd(), configLogger);
                             const currentState = state.imports[configId];
                             if (currentState && currentState.lastCommitSha) {
                                 configLogger.debug(`🔍 Checking repository changes for ${configName}...`);
                                 const latestCommit = await getLatestCommitInfo(octokit, config);
-                                if (latestCommit && currentState.lastCommitSha === latestCommit.sha) {
+                                if (latestCommit &&
+                                    currentState.lastCommitSha === latestCommit.sha) {
                                     configLogger.info(`✅ Repository ${configName} unchanged (${latestCommit.sha.slice(0, 7)}) - skipping import`);
                                     // Update summary for unchanged repository
                                     summary.duration = Date.now() - startTime;
                                     summary.filesProcessed = 0;
                                     summary.filesUpdated = 0;
                                     summary.filesUnchanged = 0;
-                                    summary.status = 'success';
+                                    summary.status = "success";
                                     configLogger.logImportSummary(summary);
                                     continue; // Skip to next config
                                 }
                                 else if (latestCommit) {
-                                    configLogger.info(`🔄 Repository ${configName} changed (${currentState.lastCommitSha?.slice(0, 7) || 'unknown'} -> ${latestCommit.sha.slice(0, 7)}) - proceeding with import`);
+                                    configLogger.info(`🔄 Repository ${configName} changed (${currentState.lastCommitSha?.slice(0, 7) || "unknown"} -> ${latestCommit.sha.slice(0, 7)}) - proceeding with import`);
                                 }
                             }
                             else {
@@ -131,13 +108,29 @@ export function githubLoader({ octokit, configs, fetchOptions = {}, clear = fals
                     else {
                         configLogger.info(`🔄 Force mode enabled for ${configName} - proceeding with full import`);
                     }
+                    // Determine effective clear setting: per-config takes precedence over global
+                    const effectiveClear = config.clear ?? clear;
+                    // Perform selective cleanup before importing if clear is enabled
+                    if (effectiveClear) {
+                        configLogger.info(`🧹 Clearing obsolete files for ${configName}...`);
+                        try {
+                            await performSelectiveCleanup(config, { ...context, logger: configLogger }, octokit);
+                        }
+                        catch (error) {
+                            configLogger.warn(`Cleanup failed for ${configName}, continuing with import: ${error}`);
+                        }
+                    }
                     // Perform the import with spinner
                     const stats = await globalLogger.withSpinner(`🔄 Importing ${configName}...`, () => toCollectionEntry({
-                        context: { ...context, logger: configLogger },
+                        context: {
+                            ...context,
+                            logger: configLogger,
+                        },
                         octokit,
                         options: config,
                         fetchOptions,
                         force,
+                        clear: effectiveClear,
                     }), `✅ ${configName} imported successfully`, `❌ ${configName} import failed`);
                     summary.duration = Date.now() - startTime;
                     summary.filesProcessed = stats?.processed || 0;
@@ -145,7 +138,7 @@ export function githubLoader({ octokit, configs, fetchOptions = {}, clear = fals
                     summary.filesUnchanged = stats?.unchanged || 0;
                     summary.assetsDownloaded = stats?.assetsDownloaded || 0;
                     summary.assetsCached = stats?.assetsCached || 0;
-                    summary.status = 'success';
+                    summary.status = "success";
                     // Log structured summary
                     configLogger.logImportSummary(summary);
                     // Update state tracking for future dry runs
@@ -154,11 +147,11 @@ export function githubLoader({ octokit, configs, fetchOptions = {}, clear = fals
                         const { data } = await octokit.rest.repos.listCommits({
                             owner: config.owner,
                             repo: config.repo,
-                            sha: config.ref || 'main',
-                            per_page: 1
+                            sha: config.ref || "main",
+                            per_page: 1,
                         });
                         if (data.length > 0) {
-                            await updateImportState(process.cwd(), config, data[0].sha);
+                            await updateImportState(process.cwd(), config, data[0].sha, configLogger);
                         }
                     }
                     catch (error) {
@@ -168,8 +161,9 @@ export function githubLoader({ octokit, configs, fetchOptions = {}, clear = fals
                 }
                 catch (error) {
                     summary.duration = Date.now() - startTime;
-                    summary.status = 'error';
-                    summary.error = error.message;
+                    summary.status = "error";
+                    summary.error =
+                        error instanceof Error ? error.message : String(error);
                     configLogger.logImportSummary(summary);
                     // Continue with other configs even if one fails
                 }

package/dist/github.logger.d.ts

@@ -1,7 +1,7 @@
 /**
  * Multi-level logging system for astro-github-loader
  */
-export type LogLevel = 'silent' | 'default' | 'verbose' | 'debug';
+export type LogLevel = "silent" | "default" | "verbose" | "debug";
 export interface LoggerOptions {
     level: LogLevel;
     prefix?: string;
@@ -16,7 +16,7 @@ export interface ImportSummary {
     assetsDownloaded?: number;
     assetsCached?: number;
     duration: number;
-    status: 'success' | 'error' | 'cancelled';
+    status: "success" | "error" | "cancelled";
     error?: string;
 }
 export interface SyncSummary {

package/dist/github.logger.js

@@ -6,10 +6,10 @@
  */
 export class Logger {
     constructor(options) {
-        this.spinnerChars = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+        this.spinnerChars = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
         this.spinnerIndex = 0;
         this.level = options.level;
-        this.prefix = options.prefix || '';
+        this.prefix = options.prefix || "";
     }
     /**
      * Set the logging level
@@ -51,7 +51,7 @@ export class Logger {
      * Default level - summary information only
      */
     info(message) {
-        if (this.shouldLog('default')) {
+        if (this.shouldLog("default")) {
             console.log(this.formatMessage(message));
         }
     }
@@ -59,7 +59,7 @@ export class Logger {
      * Verbose level - detailed operation information
      */
     verbose(message) {
-        if (this.shouldLog('verbose')) {
+        if (this.shouldLog("verbose")) {
             console.log(this.formatMessage(message));
         }
     }
@@ -67,7 +67,7 @@ export class Logger {
      * Debug level - all information including diagnostics
      */
     debug(message) {
-        if (this.shouldLog('debug')) {
+        if (this.shouldLog("debug")) {
             console.log(this.formatMessage(message));
         }
     }
@@ -75,7 +75,7 @@ export class Logger {
      * Error - always shown unless silent
      */
     error(message) {
-        if (this.shouldLog('default')) {
+        if (this.shouldLog("default")) {
             console.error(this.formatMessage(message));
         }
     }
@@ -83,7 +83,7 @@ export class Logger {
      * Warning - shown at default level and above
      */
     warn(message) {
-        if (this.shouldLog('default')) {
+        if (this.shouldLog("default")) {
             console.warn(this.formatMessage(message));
         }
     }
@@ -91,27 +91,32 @@ export class Logger {
      * Log structured import summary (default level)
      */
     logImportSummary(summary) {
-        if (!this.shouldLog('default'))
+        if (!this.shouldLog("default"))
             return;
-        const statusIcon = summary.status === 'success' ? '✅' : summary.status === 'error' ? '❌' : '🚫';
-        this.info('');
+        const statusIcon = summary.status === "success"
+            ? "✅"
+            : summary.status === "error"
+                ? "❌"
+                : "🚫";
+        this.info("");
         this.info(`📊 Import Summary: ${summary.configName}`);
-        this.info(`├─ Repository: ${summary.repository}${summary.ref ? `@${summary.ref}` : ''}`);
+        this.info(`├─ Repository: ${summary.repository}${summary.ref ? `@${summary.ref}` : ""}`);
         this.info(`├─ Files: ${summary.filesProcessed} processed, ${summary.filesUpdated} updated, ${summary.filesUnchanged} unchanged`);
-        if (summary.assetsDownloaded !== undefined || summary.assetsCached !== undefined) {
+        if (summary.assetsDownloaded !== undefined ||
+            summary.assetsCached !== undefined) {
             const downloaded = summary.assetsDownloaded || 0;
             const cached = summary.assetsCached || 0;
             this.info(`├─ Assets: ${downloaded} downloaded, ${cached} cached`);
         }
         this.info(`├─ Duration: ${(summary.duration / 1000).toFixed(1)}s`);
-        this.info(`└─ Status: ${statusIcon} ${summary.status === 'success' ? 'Success' : summary.status === 'error' ? `Error: ${summary.error}` : 'Cancelled'}`);
-        this.info('');
+        this.info(`└─ Status: ${statusIcon} ${summary.status === "success" ? "Success" : summary.status === "error" ? `Error: ${summary.error}` : "Cancelled"}`);
+        this.info("");
     }
     /**
      * Log sync operation summary (default level)
      */
     logSyncSummary(configName, summary) {
-        if (!this.shouldLog('default'))
+        if (!this.shouldLog("default"))
             return;
         if (summary.added > 0 || summary.updated > 0 || summary.deleted > 0) {
             this.info(`Sync completed for ${configName}: ${summary.added} added, ${summary.updated} updated, ${summary.deleted} deleted (${summary.duration}ms)`);
@@ -124,7 +129,7 @@ export class Logger {
      * Log cleanup operation summary (default level)
      */
     logCleanupSummary(configName, summary) {
-        if (!this.shouldLog('default'))
+        if (!this.shouldLog("default"))
             return;
         if (summary.deleted > 0) {
             this.info(`Cleanup completed for ${configName}: ${summary.deleted} obsolete files deleted (${summary.duration}ms)`);
@@ -137,14 +142,18 @@ export class Logger {
      * Log file-level processing (verbose level)
      */
     logFileProcessing(action, filePath, details) {
-        const message = details ? `${action}: ${filePath} - ${details}` : `${action}: ${filePath}`;
+        const message = details
+            ? `${action}: ${filePath} - ${details}`
+            : `${action}: ${filePath}`;
         this.verbose(message);
     }
     /**
      * Log asset processing (verbose level)
      */
     logAssetProcessing(action, assetPath, details) {
-        const message = details ? `Asset ${action}: ${assetPath} - ${details}` : `Asset ${action}: ${assetPath}`;
+        const message = details
+            ? `Asset ${action}: ${assetPath} - ${details}`
+            : `Asset ${action}: ${assetPath}`;
         this.verbose(message);
     }
     /**
@@ -195,8 +204,8 @@ export class Logger {
     /**
      * Start a spinner with duration timer for long-running operations
      */
-    startSpinner(message = 'Processing...') {
-        if (this.level === 'silent')
+    startSpinner(message = "Processing...") {
+        if (this.level === "silent")
             return;
         this.spinnerStartTime = Date.now();
         this.spinnerIndex = 0;
@@ -232,7 +241,7 @@ export class Logger {
             process.stdout.write(`\r${formattedMessage}\n`);
         }
         else {
-            process.stdout.write('\r\x1b[K'); // Clear the line
+            process.stdout.write("\r\x1b[K"); // Clear the line
         }
         this.spinnerStartTime = undefined;
     }
@@ -243,11 +252,11 @@ export class Logger {
         this.startSpinner(message);
         try {
             const result = await fn();
-            this.stopSpinner(successMessage || `✅ ${message.replace(/^[🔄⏳]?\s*/, '')} completed`);
+            this.stopSpinner(successMessage || `✅ ${message.replace(/^[🔄⏳]?\s*/, "")} completed`);
             return result;
         }
         catch (error) {
-            this.stopSpinner(errorMessage || `❌ ${message.replace(/^[🔄⏳]?\s*/, '')} failed`);
+            this.stopSpinner(errorMessage || `❌ ${message.replace(/^[🔄⏳]?\s*/, "")} failed`);
             throw error;
         }
     }
@@ -255,6 +264,6 @@ export class Logger {
 /**
  * Create a logger instance with the specified level
  */
-export function createLogger(level = 'default', prefix) {
+export function createLogger(level = "default", prefix) {
     return new Logger({ level, prefix });
 }

package/dist/github.paths.d.ts

@@ -0,0 +1,76 @@
+import type { ExtendedLoaderContext, ImportOptions, MatchedPattern } from "./github.types.js";
+export interface ImportStats {
+    processed: number;
+    updated: number;
+    unchanged: number;
+    assetsDownloaded?: number;
+    assetsCached?: number;
+}
+/**
+ * Generates a unique identifier from a file path by removing the extension
+ * @param filePath - The file path to generate ID from
+ * @return {string} The generated identifier as a string with extension removed
+ * @internal
+ */
+export declare function generateId(filePath: string): string;
+/**
+ * Applies path mapping logic to get the final filename for a file
+ *
+ * Supports two types of path mappings:
+ * - **File mapping**: Exact file path match (e.g., 'docs/README.md' -> 'docs/overview.md')
+ * - **Folder mapping**: Folder path with trailing slash (e.g., 'docs/capabilities/' -> 'docs/')
+ *
+ * @param filePath - Original source file path
+ * @param matchedPattern - The pattern that matched this file
+ * @param options - Import options containing path mappings
+ * @returns Final filename after applying path mapping logic
+ * @internal
+ */
+export declare function applyRename(filePath: string, matchedPattern?: MatchedPattern | null, options?: ImportOptions): string;
+/**
+ * Generates a local file path based on the matched pattern and file path
+ * @param filePath - The original file path from the repository
+ * @param matchedPattern - The pattern that matched this file (or null if no includes specified)
+ * @param options - Import options containing includes patterns for path mapping lookups
+ * @return {string} The local file path where this content should be stored
+ * @internal
+ */
+export declare function generatePath(filePath: string, matchedPattern?: MatchedPattern | null, options?: ImportOptions): string;
+/**
+ * Checks if a file path should be included and returns the matching pattern
+ * @param filePath - The file path to check (relative to the repository root)
+ * @param options - Import options containing includes patterns
+ * @returns Object with include status and matched pattern, or null if not included
+ * @internal
+ */
+export declare function shouldIncludeFile(filePath: string, options: ImportOptions): {
+    included: true;
+    matchedPattern: MatchedPattern | null;
+} | {
+    included: false;
+    matchedPattern: null;
+};
+/**
+ * Get the headers needed to make a conditional request.
+ * Uses the etag and last-modified values from the meta store.
+ * @internal
+ */
+export declare function getHeaders({ init, meta, id, }: {
+    /** Initial headers to include */
+    init?: RequestInit["headers"];
+    /** Meta store to get etag and last-modified values from */
+    meta: ExtendedLoaderContext["meta"];
+    id: string;
+}): Headers;
+/**
+ * Store the etag or last-modified headers from a response in the meta store.
+ * @internal
+ */
+export declare function syncHeaders({ headers, meta, id, }: {
+    /** Headers from the response */
+    headers: Headers;
+    /** Meta store to store etag and last-modified values in */
+    meta: ExtendedLoaderContext["meta"];
+    /** id string */
+    id: string;
+}): void;

package/dist/github.paths.js

@@ -0,0 +1,190 @@
+import path, { join, basename } from "node:path";
+import picomatch from "picomatch";
+/**
+ * Generates a unique identifier from a file path by removing the extension
+ * @param filePath - The file path to generate ID from
+ * @return {string} The generated identifier as a string with extension removed
+ * @internal
+ */
+export function generateId(filePath) {
+    let id = filePath;
+    // Remove file extension for ID generation
+    const lastDotIndex = id.lastIndexOf(".");
+    if (lastDotIndex > 0) {
+        id = id.substring(0, lastDotIndex);
+    }
+    return id;
+}
+/**
+ * Applies path mapping logic to get the final filename for a file
+ *
+ * Supports two types of path mappings:
+ * - **File mapping**: Exact file path match (e.g., 'docs/README.md' -> 'docs/overview.md')
+ * - **Folder mapping**: Folder path with trailing slash (e.g., 'docs/capabilities/' -> 'docs/')
+ *
+ * @param filePath - Original source file path
+ * @param matchedPattern - The pattern that matched this file
+ * @param options - Import options containing path mappings
+ * @returns Final filename after applying path mapping logic
+ * @internal
+ */
+export function applyRename(filePath, matchedPattern, options) {
+    if (options?.includes &&
+        matchedPattern &&
+        matchedPattern.index < options.includes.length) {
+        const includePattern = options.includes[matchedPattern.index];
+        if (includePattern.pathMappings) {
+            // First check for exact file match (current behavior - backwards compatible)
+            if (includePattern.pathMappings[filePath]) {
+                const mappingValue = includePattern.pathMappings[filePath];
+                return typeof mappingValue === "string"
+                    ? mappingValue
+                    : mappingValue.target;
+            }
+            // Then check for folder-to-folder mappings
+            for (const [sourceFolder, mappingValue] of Object.entries(includePattern.pathMappings)) {
+                // Check if this is a folder mapping (ends with /) and file is within it
+                if (sourceFolder.endsWith("/") && filePath.startsWith(sourceFolder)) {
+                    // Replace the source folder path with target folder path
+                    const targetFolder = typeof mappingValue === "string"
+                        ? mappingValue
+                        : mappingValue.target;
+                    const relativePath = filePath.slice(sourceFolder.length);
+                    return path.posix.join(targetFolder, relativePath);
+                }
+            }
+        }
+    }
+    // Return original filename if no path mapping found
+    return basename(filePath);
+}
+/**
+ * Generates a local file path based on the matched pattern and file path
+ * @param filePath - The original file path from the repository
+ * @param matchedPattern - The pattern that matched this file (or null if no includes specified)
+ * @param options - Import options containing includes patterns for path mapping lookups
+ * @return {string} The local file path where this content should be stored
+ * @internal
+ */
+export function generatePath(filePath, matchedPattern, options) {
+    if (matchedPattern) {
+        // Extract the directory part from the pattern (before any glob wildcards)
+        const pattern = matchedPattern.pattern;
+        const beforeGlob = pattern.split(/[*?{]/)[0];
+        // Remove the pattern prefix from the file path to get the relative path
+        let relativePath = filePath;
+        if (beforeGlob && filePath.startsWith(beforeGlob)) {
+            relativePath = filePath.substring(beforeGlob.length);
+            // Remove leading slash if present
+            if (relativePath.startsWith("/")) {
+                relativePath = relativePath.substring(1);
+            }
+        }
+        // If no relative path remains, use just the filename
+        if (!relativePath) {
+            relativePath = basename(filePath);
+        }
+        // Apply path mapping logic
+        const finalFilename = applyRename(filePath, matchedPattern, options);
+        // Always apply path mapping if applyRename returned something different from the original basename
+        // OR if there are pathMappings configured (since empty string mappings might return same basename)
+        const hasPathMappings = options?.includes?.[matchedPattern.index]?.pathMappings &&
+            Object.keys(options.includes[matchedPattern.index].pathMappings).length >
+                0;
+        if (finalFilename !== basename(filePath) || hasPathMappings) {
+            // Check if applyRename returned a full path (contains path separators) or just a filename
+            if (finalFilename.includes("/") || finalFilename.includes("\\")) {
+                // applyRename returned a full relative path - need to extract relative part
+                // Remove the pattern prefix to get the relative path within the pattern context
+                const beforeGlob = pattern.split(/[*?{]/)[0];
+                if (beforeGlob && finalFilename.startsWith(beforeGlob)) {
+                    relativePath = finalFilename.substring(beforeGlob.length);
+                    // Remove leading slash if present
+                    if (relativePath.startsWith("/")) {
+                        relativePath = relativePath.substring(1);
+                    }
+                }
+                else {
+                    relativePath = finalFilename;
+                }
+            }
+            else {
+                // applyRename returned just a filename
+                // If the filename is different due to pathMapping, use it directly
+                // This handles cases where pathMappings flatten directory structures
+                relativePath = finalFilename;
+            }
+        }
+        return join(matchedPattern.basePath, relativePath);
+    }
+    // Should not happen since we always use includes
+    throw new Error("No matched pattern provided - includes are required");
+}
+/**
+ * Checks if a file path should be included and returns the matching pattern
+ * @param filePath - The file path to check (relative to the repository root)
+ * @param options - Import options containing includes patterns
+ * @returns Object with include status and matched pattern, or null if not included
+ * @internal
+ */
+export function shouldIncludeFile(filePath, options) {
+    const { includes } = options;
+    // If no include patterns specified, include all files
+    if (!includes || includes.length === 0) {
+        return { included: true, matchedPattern: null };
+    }
+    // Check each include pattern to find a match
+    for (let i = 0; i < includes.length; i++) {
+        const includePattern = includes[i];
+        const matcher = picomatch(includePattern.pattern);
+        if (matcher(filePath)) {
+            return {
+                included: true,
+                matchedPattern: {
+                    pattern: includePattern.pattern,
+                    basePath: includePattern.basePath,
+                    index: i,
+                },
+            };
+        }
+    }
+    // No patterns matched
+    return { included: false, matchedPattern: null };
+}
+/**
+ * Get the headers needed to make a conditional request.
+ * Uses the etag and last-modified values from the meta store.
+ * @internal
+ */
+export function getHeaders({ init, meta, id, }) {
+    const tag = `${id}-etag`;
+    const lastModifiedTag = `${id}-last-modified`;
+    const etag = meta.get(tag);
+    const lastModified = meta.get(lastModifiedTag);
+    const headers = new Headers(init);
+    if (etag) {
+        headers.set("If-None-Match", etag);
+    }
+    else if (lastModified) {
+        headers.set("If-Modified-Since", lastModified);
+    }
+    return headers;
+}
+/**
+ * Store the etag or last-modified headers from a response in the meta store.
+ * @internal
+ */
+export function syncHeaders({ headers, meta, id, }) {
+    const etag = headers.get("etag");
+    const lastModified = headers.get("last-modified");
+    const tag = `${id}-etag`;
+    const lastModifiedTag = `${id}-last-modified`;
+    meta.delete(tag);
+    meta.delete(lastModifiedTag);
+    if (etag) {
+        meta.set(tag, etag);
+    }
+    else if (lastModified) {
+        meta.set(lastModifiedTag, lastModified);
+    }
+}

package/dist/github.storage.d.ts

@@ -0,0 +1,15 @@
+import type { ImportedFile } from "./github.link-transform.js";
+import type { ExtendedLoaderContext } from "./github.types.js";
+/**
+ * Ensures directory exists and writes file to disk.
+ * @internal
+ */
+export declare function syncFile(path: string, content: string): Promise<void>;
+/**
+ * Stores a processed file in Astro's content store
+ * @internal
+ */
+export declare function storeProcessedFile(file: ImportedFile, context: ExtendedLoaderContext, clear: boolean): Promise<{
+    id: string;
+    filePath: string;
+}>;