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

package/LICENSE.md

@@ -1,93 +1,26 @@
-Elastic License 2.0
+# Proprietary License
 
-URL: https://www.elastic.co/licensing/elastic-license
+Copyright (c) 2024-2025 ArcBlock, Inc. All Rights Reserved.
 
-## Acceptance
+This software and associated documentation files (the "Software") are proprietary
+and confidential. Unauthorized copying, modification, distribution, or use of
+this Software, via any medium, is strictly prohibited.
 
-By using the software, you agree to all of the terms and conditions below.
+The Software is provided for internal use only within ArcBlock, Inc. and its
+authorized affiliates.
 
-## Copyright License
+## No License Granted
 
-The licensor grants you a non-exclusive, royalty-free, worldwide,
-non-sublicensable, non-transferable license to use, copy, distribute, make
-available, and prepare derivative works of the software, in each case subject to
-the limitations and conditions below.
+No license, express or implied, is granted to any party for any purpose.
+All rights are reserved by ArcBlock, Inc.
 
-## Limitations
+## Public Artifact Distribution
 
-You may not provide the software to third parties as a hosted or managed
-service, where the service provides users with access to any substantial set of
-the features or functionality of the software.
+Portions of this Software may be released publicly under separate open-source
+licenses (such as MIT License) through designated public repositories. Such
+public releases are governed by their respective licenses and do not affect
+the proprietary nature of this repository.
 
-You may not move, change, disable, or circumvent the license key functionality
-in the software, and you may not remove or obscure any functionality in the
-software that is protected by the license key.
+## Contact
 
-You may not alter, remove, or obscure any licensing, copyright, or other notices
-of the licensor in the software. Any use of the licensor’s trademarks is subject
-to applicable law.
-
-## Patents
-
-The licensor grants you a license, under any patent claims the licensor can
-license, or becomes able to license, to make, have made, use, sell, offer for
-sale, import and have imported the software, in each case subject to the
-limitations and conditions in this license. This license does not cover any
-patent claims that you cause to be infringed by modifications or additions to
-the software. If you or your company make any written claim that the software
-infringes or contributes to infringement of any patent, your patent license for
-the software granted under these terms ends immediately. If your company makes
-such a claim, your patent license ends immediately for work on behalf of your
-company.
-
-## Notices
-
-You must ensure that anyone who gets a copy of any part of the software from you
-also gets a copy of these terms.
-
-If you modify the software, you must include in any modified copies of the
-software prominent notices stating that you have modified the software.
-
-## No Other Rights
-
-These terms do not imply any licenses other than those expressly granted in
-these terms.
-
-## Termination
-
-If you use the software in violation of these terms, such use is not licensed,
-and your licenses will automatically terminate. If the licensor provides you
-with a notice of your violation, and you cease all violation of this license no
-later than 30 days after you receive that notice, your licenses will be
-reinstated retroactively. However, if you violate these terms after such
-reinstatement, any additional violation of these terms will cause your licenses
-to terminate automatically and permanently.
-
-## No Liability
-
-*As far as the law allows, the software comes as is, without any warranty or
-condition, and the licensor will not be liable to you for any damages arising
-out of these terms or the use or nature of the software, under any kind of
-legal claim.*
-
-## Definitions
-
-The **licensor** is the entity offering these terms, and the **software** is the
-software the licensor makes available under these terms, including any portion
-of it.
-
-**you** refers to the individual or entity agreeing to these terms.
-
-**your company** is any legal entity, sole proprietorship, or other kind of
-organization that you work for, plus all organizations that have control over,
-are under the control of, or are under common control with that
-organization. **control** means ownership of substantially all the assets of an
-entity, or the power to direct its management and policies by vote, contract, or
-otherwise. Control can be direct or indirect.
-
-**your licenses** are all the licenses granted to you for the software under
-these terms.
-
-**use** means anything you do with the software requiring one of your licenses.
-
-**trademark** means trademarks, service marks, and similar rights.
+For licensing inquiries, contact: legal@arcblock.io

package/README.md

@@ -226,7 +226,3 @@ await aigne.invoke(agent, {
   message: "Review the authentication code in src/auth/",
 });
 ```
-
-## License
-
-This project is licensed under the [Elastic-2.0](../../LICENSE.md) License.

package/dist/index.cjs

@@ -9,11 +9,12 @@ 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 execFileAsync = (0, node_util.promisify)(node_child_process.execFile);
 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"),
+	repoPath: (0, _aigne_afs_utils_zod.optionalize)(zod.z.string().describe("The path to the git repository")),
+	remoteUrl: (0, _aigne_afs_utils_zod.optionalize)(zod.z.string().describe("Remote repository URL (https or git protocol)")),
 	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")),
@@ -21,35 +22,107 @@ const afsGitOptionsSchema = (0, _aigne_afs_utils_zod.camelize)(zod.z.object({
 	commitAuthor: (0, _aigne_afs_utils_zod.optionalize)(zod.z.object({
 		name: zod.z.string(),
 		email: zod.z.string()
-	}))
-}));
+	})),
+	depth: (0, _aigne_afs_utils_zod.optionalize)(zod.z.number().describe("Clone depth for shallow clone")),
+	autoCleanup: (0, _aigne_afs_utils_zod.optionalize)(zod.z.boolean().describe("Automatically clean up cloned repository on cleanup()")),
+	cloneOptions: (0, _aigne_afs_utils_zod.optionalize)(zod.z.object({ auth: (0, _aigne_afs_utils_zod.optionalize)(zod.z.object({
+		username: (0, _aigne_afs_utils_zod.optionalize)(zod.z.string()),
+		password: (0, _aigne_afs_utils_zod.optionalize)(zod.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 }) {
-		return new AFSGit({
+		const instance = new AFSGit({
 			...await AFSGit.schema().parseAsync(parsed),
 			cwd: (0, node_path.dirname)(filepath)
 		});
+		await instance.ready();
+		return instance;
 	}
+	initPromise;
 	git;
 	tempBase;
 	worktrees = /* @__PURE__ */ new Map();
 	repoHash;
+	isAutoCloned = false;
+	clonedPath;
+	repoPath;
 	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";
+		let repoName;
+		if (options.repoPath) {
+			repoPath = (0, node_path.isAbsolute)(options.repoPath) ? options.repoPath : (0, node_path.join)(options.cwd || process.cwd(), options.repoPath);
+			repoName = (0, node_path.basename)(repoPath);
+		} else if (options.remoteUrl) {
+			const urlParts = options.remoteUrl.split("/");
+			repoName = urlParts[urlParts.length - 1]?.replace(/\.git$/, "") || "git";
+			const repoHash = (0, node_crypto.createHash)("md5").update(options.remoteUrl).digest("hex").substring(0, 8);
+			repoPath = (0, node_path.join)((0, node_os.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.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}`);
+		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 ? (0, node_path.isAbsolute)(options.repoPath) ? options.repoPath : (0, node_path.join)(options.cwd || process.cwd(), options.repoPath) : this.repoPath;
+			if (!options.repoPath) this.isAutoCloned = true;
+			if (!await (0, node_fs_promises.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 = (0, node_crypto.createHash)("md5").update(targetPath).digest("hex").substring(0, 8);
+				this.tempBase = (0, node_path.join)((0, node_os.tmpdir)(), `afs-git-${this.repoHash}`);
+			}
+			this.clonedPath = this.isAutoCloned ? targetPath : void 0;
+		}
+		this.git = (0, simple_git.simpleGit)(this.repoPath);
+	}
+	/**
+	* Clone a remote repository to local path
+	*/
+	static async cloneRepository(remoteUrl, targetPath, options = {}) {
+		const git = (0, simple_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;
@@ -136,8 +209,8 @@ var AFSGit = class AFSGit {
 	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;
+			this.worktrees.set(branch, this.repoPath);
+			return this.repoPath;
 		}
 		const worktreePath = (0, node_path.join)(this.tempBase, branch);
 		if (!await (0, node_fs_promises.stat)(worktreePath).then(() => true).catch(() => false)) {
@@ -242,6 +315,7 @@ var AFSGit = class AFSGit {
 		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);
@@ -254,6 +328,7 @@ var AFSGit = class AFSGit {
 		return this.listWithGitLsTree(branch, filePath, options);
 	}
 	async read(path, _options) {
+		await this.ready();
 		const { branch, filePath } = this.parsePath(path);
 		if (!branch) return { data: {
 			id: "/",
@@ -322,6 +397,7 @@ var AFSGit = class AFSGit {
 		}
 	}
 	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);
@@ -366,6 +442,7 @@ var AFSGit = class AFSGit {
 		} };
 	}
 	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);
@@ -388,6 +465,7 @@ var AFSGit = class AFSGit {
 		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");
@@ -418,6 +496,7 @@ var AFSGit = class AFSGit {
 		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: [],
@@ -476,9 +555,32 @@ var AFSGit = class AFSGit {
 		}
 	}
 	/**
+	* 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",
@@ -494,6 +596,13 @@ var AFSGit = class AFSGit {
 				force: true
 			});
 		} catch {}
+		const autoCleanup = this.options.autoCleanup ?? true;
+		if (this.isAutoCloned && autoCleanup && this.clonedPath) try {
+			await (0, node_fs_promises.rm)(this.clonedPath, {
+				recursive: true,
+				force: true
+			});
+		} catch {}
 	}
 };
 

package/dist/index.d.cts

@@ -4,8 +4,28 @@ import { z } from "zod";
 //#region src/index.d.ts
 interface AFSGitOptions {
   name?: string;
-  repoPath: string;
+  /**
+       * Local path to git repository.
+       * If remoteUrl is provided and repoPath doesn't exist, will clone to this path.
+       * If remoteUrl is provided and repoPath is not specified, clones to temp directory.
+       */
+  repoPath?: string;
+  /**
+       * Remote repository URL (https or git protocol).
+       * If provided, will clone the repository if repoPath doesn't exist.
+       * Examples:
+       * - https://github.com/user/repo.git
+       * - git@github.com:user/repo.git
+       */
+  remoteUrl?: string;
   description?: string;
+  /**
+       * List of branches to expose/access.
+       * Also used for clone optimization when cloning from remoteUrl:
+       * - Single branch (e.g., ['main']): Uses --single-branch for faster clone
+       * - Multiple branches: Clones all branches, filters access to specified ones
+       * - Not specified: All branches are accessible
+       */
   branches?: string[];
   /**
        * Access mode for this module.
@@ -26,14 +46,38 @@ interface AFSGitOptions {
     name: string;
     email: string;
   };
+  /**
+       * Clone depth for shallow clone (only used when cloning from remoteUrl)
+       * @default 1
+       */
+  depth?: number;
+  /**
+       * Automatically clean up cloned repository on cleanup()
+       * Only applies when repository was auto-cloned to temp directory
+       * @default true
+       */
+  autoCleanup?: boolean;
+  /**
+       * Git clone options (only used when cloning from remoteUrl)
+       */
+  cloneOptions?: {
+    /**
+             * Authentication credentials for private repositories
+             */
+    auth?: {
+      username?: string;
+      password?: string;
+    };
+  };
 }
 declare class AFSGit implements AFSModule {
   options: AFSGitOptions & {
     cwd?: string;
   };
-  static schema(): z.ZodEffects<z.ZodObject<{
+  static schema(): z.ZodEffects<z.ZodEffects<z.ZodObject<{
     name: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
-    repoPath: z.ZodString;
+    repoPath: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+    remoteUrl: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
     description: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
     branches: z.ZodType<string[] | undefined, z.ZodTypeDef, string[] | undefined>;
     accessMode: z.ZodType<"readonly" | "readwrite" | undefined, z.ZodTypeDef, "readonly" | "readwrite" | undefined>;
@@ -45,9 +89,23 @@ declare class AFSGit implements AFSModule {
       name: string;
       email: string;
     } | undefined>;
+    depth: z.ZodType<number | undefined, z.ZodTypeDef, number | undefined>;
+    autoCleanup: z.ZodType<boolean | undefined, z.ZodTypeDef, boolean | undefined>;
+    cloneOptions: z.ZodType<{
+      auth?: {
+        username?: string | undefined;
+        password?: string | undefined;
+      } | undefined;
+    } | undefined, z.ZodTypeDef, {
+      auth?: {
+        username?: string | undefined;
+        password?: string | undefined;
+      } | undefined;
+    } | undefined>;
   }, "strip", z.ZodTypeAny, {
-    repoPath: string;
     name?: string | undefined;
+    repoPath?: string | undefined;
+    remoteUrl?: string | undefined;
     description?: string | undefined;
     branches?: string[] | undefined;
     accessMode?: "readonly" | "readwrite" | undefined;
@@ -56,9 +114,18 @@ declare class AFSGit implements AFSModule {
       name: string;
       email: string;
     } | undefined;
+    depth?: number | undefined;
+    autoCleanup?: boolean | undefined;
+    cloneOptions?: {
+      auth?: {
+        username?: string | undefined;
+        password?: string | undefined;
+      } | undefined;
+    } | undefined;
   }, {
-    repoPath: string;
     name?: string | undefined;
+    repoPath?: string | undefined;
+    remoteUrl?: string | undefined;
     description?: string | undefined;
     branches?: string[] | undefined;
     accessMode?: "readonly" | "readwrite" | undefined;
@@ -67,9 +134,18 @@ declare class AFSGit implements AFSModule {
       name: string;
       email: string;
     } | undefined;
+    depth?: number | undefined;
+    autoCleanup?: boolean | undefined;
+    cloneOptions?: {
+      auth?: {
+        username?: string | undefined;
+        password?: string | undefined;
+      } | undefined;
+    } | undefined;
   }>, {
-    repoPath: string;
     name?: string | undefined;
+    repoPath?: string | undefined;
+    remoteUrl?: string | undefined;
     description?: string | undefined;
     branches?: string[] | undefined;
     accessMode?: "readonly" | "readwrite" | undefined;
@@ -78,18 +154,83 @@ declare class AFSGit implements AFSModule {
       name: string;
       email: string;
     } | undefined;
+    depth?: number | undefined;
+    autoCleanup?: boolean | undefined;
+    cloneOptions?: {
+      auth?: {
+        username?: string | undefined;
+        password?: string | undefined;
+      } | undefined;
+    } | undefined;
+  }, {
+    name?: string | undefined;
+    repoPath?: string | undefined;
+    remoteUrl?: string | undefined;
+    description?: string | undefined;
+    branches?: string[] | undefined;
+    accessMode?: "readonly" | "readwrite" | undefined;
+    autoCommit?: boolean | undefined;
+    commitAuthor?: {
+      name: string;
+      email: string;
+    } | undefined;
+    depth?: number | undefined;
+    autoCleanup?: boolean | undefined;
+    cloneOptions?: {
+      auth?: {
+        username?: string | undefined;
+        password?: string | undefined;
+      } | undefined;
+    } | undefined;
+  }>, {
+    name?: string | undefined;
+    repoPath?: string | undefined;
+    remoteUrl?: string | undefined;
+    description?: string | undefined;
+    branches?: string[] | undefined;
+    accessMode?: "readonly" | "readwrite" | undefined;
+    autoCommit?: boolean | undefined;
+    commitAuthor?: {
+      name: string;
+      email: string;
+    } | undefined;
+    depth?: number | undefined;
+    autoCleanup?: boolean | undefined;
+    cloneOptions?: {
+      auth?: {
+        username?: string | undefined;
+        password?: string | undefined;
+      } | undefined;
+    } | undefined;
   }, any>;
   static load({
     filepath,
     parsed
   }: AFSModuleLoadParams): Promise<AFSGit>;
+  private initPromise;
   private git;
   private tempBase;
   private worktrees;
   private repoHash;
+  private isAutoCloned;
+  private clonedPath?;
+  private repoPath;
   constructor(options: AFSGitOptions & {
     cwd?: string;
   });
+  /**
+       * Wait for async initialization to complete
+       */
+  ready(): Promise<void>;
+  /**
+       * Async initialization logic (runs in constructor)
+       * Handles cloning remote repositories if needed
+       */
+  private initialize;
+  /**
+       * Clone a remote repository to local path
+       */
+  private static cloneRepository;
   name: string;
   description?: string;
   accessMode: AFSAccessMode;
@@ -138,6 +279,18 @@ declare class AFSGit implements AFSModule {
     message?: string;
   }>;
   search(path: string, query: string, options?: AFSSearchOptions): Promise<AFSSearchResult>;
+  /**
+       * Fetch latest changes from remote
+       */
+  fetch(): Promise<void>;
+  /**
+       * Pull latest changes from remote for current branch
+       */
+  pull(): Promise<void>;
+  /**
+       * Push local changes to remote
+       */
+  push(branch?: string): Promise<void>;
   /**
        * Cleanup all worktrees (useful when unmounting)
        */

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../src/index.ts"],"mappings":";;;;UAkCiB,aAAA;EAAA,IAAA;EAAA,QAAA;EAAA,WAAA;EAAA,QAAA;EAAA;AA+CjB;;;;;EA/CiB,UAAA,GAWF,aAAA;EAAA;AAoCf;;;EApCe,UAAA;EAAA;AAoCf;;EApCe,YAAA;IAAA,IAAA;IAAA,KAAA;EAAA;AAAA;AAAA,cAoCF,MAAA,YAAkB,SAAA;EAAA,OAAA,EAeD,aAAA;IAAA,GAAA;EAAA;EAAA,OAAA,OAAA,GAdf,CAAA,CAAA,UAAA,CAAA,CAAA,CAAA,SAAA;IAAA,IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAI2B,mBAAA,GAAmB,OAAA,CAAA,MAAA;EAAA,QAAA,GAAA;EAAA,QAAA,QAAA;EAAA,QAAA,SAAA;EAAA,QAAA,QAAA;EAAA,YAAA,OAAA,EAU/B,aAAA;IAAA,GAAA;EAAA;EAAA,IAAA;EAAA,WAAA;EAAA,UAAA,EAwBhB,aAAA;EAAA;;;;;;;;;EAAA,QAAA,SAAA;EAAA;;;EAAA,QAAA,WAAA;EAAA;;;EAAA,QAAA,YAAA;EAAA;;;EAAA,QAAA,WAAA;EAAA;;;EAAA,QAAA,cAAA;EAAA;;;EAAA,QAAA,iBAAA;EAAA;;;;;;EAAA,QAAA,SAAA;EAAA,KAAA,IAAA,UAAA,OAAA,GA8PuB,cAAA,GAAiB,OAAA,CAAQ,aAAA;EAAA,KAAA,IAAA,UAAA,QAAA,GAwBxB,cAAA,GAAiB,OAAA,CAAQ,aAAA;EAAA,MAAA,IAAA,UAAA,KAAA,EA+FpD,oBAAA,EAAA,OAAA,GACG,eAAA,GACT,OAAA,CAAQ,cAAA;EAAA,OAAA,IAAA,UAAA,OAAA,GA6E0B,gBAAA,GAAmB,OAAA,CAAQ,eAAA;EAAA,OAAA,OAAA,UAAA,OAAA,UAAA,OAAA,GAmDpD,gBAAA,GACT,OAAA;IAAA,OAAA;EAAA;EAAA,OAAA,IAAA,UAAA,KAAA,UAAA,OAAA,GAwEiD,gBAAA,GAAmB,OAAA,CAAQ,eAAA;EAAA;;;EAAA,QAAA,GAsF9D,OAAA;AAAA"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/index.ts"],"mappings":";;;;UAiCiB,aAAA;EAAA,IAAA;EAAA;AA6GjB;;;;EA7GiB,QAAA;EAAA;AA6GjB;;;;;;EA7GiB,SAAA;EAAA,WAAA;EAAA;AA6GjB;;;;;;EA7GiB,QAAA;EAAA;AA6GjB;;;;;EA7GiB,UAAA,GA+BF,aAAA;EAAA;AA8Ef;;;EA9Ee,UAAA;EAAA;AA8Ef;;EA9Ee,YAAA;IAAA,IAAA;IAAA,KAAA;EAAA;EAAA;AA8Ef;;;EA9Ee,KAAA;EAAA;AA8Ef;;;;EA9Ee,WAAA;EAAA;AA8Ef;;EA9Ee,YAAA;IAAA;AA8Ef;;IA9Ee,IAAA;MAAA,QAAA;MAAA,QAAA;IAAA;EAAA;AAAA;AAAA,cA8EF,MAAA,YAAkB,SAAA;EAAA,OAAA,EAqBD,aAAA;IAAA,GAAA;EAAA;EAAA,OAAA,OAAA,GApBf,CAAA,CAAA,UAAA,CAAA,CAAA,CAAA,UAAA,CAAA,CAAA,CAAA,SAAA;IAAA,IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAI2B,mBAAA,GAAmB,OAAA,CAAA,MAAA;EAAA,QAAA,WAAA;EAAA,QAAA,GAAA;EAAA,QAAA,QAAA;EAAA,QAAA,SAAA;EAAA,QAAA,QAAA;EAAA,QAAA,YAAA;EAAA,QAAA,UAAA;EAAA,QAAA,QAAA;EAAA,YAAA,OAAA,EAgB/B,aAAA;IAAA,GAAA;EAAA;EAAA;;;EAAA,MAAA,GAgDb,OAAA;EAAA;;;;EAAA,QAAA,UAAA;EAAA;;;EAAA,eAAA,eAAA;EAAA,IAAA;EAAA,WAAA;EAAA,UAAA,EAgGH,aAAA;EAAA;;;;;;;;;EAAA,QAAA,SAAA;EAAA;;;EAAA,QAAA,WAAA;EAAA;;;EAAA,QAAA,YAAA;EAAA;;;EAAA,QAAA,WAAA;EAAA;;;EAAA,QAAA,cAAA;EAAA;;;EAAA,QAAA,iBAAA;EAAA;;;;;;EAAA,QAAA,SAAA;EAAA,KAAA,IAAA,UAAA,OAAA,GA8PuB,cAAA,GAAiB,OAAA,CAAQ,aAAA;EAAA,KAAA,IAAA,UAAA,QAAA,GAyBxB,cAAA,GAAiB,OAAA,CAAQ,aAAA;EAAA,MAAA,IAAA,UAAA,KAAA,EAgGpD,oBAAA,EAAA,OAAA,GACG,eAAA,GACT,OAAA,CAAQ,cAAA;EAAA,OAAA,IAAA,UAAA,OAAA,GA2E0B,gBAAA,GAAmB,OAAA,CAAQ,eAAA;EAAA,OAAA,OAAA,UAAA,OAAA,UAAA,OAAA,GAoDpD,gBAAA,GACT,OAAA;IAAA,OAAA;EAAA;EAAA,OAAA,IAAA,UAAA,KAAA,UAAA,OAAA,GAyEiD,gBAAA,GAAmB,OAAA,CAAQ,eAAA;EAAA;;;EAAA,MAAA,GAuFhE,OAAA;EAAA;;;EAAA,KAAA,GAQD,OAAA;EAAA;;;EAAA,KAAA,MAAA,YAQe,OAAA;EAAA;;;EAAA,QAAA,GAYZ,OAAA;AAAA"}

package/dist/index.d.mts

@@ -4,8 +4,28 @@ import { AFSAccessMode, AFSDeleteOptions, AFSDeleteResult, AFSListOptions, AFSLi
 //#region src/index.d.ts
 interface AFSGitOptions {
   name?: string;
-  repoPath: string;
+  /**
+       * Local path to git repository.
+       * If remoteUrl is provided and repoPath doesn't exist, will clone to this path.
+       * If remoteUrl is provided and repoPath is not specified, clones to temp directory.
+       */
+  repoPath?: string;
+  /**
+       * Remote repository URL (https or git protocol).
+       * If provided, will clone the repository if repoPath doesn't exist.
+       * Examples:
+       * - https://github.com/user/repo.git
+       * - git@github.com:user/repo.git
+       */
+  remoteUrl?: string;
   description?: string;
+  /**
+       * List of branches to expose/access.
+       * Also used for clone optimization when cloning from remoteUrl:
+       * - Single branch (e.g., ['main']): Uses --single-branch for faster clone
+       * - Multiple branches: Clones all branches, filters access to specified ones
+       * - Not specified: All branches are accessible
+       */
   branches?: string[];
   /**
        * Access mode for this module.
@@ -26,14 +46,38 @@ interface AFSGitOptions {
     name: string;
     email: string;
   };
+  /**
+       * Clone depth for shallow clone (only used when cloning from remoteUrl)
+       * @default 1
+       */
+  depth?: number;
+  /**
+       * Automatically clean up cloned repository on cleanup()
+       * Only applies when repository was auto-cloned to temp directory
+       * @default true
+       */
+  autoCleanup?: boolean;
+  /**
+       * Git clone options (only used when cloning from remoteUrl)
+       */
+  cloneOptions?: {
+    /**
+             * Authentication credentials for private repositories
+             */
+    auth?: {
+      username?: string;
+      password?: string;
+    };
+  };
 }
 declare class AFSGit implements AFSModule {
   options: AFSGitOptions & {
     cwd?: string;
   };
-  static schema(): z.ZodEffects<z.ZodObject<{
+  static schema(): z.ZodEffects<z.ZodEffects<z.ZodObject<{
     name: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
-    repoPath: z.ZodString;
+    repoPath: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+    remoteUrl: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
     description: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
     branches: z.ZodType<string[] | undefined, z.ZodTypeDef, string[] | undefined>;
     accessMode: z.ZodType<"readonly" | "readwrite" | undefined, z.ZodTypeDef, "readonly" | "readwrite" | undefined>;
@@ -45,9 +89,23 @@ declare class AFSGit implements AFSModule {
       name: string;
       email: string;
     } | undefined>;
+    depth: z.ZodType<number | undefined, z.ZodTypeDef, number | undefined>;
+    autoCleanup: z.ZodType<boolean | undefined, z.ZodTypeDef, boolean | undefined>;
+    cloneOptions: z.ZodType<{
+      auth?: {
+        username?: string | undefined;
+        password?: string | undefined;
+      } | undefined;
+    } | undefined, z.ZodTypeDef, {
+      auth?: {
+        username?: string | undefined;
+        password?: string | undefined;
+      } | undefined;
+    } | undefined>;
   }, "strip", z.ZodTypeAny, {
-    repoPath: string;
     name?: string | undefined;
+    repoPath?: string | undefined;
+    remoteUrl?: string | undefined;
     description?: string | undefined;
     branches?: string[] | undefined;
     accessMode?: "readonly" | "readwrite" | undefined;
@@ -56,9 +114,18 @@ declare class AFSGit implements AFSModule {
       name: string;
       email: string;
     } | undefined;
+    depth?: number | undefined;
+    autoCleanup?: boolean | undefined;
+    cloneOptions?: {
+      auth?: {
+        username?: string | undefined;
+        password?: string | undefined;
+      } | undefined;
+    } | undefined;
   }, {
-    repoPath: string;
     name?: string | undefined;
+    repoPath?: string | undefined;
+    remoteUrl?: string | undefined;
     description?: string | undefined;
     branches?: string[] | undefined;
     accessMode?: "readonly" | "readwrite" | undefined;
@@ -67,9 +134,18 @@ declare class AFSGit implements AFSModule {
       name: string;
       email: string;
     } | undefined;
+    depth?: number | undefined;
+    autoCleanup?: boolean | undefined;
+    cloneOptions?: {
+      auth?: {
+        username?: string | undefined;
+        password?: string | undefined;
+      } | undefined;
+    } | undefined;
   }>, {
-    repoPath: string;
     name?: string | undefined;
+    repoPath?: string | undefined;
+    remoteUrl?: string | undefined;
     description?: string | undefined;
     branches?: string[] | undefined;
     accessMode?: "readonly" | "readwrite" | undefined;
@@ -78,18 +154,83 @@ declare class AFSGit implements AFSModule {
       name: string;
       email: string;
     } | undefined;
+    depth?: number | undefined;
+    autoCleanup?: boolean | undefined;
+    cloneOptions?: {
+      auth?: {
+        username?: string | undefined;
+        password?: string | undefined;
+      } | undefined;
+    } | undefined;
+  }, {
+    name?: string | undefined;
+    repoPath?: string | undefined;
+    remoteUrl?: string | undefined;
+    description?: string | undefined;
+    branches?: string[] | undefined;
+    accessMode?: "readonly" | "readwrite" | undefined;
+    autoCommit?: boolean | undefined;
+    commitAuthor?: {
+      name: string;
+      email: string;
+    } | undefined;
+    depth?: number | undefined;
+    autoCleanup?: boolean | undefined;
+    cloneOptions?: {
+      auth?: {
+        username?: string | undefined;
+        password?: string | undefined;
+      } | undefined;
+    } | undefined;
+  }>, {
+    name?: string | undefined;
+    repoPath?: string | undefined;
+    remoteUrl?: string | undefined;
+    description?: string | undefined;
+    branches?: string[] | undefined;
+    accessMode?: "readonly" | "readwrite" | undefined;
+    autoCommit?: boolean | undefined;
+    commitAuthor?: {
+      name: string;
+      email: string;
+    } | undefined;
+    depth?: number | undefined;
+    autoCleanup?: boolean | undefined;
+    cloneOptions?: {
+      auth?: {
+        username?: string | undefined;
+        password?: string | undefined;
+      } | undefined;
+    } | undefined;
   }, any>;
   static load({
     filepath,
     parsed
   }: AFSModuleLoadParams): Promise<AFSGit>;
+  private initPromise;
   private git;
   private tempBase;
   private worktrees;
   private repoHash;
+  private isAutoCloned;
+  private clonedPath?;
+  private repoPath;
   constructor(options: AFSGitOptions & {
     cwd?: string;
   });
+  /**
+       * Wait for async initialization to complete
+       */
+  ready(): Promise<void>;
+  /**
+       * Async initialization logic (runs in constructor)
+       * Handles cloning remote repositories if needed
+       */
+  private initialize;
+  /**
+       * Clone a remote repository to local path
+       */
+  private static cloneRepository;
   name: string;
   description?: string;
   accessMode: AFSAccessMode;
@@ -138,6 +279,18 @@ declare class AFSGit implements AFSModule {
     message?: string;
   }>;
   search(path: string, query: string, options?: AFSSearchOptions): Promise<AFSSearchResult>;
+  /**
+       * Fetch latest changes from remote
+       */
+  fetch(): Promise<void>;
+  /**
+       * Pull latest changes from remote for current branch
+       */
+  pull(): Promise<void>;
+  /**
+       * Push local changes to remote
+       */
+  push(branch?: string): Promise<void>;
   /**
        * Cleanup all worktrees (useful when unmounting)
        */

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"mappings":";;;;UAkCiB,aAAA;EAAA,IAAA;EAAA,QAAA;EAAA,WAAA;EAAA,QAAA;EAAA;AA+CjB;;;;;EA/CiB,UAAA,GAWF,aAAA;EAAA;AAoCf;;;EApCe,UAAA;EAAA;AAoCf;;EApCe,YAAA;IAAA,IAAA;IAAA,KAAA;EAAA;AAAA;AAAA,cAoCF,MAAA,YAAkB,SAAA;EAAA,OAAA,EAeD,aAAA;IAAA,GAAA;EAAA;EAAA,OAAA,OAAA,GAdf,CAAA,CAAA,UAAA,CAAA,CAAA,CAAA,SAAA;IAAA,IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAI2B,mBAAA,GAAmB,OAAA,CAAA,MAAA;EAAA,QAAA,GAAA;EAAA,QAAA,QAAA;EAAA,QAAA,SAAA;EAAA,QAAA,QAAA;EAAA,YAAA,OAAA,EAU/B,aAAA;IAAA,GAAA;EAAA;EAAA,IAAA;EAAA,WAAA;EAAA,UAAA,EAwBhB,aAAA;EAAA;;;;;;;;;EAAA,QAAA,SAAA;EAAA;;;EAAA,QAAA,WAAA;EAAA;;;EAAA,QAAA,YAAA;EAAA;;;EAAA,QAAA,WAAA;EAAA;;;EAAA,QAAA,cAAA;EAAA;;;EAAA,QAAA,iBAAA;EAAA;;;;;;EAAA,QAAA,SAAA;EAAA,KAAA,IAAA,UAAA,OAAA,GA8PuB,cAAA,GAAiB,OAAA,CAAQ,aAAA;EAAA,KAAA,IAAA,UAAA,QAAA,GAwBxB,cAAA,GAAiB,OAAA,CAAQ,aAAA;EAAA,MAAA,IAAA,UAAA,KAAA,EA+FpD,oBAAA,EAAA,OAAA,GACG,eAAA,GACT,OAAA,CAAQ,cAAA;EAAA,OAAA,IAAA,UAAA,OAAA,GA6E0B,gBAAA,GAAmB,OAAA,CAAQ,eAAA;EAAA,OAAA,OAAA,UAAA,OAAA,UAAA,OAAA,GAmDpD,gBAAA,GACT,OAAA;IAAA,OAAA;EAAA;EAAA,OAAA,IAAA,UAAA,KAAA,UAAA,OAAA,GAwEiD,gBAAA,GAAmB,OAAA,CAAQ,eAAA;EAAA;;;EAAA,QAAA,GAsF9D,OAAA;AAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"mappings":";;;;UAiCiB,aAAA;EAAA,IAAA;EAAA;AA6GjB;;;;EA7GiB,QAAA;EAAA;AA6GjB;;;;;;EA7GiB,SAAA;EAAA,WAAA;EAAA;AA6GjB;;;;;;EA7GiB,QAAA;EAAA;AA6GjB;;;;;EA7GiB,UAAA,GA+BF,aAAA;EAAA;AA8Ef;;;EA9Ee,UAAA;EAAA;AA8Ef;;EA9Ee,YAAA;IAAA,IAAA;IAAA,KAAA;EAAA;EAAA;AA8Ef;;;EA9Ee,KAAA;EAAA;AA8Ef;;;;EA9Ee,WAAA;EAAA;AA8Ef;;EA9Ee,YAAA;IAAA;AA8Ef;;IA9Ee,IAAA;MAAA,QAAA;MAAA,QAAA;IAAA;EAAA;AAAA;AAAA,cA8EF,MAAA,YAAkB,SAAA;EAAA,OAAA,EAqBD,aAAA;IAAA,GAAA;EAAA;EAAA,OAAA,OAAA,GApBf,CAAA,CAAA,UAAA,CAAA,CAAA,CAAA,UAAA,CAAA,CAAA,CAAA,SAAA;IAAA,IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAI2B,mBAAA,GAAmB,OAAA,CAAA,MAAA;EAAA,QAAA,WAAA;EAAA,QAAA,GAAA;EAAA,QAAA,QAAA;EAAA,QAAA,SAAA;EAAA,QAAA,QAAA;EAAA,QAAA,YAAA;EAAA,QAAA,UAAA;EAAA,QAAA,QAAA;EAAA,YAAA,OAAA,EAgB/B,aAAA;IAAA,GAAA;EAAA;EAAA;;;EAAA,MAAA,GAgDb,OAAA;EAAA;;;;EAAA,QAAA,UAAA;EAAA;;;EAAA,eAAA,eAAA;EAAA,IAAA;EAAA,WAAA;EAAA,UAAA,EAgGH,aAAA;EAAA;;;;;;;;;EAAA,QAAA,SAAA;EAAA;;;EAAA,QAAA,WAAA;EAAA;;;EAAA,QAAA,YAAA;EAAA;;;EAAA,QAAA,WAAA;EAAA;;;EAAA,QAAA,cAAA;EAAA;;;EAAA,QAAA,iBAAA;EAAA;;;;;;EAAA,QAAA,SAAA;EAAA,KAAA,IAAA,UAAA,OAAA,GA8PuB,cAAA,GAAiB,OAAA,CAAQ,aAAA;EAAA,KAAA,IAAA,UAAA,QAAA,GAyBxB,cAAA,GAAiB,OAAA,CAAQ,aAAA;EAAA,MAAA,IAAA,UAAA,KAAA,EAgGpD,oBAAA,EAAA,OAAA,GACG,eAAA,GACT,OAAA,CAAQ,cAAA;EAAA,OAAA,IAAA,UAAA,OAAA,GA2E0B,gBAAA,GAAmB,OAAA,CAAQ,eAAA;EAAA,OAAA,OAAA,UAAA,OAAA,UAAA,OAAA,GAoDpD,gBAAA,GACT,OAAA;IAAA,OAAA;EAAA;EAAA,OAAA,IAAA,UAAA,KAAA,UAAA,OAAA,GAyEiD,gBAAA,GAAmB,OAAA,CAAQ,eAAA;EAAA;;;EAAA,MAAA,GAuFhE,OAAA;EAAA;;;EAAA,KAAA,GAQD,OAAA;EAAA;;;EAAA,KAAA,MAAA,YAQe,OAAA;EAAA;;;EAAA,QAAA,GAYZ,OAAA;AAAA"}

package/dist/index.mjs

@@ -9,11 +9,12 @@ import { simpleGit } from "simple-git";
 import { z } from "zod";
 
 //#region src/index.ts
-const execFileAsync = promisify(execFile);
 const LIST_MAX_LIMIT = 1e3;
+const execFileAsync = promisify(execFile);
 const afsGitOptionsSchema = camelize(z.object({
 	name: optionalize(z.string()),
-	repoPath: z.string().describe("The path to the git repository"),
+	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")),
@@ -21,35 +22,107 @@ const afsGitOptionsSchema = camelize(z.object({
 	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 }) {
-		return new AFSGit({
+		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;
-		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";
+		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.git = simpleGit(repoPath);
 		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;
@@ -136,8 +209,8 @@ var AFSGit = class AFSGit {
 	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;
+			this.worktrees.set(branch, this.repoPath);
+			return this.repoPath;
 		}
 		const worktreePath = join(this.tempBase, branch);
 		if (!await stat(worktreePath).then(() => true).catch(() => false)) {
@@ -242,6 +315,7 @@ var AFSGit = class AFSGit {
 		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);
@@ -254,6 +328,7 @@ var AFSGit = class AFSGit {
 		return this.listWithGitLsTree(branch, filePath, options);
 	}
 	async read(path, _options) {
+		await this.ready();
 		const { branch, filePath } = this.parsePath(path);
 		if (!branch) return { data: {
 			id: "/",
@@ -322,6 +397,7 @@ var AFSGit = class AFSGit {
 		}
 	}
 	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);
@@ -366,6 +442,7 @@ var AFSGit = class AFSGit {
 		} };
 	}
 	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);
@@ -388,6 +465,7 @@ var AFSGit = class AFSGit {
 		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");
@@ -418,6 +496,7 @@ var AFSGit = class AFSGit {
 		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: [],
@@ -476,9 +555,32 @@ var AFSGit = class AFSGit {
 		}
 	}
 	/**
+	* 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",
@@ -494,6 +596,13 @@ var AFSGit = class AFSGit {
 				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 {}
 	}
 };
 

package/dist/index.mjs.map

@@ -1 +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":";;;;;;;;;;;AAOA,MAAM,gBAAgB,UAAU,SAAS;AAyBzC,MAAM,iBAAiB;AA4BvB,MAAM,sBAAsB,SAC1B,EAAE,OAAO;CACP,MAAM,YAAY,EAAE,QAAQ,CAAC;CAC7B,UAAU,EAAE,QAAQ,CAAC,SAAS,iCAAiC;CAC/D,aAAa,YAAY,EAAE,QAAQ,CAAC,SAAS,kCAAkC,CAAC;CAChF,UAAU,YAAY,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,SAAS,6BAA6B,CAAC;CACjF,YAAY,YACV,EAAE,KAAK,CAAC,YAAY,YAAY,CAAC,CAAC,SAAS,8BAA8B,CAC1E;CACD,YAAY,YACV,EAAE,SAAS,CAAC,SAAS,sDAAsD,CAC5E;CACD,cAAc,YACZ,EAAE,OAAO;EACP,MAAM,EAAE,QAAQ;EAChB,OAAO,EAAE,QAAQ;EAClB,CAAC,CACH;CACF,CAAC,CACH;AAED,IAAa,SAAb,MAAa,OAA4B;CACvC,OAAO,SAAS;AACd,SAAO;;CAGT,aAAa,KAAK,EAAE,UAAU,UAA+B;AAE3D,SAAO,IAAI,OAAO;GAAE,GADN,MAAM,OAAO,QAAQ,CAAC,WAAW,OAAO;GACxB,KAAK,QAAQ,SAAS;GAAE,CAAC;;CAGzD,AAAQ;CACR,AAAQ;CACR,AAAQ,4BAAiC,IAAI,KAAK;CAClD,AAAQ;CAER,YAAY,AAAO,SAA2C;EAA3C;AACjB,WAAS,qBAAqB,QAAQ;EAEtC,IAAI;AACJ,MAAI,WAAW,QAAQ,SAAS,CAC9B,YAAW,QAAQ;MAEnB,YAAW,KAAK,QAAQ,OAAO,QAAQ,KAAK,EAAE,QAAQ,SAAS;AAGjE,OAAK,QAAQ,WAAW;AACxB,OAAK,OAAO,QAAQ,QAAQ,SAAS,SAAS,IAAI;AAClD,OAAK,cAAc,QAAQ;AAC3B,OAAK,aAAa,QAAQ,cAAc;AAExC,OAAK,MAAM,UAAU,SAAS;AAG9B,OAAK,WAAW,WAAW,MAAM,CAAC,OAAO,SAAS,CAAC,OAAO,MAAM,CAAC,UAAU,GAAG,EAAE;AAChF,OAAK,WAAW,KAAK,QAAQ,EAAE,WAAW,KAAK,WAAW;;CAG5D;CACA;CACA;;;;;;;;;;CAWA,AAAQ,UAAU,MAAqD;EAErE,MAAM,WADa,KAAK,KAAK,KAAK,CACN,MAAM,IAAI,CAAC,OAAO,QAAQ;AAEtD,MAAI,SAAS,WAAW,EACtB,QAAO;GAAE,QAAQ;GAAW,UAAU;GAAI;AAO5C,SAAO;GAAE,QAHM,SAAS,GAAI,QAAQ,MAAM,IAAI;GAG7B,UAFA,SAAS,MAAM,EAAE,CAAC,KAAK,IAAI;GAEjB;;;;;CAM7B,AAAQ,YAAY,UAA0B;AAwB5C,SAtB0C;GAExC,KAAK;GACL,KAAK;GACL,MAAM;GACN,KAAK;GACL,KAAK;GACL,MAAM;GACN,KAAK;GACL,KAAK;GAEL,KAAK;GACL,KAAK;GACL,IAAI;GAEJ,IAAI;GACJ,IAAI;GACJ,MAAM;GACN,MAAM;GACN,KAAK;GACL,KAAK;GACN,CAtBW,SAAS,MAAM,IAAI,CAAC,KAAK,EAAE,aAAa,IAuB5B,OAAO;;;;;CAMjC,AAAQ,aAAa,UAA2B;EAC9C,MAAM,MAAM,SAAS,MAAM,IAAI,CAAC,KAAK,EAAE,aAAa;AAmBpD,SAlByB;GACvB;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACD,CACuB,SAAS,OAAO,GAAG;;;;;CAM7C,MAAc,cAAiC;EAE7C,MAAM,eADgB,MAAM,KAAK,IAAI,aAAa,EAChB;AAGlC,MAAI,KAAK,QAAQ,YAAY,KAAK,QAAQ,SAAS,SAAS,EAC1D,QAAO,YAAY,QAAQ,WAAW,KAAK,QAAQ,SAAU,SAAS,OAAO,CAAC;AAGhF,SAAO;;;;;CAMT,MAAc,eAAe,QAAiC;AAC5D,MAAI,KAAK,UAAU,IAAI,OAAO,CAC5B,QAAO,KAAK,UAAU,IAAI,OAAO;AAKnC,OADsB,MAAM,KAAK,IAAI,SAAS,CAAC,gBAAgB,OAAO,CAAC,EACrD,MAAM,KAAK,QAAQ;AAEnC,QAAK,UAAU,IAAI,QAAQ,KAAK,QAAQ,SAAS;AACjD,UAAO,KAAK,QAAQ;;EAGtB,MAAM,eAAe,KAAK,KAAK,UAAU,OAAO;AAOhD,MAAI,CAJW,MAAM,KAAK,aAAa,CACpC,WAAW,KAAK,CAChB,YAAY,MAAM,EAER;AACX,SAAM,MAAM,KAAK,UAAU,EAAE,WAAW,MAAM,CAAC;AAC/C,SAAM,KAAK,IAAI,IAAI;IAAC;IAAY;IAAO;IAAc;IAAO,CAAC;;AAG/D,OAAK,UAAU,IAAI,QAAQ,aAAa;AACxC,SAAO;;;;;CAMT,MAAc,kBACZ,QACA,MACA,SACwB;EACxB,MAAM,WAAW,SAAS,YAAY;EACtC,MAAM,QAAQ,KAAK,IAAI,SAAS,SAAS,gBAAgB,eAAe;EAExE,MAAM,UAAsB,EAAE;EAC9B,MAAM,aAAa,QAAQ;EAC3B,MAAM,UAAU,aAAa,GAAG,OAAO,GAAG,eAAe;AAEzD,MAAI;GAEF,MAAM,WAAW,MAAM,KAAK,IACzB,IAAI;IAAC;IAAY;IAAM;IAAQ,CAAC,CAChC,MAAM,MAAM,EAAE,MAAM,CAAC,CACrB,YAAY,KAAK;AAEpB,OAAI,aAAa,KAEf,QAAO,EAAE,MAAM,EAAE,EAAE;AAIrB,OAAI,aAAa,QAAQ;IACvB,MAAM,OAAO,MAAM,KAAK,IACrB,IAAI;KAAC;KAAY;KAAM;KAAQ,CAAC,CAChC,MAAM,MAAM,OAAO,SAAS,EAAE,MAAM,EAAE,GAAG,CAAC;IAE7C,MAAM,UAAU,KAAK,UAAU,QAAQ,KAAK;AAC5C,YAAQ,KAAK;KACX,IAAI;KACJ,MAAM;KACN,UAAU;MACR,MAAM;MACN;MACD;KACF,CAAC;AAEF,WAAO,EAAE,MAAM,SAAS;;GAS1B,MAAM,QAAqB,CAAC;IAAE,MAAM;IAAY,OAAO;IAAG,CAAC;AAE3D,UAAO,MAAM,SAAS,GAAG;IAEvB,MAAM,EAAE,MAAM,UAAU,UADX,MAAM,OAAO;IAI1B,MAAM,cAAc,WAAW,GAAG,OAAO,GAAG,aAAa;IAGzD,MAAM,SAFS,MAAM,KAAK,IAAI,IAAI;KAAC;KAAW;KAAM;KAAY,CAAC,EAG9D,MAAM,KAAK,CACX,QAAQ,SAAS,KAAK,MAAM,CAAC,CAC7B,MAAM,GAAG,QAAQ,QAAQ,OAAO;AAEnC,SAAK,MAAM,QAAQ,OAAO;KAIxB,MAAM,QAAQ,KAAK,MAAM,iDAAiD;AAC1E,SAAI,CAAC,MAAO;KAEZ,MAAM,OAAO,MAAM;KACnB,MAAM,UAAU,MAAM;KACtB,MAAM,OAAO,MAAM;KACnB,MAAM,cAAc,SAAS;KAC7B,MAAM,OAAO,YAAY,MAAM,SAAY,OAAO,SAAS,SAAS,GAAG;KAEvE,MAAM,WAAW,WAAW,GAAG,SAAS,GAAG,SAAS;KACpD,MAAM,UAAU,KAAK,UAAU,QAAQ,SAAS;AAEhD,aAAQ,KAAK;MACX,IAAI;MACJ,MAAM;MACN,UAAU;OACR,MAAM,cAAc,cAAc;OAClC;OACD;MACF,CAAC;AAGF,SAAI,eAAe,QAAQ,IAAI,SAC7B,OAAM,KAAK;MAAE,MAAM;MAAU,OAAO,QAAQ;MAAG,CAAC;AAIlD,SAAI,QAAQ,UAAU,MACpB,QAAO,EAAE,MAAM,SAAS;;;AAK9B,UAAO,EAAE,MAAM,SAAS;WACjB,OAAO;AACd,UAAO;IAAE,MAAM,EAAE;IAAE,SAAU,MAAgB;IAAS;;;;;;;;;CAU1D,AAAQ,UAAU,QAAgB,UAA2B;EAE3D,MAAM,gBAAgB,OAAO,QAAQ,OAAO,IAAI;AAChD,MAAI,CAAC,SACH,QAAO,IAAI;AAEb,SAAO,IAAI,cAAc,GAAG;;CAG9B,MAAM,KAAK,MAAc,SAAkD;EACzE,MAAM,EAAE,QAAQ,aAAa,KAAK,UAAU,KAAK;AAGjD,MAAI,CAAC,OAEH,QAAO,EACL,OAFe,MAAM,KAAK,aAAa,EAExB,KAAK,SAAS;GAC3B,MAAM,cAAc,KAAK,UAAU,KAAK;AACxC,UAAO;IACL,IAAI;IACJ,MAAM;IACN,UAAU,EACR,MAAM,aACP;IACF;IACD,EACH;AAIH,SAAO,KAAK,kBAAkB,QAAQ,UAAU,QAAQ;;CAG1D,MAAM,KAAK,MAAc,UAAmD;EAC1E,MAAM,EAAE,QAAQ,aAAa,KAAK,UAAU,KAAK;AAEjD,MAAI,CAAC,OACH,QAAO,EACL,MAAM;GACJ,IAAI;GACJ,MAAM;GACN,UAAU,EAAE,MAAM,aAAa;GAChC,EACF;AAGH,MAAI,CAAC,UAAU;GACb,MAAM,aAAa,KAAK,UAAU,OAAO;AACzC,UAAO,EACL,MAAM;IACJ,IAAI;IACJ,MAAM;IACN,UAAU,EAAE,MAAM,aAAa;IAChC,EACF;;AAGH,MAAI;AAMF,OAJmB,MAAM,KAAK,IAC3B,IAAI;IAAC;IAAY;IAAM,GAAG,OAAO,GAAG;IAAW,CAAC,CAChD,MAAM,MAAM,EAAE,MAAM,CAAC,KAEL,QAAQ;IAEzB,MAAMA,YAAU,KAAK,UAAU,QAAQ,SAAS;AAChD,WAAO,EACL,MAAM;KACJ,IAAIA;KACJ,MAAMA;KACN,UAAU,EACR,MAAM,aACP;KACF,EACF;;GAIH,MAAM,OAAO,MAAM,KAAK,IACrB,IAAI;IAAC;IAAY;IAAM,GAAG,OAAO,GAAG;IAAW,CAAC,CAChD,MAAM,MAAM,OAAO,SAAS,EAAE,MAAM,EAAE,GAAG,CAAC;GAG7C,MAAM,WAAW,KAAK,YAAY,SAAS;GAC3C,MAAM,WAAW,KAAK,aAAa,SAAS;GAE5C,IAAI;GACJ,MAAM,WAAgC;IACpC,MAAM;IACN;IACA;IACD;AAED,OAAI,UAAU;IAEZ,MAAM,EAAE,WAAW,MAAM,cAAc,OAAO;KAAC;KAAY;KAAM,GAAG,OAAO,GAAG;KAAW,EAAE;KACzF,KAAK,KAAK,QAAQ;KAClB,UAAU;KACV,WAAW,KAAK,OAAO;KACxB,CAAC;AAEF,cAAW,OAAkB,SAAS,SAAS;AAE/C,aAAS,cAAc;SAGvB,WAAU,MAAM,KAAK,IAAI,KAAK,CAAC,GAAG,OAAO,GAAG,WAAW,CAAC;GAG1D,MAAM,UAAU,KAAK,UAAU,QAAQ,SAAS;AAChD,UAAO,EACL,MAAM;IACJ,IAAI;IACJ,MAAM;IACN;IACA;IACD,EACF;WACM,OAAO;AACd,UAAO;IACL,MAAM;IACN,SAAU,MAAgB;IAC3B;;;CAIL,MAAM,MACJ,MACA,OACA,SACyB;EACzB,MAAM,EAAE,QAAQ,aAAa,KAAK,UAAU,KAAK;AAEjD,MAAI,CAAC,UAAU,CAAC,SACd,OAAM,IAAI,MAAM,sCAAsC;EAIxD,MAAM,eAAe,MAAM,KAAK,eAAe,OAAO;EACtD,MAAM,WAAW,KAAK,cAAc,SAAS;EAC7C,MAAM,SAAS,SAAS,UAAU;AAIlC,QAAM,MADY,QAAQ,SAAS,EACZ,EAAE,WAAW,MAAM,CAAC;AAG3C,MAAI,MAAM,YAAY,QAAW;GAC/B,IAAI;AACJ,OAAI,OAAO,MAAM,YAAY,SAC3B,kBAAiB,MAAM;OAEvB,kBAAiB,KAAK,UAAU,MAAM,SAAS,MAAM,EAAE;AAEzD,SAAM,UAAU,UAAU,gBAAgB;IACxC,UAAU;IACV,MAAM,SAAS,MAAM;IACtB,CAAC;;AAIJ,MAAI,KAAK,QAAQ,YAAY;GAC3B,MAAM,cAAc,UAAU,aAAa;AAC3C,SAAM,YAAY,IAAI,SAAS;AAE/B,OAAI,KAAK,QAAQ,cAAc;AAC7B,UAAM,YAAY,UAChB,aACA,KAAK,QAAQ,aAAa,MAC1B,QACA,QACD;AACD,UAAM,YAAY,UAChB,cACA,KAAK,QAAQ,aAAa,OAC1B,QACA,QACD;;AAGH,SAAM,YAAY,OAAO,UAAU,WAAW;;EAIhD,MAAM,QAAQ,MAAM,KAAK,SAAS;EAElC,MAAM,UAAU,KAAK,UAAU,QAAQ,SAAS;AAkBhD,SAAO,EAAE,MAjBsB;GAC7B,IAAI;GACJ,MAAM;GACN,SAAS,MAAM;GACf,SAAS,MAAM;GACf,WAAW,MAAM;GACjB,WAAW,MAAM;GACjB,UAAU;IACR,GAAG,MAAM;IACT,MAAM,MAAM,aAAa,GAAG,cAAc;IAC1C,MAAM,MAAM;IACb;GACD,QAAQ,MAAM;GACd,WAAW,MAAM;GACjB,QAAQ,MAAM;GACf,EAE4B;;CAG/B,MAAM,OAAO,MAAc,SAAsD;EAC/E,MAAM,EAAE,QAAQ,aAAa,KAAK,UAAU,KAAK;AAEjD,MAAI,CAAC,UAAU,CAAC,SACd,OAAM,IAAI,MAAM,oCAAoC;EAItD,MAAM,eAAe,MAAM,KAAK,eAAe,OAAO;EACtD,MAAM,WAAW,KAAK,cAAc,SAAS;EAC7C,MAAM,YAAY,SAAS,aAAa;AAIxC,OAFc,MAAM,KAAK,SAAS,EAExB,aAAa,IAAI,CAAC,UAC1B,OAAM,IAAI,MACR,4BAA4B,KAAK,wEAClC;AAGH,QAAM,GAAG,UAAU;GAAE;GAAW,OAAO;GAAM,CAAC;AAG9C,MAAI,KAAK,QAAQ,YAAY;GAC3B,MAAM,cAAc,UAAU,aAAa;AAC3C,SAAM,YAAY,IAAI,SAAS;AAE/B,OAAI,KAAK,QAAQ,cAAc;AAC7B,UAAM,YAAY,UAChB,aACA,KAAK,QAAQ,aAAa,MAC1B,QACA,QACD;AACD,UAAM,YAAY,UAChB,cACA,KAAK,QAAQ,aAAa,OAC1B,QACA,QACD;;AAGH,SAAM,YAAY,OAAO,UAAU,WAAW;;AAGhD,SAAO,EAAE,SAAS,yBAAyB,QAAQ;;CAGrD,MAAM,OACJ,SACA,SACA,SAC+B;EAC/B,MAAM,EAAE,QAAQ,WAAW,UAAU,gBAAgB,KAAK,UAAU,QAAQ;EAC5E,MAAM,EAAE,QAAQ,WAAW,UAAU,gBAAgB,KAAK,UAAU,QAAQ;AAE5E,MAAI,CAAC,aAAa,CAAC,YACjB,OAAM,IAAI,MAAM,yCAAyC;AAG3D,MAAI,CAAC,aAAa,CAAC,YACjB,OAAM,IAAI,MAAM,uCAAuC;AAGzD,MAAI,cAAc,UAChB,OAAM,IAAI,MAAM,gCAAgC;EAIlD,MAAM,eAAe,MAAM,KAAK,eAAe,UAAU;EACzD,MAAM,cAAc,KAAK,cAAc,YAAY;EACnD,MAAM,cAAc,KAAK,cAAc,YAAY;EACnD,MAAM,YAAY,SAAS,aAAa;AAGxC,QAAM,KAAK,YAAY;AAGvB,MAAI;AACF,SAAM,KAAK,YAAY;AACvB,OAAI,CAAC,UACH,OAAM,IAAI,MACR,gBAAgB,QAAQ,sDACzB;WAEI,OAAO;AACd,OAAK,MAAgC,SAAS,SAC5C,OAAM;;AAMV,QAAM,MADe,QAAQ,YAAY,EACf,EAAE,WAAW,MAAM,CAAC;AAG9C,QAAM,OAAO,aAAa,YAAY;AAGtC,MAAI,KAAK,QAAQ,YAAY;GAC3B,MAAM,cAAc,UAAU,aAAa;AAC3C,SAAM,YAAY,IAAI,CAAC,aAAa,YAAY,CAAC;AAEjD,OAAI,KAAK,QAAQ,cAAc;AAC7B,UAAM,YAAY,UAChB,aACA,KAAK,QAAQ,aAAa,MAC1B,QACA,QACD;AACD,UAAM,YAAY,UAChB,cACA,KAAK,QAAQ,aAAa,OAC1B,QACA,QACD;;AAGH,SAAM,YAAY,OAAO,UAAU,YAAY,MAAM,cAAc;;AAGrE,SAAO,EAAE,SAAS,yBAAyB,QAAQ,QAAQ,QAAQ,IAAI;;CAGzE,MAAM,OAAO,MAAc,OAAe,SAAsD;EAC9F,MAAM,EAAE,QAAQ,aAAa,KAAK,UAAU,KAAK;AAEjD,MAAI,CAAC,OACH,QAAO;GAAE,MAAM,EAAE;GAAE,SAAS;GAAiC;EAG/D,MAAM,QAAQ,KAAK,IAAI,SAAS,SAAS,gBAAgB,eAAe;AAExE,MAAI;GAEF,MAAM,OAAO;IAAC;IAAQ;IAAM;IAAK;AAEjC,OAAI,SAAS,kBAAkB,MAC7B,MAAK,KAAK,KAAK;AAGjB,QAAK,KAAK,OAAO,OAAO;AAGxB,OAAI,SACF,MAAK,KAAK,MAAM,SAAS;GAI3B,MAAM,SADS,MAAM,KAAK,IAAI,IAAI,KAAK,EAClB,MAAM,KAAK,CAAC,QAAQ,SAAS,KAAK,MAAM,CAAC;GAE9D,MAAM,UAAsB,EAAE;GAC9B,MAAM,iCAAiB,IAAI,KAAa;AAExC,QAAK,MAAM,QAAQ,OAAO;IAGxB,IAAI;IACJ,IAAI;IACJ,IAAI;IAEJ,MAAM,kBAAkB,KAAK,MAAM,6BAA6B;AAChE,QAAI,iBAAiB;AACnB,iBAAY,gBAAgB;AAC5B,eAAU,gBAAgB;AAC1B,eAAU,gBAAgB;WACrB;KAEL,MAAM,gBAAgB,KAAK,MAAM,uBAAuB;AACxD,SAAI,CAAC,cAAe;AACpB,iBAAY,cAAc;AAC1B,eAAU,cAAc;AACxB,eAAU,cAAc;;IAG1B,MAAM,UAAU,KAAK,UAAU,QAAQ,UAAU;AAEjD,QAAI,eAAe,IAAI,QAAQ,CAAE;AACjC,mBAAe,IAAI,QAAQ;AAE3B,YAAQ,KAAK;KACX,IAAI;KACJ,MAAM;KACN,SAAS,QAAQ,QAAQ,IAAI;KAC7B,UAAU,EACR,MAAM,QACP;KACF,CAAC;AAEF,QAAI,QAAQ,UAAU,MACpB;;AAIJ,UAAO;IACL,MAAM;IACN,SAAS,QAAQ,UAAU,QAAQ,8BAA8B,UAAU;IAC5E;WACM,OAAO;AAEd,OAAK,MAAgB,QAAQ,SAAS,4BAA4B,CAChE,QAAO,EAAE,MAAM,EAAE,EAAE;AAErB,UAAO;IAAE,MAAM,EAAE;IAAE,SAAU,MAAgB;IAAS;;;;;;CAO1D,MAAM,UAAyB;AAC7B,OAAK,MAAM,CAAC,SAAS,iBAAiB,KAAK,UACzC,KAAI;AACF,SAAM,KAAK,IAAI,IAAI;IAAC;IAAY;IAAU;IAAc;IAAU,CAAC;WAC5D,QAAQ;AAInB,OAAK,UAAU,OAAO;AAGtB,MAAI;AACF,SAAM,GAAG,KAAK,UAAU;IAAE,WAAW;IAAM,OAAO;IAAM,CAAC;UACnD"}
+{"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\";\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\nconst execFileAsync = promisify(execFile);\n\nexport interface AFSGitOptions {\n  name?: string;\n  /**\n   * Local path to git repository.\n   * If remoteUrl is provided and repoPath doesn't exist, will clone to this path.\n   * If remoteUrl is provided and repoPath is not specified, clones to temp directory.\n   */\n  repoPath?: string;\n  /**\n   * Remote repository URL (https or git protocol).\n   * If provided, will clone the repository if repoPath doesn't exist.\n   * Examples:\n   * - https://github.com/user/repo.git\n   * - git@github.com:user/repo.git\n   */\n  remoteUrl?: string;\n  description?: string;\n  /**\n   * List of branches to expose/access.\n   * Also used for clone optimization when cloning from remoteUrl:\n   * - Single branch (e.g., ['main']): Uses --single-branch for faster clone\n   * - Multiple branches: Clones all branches, filters access to specified ones\n   * - Not specified: All branches are accessible\n   */\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   * Clone depth for shallow clone (only used when cloning from remoteUrl)\n   * @default 1\n   */\n  depth?: number;\n  /**\n   * Automatically clean up cloned repository on cleanup()\n   * Only applies when repository was auto-cloned to temp directory\n   * @default true\n   */\n  autoCleanup?: boolean;\n  /**\n   * Git clone options (only used when cloning from remoteUrl)\n   */\n  cloneOptions?: {\n    /**\n     * Authentication credentials for private repositories\n     */\n    auth?: {\n      username?: string;\n      password?: string;\n    };\n  };\n}\n\nconst afsGitOptionsSchema = camelize(\n  z\n    .object({\n      name: optionalize(z.string()),\n      repoPath: optionalize(z.string().describe(\"The path to the git repository\")),\n      remoteUrl: optionalize(z.string().describe(\"Remote repository URL (https or git protocol)\")),\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      depth: optionalize(z.number().describe(\"Clone depth for shallow clone\")),\n      autoCleanup: optionalize(\n        z.boolean().describe(\"Automatically clean up cloned repository on cleanup()\"),\n      ),\n      cloneOptions: optionalize(\n        z.object({\n          auth: optionalize(\n            z.object({\n              username: optionalize(z.string()),\n              password: optionalize(z.string()),\n            }),\n          ),\n        }),\n      ),\n    })\n    .refine((data) => data.repoPath || data.remoteUrl, {\n      message: \"Either repoPath or remoteUrl must be provided\",\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    const instance = new AFSGit({ ...valid, cwd: dirname(filepath) });\n    await instance.ready();\n    return instance;\n  }\n\n  private initPromise: Promise<void>;\n  private git: SimpleGit;\n  private tempBase: string;\n  private worktrees: Map<string, string> = new Map();\n  private repoHash: string;\n  private isAutoCloned = false;\n  private clonedPath?: string;\n  private repoPath: string;\n\n  constructor(public options: AFSGitOptions & { cwd?: string }) {\n    zodParse(afsGitOptionsSchema, options);\n\n    // Synchronously determine repoPath to initialize name\n    let repoPath: string;\n    let repoName: string;\n\n    if (options.repoPath) {\n      // Use provided repoPath\n      repoPath = isAbsolute(options.repoPath)\n        ? options.repoPath\n        : join(options.cwd || process.cwd(), options.repoPath);\n      repoName = basename(repoPath);\n    } else if (options.remoteUrl) {\n      // Extract repo name from URL for temporary name\n      const urlParts = options.remoteUrl.split(\"/\");\n      const lastPart = urlParts[urlParts.length - 1];\n      repoName = lastPart?.replace(/\\.git$/, \"\") || \"git\";\n\n      // Will be updated during async init, use temp path for now\n      const repoHash = createHash(\"md5\").update(options.remoteUrl).digest(\"hex\").substring(0, 8);\n      repoPath = join(tmpdir(), `afs-git-remote-${repoHash}`);\n    } else {\n      // This should never happen due to schema validation\n      throw new Error(\"Either repoPath or remoteUrl must be provided\");\n    }\n\n    // Initialize basic properties immediately\n    this.repoPath = repoPath;\n    this.name = options.name || repoName;\n    this.description = options.description;\n    this.accessMode = options.accessMode ?? \"readonly\";\n\n    // Calculate hash for temp directories\n    this.repoHash = createHash(\"md5\").update(repoPath).digest(\"hex\").substring(0, 8);\n    this.tempBase = join(tmpdir(), `afs-git-${this.repoHash}`);\n\n    // Note: git and other properties will be initialized in initialize() after cloning\n    // We need to delay simpleGit() initialization until the directory exists\n    this.git = null as any; // Will be set in initialize()\n\n    // Start async initialization (cloning if needed)\n    this.initPromise = this.initialize();\n  }\n\n  /**\n   * Wait for async initialization to complete\n   */\n  async ready(): Promise<void> {\n    await this.initPromise;\n  }\n\n  /**\n   * Async initialization logic (runs in constructor)\n   * Handles cloning remote repositories if needed\n   */\n  private async initialize(): Promise<void> {\n    const options = this.options;\n\n    // If remoteUrl is provided, handle cloning\n    if (options.remoteUrl) {\n      const targetPath = options.repoPath\n        ? isAbsolute(options.repoPath)\n          ? options.repoPath\n          : join(options.cwd || process.cwd(), options.repoPath)\n        : this.repoPath; // Use temp path set in constructor\n\n      // Mark as auto-cloned if we're using temp directory\n      if (!options.repoPath) {\n        this.isAutoCloned = true;\n      }\n\n      // Check if repoPath exists, if not, clone to it\n      const exists = await stat(targetPath)\n        .then(() => true)\n        .catch(() => false);\n\n      if (!exists) {\n        // Determine if single-branch optimization should be used\n        const singleBranch = options.branches?.length === 1 ? options.branches[0] : undefined;\n\n        await AFSGit.cloneRepository(options.remoteUrl, targetPath, {\n          depth: options.depth ?? 1,\n          branch: singleBranch,\n          auth: options.cloneOptions?.auth,\n        });\n      }\n\n      // Update properties if targetPath differs from constructor initialization\n      if (targetPath !== this.repoPath) {\n        this.repoPath = targetPath;\n        this.repoHash = createHash(\"md5\").update(targetPath).digest(\"hex\").substring(0, 8);\n        this.tempBase = join(tmpdir(), `afs-git-${this.repoHash}`);\n      }\n\n      this.clonedPath = this.isAutoCloned ? targetPath : undefined;\n    }\n\n    // Now that the directory exists (either it was there or we cloned it), initialize git\n    this.git = simpleGit(this.repoPath);\n  }\n\n  /**\n   * Clone a remote repository to local path\n   */\n  private static async cloneRepository(\n    remoteUrl: string,\n    targetPath: string,\n    options: {\n      depth?: number;\n      branch?: string;\n      auth?: { username?: string; password?: string };\n    } = {},\n  ): Promise<void> {\n    const git = simpleGit();\n\n    // Build clone options\n    const cloneArgs: string[] = [];\n\n    if (options.depth) {\n      cloneArgs.push(\"--depth\", options.depth.toString());\n    }\n\n    if (options.branch) {\n      cloneArgs.push(\"--branch\", options.branch, \"--single-branch\");\n    }\n\n    // Handle authentication in URL if provided\n    let cloneUrl = remoteUrl;\n    if (options.auth?.username && options.auth?.password) {\n      // Insert credentials into HTTPS URL\n      if (remoteUrl.startsWith(\"https://\")) {\n        const url = new URL(remoteUrl);\n        url.username = encodeURIComponent(options.auth.username);\n        url.password = encodeURIComponent(options.auth.password);\n        cloneUrl = url.toString();\n      }\n    }\n\n    await git.clone(cloneUrl, targetPath, cloneArgs);\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.repoPath);\n      return this.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    await this.ready();\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    await this.ready();\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    await this.ready();\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, { encoding: \"utf8\", flag: append ? \"a\" : \"w\" });\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    await this.ready();\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    await this.ready();\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    await this.ready();\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   * Fetch latest changes from remote\n   */\n  async fetch(): Promise<void> {\n    await this.ready();\n    await this.git.fetch();\n  }\n\n  /**\n   * Pull latest changes from remote for current branch\n   */\n  async pull(): Promise<void> {\n    await this.ready();\n    await this.git.pull();\n  }\n\n  /**\n   * Push local changes to remote\n   */\n  async push(branch?: string): Promise<void> {\n    await this.ready();\n    if (branch) {\n      await this.git.push(\"origin\", branch);\n    } else {\n      await this.git.push();\n    }\n  }\n\n  /**\n   * Cleanup all worktrees (useful when unmounting)\n   */\n  async cleanup(): Promise<void> {\n    await this.ready();\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    // Cleanup cloned repository if auto-cloned and autoCleanup enabled\n    const autoCleanup = this.options.autoCleanup ?? true;\n    if (this.isAutoCloned && autoCleanup && this.clonedPath) {\n      try {\n        await rm(this.clonedPath, { recursive: true, force: true });\n      } catch {\n        // Ignore cleanup errors\n      }\n    }\n  }\n}\n\nconst _typeCheck: AFSModuleClass<AFSGit, AFSGitOptions> = AFSGit;\n"],"mappings":"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"}

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@aigne/afs-git",
-  "version": "1.11.0-beta",
+  "version": "1.11.0-beta.1",
   "description": "AIGNE AFS module for git storage",
-  "license": "Elastic-2.0",
+  "license": "UNLICENSED",
   "publishConfig": {
     "access": "public"
   },
@@ -35,7 +35,7 @@
   "dependencies": {
     "simple-git": "^3.27.0",
     "zod": "^3.25.67",
-    "@aigne/afs": "^1.11.0-beta"
+    "@aigne/afs": "^1.11.0-beta.1"
   },
   "devDependencies": {
     "@types/bun": "^1.3.6",