@aigne/afs-git 1.1.0 → 1.11.0-beta.1

package/dist/index.mjs

@@ -0,0 +1,611 @@
+import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
+import { mkdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename, dirname, isAbsolute, join } from "node:path";
+import { promisify } from "node:util";
+import { camelize, optionalize, zodParse } from "@aigne/afs/utils/zod";
+import { simpleGit } from "simple-git";
+import { z } from "zod";
+
+//#region src/index.ts
+const LIST_MAX_LIMIT = 1e3;
+const execFileAsync = promisify(execFile);
+const afsGitOptionsSchema = camelize(z.object({
+	name: optionalize(z.string()),
+	repoPath: optionalize(z.string().describe("The path to the git repository")),
+	remoteUrl: optionalize(z.string().describe("Remote repository URL (https or git protocol)")),
+	description: optionalize(z.string().describe("A description of the repository")),
+	branches: optionalize(z.array(z.string()).describe("List of branches to expose")),
+	accessMode: optionalize(z.enum(["readonly", "readwrite"]).describe("Access mode for this module")),
+	autoCommit: optionalize(z.boolean().describe("Automatically commit changes after write operations")),
+	commitAuthor: optionalize(z.object({
+		name: z.string(),
+		email: z.string()
+	})),
+	depth: optionalize(z.number().describe("Clone depth for shallow clone")),
+	autoCleanup: optionalize(z.boolean().describe("Automatically clean up cloned repository on cleanup()")),
+	cloneOptions: optionalize(z.object({ auth: optionalize(z.object({
+		username: optionalize(z.string()),
+		password: optionalize(z.string())
+	})) }))
+}).refine((data) => data.repoPath || data.remoteUrl, { message: "Either repoPath or remoteUrl must be provided" }));
+var AFSGit = class AFSGit {
+	static schema() {
+		return afsGitOptionsSchema;
+	}
+	static async load({ filepath, parsed }) {
+		const instance = new AFSGit({
+			...await AFSGit.schema().parseAsync(parsed),
+			cwd: dirname(filepath)
+		});
+		await instance.ready();
+		return instance;
+	}
+	initPromise;
+	git;
+	tempBase;
+	worktrees = /* @__PURE__ */ new Map();
+	repoHash;
+	isAutoCloned = false;
+	clonedPath;
+	repoPath;
+	constructor(options) {
+		this.options = options;
+		zodParse(afsGitOptionsSchema, options);
+		let repoPath;
+		let repoName;
+		if (options.repoPath) {
+			repoPath = isAbsolute(options.repoPath) ? options.repoPath : join(options.cwd || process.cwd(), options.repoPath);
+			repoName = basename(repoPath);
+		} else if (options.remoteUrl) {
+			const urlParts = options.remoteUrl.split("/");
+			repoName = urlParts[urlParts.length - 1]?.replace(/\.git$/, "") || "git";
+			const repoHash = createHash("md5").update(options.remoteUrl).digest("hex").substring(0, 8);
+			repoPath = join(tmpdir(), `afs-git-remote-${repoHash}`);
+		} else throw new Error("Either repoPath or remoteUrl must be provided");
+		this.repoPath = repoPath;
+		this.name = options.name || repoName;
+		this.description = options.description;
+		this.accessMode = options.accessMode ?? "readonly";
+		this.repoHash = createHash("md5").update(repoPath).digest("hex").substring(0, 8);
+		this.tempBase = join(tmpdir(), `afs-git-${this.repoHash}`);
+		this.git = null;
+		this.initPromise = this.initialize();
+	}
+	/**
+	* Wait for async initialization to complete
+	*/
+	async ready() {
+		await this.initPromise;
+	}
+	/**
+	* Async initialization logic (runs in constructor)
+	* Handles cloning remote repositories if needed
+	*/
+	async initialize() {
+		const options = this.options;
+		if (options.remoteUrl) {
+			const targetPath = options.repoPath ? isAbsolute(options.repoPath) ? options.repoPath : join(options.cwd || process.cwd(), options.repoPath) : this.repoPath;
+			if (!options.repoPath) this.isAutoCloned = true;
+			if (!await stat(targetPath).then(() => true).catch(() => false)) {
+				const singleBranch = options.branches?.length === 1 ? options.branches[0] : void 0;
+				await AFSGit.cloneRepository(options.remoteUrl, targetPath, {
+					depth: options.depth ?? 1,
+					branch: singleBranch,
+					auth: options.cloneOptions?.auth
+				});
+			}
+			if (targetPath !== this.repoPath) {
+				this.repoPath = targetPath;
+				this.repoHash = createHash("md5").update(targetPath).digest("hex").substring(0, 8);
+				this.tempBase = join(tmpdir(), `afs-git-${this.repoHash}`);
+			}
+			this.clonedPath = this.isAutoCloned ? targetPath : void 0;
+		}
+		this.git = simpleGit(this.repoPath);
+	}
+	/**
+	* Clone a remote repository to local path
+	*/
+	static async cloneRepository(remoteUrl, targetPath, options = {}) {
+		const git = simpleGit();
+		const cloneArgs = [];
+		if (options.depth) cloneArgs.push("--depth", options.depth.toString());
+		if (options.branch) cloneArgs.push("--branch", options.branch, "--single-branch");
+		let cloneUrl = remoteUrl;
+		if (options.auth?.username && options.auth?.password) {
+			if (remoteUrl.startsWith("https://")) {
+				const url = new URL(remoteUrl);
+				url.username = encodeURIComponent(options.auth.username);
+				url.password = encodeURIComponent(options.auth.password);
+				cloneUrl = url.toString();
+			}
+		}
+		await git.clone(cloneUrl, targetPath, cloneArgs);
+	}
+	name;
+	description;
+	accessMode;
+	/**
+	* Parse AFS path into branch and file path
+	* Branch names may contain slashes and are encoded with ~ in paths
+	* Examples:
+	*   "/" -> { branch: undefined, filePath: "" }
+	*   "/main" -> { branch: "main", filePath: "" }
+	*   "/feature~new-feature" -> { branch: "feature/new-feature", filePath: "" }
+	*   "/main/src/index.ts" -> { branch: "main", filePath: "src/index.ts" }
+	*/
+	parsePath(path) {
+		const segments = join("/", path).split("/").filter(Boolean);
+		if (segments.length === 0) return {
+			branch: void 0,
+			filePath: ""
+		};
+		return {
+			branch: segments[0].replace(/~/g, "/"),
+			filePath: segments.slice(1).join("/")
+		};
+	}
+	/**
+	* Detect MIME type based on file extension
+	*/
+	getMimeType(filePath) {
+		return {
+			png: "image/png",
+			jpg: "image/jpeg",
+			jpeg: "image/jpeg",
+			gif: "image/gif",
+			bmp: "image/bmp",
+			webp: "image/webp",
+			svg: "image/svg+xml",
+			ico: "image/x-icon",
+			pdf: "application/pdf",
+			txt: "text/plain",
+			md: "text/markdown",
+			js: "text/javascript",
+			ts: "text/typescript",
+			json: "application/json",
+			html: "text/html",
+			css: "text/css",
+			xml: "text/xml"
+		}[filePath.split(".").pop()?.toLowerCase() || ""] || "application/octet-stream";
+	}
+	/**
+	* Check if file is likely binary based on extension
+	*/
+	isBinaryFile(filePath) {
+		const ext = filePath.split(".").pop()?.toLowerCase();
+		return [
+			"png",
+			"jpg",
+			"jpeg",
+			"gif",
+			"bmp",
+			"webp",
+			"ico",
+			"pdf",
+			"zip",
+			"tar",
+			"gz",
+			"exe",
+			"dll",
+			"so",
+			"dylib",
+			"wasm"
+		].includes(ext || "");
+	}
+	/**
+	* Get list of available branches
+	*/
+	async getBranches() {
+		const allBranches = (await this.git.branchLocal()).all;
+		if (this.options.branches && this.options.branches.length > 0) return allBranches.filter((branch) => this.options.branches.includes(branch));
+		return allBranches;
+	}
+	/**
+	* Ensure worktree exists for a branch (lazy creation)
+	*/
+	async ensureWorktree(branch) {
+		if (this.worktrees.has(branch)) return this.worktrees.get(branch);
+		if ((await this.git.revparse(["--abbrev-ref", "HEAD"])).trim() === branch) {
+			this.worktrees.set(branch, this.repoPath);
+			return this.repoPath;
+		}
+		const worktreePath = join(this.tempBase, branch);
+		if (!await stat(worktreePath).then(() => true).catch(() => false)) {
+			await mkdir(this.tempBase, { recursive: true });
+			await this.git.raw([
+				"worktree",
+				"add",
+				worktreePath,
+				branch
+			]);
+		}
+		this.worktrees.set(branch, worktreePath);
+		return worktreePath;
+	}
+	/**
+	* List files using git ls-tree (no worktree needed)
+	*/
+	async listWithGitLsTree(branch, path, options) {
+		const maxDepth = options?.maxDepth ?? 1;
+		const limit = Math.min(options?.limit || LIST_MAX_LIMIT, LIST_MAX_LIMIT);
+		const entries = [];
+		const targetPath = path || "";
+		const treeish = targetPath ? `${branch}:${targetPath}` : branch;
+		try {
+			const pathType = await this.git.raw([
+				"cat-file",
+				"-t",
+				treeish
+			]).then((t) => t.trim()).catch(() => null);
+			if (pathType === null) return { data: [] };
+			if (pathType === "blob") {
+				const size = await this.git.raw([
+					"cat-file",
+					"-s",
+					treeish
+				]).then((s) => Number.parseInt(s.trim(), 10));
+				const afsPath = this.buildPath(branch, path);
+				entries.push({
+					id: afsPath,
+					path: afsPath,
+					metadata: {
+						type: "file",
+						size
+					}
+				});
+				return { data: entries };
+			}
+			const queue = [{
+				path: targetPath,
+				depth: 0
+			}];
+			while (queue.length > 0) {
+				const { path: itemPath, depth } = queue.shift();
+				const itemTreeish = itemPath ? `${branch}:${itemPath}` : branch;
+				const lines = (await this.git.raw([
+					"ls-tree",
+					"-l",
+					itemTreeish
+				])).split("\n").filter((line) => line.trim()).slice(0, limit - entries.length);
+				for (const line of lines) {
+					const match = line.match(/^(\d+)\s+(blob|tree)\s+(\w+)\s+(-|\d+)\s+(.+)$/);
+					if (!match) continue;
+					const type = match[2];
+					const sizeStr = match[4];
+					const name = match[5];
+					const isDirectory = type === "tree";
+					const size = sizeStr === "-" ? void 0 : Number.parseInt(sizeStr, 10);
+					const fullPath = itemPath ? `${itemPath}/${name}` : name;
+					const afsPath = this.buildPath(branch, fullPath);
+					entries.push({
+						id: afsPath,
+						path: afsPath,
+						metadata: {
+							type: isDirectory ? "directory" : "file",
+							size
+						}
+					});
+					if (isDirectory && depth + 1 < maxDepth) queue.push({
+						path: fullPath,
+						depth: depth + 1
+					});
+					if (entries.length >= limit) return { data: entries };
+				}
+			}
+			return { data: entries };
+		} catch (error) {
+			return {
+				data: [],
+				message: error.message
+			};
+		}
+	}
+	/**
+	* Build AFS path with encoded branch name
+	* Branch names with slashes are encoded by replacing / with ~
+	* @param branch Branch name (may contain slashes)
+	* @param filePath File path within branch
+	*/
+	buildPath(branch, filePath) {
+		const encodedBranch = branch.replace(/\//g, "~");
+		if (!filePath) return `/${encodedBranch}`;
+		return `/${encodedBranch}/${filePath}`;
+	}
+	async list(path, options) {
+		await this.ready();
+		const { branch, filePath } = this.parsePath(path);
+		if (!branch) return { data: (await this.getBranches()).map((name) => {
+			const encodedPath = this.buildPath(name);
+			return {
+				id: encodedPath,
+				path: encodedPath,
+				metadata: { type: "directory" }
+			};
+		}) };
+		return this.listWithGitLsTree(branch, filePath, options);
+	}
+	async read(path, _options) {
+		await this.ready();
+		const { branch, filePath } = this.parsePath(path);
+		if (!branch) return { data: {
+			id: "/",
+			path: "/",
+			metadata: { type: "directory" }
+		} };
+		if (!filePath) {
+			const branchPath = this.buildPath(branch);
+			return { data: {
+				id: branchPath,
+				path: branchPath,
+				metadata: { type: "directory" }
+			} };
+		}
+		try {
+			if (await this.git.raw([
+				"cat-file",
+				"-t",
+				`${branch}:${filePath}`
+			]).then((t) => t.trim()) === "tree") {
+				const afsPath$1 = this.buildPath(branch, filePath);
+				return { data: {
+					id: afsPath$1,
+					path: afsPath$1,
+					metadata: { type: "directory" }
+				} };
+			}
+			const size = await this.git.raw([
+				"cat-file",
+				"-s",
+				`${branch}:${filePath}`
+			]).then((s) => Number.parseInt(s.trim(), 10));
+			const mimeType = this.getMimeType(filePath);
+			const isBinary = this.isBinaryFile(filePath);
+			let content;
+			const metadata = {
+				type: "file",
+				size,
+				mimeType
+			};
+			if (isBinary) {
+				const { stdout } = await execFileAsync("git", [
+					"cat-file",
+					"-p",
+					`${branch}:${filePath}`
+				], {
+					cwd: this.options.repoPath,
+					encoding: "buffer",
+					maxBuffer: 10 * 1024 * 1024
+				});
+				content = stdout.toString("base64");
+				metadata.contentType = "base64";
+			} else content = await this.git.show([`${branch}:${filePath}`]);
+			const afsPath = this.buildPath(branch, filePath);
+			return { data: {
+				id: afsPath,
+				path: afsPath,
+				content,
+				metadata
+			} };
+		} catch (error) {
+			return {
+				data: void 0,
+				message: error.message
+			};
+		}
+	}
+	async write(path, entry, options) {
+		await this.ready();
+		const { branch, filePath } = this.parsePath(path);
+		if (!branch || !filePath) throw new Error("Cannot write to root or branch root");
+		const worktreePath = await this.ensureWorktree(branch);
+		const fullPath = join(worktreePath, filePath);
+		const append = options?.append ?? false;
+		await mkdir(dirname(fullPath), { recursive: true });
+		if (entry.content !== void 0) {
+			let contentToWrite;
+			if (typeof entry.content === "string") contentToWrite = entry.content;
+			else contentToWrite = JSON.stringify(entry.content, null, 2);
+			await writeFile(fullPath, contentToWrite, {
+				encoding: "utf8",
+				flag: append ? "a" : "w"
+			});
+		}
+		if (this.options.autoCommit) {
+			const gitInstance = simpleGit(worktreePath);
+			await gitInstance.add(filePath);
+			if (this.options.commitAuthor) {
+				await gitInstance.addConfig("user.name", this.options.commitAuthor.name, void 0, "local");
+				await gitInstance.addConfig("user.email", this.options.commitAuthor.email, void 0, "local");
+			}
+			await gitInstance.commit(`Update ${filePath}`);
+		}
+		const stats = await stat(fullPath);
+		const afsPath = this.buildPath(branch, filePath);
+		return { data: {
+			id: afsPath,
+			path: afsPath,
+			content: entry.content,
+			summary: entry.summary,
+			createdAt: stats.birthtime,
+			updatedAt: stats.mtime,
+			metadata: {
+				...entry.metadata,
+				type: stats.isDirectory() ? "directory" : "file",
+				size: stats.size
+			},
+			userId: entry.userId,
+			sessionId: entry.sessionId,
+			linkTo: entry.linkTo
+		} };
+	}
+	async delete(path, options) {
+		await this.ready();
+		const { branch, filePath } = this.parsePath(path);
+		if (!branch || !filePath) throw new Error("Cannot delete root or branch root");
+		const worktreePath = await this.ensureWorktree(branch);
+		const fullPath = join(worktreePath, filePath);
+		const recursive = options?.recursive ?? false;
+		if ((await stat(fullPath)).isDirectory() && !recursive) throw new Error(`Cannot delete directory '${path}' without recursive option. Set recursive: true to delete directories.`);
+		await rm(fullPath, {
+			recursive,
+			force: true
+		});
+		if (this.options.autoCommit) {
+			const gitInstance = simpleGit(worktreePath);
+			await gitInstance.add(filePath);
+			if (this.options.commitAuthor) {
+				await gitInstance.addConfig("user.name", this.options.commitAuthor.name, void 0, "local");
+				await gitInstance.addConfig("user.email", this.options.commitAuthor.email, void 0, "local");
+			}
+			await gitInstance.commit(`Delete ${filePath}`);
+		}
+		return { message: `Successfully deleted: ${path}` };
+	}
+	async rename(oldPath, newPath, options) {
+		await this.ready();
+		const { branch: oldBranch, filePath: oldFilePath } = this.parsePath(oldPath);
+		const { branch: newBranch, filePath: newFilePath } = this.parsePath(newPath);
+		if (!oldBranch || !oldFilePath) throw new Error("Cannot rename from root or branch root");
+		if (!newBranch || !newFilePath) throw new Error("Cannot rename to root or branch root");
+		if (oldBranch !== newBranch) throw new Error("Cannot rename across branches");
+		const worktreePath = await this.ensureWorktree(oldBranch);
+		const oldFullPath = join(worktreePath, oldFilePath);
+		const newFullPath = join(worktreePath, newFilePath);
+		const overwrite = options?.overwrite ?? false;
+		await stat(oldFullPath);
+		try {
+			await stat(newFullPath);
+			if (!overwrite) throw new Error(`Destination '${newPath}' already exists. Set overwrite: true to replace it.`);
+		} catch (error) {
+			if (error.code !== "ENOENT") throw error;
+		}
+		await mkdir(dirname(newFullPath), { recursive: true });
+		await rename(oldFullPath, newFullPath);
+		if (this.options.autoCommit) {
+			const gitInstance = simpleGit(worktreePath);
+			await gitInstance.add([oldFilePath, newFilePath]);
+			if (this.options.commitAuthor) {
+				await gitInstance.addConfig("user.name", this.options.commitAuthor.name, void 0, "local");
+				await gitInstance.addConfig("user.email", this.options.commitAuthor.email, void 0, "local");
+			}
+			await gitInstance.commit(`Rename ${oldFilePath} to ${newFilePath}`);
+		}
+		return { message: `Successfully renamed '${oldPath}' to '${newPath}'` };
+	}
+	async search(path, query, options) {
+		await this.ready();
+		const { branch, filePath } = this.parsePath(path);
+		if (!branch) return {
+			data: [],
+			message: "Search requires a branch path"
+		};
+		const limit = Math.min(options?.limit || LIST_MAX_LIMIT, LIST_MAX_LIMIT);
+		try {
+			const args = [
+				"grep",
+				"-n",
+				"-I"
+			];
+			if (options?.caseSensitive === false) args.push("-i");
+			args.push(query, branch);
+			if (filePath) args.push("--", filePath);
+			const lines = (await this.git.raw(args)).split("\n").filter((line) => line.trim());
+			const entries = [];
+			const processedFiles = /* @__PURE__ */ new Set();
+			for (const line of lines) {
+				let matchPath;
+				let lineNum;
+				let content;
+				const matchWithBranch = line.match(/^[^:]+:([^:]+):(\d+):(.+)$/);
+				if (matchWithBranch) {
+					matchPath = matchWithBranch[1];
+					lineNum = matchWithBranch[2];
+					content = matchWithBranch[3];
+				} else {
+					const matchNoBranch = line.match(/^([^:]+):(\d+):(.+)$/);
+					if (!matchNoBranch) continue;
+					matchPath = matchNoBranch[1];
+					lineNum = matchNoBranch[2];
+					content = matchNoBranch[3];
+				}
+				const afsPath = this.buildPath(branch, matchPath);
+				if (processedFiles.has(afsPath)) continue;
+				processedFiles.add(afsPath);
+				entries.push({
+					id: afsPath,
+					path: afsPath,
+					summary: `Line ${lineNum}: ${content}`,
+					metadata: { type: "file" }
+				});
+				if (entries.length >= limit) break;
+			}
+			return {
+				data: entries,
+				message: entries.length >= limit ? `Results truncated to limit ${limit}` : void 0
+			};
+		} catch (error) {
+			if (error.message.includes("did not match any file(s)")) return { data: [] };
+			return {
+				data: [],
+				message: error.message
+			};
+		}
+	}
+	/**
+	* Fetch latest changes from remote
+	*/
+	async fetch() {
+		await this.ready();
+		await this.git.fetch();
+	}
+	/**
+	* Pull latest changes from remote for current branch
+	*/
+	async pull() {
+		await this.ready();
+		await this.git.pull();
+	}
+	/**
+	* Push local changes to remote
+	*/
+	async push(branch) {
+		await this.ready();
+		if (branch) await this.git.push("origin", branch);
+		else await this.git.push();
+	}
+	/**
+	* Cleanup all worktrees (useful when unmounting)
+	*/
+	async cleanup() {
+		await this.ready();
+		for (const [_branch, worktreePath] of this.worktrees) try {
+			await this.git.raw([
+				"worktree",
+				"remove",
+				worktreePath,
+				"--force"
+			]);
+		} catch (_error) {}
+		this.worktrees.clear();
+		try {
+			await rm(this.tempBase, {
+				recursive: true,
+				force: true
+			});
+		} catch {}
+		const autoCleanup = this.options.autoCleanup ?? true;
+		if (this.isAutoCloned && autoCleanup && this.clonedPath) try {
+			await rm(this.clonedPath, {
+				recursive: true,
+				force: true
+			});
+		} catch {}
+	}
+};
+
+//#endregion
+export { AFSGit };
+//# sourceMappingURL=index.mjs.map