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

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,GAyCxB,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,18 +315,36 @@ 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);
-			return {
-				id: encodedPath,
-				path: encodedPath,
-				metadata: { type: "directory" }
-			};
-		}) };
+		const maxDepth = options?.maxDepth ?? 1;
+		const limit = Math.min(options?.limit || LIST_MAX_LIMIT, LIST_MAX_LIMIT);
+		if (!branch) {
+			const branches = await this.getBranches();
+			const entries = [];
+			for (const name of branches) {
+				if (entries.length >= limit) break;
+				const encodedPath = this.buildPath(name);
+				entries.push({
+					id: encodedPath,
+					path: encodedPath,
+					metadata: { type: "directory" }
+				});
+				if (maxDepth > 1) {
+					const branchResult = await this.listWithGitLsTree(name, "", {
+						...options,
+						maxDepth: maxDepth - 1,
+						limit: limit - entries.length
+					});
+					entries.push(...branchResult.data);
+				}
+			}
+			return { data: entries };
+		}
 		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 +413,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 +458,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 +481,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 +512,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 +571,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 +612,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 {}
 	}
 };