@larkiny/astro-github-loader 0.9.0

package/dist/github.dryrun.d.ts

@@ -0,0 +1,72 @@
+import type { ImportOptions, LoaderContext } from "./github.types.js";
+/**
+ * Represents the state of a single import configuration
+ */
+export interface ImportState {
+    /** Configuration name for identification */
+    name: string;
+    /** Repository owner/name/path identifier */
+    repoId: string;
+    /** Last known commit SHA */
+    lastCommitSha?: string;
+    /** Last import timestamp */
+    lastImported?: string;
+    /** Git reference being tracked */
+    ref: string;
+}
+/**
+ * State file structure
+ */
+export interface StateFile {
+    /** Map of config identifiers to their state */
+    imports: Record<string, ImportState>;
+    /** Last check timestamp */
+    lastChecked: string;
+}
+/**
+ * Information about repository changes
+ */
+export interface RepositoryChangeInfo {
+    /** Configuration details */
+    config: ImportOptions;
+    /** Current state */
+    state: ImportState;
+    /** Whether repository needs to be re-imported */
+    needsReimport: boolean;
+    /** Latest commit SHA from remote */
+    latestCommitSha?: string;
+    /** Latest commit message */
+    latestCommitMessage?: string;
+    /** Latest commit date */
+    latestCommitDate?: string;
+    /** Error message if check failed */
+    error?: string;
+}
+/**
+ * Creates a unique identifier for an import configuration
+ */
+export declare function createConfigId(config: ImportOptions): string;
+/**
+ * Loads the import state from the state file
+ */
+export declare function loadImportState(workingDir: string): Promise<StateFile>;
+/**
+ * Gets the latest commit information for a repository path
+ */
+export declare function getLatestCommitInfo(octokit: any, config: ImportOptions, signal?: AbortSignal): Promise<{
+    sha: string;
+    message: string;
+    date: string;
+} | null>;
+/**
+ * Updates the import state after a successful import
+ */
+export declare function updateImportState(workingDir: string, config: ImportOptions, commitSha?: string): Promise<void>;
+/**
+ * Performs a dry run check on all configured repositories
+ */
+export declare function performDryRun(configs: ImportOptions[], context: LoaderContext, octokit: any, workingDir?: string, signal?: AbortSignal): Promise<RepositoryChangeInfo[]>;
+/**
+ * Formats and displays the dry run results
+ */
+export declare function displayDryRunResults(results: RepositoryChangeInfo[], logger: any): void;

package/dist/github.dryrun.js

@@ -0,0 +1,247 @@
+import { promises as fs } from "node:fs";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+const STATE_FILENAME = '.github-import-state.json';
+/**
+ * Creates a unique identifier for an import configuration
+ */
+export function createConfigId(config) {
+    return `${config.owner}/${config.repo}@${config.ref || 'main'}`;
+}
+/**
+ * Loads the import state from the state file
+ */
+export async function loadImportState(workingDir) {
+    const statePath = join(workingDir, STATE_FILENAME);
+    if (!existsSync(statePath)) {
+        return {
+            imports: {},
+            lastChecked: new Date().toISOString()
+        };
+    }
+    try {
+        const content = await fs.readFile(statePath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        console.warn(`Failed to load import state from ${statePath}, starting fresh:`, error);
+        return {
+            imports: {},
+            lastChecked: new Date().toISOString()
+        };
+    }
+}
+/**
+ * Saves the import state to the state file
+ */
+async function saveImportState(workingDir, state) {
+    const statePath = join(workingDir, STATE_FILENAME);
+    try {
+        await fs.writeFile(statePath, JSON.stringify(state, null, 2), 'utf-8');
+    }
+    catch (error) {
+        console.warn(`Failed to save import state to ${statePath}:`, error);
+    }
+}
+/**
+ * Gets the latest commit information for a repository path
+ */
+export async function getLatestCommitInfo(octokit, config, signal) {
+    const { owner, repo, ref = "main" } = config;
+    try {
+        // Get commits for the entire repository
+        const { data } = await octokit.rest.repos.listCommits({
+            owner,
+            repo,
+            sha: ref,
+            per_page: 1,
+            request: { signal }
+        });
+        if (data.length === 0) {
+            return null;
+        }
+        const latestCommit = data[0];
+        return {
+            sha: latestCommit.sha,
+            message: latestCommit.commit.message.split('\n')[0], // First line only
+            date: latestCommit.commit.committer?.date || latestCommit.commit.author?.date || new Date().toISOString()
+        };
+    }
+    catch (error) {
+        if (error.status === 404) {
+            throw new Error(`Repository not found: ${owner}/${repo}`);
+        }
+        throw error;
+    }
+}
+/**
+ * Checks a single repository for changes
+ */
+async function checkRepositoryForChanges(octokit, config, currentState, signal) {
+    const configName = config.name || `${config.owner}/${config.repo}`;
+    try {
+        const latestCommit = await getLatestCommitInfo(octokit, config, signal);
+        if (!latestCommit) {
+            return {
+                config,
+                state: currentState,
+                needsReimport: false,
+                error: "No commits found in repository"
+            };
+        }
+        const needsReimport = !currentState.lastCommitSha || currentState.lastCommitSha !== latestCommit.sha;
+        return {
+            config,
+            state: currentState,
+            needsReimport,
+            latestCommitSha: latestCommit.sha,
+            latestCommitMessage: latestCommit.message,
+            latestCommitDate: latestCommit.date
+        };
+    }
+    catch (error) {
+        return {
+            config,
+            state: currentState,
+            needsReimport: false,
+            error: error.message
+        };
+    }
+}
+/**
+ * Updates the import state after a successful import
+ */
+export async function updateImportState(workingDir, config, commitSha) {
+    const state = await loadImportState(workingDir);
+    const configId = createConfigId(config);
+    const configName = config.name || `${config.owner}/${config.repo}`;
+    state.imports[configId] = {
+        name: configName,
+        repoId: configId,
+        lastCommitSha: commitSha,
+        lastImported: new Date().toISOString(),
+        ref: config.ref || 'main'
+    };
+    await saveImportState(workingDir, state);
+}
+/**
+ * Performs a dry run check on all configured repositories
+ */
+export async function performDryRun(configs, context, octokit, workingDir = process.cwd(), signal) {
+    const { logger } = context;
+    logger.info("🔍 Performing dry run - checking for repository changes...");
+    // Load current state
+    const state = await loadImportState(workingDir);
+    const results = [];
+    // Check each configuration
+    for (const config of configs) {
+        if (config.enabled === false) {
+            logger.debug(`Skipping disabled config: ${config.name || `${config.owner}/${config.repo}`}`);
+            continue;
+        }
+        const configId = createConfigId(config);
+        const configName = config.name || `${config.owner}/${config.repo}`;
+        // Get current state for this config
+        const currentState = state.imports[configId] || {
+            name: configName,
+            repoId: configId,
+            ref: config.ref || 'main'
+        };
+        logger.debug(`Checking ${configName}...`);
+        try {
+            const changeInfo = await checkRepositoryForChanges(octokit, config, currentState, signal);
+            results.push(changeInfo);
+        }
+        catch (error) {
+            if (signal?.aborted)
+                throw error;
+            results.push({
+                config,
+                state: currentState,
+                needsReimport: false,
+                error: `Failed to check repository: ${error.message}`
+            });
+        }
+    }
+    // Update last checked time
+    state.lastChecked = new Date().toISOString();
+    await saveImportState(workingDir, state);
+    return results;
+}
+/**
+ * Formats and displays the dry run results
+ */
+export function displayDryRunResults(results, logger) {
+    logger.info("\n📊 Repository Import Status:");
+    logger.info("=".repeat(50));
+    let needsReimportCount = 0;
+    let errorCount = 0;
+    for (const result of results) {
+        const configName = result.config.name || `${result.config.owner}/${result.config.repo}`;
+        if (result.error) {
+            logger.info(`❌ ${configName}: ${result.error}`);
+            errorCount++;
+        }
+        else if (result.needsReimport) {
+            logger.info(`🔄 ${configName}: Needs re-import`);
+            if (result.latestCommitMessage) {
+                logger.info(`   Latest commit: ${result.latestCommitMessage}`);
+            }
+            if (result.latestCommitDate) {
+                const date = new Date(result.latestCommitDate);
+                const timeAgo = getTimeAgo(date);
+                logger.info(`   Committed: ${timeAgo}`);
+            }
+            if (result.state.lastImported) {
+                const lastImported = new Date(result.state.lastImported);
+                const importTimeAgo = getTimeAgo(lastImported);
+                logger.info(`   Last imported: ${importTimeAgo}`);
+            }
+            else {
+                logger.info(`   Last imported: Never`);
+            }
+            needsReimportCount++;
+        }
+        else {
+            logger.info(`✅ ${configName}: Up to date`);
+            if (result.state.lastImported) {
+                const lastImported = new Date(result.state.lastImported);
+                const timeAgo = getTimeAgo(lastImported);
+                logger.info(`   Last imported: ${timeAgo}`);
+            }
+        }
+    }
+    logger.info("=".repeat(50));
+    logger.info(`📈 Summary: ${needsReimportCount} of ${results.length} repositories need re-import, ${errorCount} errors`);
+    if (needsReimportCount > 0) {
+        logger.info("\n💡 To import updated repositories:");
+        logger.info("1. Delete the target import folders for repositories that need re-import");
+        logger.info("2. Run the import process normally (dryRun: false)");
+        logger.info("3. Fresh content will be imported automatically");
+    }
+    else {
+        logger.info("\n🎉 All repositories are up to date!");
+    }
+}
+/**
+ * Helper function to format time differences in a human-readable way
+ */
+function getTimeAgo(date) {
+    const now = new Date();
+    const diffMs = now.getTime() - date.getTime();
+    const diffMins = Math.floor(diffMs / (1000 * 60));
+    const diffHours = Math.floor(diffMs / (1000 * 60 * 60));
+    const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
+    if (diffMins < 60) {
+        return `${diffMins} minutes ago`;
+    }
+    else if (diffHours < 24) {
+        return `${diffHours} hours ago`;
+    }
+    else if (diffDays < 7) {
+        return `${diffDays} days ago`;
+    }
+    else {
+        return date.toLocaleDateString();
+    }
+}

package/dist/github.link-transform.d.ts

@@ -0,0 +1,77 @@
+import type { LinkMapping, LinkTransformContext, IncludePattern } from './github.types.js';
+import type { Logger } from './github.logger.js';
+/**
+ * Represents an imported file with its content and metadata
+ */
+export interface ImportedFile {
+    /** Original source path in the repository */
+    sourcePath: string;
+    /** Target path where the file will be written */
+    targetPath: string;
+    /** File content */
+    content: string;
+    /** File ID for cross-referencing */
+    id: string;
+    /** Context information for link transformations */
+    linkContext?: LinkTransformContext;
+}
+/**
+ * Context for global link transformation
+ */
+interface GlobalLinkContext {
+    /** Map from source paths to target paths for all imported files */
+    sourceToTargetMap: Map<string, string>;
+    /** Map from source paths to file IDs */
+    sourceToIdMap: Map<string, string>;
+    /** Base paths to strip from final URLs (e.g., "src/content/docs") */
+    stripPrefixes: string[];
+    /** Custom handlers for special link types */
+    customHandlers?: LinkHandler[];
+    /** Path mappings for common transformations */
+    linkMappings?: LinkMapping[];
+    /** Logger for debug output */
+    logger?: Logger;
+}
+/**
+ * Custom handler for specific link patterns
+ */
+export interface LinkHandler {
+    /** Test if this handler should process the link */
+    test: (link: string, context: LinkContext) => boolean;
+    /** Transform the link */
+    transform: (link: string, context: LinkContext) => string;
+}
+/**
+ * Context for individual link transformation
+ */
+interface LinkContext {
+    /** The file containing the link */
+    currentFile: ImportedFile;
+    /** The original link text */
+    originalLink: string;
+    /** Any anchor/fragment in the link */
+    anchor: string;
+    /** Global context */
+    global: GlobalLinkContext;
+}
+/**
+ * Global link transformation function
+ * Processes all imported files and resolves internal links
+ */
+export declare function globalLinkTransform(importedFiles: ImportedFile[], options: {
+    stripPrefixes: string[];
+    customHandlers?: LinkHandler[];
+    linkMappings?: LinkMapping[];
+    logger?: Logger;
+}): ImportedFile[];
+/**
+ * Generate link mappings automatically from pathMappings in include patterns
+ * @param includes - Array of include patterns with pathMappings
+ * @param stripPrefixes - Prefixes to strip when generating URLs
+ * @returns Array of generated link mappings
+ */
+export declare function generateAutoLinkMappings(includes: IncludePattern[], stripPrefixes?: string[]): LinkMapping[];
+/**
+ * Export types for use in configuration
+ */
+export type { LinkContext, GlobalLinkContext };