@funnelsgrove/cli 0.1.67 → 0.1.71

package/README.md

@@ -30,9 +30,12 @@ fgrove publish --env preview
 Inside a synced folder, `fgrove` reads `.funnelsgrove-sync.json` first, so you do not need to run `fgrove use` when switching between local funnel directories. Use `fgrove use` only when you want a global fallback context for commands outside a synced folder.
 
 `fgrove sync down` refuses to overwrite local changes in an existing synced
-folder unless `--force` is passed. If `fgrove sync up` says the remote draft
-changed since your local sync, download the latest draft into a clean temporary
-directory, merge your local changes, rerun checks, and sync again.
+folder. If `fgrove sync up` says the remote draft changed since your local sync,
+run `fgrove sync rebase`: it performs a three-way merge from the recorded base,
+preserves CLI-managed files, and leaves the working tree untouched when it finds
+conflicts. Review the merged diff, rerun `fgrove validate`, then sync up again.
+`sync down --force` is the explicit discard path and writes an automatic source
+backup under `.funnelsgrove/rebase-backups/` before replacing hosted paths.
 
 `fgrove sync up` is for funnels without GitHub source sync. When GitHub is
 connected, commit and push source changes with normal git, then run `fgrove

package/dist/cli.d.ts

@@ -151,7 +151,7 @@ type SyncTargetIdInput = {
 };
 type GeneratedConfigKind = 'offerSets' | 'experiments';
 export declare const SYNC_DOWN_GENERATED_CONFIG_KINDS: GeneratedConfigKind[];
-export declare const EXPERIMENT_TRANSACTION_RECOVERY_COMMANDS: readonly ["sync down", "sync up", "experiments sync", "offer-sets sync"];
+export declare const EXPERIMENT_TRANSACTION_RECOVERY_COMMANDS: readonly ["sync down", "sync rebase", "sync up", "experiments sync", "offer-sets sync"];
 export declare function resolveSyncTargetIds(input: SyncTargetIdInput): {
     workspaceId: string;
     funnelId?: string;

package/dist/cli.js

@@ -11,7 +11,8 @@ import { CURRENT_STEP_CONTRACT_VERSION, FUNNEL_CONTRACT_DIAGNOSTIC_CODES, PREVIO
 import { abortFunnelSourceCandidate, beginFunnelSourceCandidate, callTrpcProcedure, createFunnelExperimentFromSpec, finalizeFunnelSourceCandidate, stageFunnelSourceCandidate, } from './apiClient.js';
 import { cliReleaseIdentity } from './cliIdentity.js';
 import { clearActiveContext, getDefaultAuthConfigPath, loadActiveContext, loadAuthToken, saveActiveContext, saveAuthToken, } from './authStore.js';
-import { buildCommittedSyncManifest, buildDownloadedSyncManifest, buildSourceCandidateOperations, collectChangedSourceFiles, collectSourceSnapshot, ensureGitignore, formatSyncUploadSummary, hasLocalSourceChanges, readSyncManifest, runSyncDownLocalLifecycle, runSourceCandidateSync, writeLocalEnvFile, writeSourceFiles, writeSyncManifest, } from './localSync.js';
+import { buildCommittedSyncManifest, buildDownloadedSyncManifest, buildSourceCandidateOperations, collectChangedSourceFiles, collectSourceFiles, collectSourceSnapshot, ensureGitignore, formatSyncUploadSummary, hasLocalSourceChanges, rebaseSourceFiles, readSyncManifest, replaceSourceFiles, runSyncDownLocalLifecycle, runSourceCandidateSync, writeLocalEnvFile, writeSourceFiles, writeSourceRebaseBackup, writeSyncManifest, } from './localSync.js';
+import { mergeTextSourceWithGit } from './sourceRebase.js';
 import { executeExperimentCreate, formatExperimentCreateSuccess, recoverExperimentCreateTransaction, } from './experimentCreate.js';
 import { pullEnvFile } from './envSync.js';
 import { formatGitHubConnectRows, formatGitHubJobRows, formatGitHubStatusRows, } from './githubOutput.js';
@@ -532,6 +533,16 @@ export const repairDownloadedManagedFiles = async (targetDir, options = {}) => {
         await resolveTemplateDocsConflict(bundle, targetDir, conflict.path);
     }
 };
+const loadManagedSyncPaths = async () => {
+    const docsBundle = await loadBundledDocs(resolveTemplateDocsPath());
+    const validationManifest = parseContractToolsManifest(await readFile(path.join(resolveTemplateValidationPath(), CONTRACT_TOOLS_MANIFEST_PATH)), 'FG-DOC-001');
+    return new Set([
+        '.funnelsgrove-docs.json',
+        CONTRACT_TOOLS_MANIFEST_PATH,
+        ...docsBundle.files.keys(),
+        ...validationManifest.managedFiles.map((file) => file.path),
+    ]);
+};
 const MANAGED_VALIDATOR_SCRIPT = 'vite-node --config src/contract/funnel-validator.vite.config.ts src/contract/validate-funnel.cli.ts';
 const ensureManagedValidatorPackage = async (targetDir) => {
     const packagePath = path.join(targetDir, 'package.json');
@@ -1060,6 +1071,7 @@ const GENERATED_CONFIG_PATH_BY_KIND = {
 export const SYNC_DOWN_GENERATED_CONFIG_KINDS = ['offerSets'];
 export const EXPERIMENT_TRANSACTION_RECOVERY_COMMANDS = [
     'sync down',
+    'sync rebase',
     'sync up',
     'experiments sync',
     'offer-sets sync',
@@ -2124,15 +2136,27 @@ addExamples(analyticsCommand
 });
 const syncCommand = addExamples(program.command('sync').description('Sync funnel source'), [
     'fgrove sync down --funnel claimbee-ios --dir ./claimbee-ios',
+    'fgrove sync rebase --dir ./claimbee-ios',
     'fgrove sync up --message "Update copy"',
 ]);
+const assertHistoricalSyncBaseline = (input) => {
+    const historical = buildDownloadedSyncManifest({
+        workspaceId: input.manifest.workspaceId,
+        funnelId: input.manifest.funnelId,
+        draftVersionId: input.manifest.draftVersionId,
+        files: input.files,
+    });
+    if (JSON.stringify(historical.files) !== JSON.stringify(input.manifest.files)) {
+        throw Object.assign(new Error('The historical hosted draft no longer matches this local sync baseline. The rebase was not applied; preserve the local directory and contact FunnelsGrove support.'), { code: 'FG-SYNC-REBASE-BASE' });
+    }
+};
 addExamples(syncCommand
     .command('down')
     .description('Download funnel draft source to a local directory')
     .option('--workspace <id-or-slug-or-name>', 'Workspace id, slug, or name')
     .option('--funnel <id-or-slug>', 'Funnel id or slug')
     .requiredOption('--dir <path>', 'Local target directory')
-    .option('--force', 'Overwrite local changes in an existing synced directory'), [
+    .option('--force', 'Replace hosted source paths after saving an automatic local source backup'), [
     'fgrove sync down --funnel claimbee-ios --dir ./claimbee-ios',
 ])
     .action(async (options) => {
@@ -2143,8 +2167,11 @@ addExamples(syncCommand
         funnel: options.funnel,
         dir: options.dir,
     });
-    if (!options.force && target.manifest && await hasLocalSourceChanges(target.sourceDir, target.manifest)) {
-        throw new Error('Local sync directory has unuploaded changes. Commit, stash, sync up, or merge them before `fgrove sync down`; pass `--force` only if overwriting local changes is intentional.');
+    const hasLocalChanges = target.manifest
+        ? await hasLocalSourceChanges(target.sourceDir, target.manifest)
+        : false;
+    if (!options.force && hasLocalChanges) {
+        throw new Error('Local sync directory has unuploaded changes. Run `fgrove sync rebase --dir <path>` to preserve them, or pass `--force` only if replacing hosted source paths is intentional; force creates an automatic backup.');
     }
     const result = await callApi({
         path: 'funnels.exportSource',
@@ -2161,6 +2188,16 @@ addExamples(syncCommand
         draftVersionId: result.draftVersionId,
         files: result.files,
     });
+    if (options.force && target.manifest && hasLocalChanges) {
+        const localFiles = await collectSourceFiles(target.sourceDir);
+        const backupPath = await writeSourceRebaseBackup({
+            rootDir: target.sourceDir,
+            files: localFiles,
+            manifest: target.manifest,
+            remoteDraftVersionId: result.draftVersionId,
+        });
+        console.log(`Saved the pre-force source backup to ${path.join(target.sourceDir, backupPath)}`);
+    }
     await mkdir(target.sourceDir, { recursive: true });
     await writeSourceFiles(target.sourceDir, result.files);
     const generatedFiles = await syncGeneratedConfigFilesForCli({
@@ -2189,6 +2226,115 @@ addExamples(syncCommand
     console.log(`Synced ${result.files.length} files to ${target.sourceDir}`);
     console.log(`Wrote ${formatGeneratedFileCount(generatedFiles.length)}`);
 });
+addExamples(syncCommand
+    .command('rebase')
+    .description('Merge local source changes onto the latest hosted draft without discarding them')
+    .option('--workspace <id-or-slug-or-name>', 'Workspace id, slug, or name')
+    .option('--funnel <id-or-slug>', 'Funnel id or slug')
+    .option('--dir <path>', 'Local funnel directory', '.'), [
+    'fgrove sync rebase',
+    'fgrove sync rebase --dir ./claimbee-ios',
+])
+    .action(async (options) => {
+    const token = await readAuthToken();
+    const target = await resolveSyncTarget({
+        token,
+        workspace: options.workspace,
+        funnel: options.funnel,
+        dir: options.dir,
+    });
+    if (!target.manifest) {
+        throw Object.assign(new Error('No local sync baseline found. Run `fgrove sync down` into a new directory before rebasing.'), { code: 'FG-SYNC-REBASE-BASE' });
+    }
+    const remote = await callApi({
+        path: 'funnels.exportSource',
+        type: 'query',
+        token,
+        data: {
+            workspaceId: target.workspaceId,
+            funnelId: target.funnelId,
+        },
+    });
+    if (remote.draftVersionId === target.manifest.draftVersionId) {
+        console.log(`Local source is already based on hosted draft ${remote.draftVersionId}; no rebase is needed.`);
+        return;
+    }
+    const base = await callApi({
+        path: 'funnels.exportSource',
+        type: 'query',
+        token,
+        data: {
+            workspaceId: target.workspaceId,
+            funnelId: target.funnelId,
+            versionId: target.manifest.draftVersionId,
+        },
+    });
+    if (base.draftVersionId !== target.manifest.draftVersionId) {
+        throw Object.assign(new Error('The hosted historical export returned the wrong sync baseline. The rebase was not applied.'), { code: 'FG-SYNC-REBASE-BASE' });
+    }
+    assertHistoricalSyncBaseline({ manifest: target.manifest, files: base.files });
+    const localFiles = await collectSourceFiles(target.sourceDir);
+    const merged = await rebaseSourceFiles({
+        baseFiles: base.files,
+        localFiles,
+        remoteFiles: remote.files,
+        remoteOwnedPaths: await loadManagedSyncPaths(),
+        mergeText: mergeTextSourceWithGit,
+    });
+    if (merged.conflicts.length > 0) {
+        const conflictLines = merged.conflicts.map((conflict) => `  ${conflict.kind.padEnd(15)} ${conflict.path}`);
+        throw Object.assign(new Error([
+            `Rebase found ${merged.conflicts.length} conflicting ${merged.conflicts.length === 1 ? 'path' : 'paths'}; no local files were changed.`,
+            ...conflictLines,
+            'Resolve these paths against a fresh sync directory, or commit the local work and retry after reconciling the overlapping edits.',
+        ].join('\n')), { code: 'FG-SYNC-REBASE-CONFLICT' });
+    }
+    const backupPath = await writeSourceRebaseBackup({
+        rootDir: target.sourceDir,
+        files: localFiles,
+        manifest: target.manifest,
+        remoteDraftVersionId: remote.draftVersionId,
+    });
+    console.log(`Saved the pre-rebase source backup to ${path.join(target.sourceDir, backupPath)}`);
+    const downloadedSyncManifest = buildDownloadedSyncManifest({
+        workspaceId: target.workspaceId,
+        funnelId: target.funnelId,
+        draftVersionId: remote.draftVersionId,
+        files: remote.files,
+    });
+    await replaceSourceFiles({
+        rootDir: target.sourceDir,
+        currentFiles: localFiles,
+        nextFiles: merged.files,
+    });
+    const generatedFiles = await syncGeneratedConfigFilesForCli({
+        token,
+        target,
+        kinds: SYNC_DOWN_GENERATED_CONFIG_KINDS,
+    });
+    await writeLocalEnvFile(target.sourceDir, remote.envFile);
+    await ensureGitignore(target.sourceDir);
+    await runSyncDownLocalLifecycle({
+        recoverMigration: async () => recoverStepContractV2Migration(target.sourceDir),
+        recoverDocs: async () => repairDownloadedManagedFiles(target.sourceDir),
+        refreshDocs: async () => {
+            const docs = await executeDocsCommand({
+                targetDir: target.sourceDir,
+                options: { json: true },
+            });
+            if (docs.exitCode !== 0) {
+                const output = JSON.parse(docs.output);
+                const diagnostic = output.diagnostics?.[0];
+                throw new CliContractError(diagnostic?.code ?? 'FG-DOC-001', diagnostic?.message ?? 'Managed documentation refresh failed after sync rebase.');
+            }
+        },
+        writeSyncState: async () => writeSyncManifest(target.sourceDir, downloadedSyncManifest),
+    });
+    const localChanges = await collectChangedSourceFiles(target.sourceDir, downloadedSyncManifest);
+    console.log(`Rebased ${localChanges.files.length + localChanges.deletedPaths.length} local changes onto hosted draft ${remote.draftVersionId}.`);
+    console.log(`Wrote ${formatGeneratedFileCount(generatedFiles.length)}`);
+    console.log('Run `fgrove validate`, review the diff, then run `fgrove sync up`.');
+});
 const envCommand = addExamples(program.command('env').description('Manage local funnel environment files'), [
     'fgrove env pull --dir ./claimbee-ios',
 ]);

package/dist/localSync.d.ts

@@ -30,6 +30,24 @@ export type SourceFilePatchBatch = {
     deletedPaths: string[];
     files: SourceFile[];
 };
+export type SourceRebaseConflictKind = 'add-add' | 'delete-modify' | 'modify-delete' | 'modify-modify';
+export type SourceRebaseConflict = {
+    path: string;
+    kind: SourceRebaseConflictKind;
+};
+export type SourceTextMerge = (input: {
+    path: string;
+    base: string;
+    local: string;
+    remote: string;
+}) => Promise<{
+    content: string;
+    clean: boolean;
+}>;
+export type SourceRebaseResult = {
+    files: SourceFile[];
+    conflicts: SourceRebaseConflict[];
+};
 export type SourceCandidateOperation = {
     type: 'create' | 'modify';
     path: string;
@@ -86,6 +104,7 @@ export type SyncDownLocalLifecycle = {
 export declare function runSyncDownLocalLifecycle(lifecycle: SyncDownLocalLifecycle): Promise<void>;
 export declare const assertSafeRootFileWriteTarget: (rootDir: string, relativePath: string) => Promise<void>;
 export declare const readSafeRootFile: (rootDir: string, relativePath: string) => Promise<Buffer>;
+export declare const removeSafeRootFile: (rootDir: string, relativePath: string) => Promise<void>;
 export declare const writeSafeRootFile: (rootDir: string, relativePath: string, content: string | Buffer, hooks?: SafeRootWriteHooks) => Promise<void>;
 export declare function normalizeSyncPath(filePath: string): string;
 export declare function assertSafeSyncPath(filePath: string): string;
@@ -109,6 +128,24 @@ export declare function collectSourceSnapshot(rootDir: string): Promise<{
     sourceFiles: SourceFile[];
 }>;
 export declare function collectSourceFiles(rootDir: string): Promise<SourceFile[]>;
+export declare function rebaseSourceFiles(input: {
+    baseFiles: readonly SourceFile[];
+    localFiles: readonly SourceFile[];
+    remoteFiles: readonly SourceFile[];
+    remoteOwnedPaths?: ReadonlySet<string>;
+    mergeText?: SourceTextMerge;
+}): Promise<SourceRebaseResult>;
+export declare function replaceSourceFiles(input: {
+    rootDir: string;
+    currentFiles: readonly SourceFile[];
+    nextFiles: readonly SourceFile[];
+}): Promise<void>;
+export declare function writeSourceRebaseBackup(input: {
+    rootDir: string;
+    files: readonly SourceFile[];
+    manifest: SyncManifest;
+    remoteDraftVersionId: string;
+}): Promise<string>;
 export declare function collectChangedSourceFiles(rootDir: string, previousManifest: SyncManifest): Promise<ChangedSourceFiles>;
 export declare function hasLocalSourceChanges(rootDir: string, previousManifest: SyncManifest): Promise<boolean>;
 export declare function chunkChangedSourceFiles(changes: Pick<ChangedSourceFiles, 'deletedPaths' | 'files'>, maxContentChars?: number): SourceFilePatchBatch[];

package/dist/localSync.js

@@ -186,6 +186,23 @@ export const readSafeRootFile = async (rootDir, relativePath) => {
         await handle.close();
     }
 };
+export const removeSafeRootFile = async (rootDir, relativePath) => {
+    const resolvedRoot = await resolveSafeRoot(rootDir, false);
+    const absolutePath = await assertSafeExistingPath(resolvedRoot, relativePath, false, true);
+    try {
+        const metadata = await lstat(absolutePath);
+        if (metadata.isSymbolicLink() || !metadata.isFile()) {
+            throw sourceCandidateInvariantError(`Local sync path is not a regular file: ${relativePath}`);
+        }
+    }
+    catch (error) {
+        if (isErrno(error, 'ENOENT'))
+            return;
+        throw error;
+    }
+    await rm(absolutePath);
+    await syncDirectory(path.dirname(absolutePath));
+};
 export const writeSafeRootFile = async (rootDir, relativePath, content, hooks = {}) => {
     const resolvedRoot = await resolveSafeRoot(rootDir, true);
     const absolutePath = await assertSafeExistingPath(resolvedRoot, relativePath, true, false, hooks);
@@ -365,6 +382,119 @@ export async function collectSourceSnapshot(rootDir) {
 export async function collectSourceFiles(rootDir) {
     return (await collectSourceSnapshot(rootDir)).sourceFiles;
 }
+const sourceFileBytes = (file) => (decodeBinarySourceContent(file) ?? Buffer.from(file.content, 'utf8'));
+const sourceFilesEqual = (left, right) => {
+    if (!left || !right)
+        return left === right;
+    return sourceFileBytes(left).equals(sourceFileBytes(right));
+};
+const mapSourceFiles = (files, label) => {
+    const output = new Map();
+    const pathByFolded = new Map();
+    for (const file of files) {
+        const filePath = assertSafeSyncTargetPath(file.path);
+        const folded = filePath.toLocaleLowerCase('en-US');
+        const previousPath = pathByFolded.get(folded);
+        if (previousPath) {
+            throw sourceCandidateInvariantError(`${label} source repeats or case-collides at: ${previousPath}, ${filePath}`);
+        }
+        pathByFolded.set(folded, filePath);
+        output.set(filePath, file);
+    }
+    return output;
+};
+const isTextSourceFile = (file) => (decodeBinarySourceContent(file) === null && !Buffer.from(file.content, 'utf8').includes(0));
+export async function rebaseSourceFiles(input) {
+    const base = mapSourceFiles(input.baseFiles, 'Base');
+    const local = mapSourceFiles(input.localFiles, 'Local');
+    const remote = mapSourceFiles(input.remoteFiles, 'Remote');
+    const paths = Array.from(new Set([...base.keys(), ...local.keys(), ...remote.keys()]))
+        .sort((left, right) => left.localeCompare(right));
+    const files = [];
+    const conflicts = [];
+    for (const filePath of paths) {
+        const baseFile = base.get(filePath);
+        const localFile = local.get(filePath);
+        const remoteFile = remote.get(filePath);
+        if (input.remoteOwnedPaths?.has(filePath)) {
+            if (remoteFile)
+                files.push(remoteFile);
+            continue;
+        }
+        if (sourceFilesEqual(localFile, remoteFile)) {
+            if (localFile)
+                files.push(localFile);
+            continue;
+        }
+        if (sourceFilesEqual(localFile, baseFile)) {
+            if (remoteFile)
+                files.push(remoteFile);
+            continue;
+        }
+        if (sourceFilesEqual(remoteFile, baseFile)) {
+            if (localFile)
+                files.push(localFile);
+            continue;
+        }
+        if (!baseFile) {
+            conflicts.push({ path: filePath, kind: 'add-add' });
+            continue;
+        }
+        if (!localFile) {
+            conflicts.push({ path: filePath, kind: 'delete-modify' });
+            continue;
+        }
+        if (!remoteFile) {
+            conflicts.push({ path: filePath, kind: 'modify-delete' });
+            continue;
+        }
+        if (input.mergeText
+            && isTextSourceFile(baseFile)
+            && isTextSourceFile(localFile)
+            && isTextSourceFile(remoteFile)) {
+            const merged = await input.mergeText({
+                path: filePath,
+                base: sourceFileBytes(baseFile).toString('utf8'),
+                local: sourceFileBytes(localFile).toString('utf8'),
+                remote: sourceFileBytes(remoteFile).toString('utf8'),
+            });
+            if (merged.clean) {
+                files.push({ path: filePath, content: merged.content, contentType: 'text/plain' });
+                continue;
+            }
+        }
+        conflicts.push({ path: filePath, kind: 'modify-modify' });
+    }
+    return { files, conflicts };
+}
+export async function replaceSourceFiles(input) {
+    const current = mapSourceFiles(input.currentFiles, 'Current');
+    const next = mapSourceFiles(input.nextFiles, 'Next');
+    const deletedPaths = Array.from(current.keys())
+        .filter((filePath) => !next.has(filePath))
+        .sort((left, right) => left.localeCompare(right));
+    for (const filePath of deletedPaths) {
+        await removeSafeRootFile(input.rootDir, filePath);
+    }
+    await writeSourceFiles(input.rootDir, Array.from(next.values()));
+}
+export async function writeSourceRebaseBackup(input) {
+    mapSourceFiles(input.files, 'Backup');
+    const backupId = `${new Date().toISOString().replace(/[:.]/g, '-')}-${randomUUID()}`;
+    const backupRoot = `.funnelsgrove/rebase-backups/${backupId}`;
+    for (const file of input.files) {
+        await writeSafeRootFile(input.rootDir, `${backupRoot}/source/${file.path}`, sourceFileBytes(file));
+    }
+    await writeSafeRootFile(input.rootDir, `${backupRoot}/metadata.json`, `${JSON.stringify({
+        schemaVersion: 1,
+        createdAt: new Date().toISOString(),
+        baseDraftVersionId: input.manifest.draftVersionId,
+        remoteDraftVersionId: input.remoteDraftVersionId,
+        sourcePaths: input.files.map((file) => file.path).sort((left, right) => left.localeCompare(right)),
+        syncManifest: input.manifest,
+    }, null, 2)}\n`);
+    return backupRoot;
+}
 export async function collectChangedSourceFiles(rootDir, previousManifest) {
     const currentManifest = await buildSyncManifest(rootDir, {
         workspaceId: previousManifest.workspaceId,

package/dist/sourceRebase.d.ts

@@ -0,0 +1,2 @@
+import type { SourceTextMerge } from './localSync.js';
+export declare const mergeTextSourceWithGit: SourceTextMerge;

package/dist/sourceRebase.js

@@ -0,0 +1,66 @@
+import { spawn } from 'node:child_process';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+const MAX_MERGE_OUTPUT_BYTES = 15 * 1024 * 1024;
+const runGitMergeFile = async (input) => new Promise((resolve, reject) => {
+    const child = spawn('git', [
+        'merge-file',
+        '--stdout',
+        '--diff3',
+        '-L', 'LOCAL',
+        '-L', 'BASE',
+        '-L', 'REMOTE',
+        input.localPath,
+        input.basePath,
+        input.remotePath,
+    ], { stdio: ['ignore', 'pipe', 'pipe'] });
+    const stdout = [];
+    const stderr = [];
+    let outputBytes = 0;
+    child.stdout.on('data', (chunk) => {
+        outputBytes += chunk.length;
+        if (outputBytes > MAX_MERGE_OUTPUT_BYTES) {
+            child.kill('SIGKILL');
+            return;
+        }
+        stdout.push(chunk);
+    });
+    child.stderr.on('data', (chunk) => stderr.push(chunk));
+    child.once('error', (error) => {
+        reject(new Error(error.code === 'ENOENT'
+            ? 'fgrove sync rebase requires Git for overlapping text-file changes.'
+            : `Unable to run git merge-file: ${error.message}`));
+    });
+    child.once('close', (code) => {
+        if (outputBytes > MAX_MERGE_OUTPUT_BYTES) {
+            reject(new Error('Merged file exceeds the 15 MiB safety limit.'));
+            return;
+        }
+        if (code !== 0 && code !== 1) {
+            reject(new Error(`git merge-file failed${stderr.length > 0 ? `: ${Buffer.concat(stderr).toString('utf8').trim()}` : '.'}`));
+            return;
+        }
+        resolve({
+            content: Buffer.concat(stdout).toString('utf8'),
+            clean: code === 0,
+        });
+    });
+});
+export const mergeTextSourceWithGit = async (input) => {
+    const tempDir = await mkdtemp(path.join(os.tmpdir(), 'fgrove-rebase-'));
+    const localPath = path.join(tempDir, 'local');
+    const basePath = path.join(tempDir, 'base');
+    const remotePath = path.join(tempDir, 'remote');
+    try {
+        await Promise.all([
+            writeFile(localPath, input.local),
+            writeFile(basePath, input.base),
+            writeFile(remotePath, input.remote),
+        ]);
+        return await runGitMergeFile({ localPath, basePath, remotePath });
+    }
+    finally {
+        await rm(tempDir, { recursive: true, force: true });
+    }
+};