@aigne/afs-git 1.1.0 → 1.11.0-beta

package/README.md

@@ -29,10 +29,12 @@ import { AFSGit } from "@aigne/afs-git";
 const afs = new AFS();
 
 // Mount a git repository in read-only mode
-afs.mount(new AFSGit({
-  repoPath: '/path/to/repo',
-  accessMode: 'readonly'  // default
-}));
+afs.mount(
+  new AFSGit({
+    repoPath: "/path/to/repo",
+    accessMode: "readonly", // default
+  }),
+);
 ```
 
 ### Path Structure
@@ -54,22 +56,22 @@ afs.mount(new AFSGit({
 
 ```typescript
 // List all branches
-const branches = await afs.list('/modules/git');
+const branches = await afs.list("/modules/git");
 // Returns: ['/main', '/develop', '/feature-auth']
 
 // List files in a branch
-const files = await afs.list('/modules/git/main');
+const files = await afs.list("/modules/git/main");
 // Returns files at root of main branch
 
 // List files recursively
-const allFiles = await afs.list('/modules/git/main', { maxDepth: 10 });
+const allFiles = await afs.list("/modules/git/main", { maxDepth: 10 });
 
 // Read file content
-const content = await afs.read('/modules/git/main/README.md');
+const content = await afs.read("/modules/git/main/README.md");
 console.log(content.data?.content);
 
 // Search across branch
-const results = await afs.search('/modules/git/main', 'TODO');
+const results = await afs.search("/modules/git/main", "TODO");
 // Uses git grep for fast searching
 ```
 
@@ -79,56 +81,56 @@ const results = await afs.search('/modules/git/main', 'TODO');
 import { AFSGit } from "@aigne/afs-git";
 
 const afsGit = new AFSGit({
-  repoPath: '/path/to/repo',
-  accessMode: 'readwrite',
+  repoPath: "/path/to/repo",
+  accessMode: "readwrite",
   autoCommit: true,
   commitAuthor: {
-    name: 'AI Agent',
-    email: 'agent@example.com'
-  }
+    name: "AI Agent",
+    email: "agent@example.com",
+  },
 });
 
 afs.mount(afsGit);
 
 // Write a new file (creates worktree automatically)
-await afs.write('/modules/git/main/newfile.txt', {
-  content: 'Hello World'
+await afs.write("/modules/git/main/newfile.txt", {
+  content: "Hello World",
 });
 // Automatically committed with message "Update newfile.txt"
 
 // Update existing file
-await afs.write('/modules/git/main/src/index.ts', {
-  content: updatedCode
+await afs.write("/modules/git/main/src/index.ts", {
+  content: updatedCode,
 });
 
 // Delete file
-await afs.delete('/modules/git/main/oldfile.txt');
+await afs.delete("/modules/git/main/oldfile.txt");
 // Automatically committed
 
 // Rename/move file
-await afs.rename('/modules/git/main/old.txt', '/modules/git/main/new.txt');
+await afs.rename("/modules/git/main/old.txt", "/modules/git/main/new.txt");
 ```
 
 ### Advanced Configuration
 
 ```typescript
 const afsGit = new AFSGit({
-  repoPath: '/path/to/repo',
-  name: 'my-repo',
-  description: 'My project repository',
+  repoPath: "/path/to/repo",
+  name: "my-repo",
+  description: "My project repository",
 
   // Limit accessible branches
-  branches: ['main', 'develop'],
+  branches: ["main", "develop"],
 
   // Access control
-  accessMode: 'readwrite',
+  accessMode: "readwrite",
 
   // Auto-commit settings
   autoCommit: true,
   commitAuthor: {
-    name: 'AI Agent',
-    email: 'agent@example.com'
-  }
+    name: "AI Agent",
+    email: "agent@example.com",
+  },
 });
 
 // Cleanup worktrees when done
@@ -165,15 +167,16 @@ Worktrees are created in temporary directories and cleaned up when the module is
 ```typescript
 interface AFSGitOptions {
   // Required
-  repoPath: string;              // Path to git repository
+  repoPath: string; // Path to git repository
 
   // Optional
-  name?: string;                 // Module name (default: repo basename)
-  description?: string;          // Module description
-  branches?: string[];           // Limit accessible branches
-  accessMode?: 'readonly' | 'readwrite';  // Default: 'readonly'
-  autoCommit?: boolean;          // Auto-commit changes (default: false)
-  commitAuthor?: {               // Author for commits
+  name?: string; // Module name (default: repo basename)
+  description?: string; // Module description
+  branches?: string[]; // Limit accessible branches
+  accessMode?: "readonly" | "readwrite"; // Default: 'readonly'
+  autoCommit?: boolean; // Auto-commit changes (default: false)
+  commitAuthor?: {
+    // Author for commits
     name: string;
     email: string;
   };
@@ -202,10 +205,12 @@ import { AFS } from "@aigne/afs";
 import { AFSGit } from "@aigne/afs-git";
 
 const afs = new AFS();
-afs.mount(new AFSGit({
-  repoPath: process.cwd(),
-  accessMode: 'readonly'
-}));
+afs.mount(
+  new AFSGit({
+    repoPath: process.cwd(),
+    accessMode: "readonly",
+  }),
+);
 
 const aigne = new AIGNE({});
 
@@ -213,12 +218,12 @@ const aigne = new AIGNE({});
 const agent = AIAgent.from({
   name: "CodeReviewer",
   instructions: "Review code and suggest improvements",
-  afs
+  afs,
 });
 
 // Agent can list files, read code, search for patterns
 await aigne.invoke(agent, {
-  message: "Review the authentication code in src/auth/"
+  message: "Review the authentication code in src/auth/",
 });
 ```
 

package/dist/index.cjs

@@ -0,0 +1,501 @@
+let node_child_process = require("node:child_process");
+let node_crypto = require("node:crypto");
+let node_fs_promises = require("node:fs/promises");
+let node_os = require("node:os");
+let node_path = require("node:path");
+let node_util = require("node:util");
+let _aigne_afs_utils_zod = require("@aigne/afs/utils/zod");
+let simple_git = require("simple-git");
+let zod = require("zod");
+
+//#region src/index.ts
+const execFileAsync = (0, node_util.promisify)(node_child_process.execFile);
+const LIST_MAX_LIMIT = 1e3;
+const afsGitOptionsSchema = (0, _aigne_afs_utils_zod.camelize)(zod.z.object({
+	name: (0, _aigne_afs_utils_zod.optionalize)(zod.z.string()),
+	repoPath: zod.z.string().describe("The path to the git repository"),
+	description: (0, _aigne_afs_utils_zod.optionalize)(zod.z.string().describe("A description of the repository")),
+	branches: (0, _aigne_afs_utils_zod.optionalize)(zod.z.array(zod.z.string()).describe("List of branches to expose")),
+	accessMode: (0, _aigne_afs_utils_zod.optionalize)(zod.z.enum(["readonly", "readwrite"]).describe("Access mode for this module")),
+	autoCommit: (0, _aigne_afs_utils_zod.optionalize)(zod.z.boolean().describe("Automatically commit changes after write operations")),
+	commitAuthor: (0, _aigne_afs_utils_zod.optionalize)(zod.z.object({
+		name: zod.z.string(),
+		email: zod.z.string()
+	}))
+}));
+var AFSGit = class AFSGit {
+	static schema() {
+		return afsGitOptionsSchema;
+	}
+	static async load({ filepath, parsed }) {
+		return new AFSGit({
+			...await AFSGit.schema().parseAsync(parsed),
+			cwd: (0, node_path.dirname)(filepath)
+		});
+	}
+	git;
+	tempBase;
+	worktrees = /* @__PURE__ */ new Map();
+	repoHash;
+	constructor(options) {
+		this.options = options;
+		(0, _aigne_afs_utils_zod.zodParse)(afsGitOptionsSchema, options);
+		let repoPath;
+		if ((0, node_path.isAbsolute)(options.repoPath)) repoPath = options.repoPath;
+		else repoPath = (0, node_path.join)(options.cwd || process.cwd(), options.repoPath);
+		this.options.repoPath = repoPath;
+		this.name = options.name || (0, node_path.basename)(repoPath) || "git";
+		this.description = options.description;
+		this.accessMode = options.accessMode ?? "readonly";
+		this.git = (0, simple_git.simpleGit)(repoPath);
+		this.repoHash = (0, node_crypto.createHash)("md5").update(repoPath).digest("hex").substring(0, 8);
+		this.tempBase = (0, node_path.join)((0, node_os.tmpdir)(), `afs-git-${this.repoHash}`);
+	}
+	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 = (0, node_path.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.options.repoPath);
+			return this.options.repoPath;
+		}
+		const worktreePath = (0, node_path.join)(this.tempBase, branch);
+		if (!await (0, node_fs_promises.stat)(worktreePath).then(() => true).catch(() => false)) {
+			await (0, node_fs_promises.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) {
+		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) {
+		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) {
+		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 = (0, node_path.join)(worktreePath, filePath);
+		const append = options?.append ?? false;
+		await (0, node_fs_promises.mkdir)((0, node_path.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 (0, node_fs_promises.writeFile)(fullPath, contentToWrite, {
+				encoding: "utf8",
+				flag: append ? "a" : "w"
+			});
+		}
+		if (this.options.autoCommit) {
+			const gitInstance = (0, simple_git.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 (0, node_fs_promises.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) {
+		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 = (0, node_path.join)(worktreePath, filePath);
+		const recursive = options?.recursive ?? false;
+		if ((await (0, node_fs_promises.stat)(fullPath)).isDirectory() && !recursive) throw new Error(`Cannot delete directory '${path}' without recursive option. Set recursive: true to delete directories.`);
+		await (0, node_fs_promises.rm)(fullPath, {
+			recursive,
+			force: true
+		});
+		if (this.options.autoCommit) {
+			const gitInstance = (0, simple_git.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) {
+		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 = (0, node_path.join)(worktreePath, oldFilePath);
+		const newFullPath = (0, node_path.join)(worktreePath, newFilePath);
+		const overwrite = options?.overwrite ?? false;
+		await (0, node_fs_promises.stat)(oldFullPath);
+		try {
+			await (0, node_fs_promises.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 (0, node_fs_promises.mkdir)((0, node_path.dirname)(newFullPath), { recursive: true });
+		await (0, node_fs_promises.rename)(oldFullPath, newFullPath);
+		if (this.options.autoCommit) {
+			const gitInstance = (0, simple_git.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) {
+		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
+			};
+		}
+	}
+	/**
+	* Cleanup all worktrees (useful when unmounting)
+	*/
+	async cleanup() {
+		for (const [_branch, worktreePath] of this.worktrees) try {
+			await this.git.raw([
+				"worktree",
+				"remove",
+				worktreePath,
+				"--force"
+			]);
+		} catch (_error) {}
+		this.worktrees.clear();
+		try {
+			await (0, node_fs_promises.rm)(this.tempBase, {
+				recursive: true,
+				force: true
+			});
+		} catch {}
+	}
+};
+
+//#endregion
+exports.AFSGit = AFSGit;