@aigne/afs-github 1.11.0-beta.6

package/dist/index.mjs

@@ -0,0 +1,1125 @@
+import { retry } from "@octokit/plugin-retry";
+import { throttling } from "@octokit/plugin-throttling";
+import { Octokit } from "@octokit/rest";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { MappingCompiler } from "@aigne/afs-mapping";
+import { WorldMappingCore } from "@aigne/afs-world-mapping";
+import { z } from "zod";
+
+//#region src/client.ts
+/**
+* GitHub API Client
+*
+* Wraps Octokit with throttling, retry, and caching.
+*/
+/**
+* GitHub API client with throttling, retry, and caching
+*/
+var GitHubClient = class {
+	octokit;
+	cache = /* @__PURE__ */ new Map();
+	cacheConfig;
+	constructor(options) {
+		this.cacheConfig = {
+			enabled: options.cache?.enabled ?? true,
+			ttl: options.cache?.ttl ?? 6e4
+		};
+		const maxRetries = options.rateLimit?.maxRetries ?? 3;
+		this.octokit = new (Octokit.plugin(throttling, retry))({
+			auth: options.auth?.token,
+			baseUrl: options.baseUrl ?? "https://api.github.com",
+			log: {
+				debug: () => {},
+				info: () => {},
+				warn: () => {},
+				error: () => {}
+			},
+			throttle: {
+				onRateLimit: (retryAfter, _options, _octokit, retryCount) => {
+					if (retryCount < maxRetries) {
+						console.warn(`Rate limited. Retrying after ${retryAfter} seconds.`);
+						return true;
+					}
+					return false;
+				},
+				onSecondaryRateLimit: (retryAfter, _options, _octokit, retryCount) => {
+					if (retryCount < maxRetries) {
+						console.warn(`Secondary rate limit. Retrying after ${retryAfter} seconds.`);
+						return true;
+					}
+					return false;
+				}
+			},
+			retry: {
+				enabled: options.rateLimit?.autoRetry ?? true,
+				retries: maxRetries
+			}
+		});
+	}
+	/**
+	* Make a request to the GitHub API
+	*/
+	async request(route, params) {
+		const isGet = route.startsWith("GET ");
+		if (isGet && this.cacheConfig.enabled) {
+			const cacheKey = this.getCacheKey(route, params);
+			const cached = this.getFromCache(cacheKey);
+			if (cached !== void 0) return cached;
+		}
+		const response = await this.octokit.request(route, params);
+		const result = {
+			data: response.data,
+			status: response.status,
+			headers: response.headers
+		};
+		if (isGet && this.cacheConfig.enabled) {
+			const cacheKey = this.getCacheKey(route, params);
+			this.setCache(cacheKey, result);
+		}
+		return result;
+	}
+	/**
+	* Generate cache key from route and params
+	*/
+	getCacheKey(route, params) {
+		return `${route}:${JSON.stringify(params ?? {})}`;
+	}
+	/**
+	* Get from cache if not expired
+	*/
+	getFromCache(key) {
+		const entry = this.cache.get(key);
+		if (!entry) return void 0;
+		if (Date.now() > entry.expiresAt) {
+			this.cache.delete(key);
+			return;
+		}
+		return entry.data;
+	}
+	/**
+	* Set cache entry
+	*/
+	setCache(key, data) {
+		this.cache.set(key, {
+			data,
+			expiresAt: Date.now() + this.cacheConfig.ttl
+		});
+	}
+	/**
+	* Clear the cache
+	*/
+	clearCache() {
+		this.cache.clear();
+	}
+	/**
+	* Get the underlying Octokit instance (for advanced usage)
+	*/
+	getOctokit() {
+		return this.octokit;
+	}
+	/**
+	* Get repository contents at a path
+	* @param owner Repository owner
+	* @param repo Repository name
+	* @param path Path within the repository (empty string for root)
+	* @param ref Optional branch, tag, or commit SHA
+	* @returns Contents item(s) - array for directories, single item for files
+	*/
+	async getContents(owner, repo, path, ref) {
+		const params = {
+			owner,
+			repo,
+			path: path || ""
+		};
+		if (ref) params.ref = ref;
+		return (await this.request("GET /repos/{owner}/{repo}/contents/{path}", params)).data;
+	}
+	/**
+	* Get blob content for large files (>1MB)
+	* @param owner Repository owner
+	* @param repo Repository name
+	* @param sha Blob SHA
+	* @returns Decoded content as string
+	*/
+	async getBlob(owner, repo, sha) {
+		const response = await this.request("GET /repos/{owner}/{repo}/git/blobs/{sha}", {
+			owner,
+			repo,
+			sha
+		});
+		return Buffer.from(response.data.content, "base64").toString("utf-8");
+	}
+	/**
+	* Get repository branches
+	* @param owner Repository owner
+	* @param repo Repository name
+	* @returns Array of branch items
+	*/
+	async getBranches(owner, repo) {
+		const allBranches = [];
+		let page = 1;
+		const perPage = 100;
+		while (true) {
+			const response = await this.request("GET /repos/{owner}/{repo}/branches", {
+				owner,
+				repo,
+				per_page: perPage,
+				page
+			});
+			allBranches.push(...response.data);
+			if (response.data.length < perPage) break;
+			page++;
+		}
+		return allBranches;
+	}
+	/**
+	* Get default branch for a repository
+	* @param owner Repository owner
+	* @param repo Repository name
+	* @returns Default branch name
+	*/
+	async getDefaultBranch(owner, repo) {
+		return (await this.request("GET /repos/{owner}/{repo}", {
+			owner,
+			repo
+		})).data.default_branch;
+	}
+};
+
+//#endregion
+//#region src/types.ts
+/**
+* Type definitions for AFSGitHub provider
+*/
+/**
+* Authentication options
+*/
+const authOptionsSchema = z.object({ token: z.string().optional() });
+/**
+* Cache configuration
+*/
+const cacheOptionsSchema = z.object({
+	enabled: z.boolean().default(true),
+	ttl: z.number().default(6e4)
+});
+/**
+* Rate limiting configuration
+*/
+const rateLimitOptionsSchema = z.object({
+	autoRetry: z.boolean().default(true),
+	maxRetries: z.number().default(3)
+});
+/**
+* Access mode for the provider
+*/
+const accessModeSchema = z.enum(["readonly", "readwrite"]).default("readonly");
+/**
+* Repository mode
+* - single-repo: Access a single repository (requires owner and repo)
+* - multi-repo: Access multiple repositories with full paths
+* - org: Access all repositories in an organization (requires owner only)
+*/
+const repoModeSchema = z.enum([
+	"single-repo",
+	"multi-repo",
+	"org"
+]).default("single-repo");
+/**
+* Owner type for org mode
+* - org: GitHub organization (uses /orgs/{org}/repos endpoint)
+* - user: GitHub user account (uses /users/{username}/repos endpoint)
+* - undefined: Auto-detect (tries org first, falls back to user)
+*/
+const ownerTypeSchema = z.enum(["org", "user"]).optional();
+/**
+* Full options schema for AFSGitHub
+*/
+const afsGitHubOptionsSchema = z.object({
+	name: z.string().default("github"),
+	description: z.string().optional(),
+	auth: authOptionsSchema.optional(),
+	owner: z.string().optional(),
+	repo: z.string().optional(),
+	accessMode: accessModeSchema.optional(),
+	mode: repoModeSchema.optional(),
+	ownerType: ownerTypeSchema.optional(),
+	baseUrl: z.string().default("https://api.github.com"),
+	mappingPath: z.string().optional(),
+	cache: cacheOptionsSchema.optional(),
+	rateLimit: rateLimitOptionsSchema.optional(),
+	ref: z.string().optional()
+});
+
+//#endregion
+//#region src/github.ts
+/**
+* AFSGitHub Provider
+*
+* AFS module for accessing GitHub Issues, PRs, and Actions.
+* Implements AFSModule and AFSWorldMappingCapable interfaces.
+*/
+const DEFAULT_MAPPING_PATH = join(fileURLToPath(new URL(".", import.meta.url)), "default-mapping");
+/**
+* AFSGitHub Provider
+*
+* Provides access to GitHub Issues, Pull Requests, and Actions through AFS.
+*
+* @example
+* ```typescript
+* const github = new AFSGitHub({
+*   auth: { token: process.env.GITHUB_TOKEN },
+*   owner: "aigne",
+*   repo: "afs",
+* });
+*
+* // Mount to AFS
+* afs.mount("/github", github);
+*
+* // List issues
+* const issues = await afs.list("/github/issues");
+* ```
+*/
+var AFSGitHub = class {
+	name;
+	description;
+	accessMode;
+	options;
+	client;
+	compiled = null;
+	mappingPath = null;
+	mappingLoadedAt;
+	mappingError;
+	/** World mapping core for schema-level path resolution and field projection (Level 1) */
+	worldCore;
+	constructor(options) {
+		const parsed = afsGitHubOptionsSchema.parse(options);
+		this.options = {
+			name: parsed.name,
+			description: parsed.description,
+			auth: parsed.auth,
+			owner: parsed.owner,
+			repo: parsed.repo,
+			accessMode: parsed.accessMode ?? "readonly",
+			mode: parsed.mode ?? "single-repo",
+			ownerType: parsed.ownerType,
+			baseUrl: parsed.baseUrl,
+			mappingPath: parsed.mappingPath,
+			cache: {
+				enabled: parsed.cache?.enabled ?? true,
+				ttl: parsed.cache?.ttl ?? 6e4
+			},
+			rateLimit: {
+				autoRetry: parsed.rateLimit?.autoRetry ?? true,
+				maxRetries: parsed.rateLimit?.maxRetries ?? 3
+			},
+			ref: parsed.ref
+		};
+		this.name = this.options.name;
+		this.description = this.options.description;
+		this.accessMode = this.options.accessMode;
+		if (this.options.mode === "single-repo") {
+			if (!this.options.owner || !this.options.repo) throw new Error("owner and repo are required in single-repo mode");
+		} else if (this.options.mode === "org") {
+			if (!this.options.owner) throw new Error("owner is required in org mode");
+			this.options.owner = this.options.owner.trim();
+		}
+		this.client = new GitHubClient({
+			auth: this.options.auth,
+			baseUrl: this.options.baseUrl,
+			cache: this.options.cache,
+			rateLimit: this.options.rateLimit
+		});
+		this.worldCore = new WorldMappingCore(this.getDefaultWorldSchema(), this.getDefaultWorldBinding());
+		this.loadDefaultMapping();
+	}
+	/**
+	* Load the default mapping configuration
+	*/
+	loadDefaultMapping() {
+		try {
+			const compiler = new MappingCompiler();
+			this.mappingPath = this.options.mappingPath ?? DEFAULT_MAPPING_PATH;
+			this.compiled = compiler.compileConfig({
+				name: "github",
+				version: "1.0",
+				defaults: {
+					baseUrl: this.options.baseUrl,
+					headers: {
+						Accept: "application/vnd.github+json",
+						"X-GitHub-Api-Version": "2022-11-28"
+					}
+				},
+				routes: this.getDefaultRoutes()
+			});
+			this.mappingLoadedAt = /* @__PURE__ */ new Date();
+			this.mappingError = void 0;
+		} catch (error) {
+			this.mappingError = error instanceof Error ? error.message : String(error);
+		}
+	}
+	/**
+	* Get default route definitions
+	* This is used when loading mapping synchronously
+	*/
+	getDefaultRoutes() {
+		return {
+			"/{owner}/{repo}/issues": { list: {
+				method: "GET",
+				path: "/repos/{owner}/{repo}/issues",
+				params: {
+					owner: "path.owner",
+					repo: "path.repo",
+					state: "query.state | default(\"open\")",
+					per_page: "query.limit | default(30)"
+				},
+				transform: {
+					items: "$",
+					entry: {
+						id: "$.number | string",
+						path: "/{owner}/{repo}/issues/{$.number}",
+						summary: "$.title",
+						content: "$.body",
+						metadata: {
+							type: "issue",
+							state: "$.state",
+							author: "$.user.login"
+						}
+					}
+				}
+			} },
+			"/{owner}/{repo}/issues/{number}": { read: {
+				method: "GET",
+				path: "/repos/{owner}/{repo}/issues/{number}",
+				params: {
+					owner: "path.owner",
+					repo: "path.repo",
+					number: "path.number"
+				},
+				transform: { entry: {
+					id: "$.number | string",
+					path: "/{owner}/{repo}/issues/{$.number}",
+					summary: "$.title",
+					content: "$.body",
+					metadata: {
+						type: "issue",
+						state: "$.state",
+						author: "$.user.login"
+					}
+				} }
+			} },
+			"/{owner}/{repo}/pulls": { list: {
+				method: "GET",
+				path: "/repos/{owner}/{repo}/pulls",
+				params: {
+					owner: "path.owner",
+					repo: "path.repo",
+					state: "query.state | default(\"open\")",
+					per_page: "query.limit | default(30)"
+				},
+				transform: {
+					items: "$",
+					entry: {
+						id: "$.number | string",
+						path: "/{owner}/{repo}/pulls/{$.number}",
+						summary: "$.title",
+						content: "$.body",
+						metadata: {
+							type: "pull_request",
+							state: "$.state",
+							author: "$.user.login"
+						}
+					}
+				}
+			} },
+			"/{owner}/{repo}/pulls/{number}": { read: {
+				method: "GET",
+				path: "/repos/{owner}/{repo}/pulls/{number}",
+				params: {
+					owner: "path.owner",
+					repo: "path.repo",
+					number: "path.number"
+				},
+				transform: { entry: {
+					id: "$.number | string",
+					path: "/{owner}/{repo}/pulls/{$.number}",
+					summary: "$.title",
+					content: "$.body",
+					metadata: {
+						type: "pull_request",
+						state: "$.state",
+						author: "$.user.login"
+					}
+				} }
+			} }
+		};
+	}
+	/**
+	* Get default world schema for GitHub
+	* Defines Issue, PullRequest, Comment as world kinds
+	*/
+	getDefaultWorldSchema() {
+		return {
+			world: "github",
+			version: "1.0",
+			kinds: {
+				Issue: {
+					key: "number",
+					path: "/{owner}/{repo}/issues/{number}",
+					fields: {
+						number: "int",
+						title: "string",
+						body: "text",
+						state: "string",
+						author: "string",
+						labels: "string",
+						assignees: "string",
+						created_at: "datetime",
+						updated_at: "datetime",
+						comments_count: "int"
+					}
+				},
+				PullRequest: {
+					key: "number",
+					path: "/{owner}/{repo}/pulls/{number}",
+					fields: {
+						number: "int",
+						title: "string",
+						body: "text",
+						state: "string",
+						author: "string",
+						created_at: "datetime",
+						updated_at: "datetime"
+					}
+				},
+				Comment: {
+					key: "id",
+					path: "/{owner}/{repo}/issues/{number}/comments/{id}",
+					fields: {
+						id: "int",
+						body: "text",
+						author: "string",
+						created_at: "datetime",
+						updated_at: "datetime"
+					}
+				}
+			}
+		};
+	}
+	/**
+	* Get default world binding for GitHub
+	* Maps world fields to GitHub API response fields
+	*/
+	getDefaultWorldBinding() {
+		return {
+			source: "/github",
+			mappings: {
+				Issue: {
+					path: "/{owner}/{repo}/issues/{number}",
+					fieldMap: {
+						author: "user_login",
+						comments_count: "comments"
+					}
+				},
+				PullRequest: {
+					path: "/{owner}/{repo}/pulls/{number}",
+					fieldMap: { author: "user_login" }
+				},
+				Comment: {
+					path: "/{owner}/{repo}/issues/{number}/comments/{id}",
+					fieldMap: { author: "user_login" }
+				}
+			}
+		};
+	}
+	onMount(_root) {}
+	/**
+	* Resolve a path based on mode
+	* - single-repo: prepend owner/repo
+	* - org: prepend owner (org name)
+	* - multi-repo: pass through
+	*/
+	resolvePath(path) {
+		let decodedPath;
+		try {
+			decodedPath = decodeURIComponent(path);
+		} catch {
+			decodedPath = path;
+		}
+		const cleanPath = decodedPath.split("/").filter((segment) => segment !== "" && segment !== "." && segment !== "..").join("/");
+		if (this.options.mode === "single-repo" && this.options.owner && this.options.repo) {
+			if (!cleanPath) return `/${this.options.owner}/${this.options.repo}`;
+			return `/${this.options.owner}/${this.options.repo}/${cleanPath}`;
+		}
+		if (this.options.mode === "org" && this.options.owner) {
+			if (!cleanPath) return "/";
+			return `/${this.options.owner}/${cleanPath}`;
+		}
+		return cleanPath ? `/${cleanPath}` : "/";
+	}
+	/**
+	* Get virtual directory structure for root path
+	* Returns the available resource types (issues, pulls, repo)
+	*/
+	getVirtualDirectories() {
+		return [
+			{
+				id: "issues",
+				path: "/issues",
+				summary: "Repository Issues",
+				metadata: {
+					childrenCount: -1,
+					description: "List and read repository issues"
+				}
+			},
+			{
+				id: "pulls",
+				path: "/pulls",
+				summary: "Pull Requests",
+				metadata: {
+					childrenCount: -1,
+					description: "List and read pull requests"
+				}
+			},
+			{
+				id: "repo",
+				path: "/repo",
+				summary: "Repository Code",
+				metadata: {
+					childrenCount: -1,
+					description: "Repository source code (via Contents API)"
+				}
+			}
+		];
+	}
+	/**
+	* Check if path is root or empty
+	*/
+	isRootPath(path) {
+		return path.replace(/^\/+|\/+$/g, "") === "";
+	}
+	/**
+	* Get root entry (the mount point itself)
+	*/
+	getRootEntry() {
+		let summary;
+		let childrenCount;
+		if (this.options.mode === "org") {
+			summary = this.description ?? `GitHub Organization: ${this.options.owner}`;
+			childrenCount = -1;
+		} else if (this.options.mode === "single-repo") {
+			summary = this.description ?? `GitHub: ${this.options.owner}/${this.options.repo}`;
+			childrenCount = 3;
+		} else {
+			summary = this.description ?? "GitHub";
+			childrenCount = -1;
+		}
+		return {
+			id: this.name,
+			path: "/",
+			summary,
+			metadata: {
+				childrenCount,
+				description: summary
+			}
+		};
+	}
+	/**
+	* Get virtual directories for a repo (issues, pulls, repo)
+	*/
+	getRepoVirtualDirectories(repoPath) {
+		return [
+			{
+				id: `${repoPath}/issues`,
+				path: `${repoPath}/issues`,
+				summary: "Repository Issues",
+				metadata: {
+					childrenCount: -1,
+					description: "List and read repository issues"
+				}
+			},
+			{
+				id: `${repoPath}/pulls`,
+				path: `${repoPath}/pulls`,
+				summary: "Pull Requests",
+				metadata: {
+					childrenCount: -1,
+					description: "List and read pull requests"
+				}
+			},
+			{
+				id: `${repoPath}/repo`,
+				path: `${repoPath}/repo`,
+				summary: "Repository Code",
+				metadata: {
+					childrenCount: -1,
+					description: "Repository source code (via Contents API)"
+				}
+			}
+		];
+	}
+	/**
+	* Check if a path represents a repo root in org mode
+	* e.g., "/reponame" without /issues or /pulls suffix
+	*/
+	isRepoRootPath(path) {
+		return path.replace(/^\/+|\/+$/g, "").split("/").filter(Boolean).length === 1;
+	}
+	/**
+	* Format a user-friendly error message based on the error type
+	*/
+	formatErrorMessage(error, context) {
+		const status = error?.status;
+		const message = error instanceof Error ? error.message : String(error);
+		const sanitized = message.replace(/ghp_[a-zA-Z0-9]+/g, "[REDACTED]");
+		if (status === 401 || message.includes("Bad credentials")) {
+			if (!this.options.auth?.token) return `GitHub authentication required for ${context}. Set GITHUB_TOKEN environment variable or provide auth.token in config.`;
+			return `GitHub token is invalid or expired. Please check your GITHUB_TOKEN and ensure it has the required permissions.`;
+		}
+		if (status === 403) {
+			if (message.includes("rate limit")) return `GitHub API rate limit exceeded. ${this.options.auth?.token ? "Your token may have hit its limit." : "Set GITHUB_TOKEN for higher rate limits (5000/hour vs 60/hour)."} Try again later.`;
+			return `GitHub access forbidden for ${context}. Check that your token has the required permissions (repo scope for private repos).`;
+		}
+		if (status === 404) return `GitHub ${context} not found. Check that the organization/user name is correct and accessible.`;
+		if (message.includes("ENOTFOUND") || message.toLowerCase().includes("network")) return `Network error connecting to GitHub. Check your internet connection.`;
+		return `GitHub API error: ${sanitized}`;
+	}
+	/**
+	* Check if a path is a repo path (should be routed to Contents API)
+	* - Single-repo mode: /repo or /repo/*
+	* - Org mode: /{repoName}/repo or /{repoName}/repo/*
+	*/
+	isRepoPath(path) {
+		const segments = path.replace(/^\/+|\/+$/g, "").split("/").filter(Boolean);
+		if (this.options.mode === "single-repo") return segments[0] === "repo";
+		if (this.options.mode === "org") return segments.length >= 2 && segments[1] === "repo";
+		return false;
+	}
+	/**
+	* Parse a repo path into owner, repo name, branch, and file path
+	* Structure: /repo/{branch}/{filePath}
+	* - Single-repo mode: /repo/main/src/index.ts -> { owner, repo, branch: "main", filePath: "src/index.ts" }
+	* - Org mode: /afs/repo/main/src/index.ts -> { owner, repo: "afs", branch: "main", filePath: "src/index.ts" }
+	*/
+	parseRepoPath(path) {
+		const segments = path.replace(/^\/+|\/+$/g, "").split("/").filter(Boolean);
+		if (this.options.mode === "single-repo") {
+			const branch = segments[1];
+			const filePath = segments.slice(2).join("/");
+			return {
+				owner: this.options.owner,
+				repo: this.options.repo,
+				branch,
+				filePath
+			};
+		}
+		if (this.options.mode === "org") {
+			const repoName = segments[0];
+			const branch = segments[2];
+			const filePath = segments.slice(3).join("/");
+			return {
+				owner: this.options.owner,
+				repo: repoName,
+				branch,
+				filePath
+			};
+		}
+		return {
+			owner: this.options.owner,
+			repo: this.options.repo,
+			branch: void 0,
+			filePath: ""
+		};
+	}
+	/**
+	* Build the path prefix for a repo entry
+	*/
+	getRepoPathPrefix(repo) {
+		return this.options.mode === "single-repo" ? "/repo" : `/${repo}/repo`;
+	}
+	/**
+	* List repository contents via GitHub Contents API
+	* - /repo -> list all branches
+	* - /repo/{branch} -> list branch root
+	* - /repo/{branch}/path -> list contents at path
+	*/
+	async listViaContentsAPI(path, _options) {
+		const { owner, repo, branch, filePath } = this.parseRepoPath(path);
+		const repoPrefix = this.getRepoPathPrefix(repo);
+		if (!branch) try {
+			const branches = await this.client.getBranches(owner, repo);
+			const defaultBranch = await this.client.getDefaultBranch(owner, repo);
+			return { data: branches.map((b) => ({
+				id: `${repoPrefix}/${b.name}`,
+				path: `${repoPrefix}/${b.name}`,
+				summary: b.name + (b.name === defaultBranch ? " (default)" : ""),
+				metadata: {
+					type: "branch",
+					sha: b.commit.sha,
+					protected: b.protected,
+					isDefault: b.name === defaultBranch,
+					childrenCount: -1
+				}
+			})) };
+		} catch (error) {
+			return {
+				data: [],
+				message: this.formatErrorMessage(error, `branches for ${owner}/${repo}`)
+			};
+		}
+		try {
+			const contents = await this.client.getContents(owner, repo, filePath, branch);
+			if (!Array.isArray(contents)) {
+				const entryPath = filePath ? `${repoPrefix}/${branch}/${contents.path}` : `${repoPrefix}/${branch}/${contents.name}`;
+				return { data: [{
+					id: entryPath,
+					path: entryPath,
+					summary: contents.name,
+					metadata: {
+						type: contents.type,
+						size: contents.size,
+						sha: contents.sha,
+						childrenCount: contents.type === "dir" ? -1 : void 0
+					}
+				}] };
+			}
+			return { data: contents.map((item) => {
+				const entryPath = filePath ? `${repoPrefix}/${branch}/${filePath}/${item.name}` : `${repoPrefix}/${branch}/${item.name}`;
+				return {
+					id: entryPath,
+					path: entryPath,
+					summary: item.name,
+					metadata: {
+						type: item.type,
+						size: item.size,
+						sha: item.sha,
+						childrenCount: item.type === "dir" ? -1 : void 0
+					}
+				};
+			}) };
+		} catch (error) {
+			if (error?.status === 404) return {
+				data: [],
+				message: `Path not found: ${branch}/${filePath || ""}`
+			};
+			return {
+				data: [],
+				message: this.formatErrorMessage(error, `repository contents for ${owner}/${repo}`)
+			};
+		}
+	}
+	/**
+	* Read file content via GitHub Contents API
+	* Path format: /repo/{branch}/{filePath}
+	*/
+	async readViaContentsAPI(path, _options) {
+		const { owner, repo, branch, filePath } = this.parseRepoPath(path);
+		const repoPrefix = this.getRepoPathPrefix(repo);
+		if (!branch) return {
+			data: void 0,
+			message: "Branch is required to read files"
+		};
+		if (!filePath) return {
+			data: void 0,
+			message: "Cannot read branch root as file"
+		};
+		try {
+			const contents = await this.client.getContents(owner, repo, filePath, branch);
+			if (Array.isArray(contents)) return {
+				data: void 0,
+				message: "Path is a directory, not a file"
+			};
+			if (contents.type !== "file") return {
+				data: void 0,
+				message: `Path is a ${contents.type}, not a file`
+			};
+			let content;
+			if (contents.content) content = Buffer.from(contents.content, "base64").toString("utf-8");
+			else content = await this.client.getBlob(owner, repo, contents.sha);
+			const entryPath = `${repoPrefix}/${branch}/${filePath}`;
+			return { data: {
+				id: entryPath,
+				path: entryPath,
+				summary: contents.name,
+				content,
+				metadata: {
+					type: "file",
+					size: contents.size,
+					sha: contents.sha,
+					branch
+				}
+			} };
+		} catch (error) {
+			if (error?.status === 404) return {
+				data: void 0,
+				message: `File not found: ${branch}/${filePath}`
+			};
+			return {
+				data: void 0,
+				message: this.formatErrorMessage(error, `file ${filePath} in ${owner}/${repo}@${branch}`)
+			};
+		}
+	}
+	/**
+	* List organization or user repositories
+	* Uses ownerType if specified, otherwise tries org endpoint first and falls back to user
+	*/
+	async listOrgRepos(includePrivate) {
+		const owner = this.options.owner;
+		const ownerType = this.options.ownerType;
+		let allRepos = [];
+		if (ownerType) try {
+			allRepos = await this.fetchAllRepos(ownerType, owner, includePrivate);
+		} catch (error) {
+			const context = ownerType === "org" ? `organization "${owner}"` : `user "${owner}"`;
+			return {
+				data: [],
+				message: this.formatErrorMessage(error, context)
+			};
+		}
+		else try {
+			allRepos = await this.fetchAllRepos("org", owner, includePrivate);
+		} catch (error) {
+			if (error instanceof Error && error.message.includes("404") || error?.status === 404) try {
+				allRepos = await this.fetchAllRepos("user", owner, includePrivate);
+			} catch (userError) {
+				if (userError?.status === 404) return {
+					data: [],
+					message: `GitHub organization or user "${owner}" not found. Check that the name is correct.`
+				};
+				return {
+					data: [],
+					message: this.formatErrorMessage(userError, `user "${owner}"`)
+				};
+			}
+			else return {
+				data: [],
+				message: this.formatErrorMessage(error, `organization "${owner}"`)
+			};
+		}
+		return { data: (this.options.auth?.token ? allRepos : allRepos.filter((r) => !r.private)).map((repo) => ({
+			id: repo.name,
+			path: `/${repo.name}`,
+			summary: repo.description || repo.name,
+			metadata: {
+				childrenCount: 3,
+				description: repo.description,
+				private: repo.private
+			}
+		})) };
+	}
+	/**
+	* Fetch all repos with pagination support
+	*/
+	async fetchAllRepos(type, owner, includePrivate) {
+		const allRepos = [];
+		let page = 1;
+		const perPage = 100;
+		while (true) {
+			let response;
+			if (type === "org") response = await this.client.request("GET /orgs/{org}/repos", {
+				org: owner,
+				per_page: perPage,
+				page,
+				type: includePrivate ? "all" : "public"
+			});
+			else response = await this.client.request("GET /users/{username}/repos", {
+				username: owner,
+				per_page: perPage,
+				page,
+				type: includePrivate ? "all" : "public"
+			});
+			const repos = response.data;
+			allRepos.push(...repos);
+			if (repos.length < perPage) break;
+			page++;
+		}
+		return allRepos;
+	}
+	/**
+	* List entries at a path
+	*/
+	async list(path, options) {
+		const maxDepth = options?.maxDepth ?? 1;
+		if (this.isRepoPath(path)) return this.listViaContentsAPI(path, options);
+		if (this.isRootPath(path)) {
+			if (maxDepth === 0) return { data: [this.getRootEntry()] };
+			if (this.options.mode === "org") return this.listOrgRepos(!!this.options.auth?.token);
+			return { data: this.getVirtualDirectories() };
+		}
+		if (this.options.mode === "org" && this.isRepoRootPath(path)) {
+			const repoName = path.replace(/^\/+|\/+$/g, "");
+			if (maxDepth === 0) return { data: [{
+				id: repoName,
+				path: `/${repoName}`,
+				summary: `Repository: ${this.options.owner}/${repoName}`,
+				metadata: { childrenCount: 2 }
+			}] };
+			return { data: this.getRepoVirtualDirectories(`/${repoName}`) };
+		}
+		const fullPath = this.resolvePath(path);
+		if (!this.compiled) return {
+			data: [],
+			message: "Mapping not loaded"
+		};
+		const resolved = this.compiled.resolve(fullPath);
+		if (!resolved || !resolved.operations.list) return {
+			data: [],
+			message: `No list operation for path: ${fullPath}`
+		};
+		const request = this.compiled.buildRequest(fullPath, "list", { query: options?.filter });
+		if (!request) return {
+			data: [],
+			message: "Failed to build request"
+		};
+		try {
+			let responseData = (await this.client.request(`${request.method} ${request.path}`, request.params)).data;
+			if (Array.isArray(responseData) && fullPath.endsWith("/issues")) responseData = responseData.filter((item) => !item.pull_request);
+			const entries = this.compiled.projectResponse(fullPath, "list", responseData);
+			if (this.options.mode === "single-repo") {
+				const prefix = `/${this.options.owner}/${this.options.repo}`;
+				for (const entry of entries) if (entry.path.startsWith(prefix)) entry.path = entry.path.slice(prefix.length) || "/";
+			} else if (this.options.mode === "org") {
+				const prefix = `/${this.options.owner}`;
+				for (const entry of entries) if (entry.path.startsWith(prefix)) entry.path = entry.path.slice(prefix.length) || "/";
+			}
+			return { data: entries };
+		} catch (error) {
+			return {
+				data: [],
+				message: this.formatErrorMessage(error, `path "${path}"`)
+			};
+		}
+	}
+	/**
+	* Read a single entry
+	*/
+	async read(path, options) {
+		if (this.isRepoPath(path)) return this.readViaContentsAPI(path, options);
+		if (this.options.mode === "org" || this.options.mode === "single-repo") {
+			const segments = path.replace(/^\/+|\/+$/g, "").split("/");
+			const issuesIdx = segments.indexOf("issues");
+			const pullsIdx = segments.indexOf("pulls");
+			if (issuesIdx !== -1 && segments[issuesIdx + 1]) {
+				const issueNum = segments[issuesIdx + 1];
+				if (!/^\d+$/.test(issueNum)) return {
+					data: void 0,
+					message: "Invalid issue number"
+				};
+			}
+			if (pullsIdx !== -1 && segments[pullsIdx + 1]) {
+				const prNum = segments[pullsIdx + 1];
+				if (!/^\d+$/.test(prNum)) return {
+					data: void 0,
+					message: "Invalid pull request number"
+				};
+			}
+		}
+		const fullPath = this.resolvePath(path);
+		if (!this.compiled) return {
+			data: void 0,
+			message: "Mapping not loaded"
+		};
+		const resolved = this.compiled.resolve(fullPath);
+		if (!resolved || !resolved.operations.read) return {
+			data: void 0,
+			message: `No read operation for path: ${fullPath}`
+		};
+		const request = this.compiled.buildRequest(fullPath, "read", {});
+		if (!request) return {
+			data: void 0,
+			message: "Failed to build request"
+		};
+		try {
+			const response = await this.client.request(`${request.method} ${request.path}`, request.params);
+			const entries = this.compiled.projectResponse(fullPath, "read", response.data);
+			if (entries.length === 0) return {
+				data: void 0,
+				message: "No data returned"
+			};
+			const entry = entries[0];
+			if (this.options.mode === "single-repo") {
+				const prefix = `/${this.options.owner}/${this.options.repo}`;
+				if (entry.path.startsWith(prefix)) entry.path = entry.path.slice(prefix.length) || "/";
+			} else if (this.options.mode === "org") {
+				const prefix = `/${this.options.owner}`;
+				if (entry.path.startsWith(prefix)) entry.path = entry.path.slice(prefix.length) || "/";
+			}
+			return { data: entry };
+		} catch (error) {
+			return {
+				data: void 0,
+				message: this.formatErrorMessage(error, `path "${path}"`)
+			};
+		}
+	}
+	async loadMapping(mappingPath) {
+		const compiler = new MappingCompiler();
+		try {
+			this.compiled = await compiler.compileDirectory(mappingPath);
+			this.mappingPath = mappingPath;
+			this.mappingLoadedAt = /* @__PURE__ */ new Date();
+			this.mappingError = void 0;
+		} catch (error) {
+			this.mappingError = error instanceof Error ? error.message : String(error);
+			throw error;
+		}
+	}
+	async reloadMapping() {
+		if (!this.mappingPath) throw new Error("No mapping path configured");
+		const previousCompiled = this.compiled;
+		try {
+			await this.loadMapping(this.mappingPath);
+		} catch (error) {
+			this.compiled = previousCompiled;
+			throw error;
+		}
+	}
+	getMappingStatus() {
+		return {
+			loaded: this.compiled !== null,
+			loadedAt: this.mappingLoadedAt,
+			mappingPath: this.mappingPath ?? void 0,
+			compiled: this.compiled !== null,
+			error: this.mappingError,
+			stats: this.compiled ? {
+				routes: this.compiled.routeCount,
+				operations: this.compiled.operationCount
+			} : void 0
+		};
+	}
+	resolve(path) {
+		const fullPath = this.resolvePath(path);
+		if (!this.compiled) return null;
+		const resolved = this.compiled.resolve(fullPath);
+		if (!resolved) return null;
+		if (!(resolved.operations.read ?? resolved.operations.list)) return null;
+		const request = this.compiled.buildRequest(fullPath, resolved.operations.read ? "read" : "list", {});
+		if (!request) return null;
+		return {
+			type: "http",
+			target: `${this.options.baseUrl}${request.path}`,
+			method: request.method,
+			params: {
+				...resolved.params,
+				...request.params
+			},
+			headers: request.headers
+		};
+	}
+	project(externalData, context) {
+		if (!this.compiled) return [];
+		const operationType = context.rule === "list" ? "list" : "read";
+		return this.compiled.projectResponse(context.path, operationType, externalData);
+	}
+	async mutate(_path, _action, _payload) {
+		return {
+			success: false,
+			error: "Write operations not yet implemented"
+		};
+	}
+};
+
+//#endregion
+export { AFSGitHub, GitHubClient, accessModeSchema, afsGitHubOptionsSchema, authOptionsSchema, cacheOptionsSchema, ownerTypeSchema, rateLimitOptionsSchema, repoModeSchema };
+//# sourceMappingURL=index.mjs.map