@idea1/cli 1.7.7 → 1.8.0

package/dist/services/git.js

@@ -2,9 +2,8 @@ import { exec, execOrThrow } from '../lib/shell.js';
 import { logger } from '../lib/logger.js';
 import { dirname, basename, join, resolve } from 'path';
 import { tmpdir } from 'os';
-import { mkdir, mkdtemp, writeFile, readFile, readdir, unlink, rm } from 'fs/promises';
+import { mkdtemp, writeFile, rm } from 'fs/promises';
 import { access } from 'fs/promises';
-import { DEFAULT_BRANCH_SETTINGS, SETTINGS_FILES, getBranchPrefix, getIntegrationBranchPrefix } from '../lib/settings.js';
 /**
  * Check if a directory exists
  */
@@ -17,100 +16,6 @@ async function directoryExists(path) {
         return false;
     }
 }
-/**
- * Sanitize a branch name for use as a filename by replacing `/` with `--`
- */
-function sanitizeBranchNameForFilename(branchName) {
-    return branchName.replace(/\//g, '--');
-}
-/**
- * Reverse of sanitizeBranchNameForFilename: `--` back to `/`
- */
-function branchNameFromFilename(filename) {
-    return filename.replace(/\.json$/, '').replace(/--/g, '/');
-}
-/**
- * Path of a branch's metadata JSON file relative to the repository root
- */
-export function getBranchMetadataRelativePath(branchName) {
-    return `.idea1/${sanitizeBranchNameForFilename(branchName)}.json`;
-}
-/**
- * Get the path to a branch's metadata JSON file inside `.idea1/`
- */
-function getBranchMetadataPath(worktreePath, branchName) {
-    return join(worktreePath, getBranchMetadataRelativePath(branchName));
-}
-/**
- * The on-disk form of a branch metadata file. The web client writes the same
- * bytes through the GitHub API, so keep this exact (2-space indent, trailing newline).
- */
-export function serializeBranchMetadata(metadata) {
-    return JSON.stringify(metadata, null, 2) + '\n';
-}
-/**
- * Read branch metadata from the JSON file in the current working tree.
- * Returns null if the file doesn't exist.
- */
-export async function readBranchMetadata(branchName) {
-    const branch = branchName ?? await getCurrentBranch();
-    const repoRoot = await getRepoRoot();
-    const metadataPath = getBranchMetadataPath(repoRoot, branch);
-    try {
-        const content = await readFile(metadataPath, 'utf-8');
-        return JSON.parse(content);
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Read a branch's committed metadata directly from a remote ref via `git show`,
- * without checking the branch out. Returns null if the file is missing or unparseable.
- * Lets callers recover durable per-branch state from a fresh clone.
- */
-export async function readBranchMetadataFromRef(branchName, remote = 'origin') {
-    const filename = `${sanitizeBranchNameForFilename(branchName)}.json`;
-    const result = await exec('git', ['show', `${remote}/${branchName}:.idea1/${filename}`]);
-    if (result.exitCode !== 0)
-        return null;
-    try {
-        return JSON.parse(result.stdout);
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Write branch metadata to the JSON file.
- * Returns false if `.idea1/` doesn't exist (e.g., main repo before worktree creation).
- */
-export async function writeBranchMetadata(metadata, worktreePath) {
-    const root = worktreePath ?? await getRepoRoot();
-    const idea1Dir = join(root, '.idea1');
-    if (!await directoryExists(idea1Dir))
-        return false;
-    const metadataPath = getBranchMetadataPath(root, metadata.branchName);
-    await writeFile(metadataPath, serializeBranchMetadata(metadata));
-    return true;
-}
-/**
- * Partially update an existing branch metadata JSON file.
- * Silently skips if the file doesn't exist (e.g., store* called before worktree exists).
- */
-async function updateBranchMetadataFile(branchName, updates) {
-    const repoRoot = await getRepoRoot();
-    const metadataPath = getBranchMetadataPath(repoRoot, branchName);
-    try {
-        const content = await readFile(metadataPath, 'utf-8');
-        const metadata = JSON.parse(content);
-        Object.assign(metadata, updates);
-        await writeFile(metadataPath, serializeBranchMetadata(metadata));
-    }
-    catch {
-        // File doesn't exist yet — silently skip
-    }
-}
 /**
  * Get the repository root path from git
  */
@@ -224,7 +129,7 @@ export async function updateBranchToLatest(branchName) {
     const worktreePath = await getWorktreePathForBranch(branchName);
     if (worktreePath) {
         logger.step(`Branch ${branchName} is in a worktree at ${worktreePath}, pulling there...`);
-        await execOrThrow('git', ['pull', 'origin', branchName], { cwd: worktreePath });
+        await pullBranch(branchName, worktreePath);
     }
     else {
         await checkoutAndPullBranch(branchName);
@@ -237,7 +142,7 @@ export async function checkoutAndPullBranch(branchName) {
     logger.step(`Checking out ${branchName}...`);
     await execOrThrow('git', ['checkout', branchName]);
     logger.step(`Pulling latest from ${branchName}...`);
-    await execOrThrow('git', ['pull', 'origin', branchName]);
+    await pullBranch(branchName);
 }
 /**
  * Create a new branch from a base branch and push it to origin
@@ -261,13 +166,13 @@ export async function prepareRepoForWorktree(fullBranchName, destBranchName, fal
     const destWorktreePath = await getWorktreePathForBranch(destBranchName);
     if (destWorktreePath) {
         logger.step(`Branch ${destBranchName} is in a worktree at ${destWorktreePath}, pulling there...`);
-        await execOrThrow('git', ['pull', 'origin', destBranchName], { cwd: destWorktreePath });
+        await pullBranch(destBranchName, destWorktreePath);
     }
     else {
         await checkoutAndPullBranch(destBranchName);
     }
     await execOrThrow('git', ['checkout', fullBranchName]);
-    await execOrThrow('git', ['pull', 'origin', fullBranchName]);
+    await pullBranch(fullBranchName);
     logger.success(`Branch ${fullBranchName} is ready for development`);
     // Must leave main working tree NOT on fullBranchName for worktree add to work
     if (destWorktreePath) {
@@ -282,7 +187,7 @@ export async function prepareRepoForWorktree(fullBranchName, destBranchName, fal
     }
     else {
         await execOrThrow('git', ['checkout', destBranchName]);
-        await execOrThrow('git', ['pull', 'origin', destBranchName]);
+        await pullBranch(destBranchName);
     }
 }
 /**
@@ -359,7 +264,7 @@ export async function checkoutBranchInMainRepo(branchName) {
             await execOrThrow('git', ['checkout', '--track', `origin/${branchName}`]);
         }
     }
-    await execOrThrow('git', ['pull', 'origin', branchName]);
+    await pullBranch(branchName);
     logger.success(`Branch ${branchName} is checked out in ${mainRepoRoot}`);
     return mainRepoRoot;
 }
@@ -402,228 +307,50 @@ export async function enterWorktreeAndSetup(worktreePath, fullBranchName) {
     await exec('git', ['push', '-u', 'origin', fullBranchName], { cwd: worktreePath });
 }
 /**
- * Store project item URL in git config for later retrieval
+ * Remember which project item a branch implements in this clone's git config
+ * (`branch.<name>.idea1ProjectItemUrl`). A local convenience only: the platform's record of the
+ * branch is the truth, and this is what it said last time the branch was resolved here.
  */
 export async function storeProjectItemUrl(projectItemUrl, branchName) {
-    const branch = branchName ?? await getCurrentBranch();
-    if (projectItemUrl && branch) {
-        await execOrThrow('git', ['config', '--local', `branch.${branch}.idea1ProjectItemUrl`, projectItemUrl]);
-        await updateBranchMetadataFile(branch, { projectItemUrl });
-        logger.dim(`Project item URL stored in git config for ${branch}`);
-    }
-}
-/**
- * Commit a `.idea1/<sanitized-branch>.json` metadata file on the branch so all
- * per-branch metadata is discoverable from any clone via `git show`.
- * Reads current values from git config and writes them into the JSON file.
- */
-export async function commitBranchMetadata(worktreePath, branchName, projectItemUrl) {
-    const metadata = { branchName };
-    // Gather all metadata from git config
-    if (projectItemUrl)
-        metadata.projectItemUrl = projectItemUrl;
-    const storedUrl = await getProjectItemUrl(branchName);
-    if (storedUrl && !metadata.projectItemUrl)
-        metadata.projectItemUrl = storedUrl;
-    const baseBranch = await getBaseBranch(branchName);
-    if (baseBranch)
-        metadata.baseBranch = baseBranch;
-    const workflowState = await getWorkflowState(branchName);
-    if (workflowState)
-        metadata.workflowState = workflowState;
-    const devWorkflowType = await getDevWorkflowType(branchName);
-    if (devWorkflowType)
-        metadata.devWorkflowType = devWorkflowType;
-    const stackBranch = await getStackBranch(branchName);
-    if (stackBranch)
-        metadata.stackBranch = stackBranch;
-    const integrationBranch = await getIntegrationBranch(branchName);
-    if (integrationBranch)
-        metadata.integrationBranch = integrationBranch;
-    // Write JSON file
-    const idea1Dir = join(worktreePath, '.idea1');
-    await mkdir(idea1Dir, { recursive: true });
-    const filename = `${sanitizeBranchNameForFilename(branchName)}.json`;
-    await writeFile(join(idea1Dir, filename), serializeBranchMetadata(metadata));
-    await execOrThrow('git', ['add', `.idea1/${filename}`], { cwd: worktreePath });
-    await execOrThrow('git', ['commit', '-m', `idea1: link to ${metadata.projectItemUrl ?? branchName}`], { cwd: worktreePath });
-    logger.dim('Committed branch metadata to branch');
-}
-/**
- * Remove the branch's `.idea1/<sanitized-branch>.json` file, commit, and push.
- * Must be called before the PR is merged so the metadata file doesn't leak into the target branch.
- */
-export async function removeBranchMetadataAndPush(branchName) {
-    const repoRoot = await getRepoRoot();
-    const filename = `${sanitizeBranchNameForFilename(branchName)}.json`;
-    const filePath = join(repoRoot, '.idea1', filename);
-    try {
-        await access(filePath);
-    }
-    catch {
-        // File doesn't exist — nothing to remove
-        return;
-    }
-    await unlink(filePath);
-    await execOrThrow('git', ['add', `.idea1/${filename}`]);
-    await execOrThrow('git', ['commit', '-m', `idea1: remove branch metadata for ${branchName}`]);
-    await execOrThrow('git', ['push']);
-    logger.dim('Removed branch metadata file before merge');
-}
-/**
- * Stage and commit the branch metadata file if it has changed.
- * Returns true if a commit was made.
- */
-export async function commitBranchMetadataIfChanged(branchName) {
-    const repoRoot = await getRepoRoot();
-    const filename = `${sanitizeBranchNameForFilename(branchName)}.json`;
-    const filePath = join(repoRoot, '.idea1', filename);
-    try {
-        await access(filePath);
-    }
-    catch {
-        return false;
-    }
-    await execOrThrow('git', ['add', `.idea1/${filename}`]);
-    const diffResult = await exec('git', ['diff', '--cached', '--quiet']);
-    if (diffResult.exitCode === 0) {
-        return false;
+    const current = await getProjectItemUrl(branchName);
+    if (current !== projectItemUrl) {
+        await execOrThrow('git', ['config', '--local', `branch.${branchName}.idea1ProjectItemUrl`, projectItemUrl]);
     }
-    const url = await getProjectItemUrl(branchName);
-    const commitRef = url ?? branchName;
-    await execOrThrow('git', ['commit', '-m', `idea1: update metadata for ${commitRef}`]);
-    logger.dim('Committed branch metadata update');
-    return true;
 }
 /**
- * The remote-branch globs that cover every branch the workflow creates: the configured
- * branch prefix and, for integration workflows, the integration prefix. Derived from
- * settings rather than assuming `working/`, so a repo that names its branches
- * differently still resolves an item to its branch.
+ * The project item URL this clone remembers for a branch, or null for a branch it has yet to resolve.
  */
-async function workflowBranchGlobs() {
-    const prefixes = new Set([DEFAULT_BRANCH_SETTINGS.branchPrefix, DEFAULT_BRANCH_SETTINGS.integrationBranchPrefix]);
-    try {
-        const repoRoot = await getRepoRoot();
-        const [branchPrefix, integrationPrefix] = await Promise.all([
-            getBranchPrefix(repoRoot),
-            getIntegrationBranchPrefix(repoRoot)
-        ]);
-        if (branchPrefix)
-            prefixes.add(branchPrefix);
-        if (integrationPrefix)
-            prefixes.add(integrationPrefix);
-    }
-    catch {
-        // Not in a repo; the built-in prefixes are the best available guess.
-    }
-    return [...prefixes].map(prefix => `origin/${prefix}/*`);
+export async function getProjectItemUrl(branchName) {
+    const result = await exec('git', ['config', '--local', '--get', `branch.${branchName}.idea1ProjectItemUrl`]);
+    return result.exitCode === 0 && result.stdout.trim() ? result.stdout.trim() : null;
 }
 /**
- * Find a branch that has a given project item URL committed in `.idea1/<branch>.json`.
- * Searches remote branches matching the configured branch prefixes.
- * Falls back to checking the legacy `.idea1/project-item-url` for pre-migration branches.
+ * The branch this clone remembers as implementing a project item, or null for an item it has yet
+ * to resolve.
  */
-export async function findBranchByProjectItemFile(projectItemUrl) {
-    const globs = await workflowBranchGlobs();
-    const result = await exec('git', ['branch', '-r', '--list', ...globs]);
-    if (result.exitCode !== 0 || !result.stdout.trim())
+export async function findBranchWithProjectItemUrl(projectItemUrl) {
+    const result = await exec('git', ['config', '--local', '--list']);
+    if (result.exitCode !== 0) {
         return null;
-    const branches = result.stdout
-        .split('\n')
-        .map(line => line.trim())
-        .filter(name => name.length > 0 && !name.includes('HEAD'));
-    for (const remoteBranch of branches) {
-        const localName = remoteBranch.replace('origin/', '');
-        const jsonFilename = `${sanitizeBranchNameForFilename(localName)}.json`;
-        // Check new per-branch JSON file
-        const jsonResult = await exec('git', ['show', `${remoteBranch}:.idea1/${jsonFilename}`]);
-        if (jsonResult.exitCode === 0) {
-            try {
-                const metadata = JSON.parse(jsonResult.stdout);
-                if (metadata.projectItemUrl === projectItemUrl) {
-                    return localName;
-                }
-            }
-            catch {
-                // Malformed JSON — skip
-            }
-        }
-        // Backward-compat: check legacy .idea1/project-item-url
-        const legacyResult = await exec('git', ['show', `${remoteBranch}:.idea1/project-item-url`]);
-        if (legacyResult.exitCode === 0 && legacyResult.stdout.trim() === projectItemUrl) {
-            return localName;
-        }
     }
-    return null;
-}
-/**
- * Resolve the branch associated with a project item URL.
- * Fetches latest, then checks local git config (fast path) before falling back
- * to searching remote branches for the committed `.idea1/<branch>.json` metadata.
- * Returns null if no branch is found.
- */
-export async function resolveBranchFromProjectItemUrl(projectItemUrl) {
-    // Fetch latest so remote refs are up-to-date
-    await fetchLatest();
-    // Fast path: search local git config
-    const result = await exec('git', ['config', '--local', '--list']);
-    if (result.exitCode === 0) {
-        const lines = result.stdout.split('\n');
-        for (const line of lines) {
-            const match = line.match(/^branch\.(.+)\.idea1projectitemurl=(.+)$/i);
-            if (match && match[2] === projectItemUrl) {
-                return match[1];
-            }
+    for (const line of result.stdout.split('\n')) {
+        const match = line.match(/^branch\.(.+)\.idea1projectitemurl=(.+)$/i);
+        if (match && match[2] === projectItemUrl) {
+            return match[1];
         }
     }
-    // Fallback: search remote branches for committed metadata
-    return findBranchByProjectItemFile(projectItemUrl);
-}
-/**
- * Read a per-branch value from git config, falling back to the committed
- * `.idea1/<branch>.json` metadata file (the durable, remote-persisted copy)
- * when no config value is set.
- *
- * @param branchName Branch to read for (defaults to the current branch).
- * @param configKey  The `branch.<branch>.<configKey>` git config key.
- * @param fromMetadata Pulls the corresponding field out of the committed metadata.
- */
-async function readBranchValue(branchName, configKey, fromMetadata) {
-    const branch = branchName ?? await getCurrentBranch();
-    const result = await exec('git', ['config', '--local', '--get', `branch.${branch}.${configKey}`]);
-    if (result.exitCode === 0 && result.stdout.trim()) {
-        return result.stdout.trim();
-    }
-    const metadata = await readBranchMetadata(branch);
-    return (metadata ? fromMetadata(metadata) : undefined) ?? null;
-}
-/**
- * Retrieve project item URL from git config, falling back to the committed
- * `.idea1/<branch>.json` metadata file (the durable, remote-persisted copy).
- */
-export async function getProjectItemUrl(branchName) {
-    return readBranchValue(branchName, 'idea1ProjectItemUrl', m => m.projectItemUrl);
+    return null;
 }
 /**
- * Store base branch in git config for later retrieval
+ * The GitHub repository `origin` points at, as `owner/name`.
  */
-export async function storeBaseBranch(baseBranch, branchName) {
-    const branch = branchName ?? await getCurrentBranch();
-    if (baseBranch && branch) {
-        await execOrThrow('git', ['config', '--local', `branch.${branch}.baseBranch`, baseBranch]);
-        await updateBranchMetadataFile(branch, { baseBranch });
-        logger.dim(`Base branch stored in git config for ${branch}: ${baseBranch}`);
+export async function getRepositoryFullName() {
+    const url = (await execOrThrow('git', ['remote', 'get-url', 'origin'])).trim();
+    const match = url.match(/[:/]([^/:]+\/[^/:]+?)(?:\.git)?\/?$/);
+    if (!match) {
+        throw new Error(`Could not read the repository name from the origin URL: ${url}`);
     }
-}
-/**
- * Retrieve base branch for a branch (with hierarchical resolution)
- */
-export async function getBaseBranch(branchName) {
-    // The authoritative source (an existing PR) is queried in the command layer.
-    // Here we resolve branch-specific config, then the committed metadata file,
-    // then null (caller decides the default).
-    return readBranchValue(branchName, 'baseBranch', m => m.baseBranch);
+    return match[1];
 }
 /**
  * Validate that a branch exists
@@ -657,13 +384,14 @@ export async function commitAllChanges(message) {
 /**
  * Push to remote branch
  */
-export async function pushToRemote(branchName) {
+export async function pushToRemote(branchName, cwd) {
     logger.step(`Pushing changes to remote branch ${branchName}...`);
-    await execOrThrow('git', ['push', '--set-upstream', 'origin', branchName]);
+    await execOrThrow('git', ['push', '--set-upstream', 'origin', branchName], { cwd });
     logger.success('Changes pushed successfully');
 }
 /**
- * Garbage collect orphaned branch configs
+ * Forget the remembered item URLs (and the per-branch config older CLI versions kept) of branches
+ * that no longer exist.
  */
 export async function gcOrphanedBranchConfigs() {
     const result = await exec('git', ['config', '--local', '--list']);
@@ -688,103 +416,6 @@ export async function gcOrphanedBranchConfigs() {
     if (removedCount > 0) {
         logger.dim(`Removed ${removedCount} orphaned branch config entries`);
     }
-    // Also clean up orphaned .idea1/*.json files
-    await gcOrphanedBranchMetadataFiles();
-}
-/**
- * Remove `.idea1/*.json` files for branches that no longer exist (excluding the settings files)
- */
-async function gcOrphanedBranchMetadataFiles() {
-    try {
-        const repoRoot = await getRepoRoot();
-        const idea1Dir = join(repoRoot, '.idea1');
-        const files = await readdir(idea1Dir);
-        let removedCount = 0;
-        for (const file of files) {
-            if (!file.endsWith('.json') || SETTINGS_FILES.includes(file))
-                continue;
-            const branchName = branchNameFromFilename(file);
-            const exists = await branchExists(branchName);
-            if (!exists) {
-                await unlink(join(idea1Dir, file));
-                removedCount++;
-            }
-        }
-        if (removedCount > 0) {
-            logger.dim(`Removed ${removedCount} orphaned branch metadata files`);
-        }
-    }
-    catch {
-        // .idea1/ directory doesn't exist or isn't readable — skip
-    }
-}
-/**
- * Store workflow state in git config for later retrieval
- */
-export async function storeWorkflowState(state, branchName) {
-    const branch = branchName ?? await getCurrentBranch();
-    if (state && branch) {
-        await execOrThrow('git', ['config', '--local', `branch.${branch}.idea1WorkflowState`, state]);
-        await updateBranchMetadataFile(branch, { workflowState: state });
-        logger.dim(`Workflow state stored in git config for ${branch}`);
-    }
-}
-/**
- * Retrieve workflow state from git config
- */
-export async function getWorkflowState(branchName) {
-    return readBranchValue(branchName, 'idea1WorkflowState', m => m.workflowState);
-}
-/**
- * Store the development workflow type in git config
- */
-export async function storeDevWorkflowType(workflowType, branchName) {
-    const branch = branchName ?? await getCurrentBranch();
-    if (workflowType && branch) {
-        await execOrThrow('git', ['config', '--local', `branch.${branch}.idea1DevWorkflowType`, workflowType]);
-        await updateBranchMetadataFile(branch, { devWorkflowType: workflowType });
-        logger.dim(`Dev workflow type stored in git config for ${branch}: ${workflowType}`);
-    }
-}
-/**
- * Retrieve the development workflow type from git config
- */
-export async function getDevWorkflowType(branchName) {
-    return readBranchValue(branchName, 'idea1DevWorkflowType', m => m.devWorkflowType);
-}
-/**
- * Store the stack branch in git config (for stacked workflows)
- */
-export async function storeStackBranch(stackBranch, branchName) {
-    const branch = branchName ?? await getCurrentBranch();
-    if (stackBranch && branch) {
-        await execOrThrow('git', ['config', '--local', `branch.${branch}.idea1StackBranch`, stackBranch]);
-        await updateBranchMetadataFile(branch, { stackBranch });
-        logger.dim(`Stack branch stored in git config for ${branch}: ${stackBranch}`);
-    }
-}
-/**
- * Retrieve the stack branch from git config
- */
-export async function getStackBranch(branchName) {
-    return readBranchValue(branchName, 'idea1StackBranch', m => m.stackBranch);
-}
-/**
- * Store the integration branch name in git config
- */
-export async function storeIntegrationBranch(integrationBranch, branchName) {
-    const branch = branchName ?? await getCurrentBranch();
-    if (integrationBranch && branch) {
-        await execOrThrow('git', ['config', '--local', `branch.${branch}.idea1IntegrationBranch`, integrationBranch]);
-        await updateBranchMetadataFile(branch, { integrationBranch });
-        logger.dim(`Integration branch stored in git config for ${branch}: ${integrationBranch}`);
-    }
-}
-/**
- * Retrieve the integration branch name from git config
- */
-export async function getIntegrationBranch(branchName) {
-    return readBranchValue(branchName, 'idea1IntegrationBranch', m => m.integrationBranch);
 }
 /**
  * Fetch and pull a specific branch from origin, ensuring it's up to date
@@ -798,16 +429,7 @@ export async function fetchAndPullBranch(branchName) {
         // Update local branch to match remote without checking it out
         const currentBranch = await getCurrentBranch();
         if (currentBranch === branchName) {
-            // Try fast-forward first; if not possible, try rebase; if conflicts, fall back to merge
-            const ffResult = await exec('git', ['pull', '--ff-only', 'origin', branchName]);
-            if (ffResult.exitCode !== 0) {
-                const rebaseResult = await exec('git', ['pull', '--rebase', 'origin', branchName]);
-                if (rebaseResult.exitCode !== 0) {
-                    await exec('git', ['rebase', '--abort']);
-                    logger.warning('Rebase had conflicts, falling back to merge commit');
-                    await execOrThrow('git', ['pull', '--no-rebase', 'origin', branchName]);
-                }
-            }
+            await pullBranch(branchName);
         }
         else {
             // Check if branch is in a secondary worktree — git fetch origin branch:branch
@@ -815,7 +437,7 @@ export async function fetchAndPullBranch(branchName) {
             const worktreePath = await getWorktreePathForBranch(branchName);
             if (worktreePath) {
                 logger.step(`Branch ${branchName} is in a worktree at ${worktreePath}, pulling there...`);
-                await execOrThrow('git', ['pull', 'origin', branchName], { cwd: worktreePath });
+                await pullBranch(branchName, worktreePath);
             }
             else {
                 await execOrThrow('git', ['fetch', 'origin', `${branchName}:${branchName}`]);
@@ -824,12 +446,39 @@ export async function fetchAndPullBranch(branchName) {
     }
 }
 /**
- * Merge a source branch into the current branch with a merge commit
+ * Run a git command that merges into `targetBranch`, checked out at `cwd` (the current directory
+ * when omitted). A merge that stops on conflicts is left in progress for the developer to resolve
+ * and reported as an error saying so; nothing is aborted, retried, or rebased.
+ */
+async function runMerge(args, sourceRef, targetBranch, cwd) {
+    const result = await exec('git', args, { cwd });
+    if (result.exitCode === 0) {
+        return;
+    }
+    const mergeInProgress = await exec('git', ['rev-parse', '-q', '--verify', 'MERGE_HEAD'], { cwd });
+    if (mergeInProgress.exitCode === 0) {
+        const location = cwd ?? (await getRepoRoot()).trim();
+        throw new Error(`Merging ${sourceRef} into ${targetBranch} has conflicts to resolve before the merge can complete. ` +
+            `Resolve them in ${location} (on ${targetBranch}), commit the merge, and push ${targetBranch}.`);
+    }
+    throw new Error(result.stderr || `Command failed: git ${args.join(' ')}`);
+}
+/**
+ * Pull `origin/<branch>` into the local branch checked out at `cwd` (the current directory when
+ * omitted). Pulls never rebase, whatever the clone's `pull.rebase` or `branch.<name>.rebase`
+ * config says: a branch that is behind fast-forwards, and one that has diverged gets a merge commit.
+ */
+export async function pullBranch(branchName, cwd) {
+    await runMerge(['pull', '--no-rebase', '--no-edit', 'origin', branchName], `origin/${branchName}`, branchName, cwd);
+}
+/**
+ * Merge a source branch into `targetBranch`, checked out at `cwd` (the current directory when
+ * omitted), always with a merge commit.
  */
-export async function mergeBranch(sourceBranch) {
-    logger.step(`Merging ${sourceBranch} into current branch...`);
-    await execOrThrow('git', ['merge', '--no-ff', sourceBranch, '--no-edit']);
-    logger.success(`Successfully merged ${sourceBranch}`);
+export async function mergeBranch(sourceBranch, targetBranch, cwd) {
+    logger.step(`Merging ${sourceBranch} into ${targetBranch}...`);
+    await runMerge(['merge', '--no-ff', '--no-edit', sourceBranch], sourceBranch, targetBranch, cwd);
+    logger.success(`Merged ${sourceBranch} into ${targetBranch}`);
 }
 /**
  * Check if merging source into target would produce conflicts,
@@ -849,12 +498,6 @@ export async function checkMergeConflicts(source, target) {
     }
     return { hasConflicts: false };
 }
-/**
- * Abort an in-progress merge
- */
-export async function abortMerge() {
-    await exec('git', ['merge', '--abort']);
-}
 /**
  * List remote branches matching a prefix pattern
  */
@@ -967,8 +610,7 @@ async function getGitCommonDir() {
 /**
  * Commit file changes on top of a ref without checking anything out, using a
  * temporary index. Returns the new commit sha (not yet on any branch). Used for
- * branches that have no local checkout, so the branch can carry its workflow
- * metadata before anyone works on it.
+ * branches that have no local checkout.
  */
 export async function commitFilesDetached(parentRef, changes, message) {
     const parentSha = (await execOrThrow('git', ['rev-parse', '--verify', `${parentRef}^{commit}`])).trim();
@@ -1008,32 +650,6 @@ export async function pushCommitToBranch(branchName, commitSha) {
         await execOrThrow('git', ['update-ref', `refs/heads/${branchName}`, commitSha]);
     }
 }
-/**
- * Create a branch on origin from a source ref (e.g. `origin/working/release`) with
- * its `.idea1/<branch>.json` metadata as the first commit. No checkout is needed.
- */
-export async function createBranchWithMetadataDetached(branchName, sourceRef, metadata) {
-    logger.step(`Creating branch ${branchName} from ${sourceRef}...`);
-    const commitSha = await commitFilesDetached(sourceRef, [{ path: getBranchMetadataRelativePath(branchName), content: serializeBranchMetadata(metadata) }], `idea1: link to ${metadata.projectItemUrl ?? branchName}`);
-    await pushCommitToBranch(branchName, commitSha);
-    logger.success(`Branch ${branchName} created on origin with its workflow metadata`);
-}
-/**
- * Update fields of the committed `.idea1/<branch>.json` on origin for a branch
- * that has no local checkout. Returns true when a commit was pushed.
- */
-export async function updateBranchMetadataDetached(branchName, updates) {
-    const remote = await readBranchMetadataFromRef(branchName);
-    const merged = { ...(remote ?? { branchName }), ...updates, branchName };
-    const unchanged = remote !== null && Object.keys(updates).every(key => remote[key] === merged[key]);
-    if (unchanged) {
-        return false;
-    }
-    const commitSha = await commitFilesDetached(`origin/${branchName}`, [{ path: getBranchMetadataRelativePath(branchName), content: serializeBranchMetadata(merged) }], `idea1: update metadata for ${merged.projectItemUrl ?? branchName}`);
-    await pushCommitToBranch(branchName, commitSha);
-    logger.dim('Committed branch metadata update on origin');
-    return true;
-}
 /**
  * Create a branch on origin pointing at a source ref, without any local checkout.
  */
@@ -1073,17 +689,4 @@ export async function fetchRemoteBranch(branchName) {
     const result = await exec('git', ['fetch', 'origin', branchName]);
     return result.exitCode === 0;
 }
-/**
- * Remove the committed `.idea1/<branch>.json` from a branch that has no local
- * checkout, so the file does not leak into the target branch when the PR merges.
- */
-export async function removeBranchMetadataDetached(branchName) {
-    const remote = await readBranchMetadataFromRef(branchName);
-    if (!remote) {
-        return;
-    }
-    const commitSha = await commitFilesDetached(`origin/${branchName}`, [{ path: getBranchMetadataRelativePath(branchName), content: null }], `idea1: remove branch metadata for ${branchName}`);
-    await pushCommitToBranch(branchName, commitSha);
-    logger.dim('Removed branch metadata file before merge');
-}
 //# sourceMappingURL=git.js.map