@renseiai/agentfactory 0.8.12 → 0.8.13

package/dist/src/merge-queue/lock-file-regeneration.test.js

@@ -0,0 +1,236 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+vi.mock('child_process', () => ({
+    exec: vi.fn(),
+}));
+vi.mock('fs/promises', () => ({
+    readFile: vi.fn(),
+    writeFile: vi.fn(),
+    access: vi.fn(),
+}));
+import { exec as execCb } from 'child_process';
+import { readFile, writeFile, access } from 'fs/promises';
+import { LockFileRegeneration } from './lock-file-regeneration.js';
+const mockExec = vi.mocked(execCb);
+const mockReadFile = vi.mocked(readFile);
+const mockWriteFile = vi.mocked(writeFile);
+const mockAccess = vi.mocked(access);
+/**
+ * Helper: configure the raw exec mock to work with promisify.
+ * promisify(exec) turns the callback-style exec into a promise.
+ * We mock by calling the callback argument immediately.
+ */
+function mockExecSuccess(stdout = '', stderr = '') {
+    mockExec.mockImplementation((_cmd, _opts, callback) => {
+        const cb = typeof _opts === 'function' ? _opts : callback;
+        cb?.(null, { stdout, stderr });
+        return {};
+    });
+}
+function mockExecFailure(message) {
+    mockExec.mockImplementation((_cmd, _opts, callback) => {
+        const cb = typeof _opts === 'function' ? _opts : callback;
+        cb?.(new Error(message), { stdout: '', stderr: '' });
+        return {};
+    });
+}
+/**
+ * Helper: set up exec to succeed for a sequence of calls.
+ * Each call pops the next result from the queue; default is success.
+ */
+function mockExecSequence(results) {
+    let callIndex = 0;
+    mockExec.mockImplementation((_cmd, _opts, callback) => {
+        const cb = typeof _opts === 'function' ? _opts : callback;
+        const result = results[callIndex] ?? { stdout: '' };
+        callIndex++;
+        if (result.error) {
+            cb?.(new Error(result.error), { stdout: '', stderr: '' });
+        }
+        else {
+            cb?.(null, { stdout: result.stdout ?? '', stderr: '' });
+        }
+        return {};
+    });
+}
+describe('LockFileRegeneration', () => {
+    let handler;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        handler = new LockFileRegeneration();
+    });
+    // -------------------------------------------------------------------------
+    // shouldRegenerate
+    // -------------------------------------------------------------------------
+    describe('shouldRegenerate', () => {
+        it('returns true when lockFileRegenerate is true and packageManager is not none', () => {
+            expect(handler.shouldRegenerate('pnpm', true)).toBe(true);
+            expect(handler.shouldRegenerate('npm', true)).toBe(true);
+            expect(handler.shouldRegenerate('yarn', true)).toBe(true);
+            expect(handler.shouldRegenerate('bun', true)).toBe(true);
+        });
+        it('returns false when lockFileRegenerate is false', () => {
+            expect(handler.shouldRegenerate('pnpm', false)).toBe(false);
+            expect(handler.shouldRegenerate('npm', false)).toBe(false);
+            expect(handler.shouldRegenerate('yarn', false)).toBe(false);
+            expect(handler.shouldRegenerate('bun', false)).toBe(false);
+            expect(handler.shouldRegenerate('none', false)).toBe(false);
+        });
+        it('returns false when packageManager is none', () => {
+            expect(handler.shouldRegenerate('none', true)).toBe(false);
+        });
+    });
+    // -------------------------------------------------------------------------
+    // getLockFileName
+    // -------------------------------------------------------------------------
+    describe('getLockFileName', () => {
+        it('returns correct file for each package manager', () => {
+            expect(handler.getLockFileName('pnpm')).toBe('pnpm-lock.yaml');
+            expect(handler.getLockFileName('npm')).toBe('package-lock.json');
+            expect(handler.getLockFileName('yarn')).toBe('yarn.lock');
+            expect(handler.getLockFileName('bun')).toBe('bun.lockb');
+        });
+        it('returns null for none', () => {
+            expect(handler.getLockFileName('none')).toBeNull();
+        });
+    });
+    // -------------------------------------------------------------------------
+    // regenerate
+    // -------------------------------------------------------------------------
+    describe('regenerate', () => {
+        it('deletes lock file, runs install, and stages result for pnpm', async () => {
+            mockAccess.mockResolvedValue(undefined);
+            mockExecSuccess();
+            const result = await handler.regenerate('/tmp/worktree', 'pnpm');
+            expect(result).toEqual({
+                success: true,
+                lockFile: 'pnpm-lock.yaml',
+                packageManager: 'pnpm',
+            });
+            // Verify exec was called 3 times: rm, install, git add
+            expect(mockExec).toHaveBeenCalledTimes(3);
+            // 1st call: rm the lock file
+            const firstCallCmd = mockExec.mock.calls[0][0];
+            expect(firstCallCmd).toContain('rm');
+            expect(firstCallCmd).toContain('pnpm-lock.yaml');
+            // 2nd call: pnpm install
+            const secondCallCmd = mockExec.mock.calls[1][0];
+            expect(secondCallCmd).toBe('pnpm install --no-frozen-lockfile');
+            // 3rd call: git add
+            const thirdCallCmd = mockExec.mock.calls[2][0];
+            expect(thirdCallCmd).toContain('git add');
+            expect(thirdCallCmd).toContain('pnpm-lock.yaml');
+        });
+        it('works for npm', async () => {
+            mockAccess.mockResolvedValue(undefined);
+            mockExecSuccess();
+            const result = await handler.regenerate('/tmp/worktree', 'npm');
+            expect(result.success).toBe(true);
+            expect(result.lockFile).toBe('package-lock.json');
+            expect(result.packageManager).toBe('npm');
+            const installCmd = mockExec.mock.calls[1][0];
+            expect(installCmd).toBe('npm install');
+        });
+        it('works for yarn', async () => {
+            mockAccess.mockResolvedValue(undefined);
+            mockExecSuccess();
+            const result = await handler.regenerate('/tmp/worktree', 'yarn');
+            expect(result.success).toBe(true);
+            expect(result.lockFile).toBe('yarn.lock');
+            expect(result.packageManager).toBe('yarn');
+            const installCmd = mockExec.mock.calls[1][0];
+            expect(installCmd).toBe('yarn install');
+        });
+        it('works for bun', async () => {
+            mockAccess.mockResolvedValue(undefined);
+            mockExecSuccess();
+            const result = await handler.regenerate('/tmp/worktree', 'bun');
+            expect(result.success).toBe(true);
+            expect(result.lockFile).toBe('bun.lockb');
+            expect(result.packageManager).toBe('bun');
+            const installCmd = mockExec.mock.calls[1][0];
+            expect(installCmd).toBe('bun install');
+        });
+        it('handles install failure gracefully', async () => {
+            // access succeeds (lock file exists), rm succeeds, install fails
+            mockAccess.mockResolvedValue(undefined);
+            mockExecSequence([
+                { stdout: '' }, // rm succeeds
+                { error: 'ENOENT: pnpm not found' }, // install fails
+            ]);
+            const result = await handler.regenerate('/tmp/worktree', 'pnpm');
+            expect(result.success).toBe(false);
+            expect(result.lockFile).toBe('pnpm-lock.yaml');
+            expect(result.packageManager).toBe('pnpm');
+            expect(result.error).toContain('pnpm not found');
+        });
+        it('handles missing lock file gracefully (no delete error)', async () => {
+            // access throws (lock file doesn't exist), so rm is skipped
+            mockAccess.mockRejectedValue(new Error('ENOENT'));
+            mockExecSuccess();
+            const result = await handler.regenerate('/tmp/worktree', 'pnpm');
+            expect(result.success).toBe(true);
+            expect(result.lockFile).toBe('pnpm-lock.yaml');
+            // Should have only 2 exec calls: install and git add (rm was skipped)
+            expect(mockExec).toHaveBeenCalledTimes(2);
+            const firstCallCmd = mockExec.mock.calls[0][0];
+            expect(firstCallCmd).toBe('pnpm install --no-frozen-lockfile');
+            const secondCallCmd = mockExec.mock.calls[1][0];
+            expect(secondCallCmd).toContain('git add');
+        });
+        it('returns error for unsupported package manager (none)', async () => {
+            const result = await handler.regenerate('/tmp/worktree', 'none');
+            expect(result.success).toBe(false);
+            expect(result.lockFile).toBe('');
+            expect(result.packageManager).toBe('none');
+            expect(result.error).toContain('Unsupported package manager');
+        });
+    });
+    // -------------------------------------------------------------------------
+    // ensureGitAttributes
+    // -------------------------------------------------------------------------
+    describe('ensureGitAttributes', () => {
+        it('creates .gitattributes if not exists', async () => {
+            mockReadFile.mockRejectedValue(new Error('ENOENT'));
+            mockWriteFile.mockResolvedValue(undefined);
+            await handler.ensureGitAttributes('/repo', 'pnpm');
+            expect(mockWriteFile).toHaveBeenCalledWith('/repo/.gitattributes', 'pnpm-lock.yaml merge=ours\n', 'utf-8');
+        });
+        it('appends entry if not already present', async () => {
+            mockReadFile.mockResolvedValue('*.md linguist-documentation\n');
+            mockWriteFile.mockResolvedValue(undefined);
+            await handler.ensureGitAttributes('/repo', 'pnpm');
+            expect(mockWriteFile).toHaveBeenCalledWith('/repo/.gitattributes', '*.md linguist-documentation\npnpm-lock.yaml merge=ours\n', 'utf-8');
+        });
+        it('appends with newline separator when file does not end with newline', async () => {
+            mockReadFile.mockResolvedValue('*.md linguist-documentation');
+            mockWriteFile.mockResolvedValue(undefined);
+            await handler.ensureGitAttributes('/repo', 'npm');
+            expect(mockWriteFile).toHaveBeenCalledWith('/repo/.gitattributes', '*.md linguist-documentation\npackage-lock.json merge=ours\n', 'utf-8');
+        });
+        it('skips if entry already present', async () => {
+            mockReadFile.mockResolvedValue('pnpm-lock.yaml merge=ours\n');
+            await handler.ensureGitAttributes('/repo', 'pnpm');
+            expect(mockWriteFile).not.toHaveBeenCalled();
+        });
+        it('handles each package manager', async () => {
+            const expectedEntries = {
+                pnpm: 'pnpm-lock.yaml merge=ours',
+                npm: 'package-lock.json merge=ours',
+                yarn: 'yarn.lock merge=ours',
+                bun: 'bun.lockb merge=ours',
+            };
+            for (const [pm, expected] of Object.entries(expectedEntries)) {
+                vi.clearAllMocks();
+                mockReadFile.mockRejectedValue(new Error('ENOENT'));
+                mockWriteFile.mockResolvedValue(undefined);
+                await handler.ensureGitAttributes('/repo', pm);
+                expect(mockWriteFile).toHaveBeenCalledWith('/repo/.gitattributes', `${expected}\n`, 'utf-8');
+            }
+        });
+        it('does nothing for unsupported package manager (none)', async () => {
+            await handler.ensureGitAttributes('/repo', 'none');
+            expect(mockReadFile).not.toHaveBeenCalled();
+            expect(mockWriteFile).not.toHaveBeenCalled();
+        });
+    });
+});

package/dist/src/merge-queue/merge-worker.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Merge Worker — Single-Instance Processor
+ *
+ * Implements the core rebase -> resolve conflicts -> regenerate lock files -> test -> merge loop.
+ * Acquires a Redis lock to ensure only one worker processes a given repository's queue at a time.
+ * Uses heartbeat to extend the lock TTL while processing, and supports graceful shutdown.
+ *
+ * All external dependencies (storage, redis) are injected via MergeWorkerDeps for testability.
+ */
+import type { PackageManager } from './lock-file-regeneration.js';
+export interface MergeWorkerConfig {
+    repoId: string;
+    repoPath: string;
+    strategy: 'rebase' | 'merge' | 'squash';
+    testCommand: string;
+    testTimeout: number;
+    lockFileRegenerate: boolean;
+    mergiraf: boolean;
+    pollInterval: number;
+    maxRetries: number;
+    escalation: {
+        onConflict: 'reassign' | 'notify' | 'park';
+        onTestFailure: 'notify' | 'park' | 'retry';
+    };
+    deleteBranchOnMerge: boolean;
+    packageManager: PackageManager;
+    remote: string;
+    targetBranch: string;
+}
+export interface MergeWorkerDeps {
+    storage: {
+        dequeue(repoId: string): Promise<any | null>;
+        markCompleted(repoId: string, prNumber: number): Promise<void>;
+        markFailed(repoId: string, prNumber: number, reason: string): Promise<void>;
+        markBlocked(repoId: string, prNumber: number, reason: string): Promise<void>;
+    };
+    redis: {
+        setNX(key: string, value: string, ttlSeconds?: number): Promise<boolean>;
+        del(key: string): Promise<void>;
+        get(key: string): Promise<string | null>;
+        set(key: string, value: string): Promise<void>;
+        expire(key: string, seconds: number): Promise<void>;
+    };
+}
+export interface MergeProcessResult {
+    prNumber: number;
+    status: 'merged' | 'conflict' | 'test-failure' | 'error';
+    message?: string;
+}
+export declare class MergeWorker {
+    private config;
+    private deps;
+    private running;
+    private heartbeatTimer;
+    constructor(config: MergeWorkerConfig, deps: MergeWorkerDeps);
+    /**
+     * Start the merge worker. Acquires a lock, then loops processing the queue.
+     */
+    start(signal?: AbortSignal): Promise<void>;
+    /**
+     * Stop the merge worker gracefully (finishes current merge before stopping).
+     */
+    stop(): void;
+    /**
+     * Process a single queue entry: rebase -> resolve conflicts -> regenerate lock files -> test -> merge
+     */
+    processEntry(entry: {
+        prNumber: number;
+        sourceBranch: string;
+        targetBranch?: string;
+        issueIdentifier?: string;
+        prUrl?: string;
+    }): Promise<MergeProcessResult>;
+    private runTests;
+    private startHeartbeat;
+    private stopHeartbeat;
+    private sleep;
+}
+//# sourceMappingURL=merge-worker.d.ts.map

package/dist/src/merge-queue/merge-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-worker.d.ts","sourceRoot":"","sources":["../../../src/merge-queue/merge-worker.ts"],"names":[],"mappings":"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"}

package/dist/src/merge-queue/merge-worker.js

@@ -0,0 +1,221 @@
+/**
+ * Merge Worker — Single-Instance Processor
+ *
+ * Implements the core rebase -> resolve conflicts -> regenerate lock files -> test -> merge loop.
+ * Acquires a Redis lock to ensure only one worker processes a given repository's queue at a time.
+ * Uses heartbeat to extend the lock TTL while processing, and supports graceful shutdown.
+ *
+ * All external dependencies (storage, redis) are injected via MergeWorkerDeps for testability.
+ */
+import { exec as execCb } from 'child_process';
+import { promisify } from 'util';
+import { createMergeStrategy } from './strategies/index.js';
+import { ConflictResolver } from './conflict-resolver.js';
+import { LockFileRegeneration } from './lock-file-regeneration.js';
+const exec = promisify(execCb);
+// ---------------------------------------------------------------------------
+// MergeWorker
+// ---------------------------------------------------------------------------
+export class MergeWorker {
+    config;
+    deps;
+    running = false;
+    heartbeatTimer = null;
+    constructor(config, deps) {
+        this.config = config;
+        this.deps = deps;
+    }
+    // ---------------------------------------------------------------------------
+    // Public API
+    // ---------------------------------------------------------------------------
+    /**
+     * Start the merge worker. Acquires a lock, then loops processing the queue.
+     */
+    async start(signal) {
+        // Acquire single-instance lock
+        const lockKey = `merge:lock:${this.config.repoId}`;
+        const acquired = await this.deps.redis.setNX(lockKey, 'worker', 300); // 5 min TTL
+        if (!acquired) {
+            throw new Error(`Another merge worker is already running for repo ${this.config.repoId}`);
+        }
+        this.running = true;
+        this.startHeartbeat(lockKey);
+        try {
+            while (this.running && !(signal?.aborted)) {
+                // Check if paused
+                const paused = await this.deps.redis.get(`merge:paused:${this.config.repoId}`);
+                if (paused) {
+                    await this.sleep(this.config.pollInterval, signal);
+                    continue;
+                }
+                // Try to dequeue next PR
+                const entry = await this.deps.storage.dequeue(this.config.repoId);
+                if (!entry) {
+                    // Queue empty — poll interval wait
+                    await this.sleep(this.config.pollInterval, signal);
+                    continue;
+                }
+                // Process the PR
+                const result = await this.processEntry(entry);
+                // Handle result
+                switch (result.status) {
+                    case 'merged':
+                        await this.deps.storage.markCompleted(this.config.repoId, result.prNumber);
+                        break;
+                    case 'conflict':
+                        await this.deps.storage.markBlocked(this.config.repoId, result.prNumber, result.message ?? 'Merge conflict');
+                        break;
+                    case 'test-failure': {
+                        const action = this.config.escalation.onTestFailure;
+                        if (action === 'park') {
+                            await this.deps.storage.markBlocked(this.config.repoId, result.prNumber, result.message ?? 'Tests failed');
+                        }
+                        else {
+                            await this.deps.storage.markFailed(this.config.repoId, result.prNumber, result.message ?? 'Tests failed');
+                        }
+                        break;
+                    }
+                    case 'error':
+                        await this.deps.storage.markFailed(this.config.repoId, result.prNumber, result.message ?? 'Unknown error');
+                        break;
+                }
+            }
+        }
+        finally {
+            // Graceful shutdown — release lock
+            this.stopHeartbeat();
+            await this.deps.redis.del(lockKey);
+            this.running = false;
+        }
+    }
+    /**
+     * Stop the merge worker gracefully (finishes current merge before stopping).
+     */
+    stop() {
+        this.running = false;
+    }
+    /**
+     * Process a single queue entry: rebase -> resolve conflicts -> regenerate lock files -> test -> merge
+     */
+    async processEntry(entry) {
+        const strategy = createMergeStrategy(this.config.strategy);
+        const conflictResolver = new ConflictResolver({
+            mergirafEnabled: this.config.mergiraf,
+            escalationStrategy: this.config.escalation.onConflict,
+        });
+        const lockFileHandler = new LockFileRegeneration();
+        const ctx = {
+            repoPath: this.config.repoPath,
+            worktreePath: this.config.repoPath, // In production, would use a dedicated worktree
+            sourceBranch: entry.sourceBranch,
+            targetBranch: entry.targetBranch ?? this.config.targetBranch,
+            prNumber: entry.prNumber,
+            remote: this.config.remote,
+        };
+        try {
+            // 1. Prepare: fetch latest main
+            const prepareResult = await strategy.prepare(ctx);
+            if (!prepareResult.success) {
+                return { prNumber: entry.prNumber, status: 'error', message: `Prepare failed: ${prepareResult.error}` };
+            }
+            // 2. Execute merge strategy (rebase/merge/squash)
+            const mergeResult = await strategy.execute(ctx);
+            // 3. Handle conflicts
+            if (mergeResult.status === 'conflict') {
+                const resolution = await conflictResolver.resolve({
+                    repoPath: ctx.repoPath,
+                    worktreePath: ctx.worktreePath,
+                    sourceBranch: ctx.sourceBranch,
+                    targetBranch: ctx.targetBranch,
+                    prNumber: ctx.prNumber,
+                    issueIdentifier: entry.issueIdentifier ?? `PR-${entry.prNumber}`,
+                    conflictFiles: mergeResult.conflictFiles ?? [],
+                    conflictDetails: mergeResult.conflictDetails,
+                });
+                if (resolution.status !== 'resolved') {
+                    return {
+                        prNumber: entry.prNumber,
+                        status: 'conflict',
+                        message: resolution.message ?? `Unresolved conflicts in: ${(resolution.unresolvedFiles ?? []).join(', ')}`,
+                    };
+                }
+            }
+            else if (mergeResult.status === 'error') {
+                return { prNumber: entry.prNumber, status: 'error', message: mergeResult.error ?? 'Merge strategy failed' };
+            }
+            // 4. Regenerate lock files if configured
+            if (lockFileHandler.shouldRegenerate(this.config.packageManager, this.config.lockFileRegenerate)) {
+                const regenResult = await lockFileHandler.regenerate(ctx.worktreePath, this.config.packageManager);
+                if (!regenResult.success) {
+                    return { prNumber: entry.prNumber, status: 'error', message: `Lock file regeneration failed: ${regenResult.error}` };
+                }
+            }
+            // 5. Run test suite
+            const testResult = await this.runTests(ctx.worktreePath);
+            if (!testResult.passed) {
+                return { prNumber: entry.prNumber, status: 'test-failure', message: testResult.output };
+            }
+            // 6. Finalize: push and merge
+            await strategy.finalize(ctx);
+            // 7. Delete branch if configured
+            if (this.config.deleteBranchOnMerge) {
+                try {
+                    await exec(`git push ${this.config.remote} --delete ${entry.sourceBranch}`, {
+                        cwd: ctx.worktreePath,
+                    });
+                }
+                catch {
+                    // Branch deletion failure is non-fatal
+                }
+            }
+            return { prNumber: entry.prNumber, status: 'merged' };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return { prNumber: entry.prNumber, status: 'error', message };
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Private helpers
+    // ---------------------------------------------------------------------------
+    async runTests(worktreePath) {
+        try {
+            const { stdout, stderr } = await exec(this.config.testCommand, {
+                cwd: worktreePath,
+                timeout: this.config.testTimeout,
+                maxBuffer: 10 * 1024 * 1024, // 10MB
+            });
+            return { passed: true, output: stdout + stderr };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.stdout ?? error.message : String(error);
+            return { passed: false, output: message };
+        }
+    }
+    startHeartbeat(lockKey) {
+        // Extend lock TTL every 60 seconds
+        this.heartbeatTimer = setInterval(async () => {
+            try {
+                await this.deps.redis.expire(lockKey, 300);
+            }
+            catch {
+                // Heartbeat failure — will be handled by TTL expiry
+            }
+        }, 60_000);
+    }
+    stopHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
+    sleep(ms, signal) {
+        return new Promise((resolve) => {
+            const timer = setTimeout(resolve, ms);
+            signal?.addEventListener('abort', () => {
+                clearTimeout(timer);
+                resolve();
+            }, { once: true });
+        });
+    }
+}

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

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

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

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