refactor: move worktree hooks to core/hooks and add post-create hook

- Relocate pre-remove command execution from util to hooks/preRemoveWorktree
- Run postCreateCmd via postCreateWorktree after successful worktree creation
- Wire createWorktreeFromInfo and removeWorktreeCmd to the new hook modules
- Remove legacy util/preRemoveWorktree implementation

Author: jackiotyu

src/core/command/createWorktreeFromInfo.ts

@@ -3,7 +3,7 @@ import { addWorktree } from '@/core/git/addWorktree';
 import { getMainFolder } from '@/core/git/getMainFolder';
 import { confirmModal } from '@/core/ui/modal';
 import { copyWorktreeFiles } from '@/core/util/copyWorktreeFiles';
-import { postCreateWorktree } from '@/core/util/postCreateWorktree';
+import { postCreateWorktree } from '@/core/hooks/postCreateWorktree';
 import { actionProgressWrapper } from '@/core/ui/progress';
 import { withResolvers } from '@/core/util/promise';
 import type { ICreateWorktreeInfo } from '@/types';

src/core/command/removeWorktreeCmd.ts

@@ -10,7 +10,7 @@ import logger from '@/core/log/logger';
 import { Config } from '@/core/config/setting';
 import { actionProgressWrapper } from '@/core/ui/progress';
 import { withResolvers } from '@/core/util/promise';
-import { preRemoveWorktree } from '@/core/util/preRemoveWorktree';
+import { preRemoveWorktree } from '@/core/hooks/preRemoveWorktree';
 import { IBranchForWorktree, IWorktreeLess } from '@/types';
 
 async function showDeleteConfirmation(worktreePath: string): Promise<'remove' | 'force' | undefined> {

src/core/hooks/postCreateWorktree.ts

@@ -0,0 +1,34 @@
+import * as vscode from 'vscode';
+import { Config } from '@/core/config/setting';
+import { runWorktreeHookCommand } from '@/core/hooks/runWorktreeHookCommand';
+import logger from '@/core/log/logger';
+
+interface IPostCreateWorktreeInfo {
+    worktreePath: string;
+    basePath: string;
+}
+
+export async function postCreateWorktree(info: IPostCreateWorktreeInfo): Promise<void> {
+    const { worktreePath, basePath } = info;
+    const postCreateCmd = Config.get('postCreateCmd', '');
+
+    if (!postCreateCmd) {
+        return;
+    }
+
+    const cmdStr = postCreateCmd.replace('$BASE_PATH', basePath).replace('$WORKTREE_PATH', worktreePath);
+
+    await runWorktreeHookCommand({
+        cmdStr,
+        worktreePath,
+        progressTitle: vscode.l10n.t('Running post-create command...'),
+        logTag: 'postCreateWorktree',
+        onExecError: (error: unknown) => {
+            const err = error as { name?: string };
+            if (err.name === 'AbortError') {
+                return;
+            }
+            logger.error(`[postCreateWorktree] ${error}`);
+        },
+    });
+}

src/core/hooks/preRemoveWorktree.ts

@@ -0,0 +1,39 @@
+import * as vscode from 'vscode';
+import { Config } from '@/core/config/setting';
+import { runWorktreeHookCommand } from '@/core/hooks/runWorktreeHookCommand';
+import logger from '@/core/log/logger';
+
+interface IPreRemoveWorktreeInfo {
+    worktreePath: string;
+    basePath: string;
+}
+
+/**
+ * Runs the user-configured `preRemoveCmd` inside the worktree directory
+ * before it is removed. Throws on failure so the caller can abort removal.
+ */
+export async function preRemoveWorktree(info: IPreRemoveWorktreeInfo): Promise<void> {
+    const { worktreePath, basePath } = info;
+    const preRemoveCmd = Config.get('preRemoveCmd', '');
+
+    if (!preRemoveCmd) {
+        return;
+    }
+
+    const cmdStr = preRemoveCmd.replace('$BASE_PATH', basePath).replace('$WORKTREE_PATH', worktreePath);
+
+    await runWorktreeHookCommand({
+        cmdStr,
+        worktreePath,
+        progressTitle: vscode.l10n.t('Running pre-remove command...'),
+        logTag: 'preRemoveWorktree',
+        onExecError: (error: unknown) => {
+            const err = error as { name?: string; message?: string };
+            logger.error(`[preRemoveWorktree] ${error}`);
+            if (err.name === 'AbortError') {
+                throw new Error(vscode.l10n.t('Pre-remove command was cancelled'));
+            }
+            throw new Error(vscode.l10n.t('Pre-remove command failed: {0}', err.message ?? String(error)));
+        },
+    });
+}

src/core/util/postCreateWorktree.ts src/core/hooks/runWorktreeHookCommand.tssrc/core/util/postCreateWorktree.ts renamed to src/core/hooks/runWorktreeHookCommand.ts

@@ -1,35 +1,38 @@
 import * as vscode from 'vscode';
-import { Config } from '@/core/config/setting';
 import { exec } from 'child_process';
 import { promisify } from 'util';
 import { withResolvers } from '@/core/util/promise';
 import { actionProgressWrapper } from '@/core/ui/progress';
 import logger from '@/core/log/logger';
 
-interface IPostCreateWorktreeInfo {
+export interface RunWorktreeHookCommandParams {
+    /** Final shell command after the caller substituted placeholders. */
+    cmdStr: string;
     worktreePath: string;
-    basePath: string;
+    progressTitle: string;
+    logTag: string;
+    /** Invoked when `exec` fails or the child errors; caller may swallow or throw. */
+    onExecError: (error: unknown) => void;
 }
-export async function postCreateWorktree(info: IPostCreateWorktreeInfo) {
-    const { worktreePath, basePath } = info;
-    const postCreateCmd = Config.get('postCreateCmd', '');
 
-    if (!postCreateCmd) return;
+/**
+ * Runs a user-configured worktree hook command (shared by post-create and pre-remove).
+ * Cancellation and `finally` ordering match legacy behavior; runtime errors go through `onExecError`.
+ */
+export async function runWorktreeHookCommand(params: RunWorktreeHookCommandParams): Promise<void> {
+    const { cmdStr, worktreePath, progressTitle, logTag, onExecError } = params;
 
     const waiting = withResolvers<void>();
     const abortController = new AbortController();
     const tokenSource = new vscode.CancellationTokenSource();
-    // Setup cancellation handling
+
     const disposeAbortSignal = tokenSource.token.onCancellationRequested(() => {
-        waiting.resolve();
         abortController.abort();
     });
 
     try {
-        const cmdStr = postCreateCmd.replace('$BASE_PATH', basePath).replace('$WORKTREE_PATH', worktreePath);
-
         actionProgressWrapper(
-            vscode.l10n.t('Running post-create command...'),
+            progressTitle,
             () => waiting.promise,
             () => {},
             tokenSource,
@@ -38,27 +41,22 @@ export async function postCreateWorktree(info: IPostCreateWorktreeInfo) {
         const execPromise = promisify(exec);
 
         const execChild = execPromise(cmdStr, {
-            cwd: worktreePath, // 默认工作目录是 worktree 目录
+            cwd: worktreePath,
             env: process.env,
             signal: abortController.signal,
             encoding: 'buffer',
         });
         execChild.child.stdout?.on('data', (data) => {
-            logger.log(`[postCreateWorktree] ${data.toString()}`);
+            logger.log(`[${logTag}] ${data.toString()}`);
         });
         execChild.child.stderr?.on('data', (data) => {
-            logger.error(`[postCreateWorktree] ${data.toString()}`);
+            logger.error(`[${logTag}] ${data.toString()}`);
         });
 
         await execChild;
-        waiting.resolve();
-        logger.log(`[postCreateWorktree] done`);
-    } catch (error: any) {
-        if (error.name === 'AbortError') {
-            // Ignore abort errors
-            return;
-        }
-        logger.error(`[postCreateWorktree] ${error}`);
+        logger.log(`[${logTag}] done`);
+    } catch (error: unknown) {
+        onExecError(error);
     } finally {
         disposeAbortSignal.dispose();
         tokenSource.dispose();