@renseiai/agentfactory 0.8.12 → 0.8.13

package/dist/src/merge-queue/strategies/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Merge Strategies Module
+ *
+ * Factory and exports for pluggable merge strategies (rebase, merge, squash).
+ */
+export type { MergeStrategy, MergeContext, PrepareResult, MergeResult } from './types.js';
+export { RebaseStrategy } from './rebase-strategy.js';
+export { MergeCommitStrategy } from './merge-commit-strategy.js';
+export { SquashStrategy } from './squash-strategy.js';
+import type { MergeStrategy } from './types.js';
+/**
+ * Create a merge strategy by name.
+ *
+ * @param name - Strategy name: 'rebase', 'merge', or 'squash'
+ * @returns MergeStrategy instance
+ * @throws Error if strategy name is unknown
+ */
+export declare function createMergeStrategy(name: 'rebase' | 'merge' | 'squash'): MergeStrategy;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/merge-queue/strategies/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/merge-queue/strategies/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AACzF,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AACrD,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAA;AAChE,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAErD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAK/C;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,GAAG,QAAQ,GAAG,aAAa,CAWtF"}

package/dist/src/merge-queue/strategies/index.js

@@ -0,0 +1,30 @@
+/**
+ * Merge Strategies Module
+ *
+ * Factory and exports for pluggable merge strategies (rebase, merge, squash).
+ */
+export { RebaseStrategy } from './rebase-strategy.js';
+export { MergeCommitStrategy } from './merge-commit-strategy.js';
+export { SquashStrategy } from './squash-strategy.js';
+import { RebaseStrategy } from './rebase-strategy.js';
+import { MergeCommitStrategy } from './merge-commit-strategy.js';
+import { SquashStrategy } from './squash-strategy.js';
+/**
+ * Create a merge strategy by name.
+ *
+ * @param name - Strategy name: 'rebase', 'merge', or 'squash'
+ * @returns MergeStrategy instance
+ * @throws Error if strategy name is unknown
+ */
+export function createMergeStrategy(name) {
+    switch (name) {
+        case 'rebase':
+            return new RebaseStrategy();
+        case 'merge':
+            return new MergeCommitStrategy();
+        case 'squash':
+            return new SquashStrategy();
+        default:
+            throw new Error(`Unknown merge strategy: ${name}`);
+    }
+}

package/dist/src/merge-queue/strategies/merge-commit-strategy.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Merge Commit Strategy
+ *
+ * Performs a standard merge commit (--no-ff) from the source branch into the target.
+ * Preserves full branch history with an explicit merge commit.
+ */
+import type { MergeStrategy, MergeContext, PrepareResult, MergeResult } from './types.js';
+export declare class MergeCommitStrategy implements MergeStrategy {
+    readonly name: "merge";
+    prepare(ctx: MergeContext): Promise<PrepareResult>;
+    execute(ctx: MergeContext): Promise<MergeResult>;
+    finalize(ctx: MergeContext): Promise<void>;
+}
+//# sourceMappingURL=merge-commit-strategy.d.ts.map

package/dist/src/merge-queue/strategies/merge-commit-strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-commit-strategy.d.ts","sourceRoot":"","sources":["../../../../src/merge-queue/strategies/merge-commit-strategy.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAIzF,qBAAa,mBAAoB,YAAW,aAAa;IACvD,QAAQ,CAAC,IAAI,EAAG,OAAO,CAAS;IAE1B,OAAO,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,aAAa,CAAC;IAWlD,OAAO,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC;IAqChD,QAAQ,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;CAGjD"}

package/dist/src/merge-queue/strategies/merge-commit-strategy.js

@@ -0,0 +1,58 @@
+/**
+ * Merge Commit Strategy
+ *
+ * Performs a standard merge commit (--no-ff) from the source branch into the target.
+ * Preserves full branch history with an explicit merge commit.
+ */
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+export class MergeCommitStrategy {
+    name = 'merge';
+    async prepare(ctx) {
+        try {
+            await execAsync(`git fetch ${ctx.remote} ${ctx.targetBranch}`, { cwd: ctx.worktreePath });
+            await execAsync(`git checkout ${ctx.targetBranch}`, { cwd: ctx.worktreePath });
+            const { stdout } = await execAsync('git rev-parse HEAD', { cwd: ctx.worktreePath });
+            return { success: true, headSha: stdout.trim() };
+        }
+        catch (err) {
+            return { success: false, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    async execute(ctx) {
+        try {
+            await execAsync(`git merge --no-ff ${ctx.remote}/${ctx.sourceBranch} -m "Merge PR #${ctx.prNumber} from ${ctx.sourceBranch}"`, { cwd: ctx.worktreePath });
+            const { stdout } = await execAsync('git rev-parse HEAD', { cwd: ctx.worktreePath });
+            return { status: 'success', mergedSha: stdout.trim() };
+        }
+        catch (err) {
+            // Check for conflicts
+            try {
+                const { stdout: conflictOutput } = await execAsync('git diff --name-only --diff-filter=U', { cwd: ctx.worktreePath });
+                const conflictFiles = conflictOutput.trim().split('\n').filter(Boolean);
+                if (conflictFiles.length > 0) {
+                    await execAsync('git merge --abort', { cwd: ctx.worktreePath });
+                    return {
+                        status: 'conflict',
+                        conflictFiles,
+                        conflictDetails: `Merge conflict in ${conflictFiles.length} file(s)`,
+                    };
+                }
+            }
+            catch {
+                // Could not detect conflicts; fall through to error
+            }
+            try {
+                await execAsync('git merge --abort', { cwd: ctx.worktreePath });
+            }
+            catch {
+                // Abort may fail if merge was not in progress
+            }
+            return { status: 'error', error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    async finalize(ctx) {
+        await execAsync(`git push ${ctx.remote} ${ctx.targetBranch}`, { cwd: ctx.worktreePath });
+    }
+}

package/dist/src/merge-queue/strategies/rebase-strategy.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Rebase Merge Strategy
+ *
+ * Rebases the source branch onto the target branch, then fast-forward merges.
+ * Produces a linear commit history without merge commits.
+ */
+import type { MergeStrategy, MergeContext, PrepareResult, MergeResult } from './types.js';
+export declare class RebaseStrategy implements MergeStrategy {
+    readonly name: "rebase";
+    prepare(ctx: MergeContext): Promise<PrepareResult>;
+    execute(ctx: MergeContext): Promise<MergeResult>;
+    finalize(ctx: MergeContext): Promise<void>;
+}
+//# sourceMappingURL=rebase-strategy.d.ts.map

package/dist/src/merge-queue/strategies/rebase-strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rebase-strategy.d.ts","sourceRoot":"","sources":["../../../../src/merge-queue/strategies/rebase-strategy.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAIzF,qBAAa,cAAe,YAAW,aAAa;IAClD,QAAQ,CAAC,IAAI,EAAG,QAAQ,CAAS;IAE3B,OAAO,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,aAAa,CAAC;IAWlD,OAAO,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC;IAmChD,QAAQ,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;CASjD"}

package/dist/src/merge-queue/strategies/rebase-strategy.js

@@ -0,0 +1,62 @@
+/**
+ * Rebase Merge Strategy
+ *
+ * Rebases the source branch onto the target branch, then fast-forward merges.
+ * Produces a linear commit history without merge commits.
+ */
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+export class RebaseStrategy {
+    name = 'rebase';
+    async prepare(ctx) {
+        try {
+            await execAsync(`git fetch ${ctx.remote} ${ctx.targetBranch}`, { cwd: ctx.worktreePath });
+            await execAsync(`git checkout ${ctx.sourceBranch}`, { cwd: ctx.worktreePath });
+            const { stdout } = await execAsync('git rev-parse HEAD', { cwd: ctx.worktreePath });
+            return { success: true, headSha: stdout.trim() };
+        }
+        catch (err) {
+            return { success: false, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    async execute(ctx) {
+        try {
+            await execAsync(`git rebase ${ctx.remote}/${ctx.targetBranch}`, { cwd: ctx.worktreePath });
+            const { stdout } = await execAsync('git rev-parse HEAD', { cwd: ctx.worktreePath });
+            return { status: 'success', mergedSha: stdout.trim() };
+        }
+        catch (err) {
+            // Check if this is a conflict
+            try {
+                const { stdout: conflictOutput } = await execAsync('git diff --name-only --diff-filter=U', { cwd: ctx.worktreePath });
+                const conflictFiles = conflictOutput.trim().split('\n').filter(Boolean);
+                if (conflictFiles.length > 0) {
+                    await execAsync('git rebase --abort', { cwd: ctx.worktreePath });
+                    return {
+                        status: 'conflict',
+                        conflictFiles,
+                        conflictDetails: `Rebase conflict in ${conflictFiles.length} file(s)`,
+                    };
+                }
+            }
+            catch {
+                // Could not detect conflicts; fall through to error
+            }
+            // Not a conflict — abort rebase and return error
+            try {
+                await execAsync('git rebase --abort', { cwd: ctx.worktreePath });
+            }
+            catch {
+                // Abort may fail if rebase was not in progress
+            }
+            return { status: 'error', error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    async finalize(ctx) {
+        await execAsync(`git push ${ctx.remote} ${ctx.sourceBranch} --force-with-lease`, { cwd: ctx.worktreePath });
+        await execAsync(`git checkout ${ctx.targetBranch}`, { cwd: ctx.worktreePath });
+        await execAsync(`git merge --ff-only ${ctx.sourceBranch}`, { cwd: ctx.worktreePath });
+        await execAsync(`git push ${ctx.remote} ${ctx.targetBranch}`, { cwd: ctx.worktreePath });
+    }
+}

package/dist/src/merge-queue/strategies/squash-strategy.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Squash Merge Strategy
+ *
+ * Squash-merges all commits from the source branch into a single commit on the target.
+ * Produces a clean, linear history with one commit per PR.
+ */
+import type { MergeStrategy, MergeContext, PrepareResult, MergeResult } from './types.js';
+export declare class SquashStrategy implements MergeStrategy {
+    readonly name: "squash";
+    prepare(ctx: MergeContext): Promise<PrepareResult>;
+    execute(ctx: MergeContext): Promise<MergeResult>;
+    finalize(ctx: MergeContext): Promise<void>;
+}
+//# sourceMappingURL=squash-strategy.d.ts.map

package/dist/src/merge-queue/strategies/squash-strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"squash-strategy.d.ts","sourceRoot":"","sources":["../../../../src/merge-queue/strategies/squash-strategy.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAIzF,qBAAa,cAAe,YAAW,aAAa;IAClD,QAAQ,CAAC,IAAI,EAAG,QAAQ,CAAS;IAE3B,OAAO,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,aAAa,CAAC;IAWlD,OAAO,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC;IAyChD,QAAQ,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;CAGjD"}

package/dist/src/merge-queue/strategies/squash-strategy.js

@@ -0,0 +1,59 @@
+/**
+ * Squash Merge Strategy
+ *
+ * Squash-merges all commits from the source branch into a single commit on the target.
+ * Produces a clean, linear history with one commit per PR.
+ */
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+export class SquashStrategy {
+    name = 'squash';
+    async prepare(ctx) {
+        try {
+            await execAsync(`git fetch ${ctx.remote} ${ctx.targetBranch}`, { cwd: ctx.worktreePath });
+            await execAsync(`git checkout ${ctx.targetBranch}`, { cwd: ctx.worktreePath });
+            const { stdout } = await execAsync('git rev-parse HEAD', { cwd: ctx.worktreePath });
+            return { success: true, headSha: stdout.trim() };
+        }
+        catch (err) {
+            return { success: false, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    async execute(ctx) {
+        try {
+            await execAsync(`git merge --squash ${ctx.remote}/${ctx.sourceBranch}`, { cwd: ctx.worktreePath });
+            await execAsync(`git commit -m "Squash merge PR #${ctx.prNumber} from ${ctx.sourceBranch}"`, { cwd: ctx.worktreePath });
+            const { stdout } = await execAsync('git rev-parse HEAD', { cwd: ctx.worktreePath });
+            return { status: 'success', mergedSha: stdout.trim() };
+        }
+        catch (err) {
+            // Check for conflicts
+            try {
+                const { stdout: conflictOutput } = await execAsync('git diff --name-only --diff-filter=U', { cwd: ctx.worktreePath });
+                const conflictFiles = conflictOutput.trim().split('\n').filter(Boolean);
+                if (conflictFiles.length > 0) {
+                    await execAsync('git merge --abort', { cwd: ctx.worktreePath });
+                    return {
+                        status: 'conflict',
+                        conflictFiles,
+                        conflictDetails: `Squash merge conflict in ${conflictFiles.length} file(s)`,
+                    };
+                }
+            }
+            catch {
+                // Could not detect conflicts; fall through to error
+            }
+            try {
+                await execAsync('git merge --abort', { cwd: ctx.worktreePath });
+            }
+            catch {
+                // Abort may fail if merge was not in progress
+            }
+            return { status: 'error', error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    async finalize(ctx) {
+        await execAsync(`git push ${ctx.remote} ${ctx.targetBranch}`, { cwd: ctx.worktreePath });
+    }
+}

package/dist/src/merge-queue/strategies/strategies.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=strategies.test.d.ts.map

package/dist/src/merge-queue/strategies/strategies.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strategies.test.d.ts","sourceRoot":"","sources":["../../../../src/merge-queue/strategies/strategies.test.ts"],"names":[],"mappings":""}

package/dist/src/merge-queue/strategies/strategies.test.js

@@ -0,0 +1,354 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+vi.mock('child_process', () => ({
+    exec: vi.fn(),
+}));
+import { exec } from 'child_process';
+import { createMergeStrategy } from './index.js';
+import { RebaseStrategy } from './rebase-strategy.js';
+import { MergeCommitStrategy } from './merge-commit-strategy.js';
+import { SquashStrategy } from './squash-strategy.js';
+const mockExec = vi.mocked(exec);
+/** Default context for all tests */
+const defaultCtx = {
+    repoPath: '/repo',
+    worktreePath: '/worktree',
+    sourceBranch: 'feature/test',
+    targetBranch: 'main',
+    prNumber: 42,
+    remote: 'origin',
+};
+/**
+ * Mock exec to succeed with given stdout for every call.
+ * Matches the promisify(exec) pattern: exec(cmd, opts, callback).
+ */
+function mockExecSuccess(stdout = '') {
+    mockExec.mockImplementation((_cmd, _opts, callback) => {
+        const cb = typeof _opts === 'function' ? _opts : callback;
+        cb?.(null, { stdout, stderr: '' });
+        return {};
+    });
+}
+/**
+ * Mock exec to fail with the given error message for every call.
+ */
+function mockExecFailure(message) {
+    mockExec.mockImplementation((_cmd, _opts, callback) => {
+        const cb = typeof _opts === 'function' ? _opts : callback;
+        cb?.(new Error(message), { stdout: '', stderr: '' });
+        return {};
+    });
+}
+/**
+ * Queue sequential mock implementations.
+ * Each entry is either a string (success stdout) or an Error (failure).
+ */
+function mockExecSequence(results) {
+    const queue = [...results];
+    mockExec.mockImplementation((_cmd, _opts, callback) => {
+        const cb = typeof _opts === 'function' ? _opts : callback;
+        const next = queue.shift();
+        if (next instanceof Error) {
+            cb?.(next, { stdout: '', stderr: '' });
+        }
+        else {
+            cb?.(null, { stdout: next ?? '', stderr: '' });
+        }
+        return {};
+    });
+}
+describe('createMergeStrategy factory', () => {
+    it('returns RebaseStrategy for "rebase"', () => {
+        const strategy = createMergeStrategy('rebase');
+        expect(strategy).toBeInstanceOf(RebaseStrategy);
+        expect(strategy.name).toBe('rebase');
+    });
+    it('returns MergeCommitStrategy for "merge"', () => {
+        const strategy = createMergeStrategy('merge');
+        expect(strategy).toBeInstanceOf(MergeCommitStrategy);
+        expect(strategy.name).toBe('merge');
+    });
+    it('returns SquashStrategy for "squash"', () => {
+        const strategy = createMergeStrategy('squash');
+        expect(strategy).toBeInstanceOf(SquashStrategy);
+        expect(strategy.name).toBe('squash');
+    });
+    it('throws on unknown strategy name', () => {
+        expect(() => createMergeStrategy('unknown')).toThrow('Unknown merge strategy: unknown');
+    });
+});
+describe('RebaseStrategy', () => {
+    let strategy;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        strategy = new RebaseStrategy();
+    });
+    it('has name "rebase"', () => {
+        expect(strategy.name).toBe('rebase');
+    });
+    describe('prepare', () => {
+        it('fetches target branch and checks out source branch', async () => {
+            mockExecSequence([
+                '', // git fetch origin main
+                '', // git checkout feature/test
+                'abc123\n', // git rev-parse HEAD
+            ]);
+            const result = await strategy.prepare(defaultCtx);
+            expect(result).toEqual({ success: true, headSha: 'abc123' });
+            expect(mockExec).toHaveBeenCalledTimes(3);
+            // Verify commands and cwd
+            const calls = mockExec.mock.calls;
+            expect(calls[0][0]).toBe('git fetch origin main');
+            expect(calls[0][1]).toEqual({ cwd: '/worktree' });
+            expect(calls[1][0]).toBe('git checkout feature/test');
+            expect(calls[1][1]).toEqual({ cwd: '/worktree' });
+            expect(calls[2][0]).toBe('git rev-parse HEAD');
+            expect(calls[2][1]).toEqual({ cwd: '/worktree' });
+        });
+        it('returns failure when fetch fails', async () => {
+            mockExecFailure('fatal: could not read from remote');
+            const result = await strategy.prepare(defaultCtx);
+            expect(result.success).toBe(false);
+            expect(result.error).toContain('could not read from remote');
+        });
+    });
+    describe('execute', () => {
+        it('runs rebase and returns success with merged SHA', async () => {
+            mockExecSequence([
+                '', // git rebase origin/main
+                'def456\n', // git rev-parse HEAD
+            ]);
+            const result = await strategy.execute(defaultCtx);
+            expect(result).toEqual({ status: 'success', mergedSha: 'def456' });
+            expect(mockExec).toHaveBeenCalledTimes(2);
+            const calls = mockExec.mock.calls;
+            expect(calls[0][0]).toBe('git rebase origin/main');
+            expect(calls[0][1]).toEqual({ cwd: '/worktree' });
+        });
+        it('detects conflicts, aborts rebase, and returns conflict result', async () => {
+            mockExecSequence([
+                new Error('CONFLICT (content): Merge conflict in file.ts'), // git rebase fails
+                'src/file.ts\nsrc/other.ts\n', // git diff --name-only --diff-filter=U
+                '', // git rebase --abort
+            ]);
+            const result = await strategy.execute(defaultCtx);
+            expect(result.status).toBe('conflict');
+            expect(result.conflictFiles).toEqual(['src/file.ts', 'src/other.ts']);
+            expect(result.conflictDetails).toBe('Rebase conflict in 2 file(s)');
+        });
+        it('aborts rebase and returns error on non-conflict failure', async () => {
+            mockExecSequence([
+                new Error('fatal: invalid upstream'), // git rebase fails
+                new Error('no conflicts'), // git diff --name-only fails (no conflict state)
+                '', // git rebase --abort
+            ]);
+            const result = await strategy.execute(defaultCtx);
+            expect(result.status).toBe('error');
+            expect(result.error).toContain('invalid upstream');
+        });
+        it('handles abort failure gracefully after error', async () => {
+            mockExecSequence([
+                new Error('fatal: something went wrong'), // git rebase fails
+                '', // git diff returns empty (no conflicts)
+                new Error('no rebase in progress'), // git rebase --abort fails
+            ]);
+            const result = await strategy.execute(defaultCtx);
+            expect(result.status).toBe('error');
+            expect(result.error).toContain('something went wrong');
+        });
+    });
+    describe('finalize', () => {
+        it('force-pushes source branch and fast-forward merges to target', async () => {
+            mockExecSequence([
+                '', // git push origin feature/test --force-with-lease
+                '', // git checkout main
+                '', // git merge --ff-only feature/test
+                '', // git push origin main
+            ]);
+            await strategy.finalize(defaultCtx);
+            expect(mockExec).toHaveBeenCalledTimes(4);
+            const calls = mockExec.mock.calls;
+            expect(calls[0][0]).toBe('git push origin feature/test --force-with-lease');
+            expect(calls[0][1]).toEqual({ cwd: '/worktree' });
+            expect(calls[1][0]).toBe('git checkout main');
+            expect(calls[1][1]).toEqual({ cwd: '/worktree' });
+            expect(calls[2][0]).toBe('git merge --ff-only feature/test');
+            expect(calls[2][1]).toEqual({ cwd: '/worktree' });
+            expect(calls[3][0]).toBe('git push origin main');
+            expect(calls[3][1]).toEqual({ cwd: '/worktree' });
+        });
+        it('throws when push fails', async () => {
+            mockExecFailure('rejected: non-fast-forward');
+            await expect(strategy.finalize(defaultCtx)).rejects.toThrow('rejected: non-fast-forward');
+        });
+    });
+});
+describe('MergeCommitStrategy', () => {
+    let strategy;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        strategy = new MergeCommitStrategy();
+    });
+    it('has name "merge"', () => {
+        expect(strategy.name).toBe('merge');
+    });
+    describe('prepare', () => {
+        it('fetches and checks out target branch', async () => {
+            mockExecSequence([
+                '', // git fetch origin main
+                '', // git checkout main
+                'aaa111\n', // git rev-parse HEAD
+            ]);
+            const result = await strategy.prepare(defaultCtx);
+            expect(result).toEqual({ success: true, headSha: 'aaa111' });
+            const calls = mockExec.mock.calls;
+            expect(calls[0][0]).toBe('git fetch origin main');
+            expect(calls[1][0]).toBe('git checkout main');
+            expect(calls[1][1]).toEqual({ cwd: '/worktree' });
+        });
+        it('returns failure on error', async () => {
+            mockExecFailure('error: pathspec did not match');
+            const result = await strategy.prepare(defaultCtx);
+            expect(result.success).toBe(false);
+            expect(result.error).toContain('pathspec did not match');
+        });
+    });
+    describe('execute', () => {
+        it('runs merge --no-ff and returns success', async () => {
+            mockExecSequence([
+                '', // git merge --no-ff
+                'bbb222\n', // git rev-parse HEAD
+            ]);
+            const result = await strategy.execute(defaultCtx);
+            expect(result).toEqual({ status: 'success', mergedSha: 'bbb222' });
+            const calls = mockExec.mock.calls;
+            expect(calls[0][0]).toBe('git merge --no-ff origin/feature/test -m "Merge PR #42 from feature/test"');
+            expect(calls[0][1]).toEqual({ cwd: '/worktree' });
+        });
+        it('detects conflicts, aborts merge, and returns conflict result', async () => {
+            mockExecSequence([
+                new Error('CONFLICT'), // git merge fails
+                'src/conflict.ts\n', // git diff --name-only --diff-filter=U
+                '', // git merge --abort
+            ]);
+            const result = await strategy.execute(defaultCtx);
+            expect(result.status).toBe('conflict');
+            expect(result.conflictFiles).toEqual(['src/conflict.ts']);
+            expect(result.conflictDetails).toBe('Merge conflict in 1 file(s)');
+        });
+        it('returns error on non-conflict failure', async () => {
+            mockExecSequence([
+                new Error('fatal: refusing to merge unrelated histories'), // git merge fails
+                '', // git diff returns empty
+                '', // git merge --abort
+            ]);
+            const result = await strategy.execute(defaultCtx);
+            expect(result.status).toBe('error');
+            expect(result.error).toContain('unrelated histories');
+        });
+    });
+    describe('finalize', () => {
+        it('pushes target branch', async () => {
+            mockExecSuccess();
+            await strategy.finalize(defaultCtx);
+            expect(mockExec).toHaveBeenCalledTimes(1);
+            const calls = mockExec.mock.calls;
+            expect(calls[0][0]).toBe('git push origin main');
+            expect(calls[0][1]).toEqual({ cwd: '/worktree' });
+        });
+    });
+});
+describe('SquashStrategy', () => {
+    let strategy;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        strategy = new SquashStrategy();
+    });
+    it('has name "squash"', () => {
+        expect(strategy.name).toBe('squash');
+    });
+    describe('prepare', () => {
+        it('fetches and checks out target branch', async () => {
+            mockExecSequence([
+                '', // git fetch origin main
+                '', // git checkout main
+                'ccc333\n', // git rev-parse HEAD
+            ]);
+            const result = await strategy.prepare(defaultCtx);
+            expect(result).toEqual({ success: true, headSha: 'ccc333' });
+            const calls = mockExec.mock.calls;
+            expect(calls[0][0]).toBe('git fetch origin main');
+            expect(calls[1][0]).toBe('git checkout main');
+            expect(calls[1][1]).toEqual({ cwd: '/worktree' });
+        });
+    });
+    describe('execute', () => {
+        it('runs merge --squash, commits, and returns success', async () => {
+            mockExecSequence([
+                '', // git merge --squash
+                '', // git commit
+                'ddd444\n', // git rev-parse HEAD
+            ]);
+            const result = await strategy.execute(defaultCtx);
+            expect(result).toEqual({ status: 'success', mergedSha: 'ddd444' });
+            const calls = mockExec.mock.calls;
+            expect(calls[0][0]).toBe('git merge --squash origin/feature/test');
+            expect(calls[0][1]).toEqual({ cwd: '/worktree' });
+            expect(calls[1][0]).toBe('git commit -m "Squash merge PR #42 from feature/test"');
+            expect(calls[1][1]).toEqual({ cwd: '/worktree' });
+        });
+        it('detects conflicts, aborts, and returns conflict result', async () => {
+            mockExecSequence([
+                new Error('CONFLICT'), // git merge --squash fails
+                'src/a.ts\nsrc/b.ts\n', // git diff --name-only --diff-filter=U
+                '', // git merge --abort
+            ]);
+            const result = await strategy.execute(defaultCtx);
+            expect(result.status).toBe('conflict');
+            expect(result.conflictFiles).toEqual(['src/a.ts', 'src/b.ts']);
+            expect(result.conflictDetails).toBe('Squash merge conflict in 2 file(s)');
+        });
+        it('returns error on non-conflict failure', async () => {
+            mockExecSequence([
+                new Error('fatal: not something we can merge'), // git merge --squash fails
+                '', // git diff returns empty
+                '', // git merge --abort
+            ]);
+            const result = await strategy.execute(defaultCtx);
+            expect(result.status).toBe('error');
+            expect(result.error).toContain('not something we can merge');
+        });
+    });
+    describe('finalize', () => {
+        it('pushes target branch', async () => {
+            mockExecSuccess();
+            await strategy.finalize(defaultCtx);
+            expect(mockExec).toHaveBeenCalledTimes(1);
+            const calls = mockExec.mock.calls;
+            expect(calls[0][0]).toBe('git push origin main');
+            expect(calls[0][1]).toEqual({ cwd: '/worktree' });
+        });
+    });
+});
+describe('All strategies use ctx.worktreePath as cwd', () => {
+    const strategies = [
+        new RebaseStrategy(),
+        new MergeCommitStrategy(),
+        new SquashStrategy(),
+    ];
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    for (const strategy of strategies) {
+        it(`${strategy.name} strategy passes worktreePath as cwd to all exec calls`, async () => {
+            const customCtx = {
+                ...defaultCtx,
+                worktreePath: '/custom/worktree/path',
+            };
+            mockExecSuccess('abc123\n');
+            await strategy.prepare(customCtx);
+            for (const call of mockExec.mock.calls) {
+                expect(call[1]).toEqual({ cwd: '/custom/worktree/path' });
+            }
+        });
+    }
+});