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

package/dist/index.mjs

@@ -0,0 +1,502 @@
+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 execFileAsync = promisify(execFile);
+const LIST_MAX_LIMIT = 1e3;
+const afsGitOptionsSchema = camelize(z.object({
+	name: optionalize(z.string()),
+	repoPath: z.string().describe("The path to the git repository"),
+	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()
+	}))
+}));
+var AFSGit = class AFSGit {
+	static schema() {
+		return afsGitOptionsSchema;
+	}
+	static async load({ filepath, parsed }) {
+		return new AFSGit({
+			...await AFSGit.schema().parseAsync(parsed),
+			cwd: dirname(filepath)
+		});
+	}
+	git;
+	tempBase;
+	worktrees = /* @__PURE__ */ new Map();
+	repoHash;
+	constructor(options) {
+		this.options = options;
+		zodParse(afsGitOptionsSchema, options);
+		let repoPath;
+		if (isAbsolute(options.repoPath)) repoPath = options.repoPath;
+		else repoPath = join(options.cwd || process.cwd(), options.repoPath);
+		this.options.repoPath = repoPath;
+		this.name = options.name || basename(repoPath) || "git";
+		this.description = options.description;
+		this.accessMode = options.accessMode ?? "readonly";
+		this.git = simpleGit(repoPath);
+		this.repoHash = createHash("md5").update(repoPath).digest("hex").substring(0, 8);
+		this.tempBase = join(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 = 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 = 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) {
+		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 = 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) {
+		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) {
+		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) {
+		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 rm(this.tempBase, {
+				recursive: true,
+				force: true
+			});
+		} catch {}
+	}
+};
+
+//#endregion
+export { AFSGit };
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["afsPath"],"sources":["../src/index.ts"],"sourcesContent":["import { execFile } from \"node:child_process\";\nimport { createHash } from \"node:crypto\";\nimport { mkdir, rename, rm, stat, writeFile } from \"node:fs/promises\";\nimport { tmpdir } from \"node:os\";\nimport { basename, dirname, isAbsolute, join } from \"node:path\";\nimport { promisify } from \"node:util\";\n\nconst execFileAsync = promisify(execFile);\n\nimport type {\n  AFSAccessMode,\n  AFSDeleteOptions,\n  AFSDeleteResult,\n  AFSEntry,\n  AFSListOptions,\n  AFSListResult,\n  AFSModule,\n  AFSModuleClass,\n  AFSModuleLoadParams,\n  AFSReadOptions,\n  AFSReadResult,\n  AFSRenameOptions,\n  AFSSearchOptions,\n  AFSSearchResult,\n  AFSWriteEntryPayload,\n  AFSWriteOptions,\n  AFSWriteResult,\n} from \"@aigne/afs\";\nimport { camelize, optionalize, zodParse } from \"@aigne/afs/utils/zod\";\nimport { type SimpleGit, simpleGit } from \"simple-git\";\nimport { z } from \"zod\";\n\nconst LIST_MAX_LIMIT = 1000;\n\nexport interface AFSGitOptions {\n  name?: string;\n  repoPath: string;\n  description?: string;\n  branches?: string[];\n  /**\n   * Access mode for this module.\n   * - \"readonly\": Only read operations are allowed, uses git commands (no worktree)\n   * - \"readwrite\": All operations are allowed, creates worktrees as needed\n   * @default \"readonly\"\n   */\n  accessMode?: AFSAccessMode;\n  /**\n   * Automatically commit changes after write operations\n   * @default false\n   */\n  autoCommit?: boolean;\n  /**\n   * Author information for commits when autoCommit is enabled\n   */\n  commitAuthor?: {\n    name: string;\n    email: string;\n  };\n}\n\nconst afsGitOptionsSchema = camelize(\n  z.object({\n    name: optionalize(z.string()),\n    repoPath: z.string().describe(\"The path to the git repository\"),\n    description: optionalize(z.string().describe(\"A description of the repository\")),\n    branches: optionalize(z.array(z.string()).describe(\"List of branches to expose\")),\n    accessMode: optionalize(\n      z.enum([\"readonly\", \"readwrite\"]).describe(\"Access mode for this module\"),\n    ),\n    autoCommit: optionalize(\n      z.boolean().describe(\"Automatically commit changes after write operations\"),\n    ),\n    commitAuthor: optionalize(\n      z.object({\n        name: z.string(),\n        email: z.string(),\n      }),\n    ),\n  }),\n);\n\nexport class AFSGit implements AFSModule {\n  static schema() {\n    return afsGitOptionsSchema;\n  }\n\n  static async load({ filepath, parsed }: AFSModuleLoadParams) {\n    const valid = await AFSGit.schema().parseAsync(parsed);\n    return new AFSGit({ ...valid, cwd: dirname(filepath) });\n  }\n\n  private git: SimpleGit;\n  private tempBase: string;\n  private worktrees: Map<string, string> = new Map();\n  private repoHash: string;\n\n  constructor(public options: AFSGitOptions & { cwd?: string }) {\n    zodParse(afsGitOptionsSchema, options);\n\n    let repoPath: string;\n    if (isAbsolute(options.repoPath)) {\n      repoPath = options.repoPath;\n    } else {\n      repoPath = join(options.cwd || process.cwd(), options.repoPath);\n    }\n\n    this.options.repoPath = repoPath;\n    this.name = options.name || basename(repoPath) || \"git\";\n    this.description = options.description;\n    this.accessMode = options.accessMode ?? \"readonly\";\n\n    this.git = simpleGit(repoPath);\n\n    // Create a hash of the repo path for unique temp directory\n    this.repoHash = createHash(\"md5\").update(repoPath).digest(\"hex\").substring(0, 8);\n    this.tempBase = join(tmpdir(), `afs-git-${this.repoHash}`);\n  }\n\n  name: string;\n  description?: string;\n  accessMode: AFSAccessMode;\n\n  /**\n   * Parse AFS path into branch and file path\n   * Branch names may contain slashes and are encoded with ~ in paths\n   * Examples:\n   *   \"/\" -> { branch: undefined, filePath: \"\" }\n   *   \"/main\" -> { branch: \"main\", filePath: \"\" }\n   *   \"/feature~new-feature\" -> { branch: \"feature/new-feature\", filePath: \"\" }\n   *   \"/main/src/index.ts\" -> { branch: \"main\", filePath: \"src/index.ts\" }\n   */\n  private parsePath(path: string): { branch?: string; filePath: string } {\n    const normalized = join(\"/\", path); // Ensure leading slash\n    const segments = normalized.split(\"/\").filter(Boolean);\n\n    if (segments.length === 0) {\n      return { branch: undefined, filePath: \"\" };\n    }\n\n    // Decode branch name (first segment): replace ~ with /\n    const branch = segments[0]!.replace(/~/g, \"/\");\n    const filePath = segments.slice(1).join(\"/\");\n\n    return { branch, filePath };\n  }\n\n  /**\n   * Detect MIME type based on file extension\n   */\n  private getMimeType(filePath: string): string {\n    const ext = filePath.split(\".\").pop()?.toLowerCase();\n    const mimeTypes: Record<string, string> = {\n      // Images\n      png: \"image/png\",\n      jpg: \"image/jpeg\",\n      jpeg: \"image/jpeg\",\n      gif: \"image/gif\",\n      bmp: \"image/bmp\",\n      webp: \"image/webp\",\n      svg: \"image/svg+xml\",\n      ico: \"image/x-icon\",\n      // Documents\n      pdf: \"application/pdf\",\n      txt: \"text/plain\",\n      md: \"text/markdown\",\n      // Code\n      js: \"text/javascript\",\n      ts: \"text/typescript\",\n      json: \"application/json\",\n      html: \"text/html\",\n      css: \"text/css\",\n      xml: \"text/xml\",\n    };\n    return mimeTypes[ext || \"\"] || \"application/octet-stream\";\n  }\n\n  /**\n   * Check if file is likely binary based on extension\n   */\n  private isBinaryFile(filePath: string): boolean {\n    const ext = filePath.split(\".\").pop()?.toLowerCase();\n    const binaryExtensions = [\n      \"png\",\n      \"jpg\",\n      \"jpeg\",\n      \"gif\",\n      \"bmp\",\n      \"webp\",\n      \"ico\",\n      \"pdf\",\n      \"zip\",\n      \"tar\",\n      \"gz\",\n      \"exe\",\n      \"dll\",\n      \"so\",\n      \"dylib\",\n      \"wasm\",\n    ];\n    return binaryExtensions.includes(ext || \"\");\n  }\n\n  /**\n   * Get list of available branches\n   */\n  private async getBranches(): Promise<string[]> {\n    const branchSummary = await this.git.branchLocal();\n    const allBranches = branchSummary.all;\n\n    // Filter by allowed branches if specified\n    if (this.options.branches && this.options.branches.length > 0) {\n      return allBranches.filter((branch) => this.options.branches!.includes(branch));\n    }\n\n    return allBranches;\n  }\n\n  /**\n   * Ensure worktree exists for a branch (lazy creation)\n   */\n  private async ensureWorktree(branch: string): Promise<string> {\n    if (this.worktrees.has(branch)) {\n      return this.worktrees.get(branch)!;\n    }\n\n    // Check if this is the current branch in the main repo\n    const currentBranch = await this.git.revparse([\"--abbrev-ref\", \"HEAD\"]);\n    if (currentBranch.trim() === branch) {\n      // Use the main repo path for the current branch\n      this.worktrees.set(branch, this.options.repoPath);\n      return this.options.repoPath;\n    }\n\n    const worktreePath = join(this.tempBase, branch);\n\n    // Check if worktree directory already exists\n    const exists = await stat(worktreePath)\n      .then(() => true)\n      .catch(() => false);\n\n    if (!exists) {\n      await mkdir(this.tempBase, { recursive: true });\n      await this.git.raw([\"worktree\", \"add\", worktreePath, branch]);\n    }\n\n    this.worktrees.set(branch, worktreePath);\n    return worktreePath;\n  }\n\n  /**\n   * List files using git ls-tree (no worktree needed)\n   */\n  private async listWithGitLsTree(\n    branch: string,\n    path: string,\n    options?: AFSListOptions,\n  ): Promise<AFSListResult> {\n    const maxDepth = options?.maxDepth ?? 1;\n    const limit = Math.min(options?.limit || LIST_MAX_LIMIT, LIST_MAX_LIMIT);\n\n    const entries: AFSEntry[] = [];\n    const targetPath = path || \"\";\n    const treeish = targetPath ? `${branch}:${targetPath}` : branch;\n\n    try {\n      // Check if the path exists and is a directory\n      const pathType = await this.git\n        .raw([\"cat-file\", \"-t\", treeish])\n        .then((t) => t.trim())\n        .catch(() => null);\n\n      if (pathType === null) {\n        // Path doesn't exist\n        return { data: [] };\n      }\n\n      // If it's a file, just return it\n      if (pathType === \"blob\") {\n        const size = await this.git\n          .raw([\"cat-file\", \"-s\", treeish])\n          .then((s) => Number.parseInt(s.trim(), 10));\n\n        const afsPath = this.buildPath(branch, path);\n        entries.push({\n          id: afsPath,\n          path: afsPath,\n          metadata: {\n            type: \"file\",\n            size,\n          },\n        });\n\n        return { data: entries };\n      }\n\n      // It's a directory, list its contents\n      interface QueueItem {\n        path: string;\n        depth: number;\n      }\n\n      const queue: QueueItem[] = [{ path: targetPath, depth: 0 }];\n\n      while (queue.length > 0) {\n        const item = queue.shift()!;\n        const { path: itemPath, depth } = item;\n\n        // List directory contents\n        const itemTreeish = itemPath ? `${branch}:${itemPath}` : branch;\n        const output = await this.git.raw([\"ls-tree\", \"-l\", itemTreeish]);\n\n        const lines = output\n          .split(\"\\n\")\n          .filter((line) => line.trim())\n          .slice(0, limit - entries.length);\n\n        for (const line of lines) {\n          // Format: <mode> <type> <hash> <size (with padding)> <name>\n          // Example: 100644 blob abc123       1234\\tREADME.md\n          // Note: size is \"-\" for trees/directories, and there can be multiple spaces/tabs before name\n          const match = line.match(/^(\\d+)\\s+(blob|tree)\\s+(\\w+)\\s+(-|\\d+)\\s+(.+)$/);\n          if (!match) continue;\n\n          const type = match[2]!;\n          const sizeStr = match[4]!;\n          const name = match[5]!;\n          const isDirectory = type === \"tree\";\n          const size = sizeStr === \"-\" ? undefined : Number.parseInt(sizeStr, 10);\n\n          const fullPath = itemPath ? `${itemPath}/${name}` : name;\n          const afsPath = this.buildPath(branch, fullPath);\n\n          entries.push({\n            id: afsPath,\n            path: afsPath,\n            metadata: {\n              type: isDirectory ? \"directory\" : \"file\",\n              size,\n            },\n          });\n\n          // Add to queue if it's a directory and we haven't reached max depth\n          if (isDirectory && depth + 1 < maxDepth) {\n            queue.push({ path: fullPath, depth: depth + 1 });\n          }\n\n          // Check limit\n          if (entries.length >= limit) {\n            return { data: entries };\n          }\n        }\n      }\n\n      return { data: entries };\n    } catch (error) {\n      return { data: [], message: (error as Error).message };\n    }\n  }\n\n  /**\n   * Build AFS path with encoded branch name\n   * Branch names with slashes are encoded by replacing / with ~\n   * @param branch Branch name (may contain slashes)\n   * @param filePath File path within branch\n   */\n  private buildPath(branch: string, filePath?: string): string {\n    // Replace / with ~ in branch name\n    const encodedBranch = branch.replace(/\\//g, \"~\");\n    if (!filePath) {\n      return `/${encodedBranch}`;\n    }\n    return `/${encodedBranch}/${filePath}`;\n  }\n\n  async list(path: string, options?: AFSListOptions): Promise<AFSListResult> {\n    const { branch, filePath } = this.parsePath(path);\n\n    // Root path - list branches\n    if (!branch) {\n      const branches = await this.getBranches();\n      return {\n        data: branches.map((name) => {\n          const encodedPath = this.buildPath(name);\n          return {\n            id: encodedPath,\n            path: encodedPath,\n            metadata: {\n              type: \"directory\",\n            },\n          };\n        }),\n      };\n    }\n\n    // List files in branch using git ls-tree\n    return this.listWithGitLsTree(branch, filePath, options);\n  }\n\n  async read(path: string, _options?: AFSReadOptions): Promise<AFSReadResult> {\n    const { branch, filePath } = this.parsePath(path);\n\n    if (!branch) {\n      return {\n        data: {\n          id: \"/\",\n          path: \"/\",\n          metadata: { type: \"directory\" },\n        },\n      };\n    }\n\n    if (!filePath) {\n      const branchPath = this.buildPath(branch);\n      return {\n        data: {\n          id: branchPath,\n          path: branchPath,\n          metadata: { type: \"directory\" },\n        },\n      };\n    }\n\n    try {\n      // Check if path is a blob (file) or tree (directory)\n      const objectType = await this.git\n        .raw([\"cat-file\", \"-t\", `${branch}:${filePath}`])\n        .then((t) => t.trim());\n\n      if (objectType === \"tree\") {\n        // It's a directory\n        const afsPath = this.buildPath(branch, filePath);\n        return {\n          data: {\n            id: afsPath,\n            path: afsPath,\n            metadata: {\n              type: \"directory\",\n            },\n          },\n        };\n      }\n\n      // It's a file, get content\n      const size = await this.git\n        .raw([\"cat-file\", \"-s\", `${branch}:${filePath}`])\n        .then((s) => Number.parseInt(s.trim(), 10));\n\n      // Determine mimeType based on file extension\n      const mimeType = this.getMimeType(filePath);\n      const isBinary = this.isBinaryFile(filePath);\n\n      let content: string;\n      const metadata: Record<string, any> = {\n        type: \"file\",\n        size,\n        mimeType,\n      };\n\n      if (isBinary) {\n        // For binary files, use execFileAsync to get raw buffer\n        const { stdout } = await execFileAsync(\"git\", [\"cat-file\", \"-p\", `${branch}:${filePath}`], {\n          cwd: this.options.repoPath,\n          encoding: \"buffer\",\n          maxBuffer: 10 * 1024 * 1024, // 10MB max\n        });\n        // Store only base64 string without data URL prefix\n        content = (stdout as Buffer).toString(\"base64\");\n        // Mark content as base64 in metadata\n        metadata.contentType = \"base64\";\n      } else {\n        // For text files, use git.show\n        content = await this.git.show([`${branch}:${filePath}`]);\n      }\n\n      const afsPath = this.buildPath(branch, filePath);\n      return {\n        data: {\n          id: afsPath,\n          path: afsPath,\n          content,\n          metadata,\n        },\n      };\n    } catch (error) {\n      return {\n        data: undefined,\n        message: (error as Error).message,\n      };\n    }\n  }\n\n  async write(\n    path: string,\n    entry: AFSWriteEntryPayload,\n    options?: AFSWriteOptions,\n  ): Promise<AFSWriteResult> {\n    const { branch, filePath } = this.parsePath(path);\n\n    if (!branch || !filePath) {\n      throw new Error(\"Cannot write to root or branch root\");\n    }\n\n    // Create worktree for write operations\n    const worktreePath = await this.ensureWorktree(branch);\n    const fullPath = join(worktreePath, filePath);\n    const append = options?.append ?? false;\n\n    // Ensure parent directory exists\n    const parentDir = dirname(fullPath);\n    await mkdir(parentDir, { recursive: true });\n\n    // Write content\n    if (entry.content !== undefined) {\n      let contentToWrite: string;\n      if (typeof entry.content === \"string\") {\n        contentToWrite = entry.content;\n      } else {\n        contentToWrite = JSON.stringify(entry.content, null, 2);\n      }\n      await writeFile(fullPath, contentToWrite, {\n        encoding: \"utf8\",\n        flag: append ? \"a\" : \"w\",\n      });\n    }\n\n    // Auto commit if enabled\n    if (this.options.autoCommit) {\n      const gitInstance = simpleGit(worktreePath);\n      await gitInstance.add(filePath);\n\n      if (this.options.commitAuthor) {\n        await gitInstance.addConfig(\n          \"user.name\",\n          this.options.commitAuthor.name,\n          undefined,\n          \"local\",\n        );\n        await gitInstance.addConfig(\n          \"user.email\",\n          this.options.commitAuthor.email,\n          undefined,\n          \"local\",\n        );\n      }\n\n      await gitInstance.commit(`Update ${filePath}`);\n    }\n\n    // Get file stats\n    const stats = await stat(fullPath);\n\n    const afsPath = this.buildPath(branch, filePath);\n    const writtenEntry: AFSEntry = {\n      id: afsPath,\n      path: afsPath,\n      content: entry.content,\n      summary: entry.summary,\n      createdAt: stats.birthtime,\n      updatedAt: stats.mtime,\n      metadata: {\n        ...entry.metadata,\n        type: stats.isDirectory() ? \"directory\" : \"file\",\n        size: stats.size,\n      },\n      userId: entry.userId,\n      sessionId: entry.sessionId,\n      linkTo: entry.linkTo,\n    };\n\n    return { data: writtenEntry };\n  }\n\n  async delete(path: string, options?: AFSDeleteOptions): Promise<AFSDeleteResult> {\n    const { branch, filePath } = this.parsePath(path);\n\n    if (!branch || !filePath) {\n      throw new Error(\"Cannot delete root or branch root\");\n    }\n\n    // Create worktree for delete operations\n    const worktreePath = await this.ensureWorktree(branch);\n    const fullPath = join(worktreePath, filePath);\n    const recursive = options?.recursive ?? false;\n\n    const stats = await stat(fullPath);\n\n    if (stats.isDirectory() && !recursive) {\n      throw new Error(\n        `Cannot delete directory '${path}' without recursive option. Set recursive: true to delete directories.`,\n      );\n    }\n\n    await rm(fullPath, { recursive, force: true });\n\n    // Auto commit if enabled\n    if (this.options.autoCommit) {\n      const gitInstance = simpleGit(worktreePath);\n      await gitInstance.add(filePath);\n\n      if (this.options.commitAuthor) {\n        await gitInstance.addConfig(\n          \"user.name\",\n          this.options.commitAuthor.name,\n          undefined,\n          \"local\",\n        );\n        await gitInstance.addConfig(\n          \"user.email\",\n          this.options.commitAuthor.email,\n          undefined,\n          \"local\",\n        );\n      }\n\n      await gitInstance.commit(`Delete ${filePath}`);\n    }\n\n    return { message: `Successfully deleted: ${path}` };\n  }\n\n  async rename(\n    oldPath: string,\n    newPath: string,\n    options?: AFSRenameOptions,\n  ): Promise<{ message?: string }> {\n    const { branch: oldBranch, filePath: oldFilePath } = this.parsePath(oldPath);\n    const { branch: newBranch, filePath: newFilePath } = this.parsePath(newPath);\n\n    if (!oldBranch || !oldFilePath) {\n      throw new Error(\"Cannot rename from root or branch root\");\n    }\n\n    if (!newBranch || !newFilePath) {\n      throw new Error(\"Cannot rename to root or branch root\");\n    }\n\n    if (oldBranch !== newBranch) {\n      throw new Error(\"Cannot rename across branches\");\n    }\n\n    // Create worktree for rename operations\n    const worktreePath = await this.ensureWorktree(oldBranch);\n    const oldFullPath = join(worktreePath, oldFilePath);\n    const newFullPath = join(worktreePath, newFilePath);\n    const overwrite = options?.overwrite ?? false;\n\n    // Check if source exists\n    await stat(oldFullPath);\n\n    // Check if destination exists\n    try {\n      await stat(newFullPath);\n      if (!overwrite) {\n        throw new Error(\n          `Destination '${newPath}' already exists. Set overwrite: true to replace it.`,\n        );\n      }\n    } catch (error) {\n      if ((error as NodeJS.ErrnoException).code !== \"ENOENT\") {\n        throw error;\n      }\n    }\n\n    // Ensure parent directory exists\n    const newParentDir = dirname(newFullPath);\n    await mkdir(newParentDir, { recursive: true });\n\n    // Perform rename\n    await rename(oldFullPath, newFullPath);\n\n    // Auto commit if enabled\n    if (this.options.autoCommit) {\n      const gitInstance = simpleGit(worktreePath);\n      await gitInstance.add([oldFilePath, newFilePath]);\n\n      if (this.options.commitAuthor) {\n        await gitInstance.addConfig(\n          \"user.name\",\n          this.options.commitAuthor.name,\n          undefined,\n          \"local\",\n        );\n        await gitInstance.addConfig(\n          \"user.email\",\n          this.options.commitAuthor.email,\n          undefined,\n          \"local\",\n        );\n      }\n\n      await gitInstance.commit(`Rename ${oldFilePath} to ${newFilePath}`);\n    }\n\n    return { message: `Successfully renamed '${oldPath}' to '${newPath}'` };\n  }\n\n  async search(path: string, query: string, options?: AFSSearchOptions): Promise<AFSSearchResult> {\n    const { branch, filePath } = this.parsePath(path);\n\n    if (!branch) {\n      return { data: [], message: \"Search requires a branch path\" };\n    }\n\n    const limit = Math.min(options?.limit || LIST_MAX_LIMIT, LIST_MAX_LIMIT);\n\n    try {\n      // Use git grep for searching (no worktree needed)\n      const args = [\"grep\", \"-n\", \"-I\"]; // -n for line numbers, -I to skip binary files\n\n      if (options?.caseSensitive === false) {\n        args.push(\"-i\");\n      }\n\n      args.push(query, branch);\n\n      // Add path filter if specified\n      if (filePath) {\n        args.push(\"--\", filePath);\n      }\n\n      const output = await this.git.raw(args);\n      const lines = output.split(\"\\n\").filter((line) => line.trim());\n\n      const entries: AFSEntry[] = [];\n      const processedFiles = new Set<string>();\n\n      for (const line of lines) {\n        // Format when searching in branch: branch:path:linenum:content\n        // Try the format with branch prefix first\n        let matchPath: string;\n        let lineNum: string;\n        let content: string;\n\n        const matchWithBranch = line.match(/^[^:]+:([^:]+):(\\d+):(.+)$/);\n        if (matchWithBranch) {\n          matchPath = matchWithBranch[1]!;\n          lineNum = matchWithBranch[2]!;\n          content = matchWithBranch[3]!;\n        } else {\n          // Try format without branch: path:linenum:content\n          const matchNoBranch = line.match(/^([^:]+):(\\d+):(.+)$/);\n          if (!matchNoBranch) continue;\n          matchPath = matchNoBranch[1]!;\n          lineNum = matchNoBranch[2]!;\n          content = matchNoBranch[3]!;\n        }\n\n        const afsPath = this.buildPath(branch, matchPath);\n\n        if (processedFiles.has(afsPath)) continue;\n        processedFiles.add(afsPath);\n\n        entries.push({\n          id: afsPath,\n          path: afsPath,\n          summary: `Line ${lineNum}: ${content}`,\n          metadata: {\n            type: \"file\",\n          },\n        });\n\n        if (entries.length >= limit) {\n          break;\n        }\n      }\n\n      return {\n        data: entries,\n        message: entries.length >= limit ? `Results truncated to limit ${limit}` : undefined,\n      };\n    } catch (error) {\n      // git grep returns exit code 1 if no matches found\n      if ((error as Error).message.includes(\"did not match any file(s)\")) {\n        return { data: [] };\n      }\n      return { data: [], message: (error as Error).message };\n    }\n  }\n\n  /**\n   * Cleanup all worktrees (useful when unmounting)\n   */\n  async cleanup(): Promise<void> {\n    for (const [_branch, worktreePath] of this.worktrees) {\n      try {\n        await this.git.raw([\"worktree\", \"remove\", worktreePath, \"--force\"]);\n      } catch (_error) {\n        // Ignore errors during cleanup\n      }\n    }\n    this.worktrees.clear();\n\n    // Remove temp directory\n    try {\n      await rm(this.tempBase, { recursive: true, force: true });\n    } catch {\n      // Ignore errors\n    }\n  }\n}\n\nconst _typeCheck: AFSModuleClass<AFSGit, AFSGitOptions> = AFSGit;\n"],"mappings":"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"}

package/package.json

@@ -1,70 +1,56 @@
 {
   "name": "@aigne/afs-git",
-  "version": "1.1.0-beta",
+  "version": "1.11.0-beta",
   "description": "AIGNE AFS module for git storage",
+  "license": "Elastic-2.0",
   "publishConfig": {
     "access": "public"
   },
-  "author": "Arcblock <blocklet@arcblock.io> https://github.com/blocklet",
-  "homepage": "https://www.aigne.io/framework",
-  "license": "Elastic-2.0",
+  "author": "Arcblock <blocklet@arcblock.io> https://github.com/arcblock",
+  "homepage": "https://github.com/arcblock/afs",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/AIGNE-io/aigne-framework"
+    "url": "git+https://github.com/arcblock/afs"
   },
   "bugs": {
-    "url": "https://github.com/AIGNE-io/aigne-framework/issues"
+    "url": "https://github.com/arcblock/afs/issues"
   },
-  "files": [
-    "lib/cjs",
-    "lib/dts",
-    "lib/esm",
-    "LICENSE",
-    "README.md",
-    "CHANGELOG.md"
-  ],
   "type": "module",
-  "main": "./lib/cjs/index.js",
-  "module": "./lib/esm/index.js",
-  "types": "./lib/dts/index.d.ts",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.cts",
   "exports": {
     ".": {
-      "import": "./lib/esm/index.js",
-      "require": "./lib/cjs/index.js",
-      "types": "./lib/dts/index.d.ts"
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.mjs"
     },
-    "./*": {
-      "import": "./lib/esm/*",
-      "require": "./lib/cjs/*",
-      "types": "./lib/dts/*"
-    }
-  },
-  "typesVersions": {
-    "*": {
-      ".": [
-        "./lib/dts/index.d.ts"
-      ]
-    }
+    "./*": "./*"
   },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md",
+    "CHANGELOG.md"
+  ],
   "dependencies": {
     "simple-git": "^3.27.0",
     "zod": "^3.25.67",
-    "@aigne/afs": "^1.4.0-beta.11",
-    "@aigne/core": "^1.72.0-beta.25"
+    "@aigne/afs": "^1.11.0-beta"
   },
   "devDependencies": {
-    "@types/bun": "^1.2.22",
+    "@types/bun": "^1.3.6",
     "npm-run-all": "^4.1.5",
-    "rimraf": "^6.0.1",
-    "typescript": "^5.9.2",
-    "@aigne/test-utils": "^0.5.69-beta.25"
+    "rimraf": "^6.1.2",
+    "tsdown": "0.20.0-beta.3",
+    "typescript": "5.9.2",
+    "@aigne/scripts": "0.0.0",
+    "@aigne/typescript-config": "0.0.0"
   },
   "scripts": {
-    "lint": "tsc --noEmit",
-    "build": "tsc --build scripts/tsconfig.build.json",
-    "clean": "rimraf lib test/coverage",
+    "build": "tsdown",
+    "check-types": "tsc --noEmit",
+    "clean": "rimraf dist coverage",
     "test": "bun test",
-    "test:coverage": "bun test --coverage --coverage-reporter=lcov --coverage-reporter=text",
-    "postbuild": "node ../../scripts/post-build-lib.mjs"
+    "test:coverage": "bun test --coverage --coverage-reporter=lcov --coverage-reporter=text"
   }
 }