ccmanager 3.8.1 → 3.9.0

package/dist/components/Configuration.js

@@ -7,6 +7,7 @@ import ConfigureStatusHooks from './ConfigureStatusHooks.js';
 import ConfigureWorktreeHooks from './ConfigureWorktreeHooks.js';
 import ConfigureWorktree from './ConfigureWorktree.js';
 import ConfigureCommand from './ConfigureCommand.js';
+import ConfigureMerge from './ConfigureMerge.js';
 import ConfigureOther from './ConfigureOther.js';
 import { shortcutManager } from '../services/shortcutManager.js';
 import { ConfigEditorProvider } from '../contexts/ConfigEditorContext.js';
@@ -34,6 +35,10 @@ const ConfigurationContent = ({ scope, onComplete }) => {
             label: 'C 🚀  Configure Command Presets',
             value: 'presets',
         },
+        {
+            label: 'M 🔀  Configure Merge/Rebase',
+            value: 'mergeConfig',
+        },
         {
             label: 'O 🧪  Other & Experimental',
             value: 'other',
@@ -62,6 +67,9 @@ const ConfigurationContent = ({ scope, onComplete }) => {
         else if (item.value === 'presets') {
             setView('presets');
         }
+        else if (item.value === 'mergeConfig') {
+            setView('mergeConfig');
+        }
         else if (item.value === 'other') {
             setView('other');
         }
@@ -90,6 +98,9 @@ const ConfigurationContent = ({ scope, onComplete }) => {
             case 'c':
                 setView('presets');
                 break;
+            case 'm':
+                setView('mergeConfig');
+                break;
             case 'o':
                 setView('other');
                 break;
@@ -117,6 +128,9 @@ const ConfigurationContent = ({ scope, onComplete }) => {
     if (view === 'presets') {
         return _jsx(ConfigureCommand, { onComplete: handleSubMenuComplete });
     }
+    if (view === 'mergeConfig') {
+        return _jsx(ConfigureMerge, { onComplete: handleSubMenuComplete });
+    }
     if (view === 'other') {
         return _jsx(ConfigureOther, { onComplete: handleSubMenuComplete });
     }

package/dist/components/ConfigureMerge.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface ConfigureMergeProps {
+    onComplete: () => void;
+}
+declare const ConfigureMerge: React.FC<ConfigureMergeProps>;
+export default ConfigureMerge;

package/dist/components/ConfigureMerge.js

@@ -0,0 +1,81 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import SelectInput from 'ink-select-input';
+import TextInputWrapper from './TextInputWrapper.js';
+import { useConfigEditor } from '../contexts/ConfigEditorContext.js';
+import { shortcutManager } from '../services/shortcutManager.js';
+const DEFAULT_MERGE_ARGS = ['--no-ff'];
+const DEFAULT_REBASE_ARGS = [];
+const ConfigureMerge = ({ onComplete }) => {
+    const configEditor = useConfigEditor();
+    const scope = configEditor.getScope();
+    const currentConfig = configEditor.getMergeConfig() || {};
+    const [mergeConfig, setMergeConfig] = useState(currentConfig);
+    const [editField, setEditField] = useState(null);
+    const [inputValue, setInputValue] = useState('');
+    const isInheriting = scope === 'project' && !configEditor.hasProjectOverride('mergeConfig');
+    const getMergeArgs = () => mergeConfig.mergeArgs ?? DEFAULT_MERGE_ARGS;
+    const getRebaseArgs = () => mergeConfig.rebaseArgs ?? DEFAULT_REBASE_ARGS;
+    const formatArgs = (args) => args.length > 0 ? args.join(' ') : '(none)';
+    const menuItems = [
+        {
+            label: `Merge Arguments: ${formatArgs(getMergeArgs())}`,
+            value: 'mergeArgs',
+        },
+        {
+            label: `Rebase Arguments: ${formatArgs(getRebaseArgs())}`,
+            value: 'rebaseArgs',
+        },
+        { label: '-----', value: 'separator' },
+        { label: '<- Back', value: 'back' },
+    ];
+    const handleSelect = (item) => {
+        if (item.value === 'separator')
+            return;
+        if (item.value === 'back') {
+            onComplete();
+            return;
+        }
+        const field = item.value;
+        setEditField(field);
+        switch (field) {
+            case 'mergeArgs':
+                setInputValue(getMergeArgs().join(' '));
+                break;
+            case 'rebaseArgs':
+                setInputValue(getRebaseArgs().join(' '));
+                break;
+        }
+    };
+    const handleFieldUpdate = (value) => {
+        const args = value.trim() ? value.trim().split(/\s+/) : [];
+        const updated = { ...mergeConfig, [editField]: args };
+        setMergeConfig(updated);
+        configEditor.setMergeConfig(updated);
+        setEditField(null);
+        setInputValue('');
+    };
+    useInput((input, key) => {
+        if (shortcutManager.matchesShortcut('cancel', input, key)) {
+            if (editField) {
+                setEditField(null);
+                setInputValue('');
+            }
+            else {
+                onComplete();
+            }
+            return;
+        }
+    });
+    if (editField) {
+        const titles = {
+            mergeArgs: 'Enter merge arguments (space-separated, default: --no-ff):',
+            rebaseArgs: 'Enter rebase arguments (space-separated, default: none):',
+        };
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "green", children: "Edit Merge Config" }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: titles[editField] }) }), _jsx(Box, { children: _jsx(TextInputWrapper, { value: inputValue, onChange: setInputValue, onSubmit: handleFieldUpdate, placeholder: "e.g., --no-ff or leave empty" }) }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["Press Enter to save, ", shortcutManager.getShortcutDisplay('cancel'), ' ', "to cancel"] }) })] }));
+    }
+    const scopeLabel = scope === 'project' ? 'Project' : 'Global';
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { bold: true, color: "green", children: ["Configure Merge/Rebase (", scopeLabel, ")"] }) }), isInheriting && (_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { backgroundColor: "cyan", color: "black", children: [' ', "Inheriting from global configuration", ' '] }) })), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: "Configure arguments for merge and rebase operations" }) }), _jsx(SelectInput, { items: menuItems, onSelect: handleSelect }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["Press Enter to edit, ", shortcutManager.getShortcutDisplay('cancel'), " to go back"] }) })] }));
+};
+export default ConfigureMerge;

package/dist/components/MergeWorktree.js

@@ -4,6 +4,7 @@ import { Box, Text, useInput } from 'ink';
 import SelectInput from 'ink-select-input';
 import { Effect } from 'effect';
 import { WorktreeService } from '../services/worktreeService.js';
+import { configReader } from '../services/config/configReader.js';
 import Confirmation, { SimpleConfirmation } from './Confirmation.js';
 import { shortcutManager } from '../services/shortcutManager.js';
 import { GitError } from '../types/errors.js';
@@ -14,9 +15,10 @@ const MergeWorktree = ({ onComplete, onCancel, }) => {
     const [targetBranch, setTargetBranch] = useState('');
     const [branchItems, setBranchItems] = useState([]);
     const [originalBranchItems, setOriginalBranchItems] = useState([]);
-    const [useRebase, setUseRebase] = useState(false);
+    const [operation, setOperation] = useState('merge');
     const [mergeError, setMergeError] = useState(null);
     const [worktreeService] = useState(() => new WorktreeService());
+    const [mergeConfig] = useState(() => configReader.getMergeConfig());
     const [isLoading, setIsLoading] = useState(true);
     const [loadError, setLoadError] = useState(null);
     useEffect(() => {
@@ -83,7 +85,7 @@ const MergeWorktree = ({ onComplete, onCancel, }) => {
             return;
         const performMerge = async () => {
             try {
-                await Effect.runPromise(worktreeService.mergeWorktreeEffect(sourceBranch, targetBranch, useRebase));
+                await Effect.runPromise(worktreeService.mergeWorktreeEffect(sourceBranch, targetBranch, operation, mergeConfig));
                 // Merge successful, check for uncommitted changes before asking about deletion
                 setStep('check-uncommitted');
             }
@@ -99,7 +101,14 @@ const MergeWorktree = ({ onComplete, onCancel, }) => {
             }
         };
         performMerge();
-    }, [step, sourceBranch, targetBranch, useRebase, worktreeService]);
+    }, [
+        step,
+        sourceBranch,
+        targetBranch,
+        operation,
+        mergeConfig,
+        worktreeService,
+    ]);
     // Check for uncommitted changes in source worktree when entering check-uncommitted step
     useEffect(() => {
         if (step !== 'check-uncommitted')
@@ -140,7 +149,7 @@ const MergeWorktree = ({ onComplete, onCancel, }) => {
         const message = (_jsxs(Text, { children: ["Choose how to integrate ", _jsx(Text, { color: "yellow", children: sourceBranch }), " into", ' ', _jsx(Text, { color: "yellow", children: targetBranch }), ":"] }));
         const hint = (_jsxs(Text, { dimColor: true, children: ["Use \u2191\u2193/j/k to navigate, Enter to select,", ' ', shortcutManager.getShortcutDisplay('cancel'), " to cancel"] }));
         const handleOperationSelect = (value) => {
-            setUseRebase(value === 'rebase');
+            setOperation(value);
             setStep('confirm-merge');
         };
         return (_jsx(Confirmation, { title: title, message: message, options: [
@@ -149,14 +158,18 @@ const MergeWorktree = ({ onComplete, onCancel, }) => {
             ], onSelect: handleOperationSelect, initialIndex: 0, hint: hint }));
     }
     if (step === 'confirm-merge') {
-        const confirmMessage = (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { bold: true, color: "green", children: ["Confirm ", useRebase ? 'Rebase' : 'Merge'] }) }), _jsxs(Text, { children: [useRebase ? 'Rebase' : 'Merge', ' ', _jsx(Text, { color: "yellow", children: sourceBranch }), ' ', useRebase ? 'onto' : 'into', ' ', _jsx(Text, { color: "yellow", children: targetBranch }), "?"] })] }));
+        const operationLabel = operation === 'rebase' ? 'Rebase' : 'Merge';
+        const preposition = operation === 'rebase' ? 'onto' : 'into';
+        const confirmMessage = (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { bold: true, color: "green", children: ["Confirm ", operationLabel] }) }), _jsxs(Text, { children: [operationLabel, " ", _jsx(Text, { color: "yellow", children: sourceBranch }), ' ', preposition, " ", _jsx(Text, { color: "yellow", children: targetBranch }), "?"] })] }));
         return (_jsx(SimpleConfirmation, { message: confirmMessage, onConfirm: () => setStep('executing-merge'), onCancel: onCancel }));
     }
     if (step === 'executing-merge') {
-        return (_jsx(Box, { flexDirection: "column", children: _jsxs(Text, { color: "green", children: [useRebase ? 'Rebasing' : 'Merging', " branches..."] }) }));
+        const executingLabel = operation === 'rebase' ? 'Rebasing' : 'Merging';
+        return (_jsx(Box, { flexDirection: "column", children: _jsxs(Text, { color: "green", children: [executingLabel, " branches..."] }) }));
     }
     if (step === 'merge-error') {
-        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { bold: true, color: "red", children: [useRebase ? 'Rebase' : 'Merge', " Failed"] }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: "red", children: mergeError }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press any key to return to menu" }) })] }));
+        const errorLabel = operation === 'rebase' ? 'Rebase' : 'Merge';
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { bold: true, color: "red", children: [errorLabel, " Failed"] }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: "red", children: mergeError }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press any key to return to menu" }) })] }));
     }
     if (step === 'check-uncommitted') {
         return (_jsx(Box, { flexDirection: "column", children: _jsx(Text, { color: "cyan", children: "Checking for uncommitted changes..." }) }));

package/dist/services/config/configEditor.d.ts

@@ -1,4 +1,4 @@
-import { ConfigScope, ProjectConfigurationData, ShortcutConfig, StatusHookConfig, WorktreeHookConfig, WorktreeConfig, CommandPresetsConfig, IConfigEditor, AutoApprovalConfig } from '../../types/index.js';
+import { ConfigScope, ProjectConfigurationData, ShortcutConfig, StatusHookConfig, WorktreeHookConfig, WorktreeConfig, CommandPresetsConfig, MergeConfig, IConfigEditor, AutoApprovalConfig } from '../../types/index.js';
 /**
  * ConfigEditor provides scope-aware configuration editing.
  * The scope is determined at construction time.
@@ -24,6 +24,8 @@ export declare class ConfigEditor implements IConfigEditor {
     setWorktreeConfig(value: WorktreeConfig): void;
     getCommandPresets(): CommandPresetsConfig | undefined;
     setCommandPresets(value: CommandPresetsConfig): void;
+    getMergeConfig(): MergeConfig | undefined;
+    setMergeConfig(value: MergeConfig): void;
     getAutoApprovalConfig(): AutoApprovalConfig | undefined;
     setAutoApprovalConfig(value: AutoApprovalConfig): void;
     reload(): void;

package/dist/services/config/configEditor.js

@@ -77,6 +77,19 @@ export class ConfigEditor {
     setCommandPresets(value) {
         this.configEditor.setCommandPresets(value);
     }
+    getMergeConfig() {
+        const globalConfig = globalConfigManager.getMergeConfig();
+        const scopedConfig = this.configEditor.getMergeConfig();
+        if (!globalConfig && !scopedConfig)
+            return undefined;
+        return {
+            ...(globalConfig || {}),
+            ...(scopedConfig || {}),
+        };
+    }
+    setMergeConfig(value) {
+        this.configEditor.setMergeConfig(value);
+    }
     getAutoApprovalConfig() {
         const globalConfig = globalConfigManager.getAutoApprovalConfig();
         const scopedConfig = this.configEditor.getAutoApprovalConfig();

package/dist/services/config/configReader.d.ts

@@ -1,5 +1,5 @@
 import { Either } from 'effect';
-import { ShortcutConfig, StatusHookConfig, WorktreeHookConfig, WorktreeConfig, CommandPresetsConfig, CommandPreset, ConfigurationData, IConfigReader } from '../../types/index.js';
+import { ShortcutConfig, StatusHookConfig, WorktreeHookConfig, WorktreeConfig, CommandPresetsConfig, MergeConfig, CommandPreset, ConfigurationData, IConfigReader } from '../../types/index.js';
 import { ValidationError } from '../../types/errors.js';
 /**
  * ConfigReader provides merged configuration reading for runtime components.
@@ -14,6 +14,7 @@ export declare class ConfigReader implements IConfigReader {
     getWorktreeHooks(): WorktreeHookConfig;
     getWorktreeConfig(): WorktreeConfig;
     getCommandPresets(): CommandPresetsConfig;
+    getMergeConfig(): MergeConfig | undefined;
     getConfiguration(): ConfigurationData;
     getAutoApprovalConfig(): NonNullable<ConfigurationData['autoApproval']>;
     isAutoApprovalEnabled(): boolean;

package/dist/services/config/configReader.js

@@ -57,6 +57,17 @@ export class ConfigReader {
             ...(projectConfig || {}),
         };
     }
+    // Merge Config - returns merged value (project fields override global fields)
+    getMergeConfig() {
+        const globalConfig = globalConfigManager.getMergeConfig();
+        const projectConfig = projectConfigManager.getMergeConfig();
+        if (!globalConfig && !projectConfig)
+            return undefined;
+        return {
+            ...(globalConfig || {}),
+            ...(projectConfig || {}),
+        };
+    }
     // Get full merged configuration
     getConfiguration() {
         return {
@@ -65,6 +76,7 @@ export class ConfigReader {
             worktreeHooks: this.getWorktreeHooks(),
             worktree: this.getWorktreeConfig(),
             commandPresets: this.getCommandPresets(),
+            mergeConfig: this.getMergeConfig(),
             autoApproval: this.getAutoApprovalConfig(),
         };
     }

package/dist/services/config/globalConfigManager.d.ts

@@ -1,4 +1,4 @@
-import { ConfigurationData, StatusHookConfig, WorktreeHookConfig, ShortcutConfig, WorktreeConfig, CommandPresetsConfig, IConfigEditor } from '../../types/index.js';
+import { ConfigurationData, StatusHookConfig, WorktreeHookConfig, ShortcutConfig, WorktreeConfig, CommandPresetsConfig, MergeConfig, IConfigEditor } from '../../types/index.js';
 declare class GlobalConfigManager implements IConfigEditor {
     private configPath;
     private legacyShortcutsPath;
@@ -21,6 +21,8 @@ declare class GlobalConfigManager implements IConfigEditor {
     private ensureDefaultPresets;
     getCommandPresets(): CommandPresetsConfig;
     setCommandPresets(presets: CommandPresetsConfig): void;
+    getMergeConfig(): MergeConfig | undefined;
+    setMergeConfig(mergeConfig: MergeConfig): void;
     /**
      * Reload configuration from disk
      */

package/dist/services/config/globalConfigManager.js

@@ -191,6 +191,13 @@ class GlobalConfigManager {
         this.config.commandPresets = presets;
         this.saveConfig();
     }
+    getMergeConfig() {
+        return this.config.mergeConfig;
+    }
+    setMergeConfig(mergeConfig) {
+        this.config.mergeConfig = mergeConfig;
+        this.saveConfig();
+    }
     /**
      * Reload configuration from disk
      */

package/dist/services/config/projectConfigManager.d.ts

@@ -1,4 +1,4 @@
-import { ProjectConfigurationData, ShortcutConfig, StatusHookConfig, WorktreeHookConfig, WorktreeConfig, CommandPresetsConfig, IConfigEditor, AutoApprovalConfig } from '../../types/index.js';
+import { ProjectConfigurationData, ShortcutConfig, StatusHookConfig, WorktreeHookConfig, WorktreeConfig, CommandPresetsConfig, MergeConfig, IConfigEditor, AutoApprovalConfig } from '../../types/index.js';
 /**
  * ProjectConfigManager handles project-specific configuration.
  * Reads/writes from `<git repository root>/.ccmanager.json`.
@@ -22,6 +22,8 @@ declare class ProjectConfigManager implements IConfigEditor {
     setWorktreeConfig(value: WorktreeConfig): void;
     getCommandPresets(): CommandPresetsConfig | undefined;
     setCommandPresets(value: CommandPresetsConfig): void;
+    getMergeConfig(): MergeConfig | undefined;
+    setMergeConfig(value: MergeConfig): void;
     getAutoApprovalConfig(): AutoApprovalConfig | undefined;
     setAutoApprovalConfig(value: AutoApprovalConfig): void;
     reload(): void;

package/dist/services/config/projectConfigManager.js

@@ -110,6 +110,14 @@ class ProjectConfigManager {
         config.commandPresets = value;
         this.saveProjectConfig();
     }
+    getMergeConfig() {
+        return this.projectConfig?.mergeConfig;
+    }
+    setMergeConfig(value) {
+        const config = this.ensureProjectConfig();
+        config.mergeConfig = value;
+        this.saveProjectConfig();
+    }
     getAutoApprovalConfig() {
         return this.projectConfig?.autoApproval;
     }

package/dist/services/worktreeService.d.ts

@@ -1,5 +1,5 @@
 import { Effect } from 'effect';
-import { Worktree } from '../types/index.js';
+import { Worktree, MergeConfig } from '../types/index.js';
 import { GitError, FileSystemError, ProcessError } from '../types/errors.js';
 /**
  * Get all worktree last opened timestamps
@@ -361,33 +361,11 @@ export declare class WorktreeService {
      *
      * @param {string} sourceBranch - Branch to merge from
      * @param {string} targetBranch - Branch to merge into
-     * @param {boolean} useRebase - Whether to use rebase instead of merge (default: false)
+     * @param {'merge' | 'rebase'} operation - The merge operation to perform (default: 'merge')
+     * @param {MergeConfig} mergeConfig - Optional configuration for merge/rebase arguments
      * @returns {Effect.Effect<void, GitError, never>} Effect that completes successfully or fails with GitError
      *
-     * @example
-     * ```typescript
-     * // Merge with Effect.all for parallel operations
-     * await Effect.runPromise(
-     *   Effect.all([
-     *     effect1,
-     *     effect2
-     *   ], {concurrency: 1}) // Sequential to avoid conflicts
-     * );
-     *
-     * // Or use Effect.catchAll for fallback behavior
-     * const result = await Effect.runPromise(
-     *   Effect.catchAll(
-     *     effect,
-     *     (error: GitError) => {
-     *       console.error(`Merge failed: ${error.stderr}`);
-     *       // Return alternative Effect or rethrow
-     *       return Effect.fail(error);
-     *     }
-     *   )
-     * );
-     * ```
-     *
      * @throws {GitError} When git merge/rebase command fails or worktrees not found
      */
-    mergeWorktreeEffect(sourceBranch: string, targetBranch: string, useRebase?: boolean): Effect.Effect<void, GitError, never>;
+    mergeWorktreeEffect(sourceBranch: string, targetBranch: string, operation?: 'merge' | 'rebase', mergeConfig?: MergeConfig): Effect.Effect<void, GitError, never>;
 }

package/dist/services/worktreeService.js

@@ -944,35 +944,13 @@ export class WorktreeService {
      *
      * @param {string} sourceBranch - Branch to merge from
      * @param {string} targetBranch - Branch to merge into
-     * @param {boolean} useRebase - Whether to use rebase instead of merge (default: false)
+     * @param {'merge' | 'rebase'} operation - The merge operation to perform (default: 'merge')
+     * @param {MergeConfig} mergeConfig - Optional configuration for merge/rebase arguments
      * @returns {Effect.Effect<void, GitError, never>} Effect that completes successfully or fails with GitError
      *
-     * @example
-     * ```typescript
-     * // Merge with Effect.all for parallel operations
-     * await Effect.runPromise(
-     *   Effect.all([
-     *     effect1,
-     *     effect2
-     *   ], {concurrency: 1}) // Sequential to avoid conflicts
-     * );
-     *
-     * // Or use Effect.catchAll for fallback behavior
-     * const result = await Effect.runPromise(
-     *   Effect.catchAll(
-     *     effect,
-     *     (error: GitError) => {
-     *       console.error(`Merge failed: ${error.stderr}`);
-     *       // Return alternative Effect or rethrow
-     *       return Effect.fail(error);
-     *     }
-     *   )
-     * );
-     * ```
-     *
      * @throws {GitError} When git merge/rebase command fails or worktrees not found
      */
-    mergeWorktreeEffect(sourceBranch, targetBranch, useRebase = false) {
+    mergeWorktreeEffect(sourceBranch, targetBranch, operation = 'merge', mergeConfig) {
         // eslint-disable-next-line @typescript-eslint/no-this-alias
         const self = this;
         return Effect.gen(function* () {
@@ -981,13 +959,13 @@ export class WorktreeService {
             const targetWorktree = worktrees.find(wt => wt.branch && wt.branch.replace('refs/heads/', '') === targetBranch);
             if (!targetWorktree) {
                 return yield* Effect.fail(new GitError({
-                    command: useRebase ? 'git rebase' : 'git merge',
+                    command: operation === 'rebase' ? 'git rebase' : 'git merge',
                     exitCode: 1,
                     stderr: 'Target branch worktree not found',
                 }));
             }
-            // Perform the merge or rebase in the target worktree
-            if (useRebase) {
+            if (operation === 'rebase') {
+                const rebaseArgs = mergeConfig?.rebaseArgs ?? [];
                 // For rebase, we need to checkout source branch and rebase it onto target
                 const sourceWorktree = worktrees.find(wt => wt.branch && wt.branch.replace('refs/heads/', '') === sourceBranch);
                 if (!sourceWorktree) {
@@ -998,9 +976,12 @@ export class WorktreeService {
                     }));
                 }
                 // Rebase source branch onto target branch
+                const rebaseCmd = `git rebase ${rebaseArgs.join(' ')} "${targetBranch}"`
+                    .replace(/\s+/g, ' ')
+                    .trim();
                 yield* Effect.try({
                     try: () => {
-                        execSync(`git rebase "${targetBranch}"`, {
+                        execSync(rebaseCmd, {
                             cwd: sourceWorktree.path,
                             encoding: 'utf8',
                         });
@@ -1008,7 +989,7 @@ export class WorktreeService {
                     catch: (error) => {
                         const execError = error;
                         return new GitError({
-                            command: `git rebase "${targetBranch}"`,
+                            command: rebaseCmd,
                             exitCode: execError.status || 1,
                             stderr: execError.stderr || String(error),
                             stdout: execError.stdout,
@@ -1036,9 +1017,11 @@ export class WorktreeService {
             }
             else {
                 // Regular merge
+                const mergeArgs = mergeConfig?.mergeArgs ?? ['--no-ff'];
+                const mergeCmd = `git merge ${mergeArgs.join(' ')} "${sourceBranch}"`;
                 yield* Effect.try({
                     try: () => {
-                        execSync(`git merge --no-ff "${sourceBranch}"`, {
+                        execSync(mergeCmd, {
                             cwd: targetWorktree.path,
                             encoding: 'utf8',
                         });
@@ -1046,7 +1029,7 @@ export class WorktreeService {
                     catch: (error) => {
                         const execError = error;
                         return new GitError({
-                            command: `git merge --no-ff "${sourceBranch}"`,
+                            command: mergeCmd,
                             exitCode: execError.status || 1,
                             stderr: execError.stderr || String(error),
                             stdout: execError.stdout,

package/dist/services/worktreeService.merge.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/worktreeService.merge.test.js

@@ -0,0 +1,179 @@
+import { describe, it, expect, afterAll, beforeEach } from 'vitest';
+import { execSync } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+import { Effect } from 'effect';
+import { WorktreeService } from './worktreeService.js';
+describe('WorktreeService mergeWorktreeEffect (real git)', () => {
+    const testDir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'ccmanager-merge-test-')));
+    const mainRepoDir = path.join(testDir, 'main-repo');
+    const sourceWorktreeDir = path.join(testDir, 'wt-source');
+    const targetWorktreeDir = path.join(testDir, 'wt-target');
+    const gitOpts = (cwd) => ({ cwd, encoding: 'utf8' });
+    const getCommitCount = (cwd) => {
+        const log = execSync('git log --oneline', gitOpts(cwd)).trim();
+        return log.split('\n').filter(l => l.length > 0).length;
+    };
+    const getLastCommitMessage = (cwd) => {
+        return execSync('git log -1 --format=%s', gitOpts(cwd)).trim();
+    };
+    const branchContainsFile = (cwd, filename) => {
+        return fs.existsSync(path.join(cwd, filename));
+    };
+    // Set up a fresh repo with source and target worktrees before each test
+    beforeEach(() => {
+        // Clean up previous iteration
+        if (fs.existsSync(mainRepoDir)) {
+            // Remove worktrees before deleting repo
+            try {
+                execSync(`git worktree remove "${sourceWorktreeDir}" --force`, gitOpts(mainRepoDir));
+            }
+            catch {
+                /* ignore */
+            }
+            try {
+                execSync(`git worktree remove "${targetWorktreeDir}" --force`, gitOpts(mainRepoDir));
+            }
+            catch {
+                /* ignore */
+            }
+            fs.rmSync(mainRepoDir, { recursive: true, force: true });
+        }
+        if (fs.existsSync(sourceWorktreeDir)) {
+            fs.rmSync(sourceWorktreeDir, { recursive: true, force: true });
+        }
+        if (fs.existsSync(targetWorktreeDir)) {
+            fs.rmSync(targetWorktreeDir, { recursive: true, force: true });
+        }
+        // Create main repository with initial commit
+        fs.mkdirSync(mainRepoDir, { recursive: true });
+        execSync('git init', gitOpts(mainRepoDir));
+        execSync('git config user.email "test@test.com"', gitOpts(mainRepoDir));
+        execSync('git config user.name "Test User"', gitOpts(mainRepoDir));
+        fs.writeFileSync(path.join(mainRepoDir, 'README.md'), '# Test Repo');
+        execSync('git add README.md', gitOpts(mainRepoDir));
+        execSync('git commit -m "Initial commit"', gitOpts(mainRepoDir));
+        // Create target branch + worktree
+        execSync('git branch target-branch', gitOpts(mainRepoDir));
+        execSync(`git worktree add "${targetWorktreeDir}" target-branch`, gitOpts(mainRepoDir));
+        // Create source branch + worktree
+        execSync('git branch source-branch', gitOpts(mainRepoDir));
+        execSync(`git worktree add "${sourceWorktreeDir}" source-branch`, gitOpts(mainRepoDir));
+        // Add commits to source branch
+        fs.writeFileSync(path.join(sourceWorktreeDir, 'feature-1.txt'), 'feature 1');
+        execSync('git add feature-1.txt', gitOpts(sourceWorktreeDir));
+        execSync('git commit -m "feat: add feature 1"', gitOpts(sourceWorktreeDir));
+        fs.writeFileSync(path.join(sourceWorktreeDir, 'feature-2.txt'), 'feature 2');
+        execSync('git add feature-2.txt', gitOpts(sourceWorktreeDir));
+        execSync('git commit -m "feat: add feature 2"', gitOpts(sourceWorktreeDir));
+    });
+    afterAll(() => {
+        if (fs.existsSync(testDir)) {
+            fs.rmSync(testDir, { recursive: true, force: true });
+        }
+    });
+    it('should merge with default --no-ff args', async () => {
+        const service = new WorktreeService(mainRepoDir);
+        await Effect.runPromise(service.mergeWorktreeEffect('source-branch', 'target-branch'));
+        // Target should now have the source files
+        expect(branchContainsFile(targetWorktreeDir, 'feature-1.txt')).toBe(true);
+        expect(branchContainsFile(targetWorktreeDir, 'feature-2.txt')).toBe(true);
+        // --no-ff creates a merge commit, so target should have:
+        // initial commit + merge commit = 4 total (initial + 2 from source + merge commit)
+        const count = getCommitCount(targetWorktreeDir);
+        expect(count).toBe(4);
+        // Last commit should be a merge commit
+        const lastMsg = getLastCommitMessage(targetWorktreeDir);
+        expect(lastMsg).toContain('Merge');
+    });
+    it('should merge with custom mergeArgs from MergeConfig', async () => {
+        const service = new WorktreeService(mainRepoDir);
+        await Effect.runPromise(service.mergeWorktreeEffect('source-branch', 'target-branch', 'merge', {
+            mergeArgs: ['--squash'],
+        }));
+        // Target should have the source files (staged by --squash)
+        expect(branchContainsFile(targetWorktreeDir, 'feature-1.txt')).toBe(true);
+        expect(branchContainsFile(targetWorktreeDir, 'feature-2.txt')).toBe(true);
+        // --squash does not create a merge commit automatically;
+        // git merge --squash stages changes but does not commit.
+        // The service does NOT auto-commit for plain merge, so check that
+        // there is no merge commit — changes are just staged.
+        // Actually let's verify: with --squash there's no extra merge commit
+        // The commit count on target should still be 1 (initial) since squash only stages
+        const count = getCommitCount(targetWorktreeDir);
+        expect(count).toBe(1);
+        // Verify there are staged changes ready to commit
+        const status = execSync('git status --porcelain', gitOpts(targetWorktreeDir)).trim();
+        expect(status).toContain('feature-1.txt');
+        expect(status).toContain('feature-2.txt');
+    });
+    it('should rebase with default (empty) rebaseArgs', async () => {
+        const service = new WorktreeService(mainRepoDir);
+        await Effect.runPromise(service.mergeWorktreeEffect('source-branch', 'target-branch', 'rebase'));
+        // Target should now have the source files via ff-only merge after rebase
+        expect(branchContainsFile(targetWorktreeDir, 'feature-1.txt')).toBe(true);
+        expect(branchContainsFile(targetWorktreeDir, 'feature-2.txt')).toBe(true);
+        // Rebase + ff-only: no merge commit, linear history
+        // initial commit + 2 feature commits = 3
+        const count = getCommitCount(targetWorktreeDir);
+        expect(count).toBe(3);
+        // Commit messages should be preserved
+        const log = execSync('git log --oneline', gitOpts(targetWorktreeDir)).trim();
+        expect(log).toContain('feat: add feature 1');
+        expect(log).toContain('feat: add feature 2');
+    });
+    it('should rebase with custom rebaseArgs from MergeConfig', async () => {
+        const service = new WorktreeService(mainRepoDir);
+        // --no-stat is a harmless rebase flag that suppresses diffstat
+        await Effect.runPromise(service.mergeWorktreeEffect('source-branch', 'target-branch', 'rebase', {
+            rebaseArgs: ['--no-stat'],
+        }));
+        // Should still produce the same result — linear history
+        expect(branchContainsFile(targetWorktreeDir, 'feature-1.txt')).toBe(true);
+        expect(branchContainsFile(targetWorktreeDir, 'feature-2.txt')).toBe(true);
+        const count = getCommitCount(targetWorktreeDir);
+        expect(count).toBe(3);
+    });
+    it('should use default args when MergeConfig is provided but mergeArgs is undefined', async () => {
+        const service = new WorktreeService(mainRepoDir);
+        // Provide MergeConfig with only rebaseArgs — mergeArgs should default to --no-ff
+        await Effect.runPromise(service.mergeWorktreeEffect('source-branch', 'target-branch', 'merge', {
+            rebaseArgs: ['--no-stat'],
+        }));
+        expect(branchContainsFile(targetWorktreeDir, 'feature-1.txt')).toBe(true);
+        expect(branchContainsFile(targetWorktreeDir, 'feature-2.txt')).toBe(true);
+        // --no-ff creates a merge commit: initial + 2 source + merge = 4
+        const count = getCommitCount(targetWorktreeDir);
+        expect(count).toBe(4);
+        const lastMsg = getLastCommitMessage(targetWorktreeDir);
+        expect(lastMsg).toContain('Merge');
+    });
+    it('should fail with GitError when target worktree not found', async () => {
+        const service = new WorktreeService(mainRepoDir);
+        const result = await Effect.runPromise(Effect.either(service.mergeWorktreeEffect('source-branch', 'nonexistent-branch')));
+        expect(result._tag).toBe('Left');
+        if (result._tag === 'Left') {
+            expect(result.left.stderr).toContain('Target branch worktree not found');
+        }
+    });
+    it('should fail with GitError on merge conflict', async () => {
+        // Create a conflicting commit on the target branch
+        fs.writeFileSync(path.join(targetWorktreeDir, 'feature-1.txt'), 'conflicting content');
+        execSync('git add feature-1.txt', gitOpts(targetWorktreeDir));
+        execSync('git commit -m "conflict: add feature-1 on target"', gitOpts(targetWorktreeDir));
+        const service = new WorktreeService(mainRepoDir);
+        const result = await Effect.runPromise(Effect.either(service.mergeWorktreeEffect('source-branch', 'target-branch')));
+        expect(result._tag).toBe('Left');
+        if (result._tag === 'Left') {
+            expect(result.left._tag).toBe('GitError');
+        }
+        // Abort the failed merge to leave repo in clean state
+        try {
+            execSync('git merge --abort', gitOpts(targetWorktreeDir));
+        }
+        catch {
+            /* ignore */
+        }
+    });
+});

package/dist/services/worktreeService.test.js

@@ -781,7 +781,7 @@ branch refs/heads/feature
                 }
                 throw new Error('Command not mocked: ' + cmd);
             });
-            const effect = service.mergeWorktreeEffect('feature', 'main', false);
+            const effect = service.mergeWorktreeEffect('feature', 'main', 'merge');
             await Effect.runPromise(effect);
             expect(execSync).toHaveBeenCalledWith('git merge --no-ff "feature"', expect.any(Object));
         });
@@ -800,7 +800,7 @@ branch refs/heads/main
                 }
                 throw new Error('Command not mocked: ' + cmd);
             });
-            const effect = service.mergeWorktreeEffect('feature', 'nonexistent', false);
+            const effect = service.mergeWorktreeEffect('feature', 'nonexistent', 'merge');
             const result = await Effect.runPromise(Effect.either(effect));
             if (result._tag === 'Left') {
                 expect(result.left).toBeInstanceOf(GitError);
@@ -810,6 +810,152 @@ branch refs/heads/main
                 expect.fail('Should have returned Left with GitError');
             }
         });
+        it('should use custom merge args from MergeConfig', async () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd === 'git worktree list --porcelain') {
+                        return `worktree /fake/path
+HEAD abcd1234
+branch refs/heads/main
+
+worktree /fake/path/feature
+HEAD efgh5678
+branch refs/heads/feature
+`;
+                    }
+                    if (cmd.includes('git merge')) {
+                        return 'Merge successful';
+                    }
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            const effect = service.mergeWorktreeEffect('feature', 'main', 'merge', {
+                mergeArgs: ['--squash'],
+            });
+            await Effect.runPromise(effect);
+            expect(execSync).toHaveBeenCalledWith('git merge --squash "feature"', expect.any(Object));
+        });
+        it('should use default --no-ff when mergeArgs not specified in MergeConfig', async () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd === 'git worktree list --porcelain') {
+                        return `worktree /fake/path
+HEAD abcd1234
+branch refs/heads/main
+
+worktree /fake/path/feature
+HEAD efgh5678
+branch refs/heads/feature
+`;
+                    }
+                    if (cmd.includes('git merge')) {
+                        return 'Merge successful';
+                    }
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            const effect = service.mergeWorktreeEffect('feature', 'main', 'merge', {
+                rebaseArgs: ['--autosquash'],
+            });
+            await Effect.runPromise(effect);
+            expect(execSync).toHaveBeenCalledWith('git merge --no-ff "feature"', expect.any(Object));
+        });
+        it('should use custom rebase args from MergeConfig', async () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd === 'git worktree list --porcelain') {
+                        return `worktree /fake/path
+HEAD abcd1234
+branch refs/heads/main
+
+worktree /fake/path/feature
+HEAD efgh5678
+branch refs/heads/feature
+`;
+                    }
+                    if (cmd.includes('git rebase')) {
+                        return 'Rebase successful';
+                    }
+                    if (cmd.includes('git merge --ff-only')) {
+                        return 'Fast-forward merge successful';
+                    }
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            const effect = service.mergeWorktreeEffect('feature', 'main', 'rebase', {
+                rebaseArgs: ['--autosquash', '--interactive'],
+            });
+            await Effect.runPromise(effect);
+            expect(execSync).toHaveBeenCalledWith('git rebase --autosquash --interactive "main"', expect.any(Object));
+        });
+        it('should use empty rebase args by default when MergeConfig has no rebaseArgs', async () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd === 'git worktree list --porcelain') {
+                        return `worktree /fake/path
+HEAD abcd1234
+branch refs/heads/main
+
+worktree /fake/path/feature
+HEAD efgh5678
+branch refs/heads/feature
+`;
+                    }
+                    if (cmd.includes('git rebase')) {
+                        return 'Rebase successful';
+                    }
+                    if (cmd.includes('git merge --ff-only')) {
+                        return 'Fast-forward merge successful';
+                    }
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            const effect = service.mergeWorktreeEffect('feature', 'main', 'rebase', {
+                mergeArgs: ['--squash'],
+            });
+            await Effect.runPromise(effect);
+            expect(execSync).toHaveBeenCalledWith('git rebase "main"', expect.any(Object));
+        });
+        it('should use multiple merge args from MergeConfig', async () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd === 'git worktree list --porcelain') {
+                        return `worktree /fake/path
+HEAD abcd1234
+branch refs/heads/main
+
+worktree /fake/path/feature
+HEAD efgh5678
+branch refs/heads/feature
+`;
+                    }
+                    if (cmd.includes('git merge')) {
+                        return 'Merge successful';
+                    }
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            const effect = service.mergeWorktreeEffect('feature', 'main', 'merge', {
+                mergeArgs: ['--no-ff', '--no-edit'],
+            });
+            await Effect.runPromise(effect);
+            expect(execSync).toHaveBeenCalledWith('git merge --no-ff --no-edit "feature"', expect.any(Object));
+        });
         it('should return Effect that fails with GitError on merge conflict', async () => {
             mockedExecSync.mockImplementation((cmd, _options) => {
                 if (typeof cmd === 'string') {
@@ -835,7 +981,7 @@ branch refs/heads/feature
                 }
                 throw new Error('Command not mocked: ' + cmd);
             });
-            const effect = service.mergeWorktreeEffect('feature', 'main', false);
+            const effect = service.mergeWorktreeEffect('feature', 'main', 'merge');
             const result = await Effect.runPromise(Effect.either(effect));
             if (result._tag === 'Left') {
                 expect(result.left).toBeInstanceOf(GitError);

package/dist/types/index.d.ts

@@ -86,6 +86,10 @@ export interface WorktreeConfig {
     sortByLastSession?: boolean;
     autoUseDefaultBranch?: boolean;
 }
+export interface MergeConfig {
+    mergeArgs?: string[];
+    rebaseArgs?: string[];
+}
 export interface CommandPreset {
     id: string;
     name: string;
@@ -109,6 +113,7 @@ export interface ConfigurationData {
     worktreeHooks?: WorktreeHookConfig;
     worktree?: WorktreeConfig;
     commandPresets?: CommandPresetsConfig;
+    mergeConfig?: MergeConfig;
     autoApproval?: {
         enabled: boolean;
         customCommand?: string;
@@ -129,6 +134,7 @@ export interface ProjectConfigurationData {
     worktreeHooks?: WorktreeHookConfig;
     worktree?: WorktreeConfig;
     commandPresets?: CommandPresetsConfig;
+    mergeConfig?: MergeConfig;
     autoApproval?: AutoApprovalConfig;
 }
 /**
@@ -142,6 +148,7 @@ export interface IConfigReader {
     getWorktreeHooks(): WorktreeHookConfig | undefined;
     getWorktreeConfig(): WorktreeConfig | undefined;
     getCommandPresets(): CommandPresetsConfig | undefined;
+    getMergeConfig(): MergeConfig | undefined;
     getAutoApprovalConfig(): AutoApprovalConfig | undefined;
     reload(): void;
 }
@@ -156,6 +163,7 @@ export interface IConfigEditor extends IConfigReader {
     setWorktreeHooks(value: WorktreeHookConfig): void;
     setWorktreeConfig(value: WorktreeConfig): void;
     setCommandPresets(value: CommandPresetsConfig): void;
+    setMergeConfig(value: MergeConfig): void;
     setAutoApprovalConfig(value: AutoApprovalConfig): void;
 }
 export interface GitProject {
@@ -211,5 +219,5 @@ export interface IWorktreeService {
     deleteWorktreeEffect(worktreePath: string, options?: {
         deleteBranch?: boolean;
     }): import('effect').Effect.Effect<void, import('../types/errors.js').GitError, never>;
-    mergeWorktreeEffect(sourceBranch: string, targetBranch: string, useRebase?: boolean): import('effect').Effect.Effect<void, import('../types/errors.js').GitError, never>;
+    mergeWorktreeEffect(sourceBranch: string, targetBranch: string, operation?: 'merge' | 'rebase', mergeConfig?: MergeConfig): import('effect').Effect.Effect<void, import('../types/errors.js').GitError, never>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ccmanager",
-	"version": "3.8.1",
+	"version": "3.9.0",
 	"description": "TUI application for managing multiple Claude Code sessions across Git worktrees",
 	"license": "MIT",
 	"author": "Kodai Kabasawa",
@@ -41,11 +41,11 @@
 		"bin"
 	],
 	"optionalDependencies": {
-		"@kodaikabasawa/ccmanager-darwin-arm64": "3.8.1",
-		"@kodaikabasawa/ccmanager-darwin-x64": "3.8.1",
-		"@kodaikabasawa/ccmanager-linux-arm64": "3.8.1",
-		"@kodaikabasawa/ccmanager-linux-x64": "3.8.1",
-		"@kodaikabasawa/ccmanager-win32-x64": "3.8.1"
+		"@kodaikabasawa/ccmanager-darwin-arm64": "3.9.0",
+		"@kodaikabasawa/ccmanager-darwin-x64": "3.9.0",
+		"@kodaikabasawa/ccmanager-linux-arm64": "3.9.0",
+		"@kodaikabasawa/ccmanager-linux-x64": "3.9.0",
+		"@kodaikabasawa/ccmanager-win32-x64": "3.9.0"
 	},
 	"devDependencies": {
 		"@eslint/js": "^9.28.0",