borgmcp 1.0.5 → 1.0.7

package/dist/sync-roles-render.js

@@ -1,118 +1,3 @@
-/**
- * gh#473 PR2 — non-clobbering sync output rendering.
- *
- * The dry-run output is UX-LOAD-BEARING: it must CLEARLY communicate each
- * conflict (which role/section or taxonomy class, cube-current vs
- * template-new, and how to accept) so the operator SEES what would be
- * clobbered. Pure string logic (mirrors `roster-render.ts` /
- * `list-roles-render.ts`) so it is unit-testable without the MCP runtime.
- *
- * The shape mirrors the worker's `NonClobberSyncResult`.
- */
-/** Truncate long fragment bodies for at-a-glance diffs. */
-function trunc(s, n = 200) {
-    if (s == null)
-        return '(absent)';
-    const flat = s.replace(/\n/g, '⏎');
-    return flat.length > n ? flat.slice(0, n) + '…' : flat;
-}
-/**
- * Render a `NonClobberSyncResult` as an operator-facing markdown report.
- *
- * Conflicts are the headline: each is surfaced with both sides + its
- * stable accept key, and the report states explicitly that conflicts are
- * KEPT (the cube's version) unless accepted. ADDs are reported as safe
- * auto-applies. Custom roles are reported untouched.
- */
-export function renderSyncRolesResult(result, templateName) {
-    // Defensive guard against client/worker deploy skew (gh#9 class). A
-    // pre-#473 worker returns the legacy sync-roles shape
-    // ({ updated, added, unchanged, skipped, dryRun }) with no `roles[]`, so
-    // `result.roles.flatMap(...)` below would throw `undefined.flatMap`.
-    // Detect the legacy shape and render an actionable message instead of
-    // crashing — the skew window (0.9.47+ client + pre-#473 worker) becomes a
-    // clean "redeploy the worker" prompt, not an exception.
-    const maybeLegacy = result;
-    if (maybeLegacy.roles === undefined && 'updated' in maybeLegacy) {
-        return [
-            `## borg:sync-roles — unavailable (server out of date)`,
-            ``,
-            `The borg server returned the legacy sync-roles response shape — it is running a version older than #473, which the non-clobbering sync view does not support.`,
-            ``,
-            `**Action:** a server (worker) deploy is pending. Retry \`borg:sync-roles\` once it lands.`,
-        ].join('\n');
-    }
-    const mode = result.dryRun
-        ? '**DRY RUN** (review conflicts below; re-run with `apply: true` + a `decisions` map to commit)'
-        : '**APPLIED**';
-    const lines = [`## borg:sync-roles — ${mode}`, `Template: ${templateName}`, ''];
-    // Gather all fragments across roles + taxonomy for tallying.
-    const allFragments = [
-        ...result.roles.flatMap((r) => r.fragments),
-        ...result.taxonomy,
-    ];
-    const conflicts = allFragments.filter((f) => f.kind === 'conflict');
-    const adds = allFragments.filter((f) => f.kind === 'add');
-    const newRoles = result.roles.filter((r) => r.status === 'new');
-    const customRoles = result.roles.filter((r) => r.status === 'custom-skipped');
-    // ── Conflicts (the headline — what would be clobbered) ──
-    if (conflicts.length > 0) {
-        lines.push(`### ⚠ ${conflicts.length} CONFLICT(s) — these fragments differ between your cube and the template`);
-        if (result.dryRun) {
-            lines.push('These differ between your cube and the template — may be because you evolved them, or because the template changed them. ' +
-                'Surfaced for review, never silently overwritten. Each defaults to **KEEP (reject)** — your version survives. ' +
-                'To take the template version of a specific fragment, pass its key in `decisions` as `"<key>": "accept"`.');
-        }
-        else {
-            lines.push('Unless explicitly accepted, each conflict was KEPT (your version preserved).');
-        }
-        lines.push('');
-        for (const f of conflicts) {
-            const applied = result.applied.acceptedConflicts.includes(f.key);
-            const status = result.dryRun
-                ? '(would KEEP your version)'
-                : applied
-                    ? '✓ accepted — template version applied'
-                    : '↩ kept your version';
-            lines.push(`- **${f.label}** \`${f.key}\` ${status}`);
-            lines.push(`  - cube (current): "${trunc(f.cubeValue)}"`);
-            lines.push(`  - template (new): "${trunc(f.templateValue)}"`);
-        }
-        lines.push('');
-    }
-    // ── Unmatched decision keys (typo'd / stale — intended accept dropped) ──
-    const unmatched = result.unmatchedDecisions ?? [];
-    if (unmatched.length > 0) {
-        lines.push(`### ⚠ ${unmatched.length} decision key(s) matched no conflict and were ignored`);
-        lines.push('These keys in your `decisions` map did not correspond to any classified conflict this run ' +
-            '(typo or stale key) — their intended accept had NO effect. Check the exact keys against the conflicts above:');
-        for (const k of unmatched) {
-            lines.push(`- \`${k}\``);
-        }
-        lines.push('');
-    }
-    // ── Additions (safe auto-apply, zero clobber risk) ──
-    if (newRoles.length > 0 || adds.length > 0) {
-        lines.push(`### Additions (safe — auto-applied, zero clobber risk)`);
-        for (const r of newRoles) {
-            const note = result.dryRun ? '(new role — would be created)' : '✓ created';
-            lines.push(`- new role **${r.name}** ${note}`);
-        }
-        for (const f of adds) {
-            const note = result.dryRun ? '(would be added)' : '✓ added';
-            lines.push(`- **${f.label}** \`${f.key}\` ${note}`);
-        }
-        lines.push('');
-    }
-    // ── Custom roles (never touched) ──
-    if (customRoles.length > 0) {
-        lines.push(`### Custom roles (untouched): ${customRoles.map((r) => r.name).join(', ')}`);
-        lines.push('');
-    }
-    // ── Clean no-op ──
-    if (conflicts.length === 0 && adds.length === 0 && newRoles.length === 0) {
-        lines.push('✓ Cube roles + taxonomy are **up to date** with the template (no changes).');
-    }
-    return lines.join('\n').trimEnd();
-}
-//# sourceMappingURL=sync-roles-render.js.map
+function p(t,r=200){if(t==null)return"(absent)";const o=t.replace(/\n/g,"\u23CE");return o.length>r?o.slice(0,r)+"\u2026":o}function y(t,r){const o=t;if(o.roles===void 0&&"updated"in o)return["## borg:sync-roles \u2014 unavailable (server out of date)","","The borg server returned the legacy sync-roles response shape \u2014 it is running a version older than #473, which the non-clobbering sync view does not support.","","**Action:** a server (worker) deploy is pending. Retry `borg:sync-roles` once it lands."].join(`
+`);const n=[`## borg:sync-roles \u2014 ${t.dryRun?"**DRY RUN** (review conflicts below; re-run with `apply: true` + a `decisions` map to commit)":"**APPLIED**"}`,`Template: ${r}`,""],d=[...t.roles.flatMap(e=>e.fragments),...t.taxonomy],c=d.filter(e=>e.kind==="conflict"),a=d.filter(e=>e.kind==="add"),i=t.roles.filter(e=>e.status==="new"),u=t.roles.filter(e=>e.status==="custom-skipped");if(c.length>0){n.push(`### \u26A0 ${c.length} CONFLICT(s) \u2014 these fragments differ between your cube and the template`),t.dryRun?n.push('These differ between your cube and the template \u2014 may be because you evolved them, or because the template changed them. Surfaced for review, never silently overwritten. Each defaults to **KEEP (reject)** \u2014 your version survives. To take the template version of a specific fragment, pass its key in `decisions` as `"<key>": "accept"`.'):n.push("Unless explicitly accepted, each conflict was KEPT (your version preserved)."),n.push("");for(const e of c){const s=t.applied.acceptedConflicts.includes(e.key),h=t.dryRun?"(would KEEP your version)":s?"\u2713 accepted \u2014 template version applied":"\u21A9 kept your version";n.push(`- **${e.label}** \`${e.key}\` ${h}`),n.push(`  - cube (current): "${p(e.cubeValue)}"`),n.push(`  - template (new): "${p(e.templateValue)}"`)}n.push("")}const l=t.unmatchedDecisions??[];if(l.length>0){n.push(`### \u26A0 ${l.length} decision key(s) matched no conflict and were ignored`),n.push("These keys in your `decisions` map did not correspond to any classified conflict this run (typo or stale key) \u2014 their intended accept had NO effect. Check the exact keys against the conflicts above:");for(const e of l)n.push(`- \`${e}\``);n.push("")}if(i.length>0||a.length>0){n.push("### Additions (safe \u2014 auto-applied, zero clobber risk)");for(const e of i){const s=t.dryRun?"(new role \u2014 would be created)":"\u2713 created";n.push(`- new role **${e.name}** ${s}`)}for(const e of a){const s=t.dryRun?"(would be added)":"\u2713 added";n.push(`- **${e.label}** \`${e.key}\` ${s}`)}n.push("")}return u.length>0&&(n.push(`### Custom roles (untouched): ${u.map(e=>e.name).join(", ")}`),n.push("")),c.length===0&&a.length===0&&i.length===0&&n.push("\u2713 Cube roles + taxonomy are **up to date** with the template (no changes)."),n.join(`
+`).trimEnd()}export{y as renderSyncRolesResult};

package/dist/sync.js

@@ -1,286 +1,22 @@
-/**
- * `borg sync` — worktree lifecycle management subcommand (gh#33).
- *
- * Reconciled to the per-worktree `wt-<suffix>` branch model (PR-B,
- * ruling ea643b33). Replaces the previous main-centric semantics
- * ("idle = on main"; "post-merge = checkout main") — under the approved
- * gh#33 model `main` is NEVER a working branch in any worktree; it is
- * purely the integration target. Every worktree works on a named
- * `wt-<suffix>` branch and `borg sync` keeps it current with
- * origin/main, returns to it after a feature branch merges, and absorbs
- * upstream into an in-progress feature branch — never touching `main`
- * as a checkout.
- *
- * All git mutation/decision logic is delegated to
- * `client/src/worktree-lifecycle.ts` (the seam PR-A added:
- * `adoptWorktree`, `syncWorktree`, `cleanupMerged`, `isMerged`,
- * `localBranchExists`) so the never-discard guards (dirty / unmerged
- * HEAD / unmerged target wt- branch) and the args-array subprocess
- * shape are shared, not duplicated.
- *
- * Lifecycle states:
- *   1. dirty             — uncommitted changes; refuse (never discard).
- *   2. on-wt             — on the per-worktree `wt-<suffix>` branch;
- *                          fast-forward it to origin/main (ff-only).
- *   3. on-main           — on `main`/`master` (or detached at a merged
- *                          point); adopt the `wt-<suffix>` branch
- *                          (Q4: main is never a working branch).
- *   4. feature-mid-sprint — on a feature branch not yet merged; absorb
- *                          origin/main into it via `git merge --no-edit`
- *                          (no rebase — cube workflow rule (a)) when
- *                          origin/main advanced; else no-op.
- *   5. feature-merged    — on a feature branch fully merged into
- *                          origin/main; return to `wt-<suffix>` and
- *                          ANNOUNCE the prunable feature branch (prune
- *                          only with `--prune`, Q3).
- *
- * Anti-features (intentional, unchanged):
- *   - No auto-stash / auto-commit / auto-discard on dirty tree.
- *   - No force-push, no rebase, no --force-with-lease.
- *   - No remote-branch deletion (Coordinator owns merge actions).
- *   - Local feature-branch deletion only on explicit `--prune` (Q3).
- */
-import { spawnSync } from 'node:child_process';
-import { basename } from 'node:path';
-import chalk from 'chalk';
-import { adoptWorktree, syncWorktree, cleanupMerged, isMerged, perWorktreeBranchName, } from './worktree-lifecycle.js';
-const defaultDeps = {
-    runSync: (cmd, args, cwd) => {
-        const r = spawnSync(cmd, args, { cwd, encoding: 'utf-8' });
-        return {
-            status: r.status,
-            stdout: r.stdout ?? '',
-            stderr: r.stderr ?? '',
-        };
-    },
-    cwd: () => process.cwd(),
-    stderr: (line) => process.stderr.write(line),
-    stdout: (line) => process.stdout.write(line),
-};
-const DEFAULT_BRANCH = 'origin/main';
-// ------------------------------------------------------------------
-// wt- branch resolution
-// ------------------------------------------------------------------
-/**
- * Resolve the per-worktree `wt-` branch for the current checkout,
- * DETERMINISTICALLY per worktree.
- *
- *   - current branch is already `wt-*` → that is the branch.
- *   - otherwise → derive `wt-<suffix>` from THIS worktree's directory
- *     basename minus the main worktree's (repo) basename prefix — the
- *     same `perWorktreeBranchName` derivation the spawn path uses, so
- *     the name matches what `borg assimilate --worktree` created.
- *
- * This must NOT list `git branch --list wt-*`: in linked worktrees the
- * local branch namespace is SHARED across all siblings (gh#33 CR-v2
- * blocker 32bc45da), so every drone's `wt-` branch is visible and a
- * "single match" heuristic is never satisfied in a real multi-drone
- * cube. The directory-derivation is unique per worktree and never
- * ambiguous. The first `worktree <path>` line of
- * `git worktree list --porcelain` is the main worktree (the repo dir);
- * its basename is the prefix to strip. For an independent clone the
- * main worktree IS this worktree, so the prefix == basename and the
- * result is `wt-<basename>` (no strip) — consistent with PR-A's
- * in-place adoption.
- */
-export function resolveWtBranch(runSync, cwd, currentBranch) {
-    if (currentBranch.startsWith('wt-'))
-        return currentBranch;
-    const top = runSync('git', ['rev-parse', '--show-toplevel'], cwd);
-    const thisDir = top.status === 0 ? top.stdout.trim() : cwd;
-    const wtList = runSync('git', ['worktree', 'list', '--porcelain'], cwd);
-    let mainDir = thisDir;
-    if (wtList.status === 0) {
-        const firstWorktreeLine = wtList.stdout
-            .split('\n')
-            .find((l) => l.startsWith('worktree '));
-        if (firstWorktreeLine)
-            mainDir = firstWorktreeLine.slice('worktree '.length).trim();
-    }
-    return perWorktreeBranchName(basename(thisDir), basename(mainDir));
-}
-/**
- * Detect the worktree's lifecycle state. Read-only except for the
- * `git fetch origin --prune` needed to measure against the latest tip.
- */
-export function detectState(deps) {
-    const { runSync, cwd } = deps;
-    const cwdValue = cwd();
-    // (1) git repo?
-    if (runSync('git', ['rev-parse', '--show-toplevel'], cwdValue).status !== 0) {
-        return { kind: 'error', reason: `not in a git repository (cwd: ${cwdValue})` };
-    }
-    // (2) dirty FIRST — never act on uncommitted changes.
-    const status = runSync('git', ['status', '--porcelain'], cwdValue);
-    if (status.status !== 0) {
-        return { kind: 'error', reason: `git status failed: ${status.stderr.trim()}` };
-    }
-    const dirty = status.stdout.split('\n').map((l) => l.trim()).filter((l) => l.length > 0);
-    if (dirty.length > 0)
-        return { kind: 'dirty', files: dirty };
-    // (3) current branch.
-    const branchProbe = runSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], cwdValue);
-    if (branchProbe.status !== 0) {
-        return { kind: 'error', reason: `cannot resolve current branch: ${branchProbe.stderr.trim()}` };
-    }
-    const branch = branchProbe.stdout.trim();
-    if (branch === 'HEAD') {
-        return { kind: 'error', reason: 'detached HEAD; run `borg assimilate` to adopt a wt- branch first' };
-    }
-    // (4) fetch — fatal on failure (can't reason about lifecycle offline).
-    const fetch = runSync('git', ['fetch', 'origin', '--prune'], cwdValue);
-    if (fetch.status !== 0) {
-        return { kind: 'error', reason: `git fetch origin failed: ${fetch.stderr.trim()}` };
-    }
-    const wtBranch = resolveWtBranch(runSync, cwdValue, branch);
-    // (5) on the per-worktree wt- branch.
-    if (branch.startsWith('wt-')) {
-        return { kind: 'on-wt', branch, wtBranch: branch };
-    }
-    // (6) on main/master — Q4: never a working branch; adopt wt-.
-    if (branch === 'main' || branch === 'master') {
-        return { kind: 'on-main', branch, wtBranch };
-    }
-    // (7) feature branch — merged vs mid-sprint.
-    // ASSUMPTION (gh#33 CR NIT 0e19637a): merged-detection keys off commit
-    // ancestry (`isMerged` = HEAD is an ancestor of origin/main), which
-    // holds for merge-commit / fast-forward integration. A squash- or
-    // rebase-merged PR leaves the feature tip a NON-ancestor → it would
-    // classify here as mid-sprint, not merged. That degrades safely
-    // (merge-back of origin/main, no discard), and this cube integrates
-    // via merge commits, so it is not triggered. If squash-merge is ever
-    // adopted, switch this to PR-merged-state detection.
-    if (isMerged(runSync, cwdValue, 'HEAD', DEFAULT_BRANCH)) {
-        return { kind: 'feature-merged', branch, wtBranch };
-    }
-    // not merged → mid-sprint. Count how far origin/main advanced past the
-    // merge-base so the message can report it (0 → no-op).
-    const mergeBase = runSync('git', ['merge-base', 'HEAD', DEFAULT_BRANCH], cwdValue);
-    const base = mergeBase.status === 0 ? mergeBase.stdout.trim() : '';
-    const count = runSync('git', ['rev-list', '--count', `${base}..${DEFAULT_BRANCH}`], cwdValue);
-    const commits = parseInt(count.stdout.trim(), 10) || 0;
-    return { kind: 'feature-mid-sprint', branch, wtBranch, commits };
-}
-// ------------------------------------------------------------------
-// Orchestrator
-// ------------------------------------------------------------------
-export async function runSync(deps = {}, opts = { prune: false }) {
-    const merged = { ...defaultDeps, ...deps };
-    const { runSync: run, cwd, stderr, stdout } = merged;
-    const state = detectState(merged);
-    if (state.kind === 'error') {
-        stderr(chalk.red(`◼ borg sync: ${state.reason}\n`));
-        return 1;
-    }
-    if (state.kind === 'dirty') {
-        stderr(chalk.yellow(`◼ Working tree has uncommitted changes.\n`));
-        for (const line of state.files.slice(0, 5))
-            stderr(chalk.gray(`  ${line}\n`));
-        if (state.files.length > 5)
-            stderr(chalk.gray(`  ... and ${state.files.length - 5} more\n`));
-        stderr(chalk.yellow(`◼ Commit, stash, or restore before running \`borg sync\`. Nothing was changed.\n`));
-        return 1;
-    }
-    // on-wt: fast-forward the per-worktree branch to origin/main (ff-only,
-    // clean-gated, never merge/rebase). Delegates to syncWorktree.
-    if (state.kind === 'on-wt') {
-        const res = syncWorktree(run, cwd(), state.wtBranch, DEFAULT_BRANCH);
-        if (res.action === 'fast-forwarded') {
-            stdout(chalk.blue(`◼ On \`${state.wtBranch}\`; fast-forwarded to ${DEFAULT_BRANCH}.\n`));
-            return 0;
-        }
-        if (res.action === 'already-current') {
-            stdout(chalk.blue(`◼ On \`${state.wtBranch}\`; up to date with ${DEFAULT_BRANCH}.\n`));
-            return 0;
-        }
-        // skipped-diverged: the wt- branch has local commits not on origin/main.
-        stderr(chalk.yellow(`◼ ${res.message ?? 'sync skipped'}.\n`));
-        return 1;
-    }
-    // on-main: adopt the wt- branch (Q4 — move off main). adoptWorktree
-    // applies the dirty / unmerged-HEAD / unmerged-target guards.
-    if (state.kind === 'on-main') {
-        return adoptAndReport(state.wtBranch, run, cwd, stdout, stderr);
-    }
-    // feature-mid-sprint: absorb origin/main into the feature branch (no
-    // rebase). Leaves the drone on the feature branch to keep working.
-    if (state.kind === 'feature-mid-sprint') {
-        if (state.commits === 0) {
-            stdout(chalk.blue(`◼ On \`${state.branch}\` (feature branch); up to date with ${DEFAULT_BRANCH}.\n`));
-            stdout(chalk.gray(`◼ Continue your sprint, or post REVIEW-READY when complete.\n`));
-            return 0;
-        }
-        const merge = run('git', ['merge', '--no-edit', DEFAULT_BRANCH], cwd());
-        if (merge.status !== 0) {
-            stderr(chalk.red(`◼ borg sync: git merge ${DEFAULT_BRANCH} failed (likely conflict). Resolve manually:\n${merge.stderr.trim()}\n`));
-            return 1;
-        }
-        stdout(chalk.blue(`◼ On \`${state.branch}\`; merged ${state.commits} commit${state.commits === 1 ? '' : 's'} from ${DEFAULT_BRANCH} (no rebase).\n`));
-        stdout(chalk.gray(`◼ Re-run tests; continue your sprint.\n`));
-        return 0;
-    }
-    // feature-merged: the PR merged. Return to the wt- branch (adopt) and
-    // announce the prunable feature branch (prune only with --prune, Q3).
-    if (state.kind === 'feature-merged') {
-        const feature = state.branch;
-        const code = adoptAndReport(state.wtBranch, run, cwd, stdout, stderr, {
-            adoptedPrefix: `◼ \`${feature}\` is merged into ${DEFAULT_BRANCH};`,
-        });
-        if (code !== 0)
-            return code; // adoption blocked (dirty/unmerged target) — don't prune
-        // Now on the wt- branch — safe to prune/announce the merged feature.
-        const cleanup = cleanupMerged(run, cwd(), feature, DEFAULT_BRANCH, { prune: opts.prune });
-        if (cleanup.action === 'pruned') {
-            stdout(chalk.blue(`◼ Pruned merged branch \`${feature}\`.\n`));
-        }
-        else if (cleanup.action === 'announced') {
-            stdout(chalk.gray(`◼ ${cleanup.message}\n`));
-        }
-        return 0;
-    }
-    // Exhaustiveness.
-    const _exhaustive = state;
-    stderr(chalk.red(`◼ borg sync: unhandled state\n`));
-    return 1;
-}
-/**
- * Shared adopt-the-wt-branch path for the on-main + feature-merged
- * states. Surfaces the never-discard outcomes; returns the process exit
- * code (0 adopted, 1 blocked/ambiguous).
- */
-function adoptAndReport(wtBranch, run, cwd, stdout, stderr, opts = {}) {
-    const res = adoptWorktree(run, cwd(), wtBranch, DEFAULT_BRANCH);
-    if (res.action === 'adopted') {
-        if (opts.adoptedPrefix) {
-            stdout(chalk.blue(`${opts.adoptedPrefix} switched to \`${wtBranch}\` at ${DEFAULT_BRANCH}.\n`));
-        }
-        else {
-            stdout(chalk.blue(`◼ On \`${wtBranch}\` at ${DEFAULT_BRANCH}.\n`));
-        }
-        return 0;
-    }
-    // skipped-dirty handled upstream (dirty state), but defensively surface.
-    stderr(chalk.yellow(`◼ borg sync: ${res.message ?? 'not adopted'}. Nothing was changed.\n`));
-    return 1;
-}
-/**
- * Parse args after `borg sync`. Supports `--prune` (Q3: delete a merged
- * feature branch after returning to the wt- branch). Rejects anything
- * else to keep room for future flags.
- */
-export function parseSyncArgs(rawArgs) {
-    let prune = false;
-    for (const arg of rawArgs) {
-        if (arg === '--prune') {
-            prune = true;
-        }
-        else {
-            return {
-                ok: false,
-                error: `unexpected argument: ${arg}. Usage: borg sync [--prune]`,
-            };
-        }
-    }
-    return { ok: true, options: { prune } };
-}
-//# sourceMappingURL=sync.js.map
+import{spawnSync as y}from"node:child_process";import{basename as p}from"node:path";import o from"chalk";import{adoptWorktree as b,syncWorktree as k,cleanupMerged as v,isMerged as A,perWorktreeBranchName as D}from"./worktree-lifecycle.js";const W={runSync:(i,e,u)=>{const r=y(i,e,{cwd:u,encoding:"utf-8"});return{status:r.status,stdout:r.stdout??"",stderr:r.stderr??""}},cwd:()=>process.cwd(),stderr:i=>process.stderr.write(i),stdout:i=>process.stdout.write(i)},c="origin/main";function x(i,e,u){if(u.startsWith("wt-"))return u;const r=i("git",["rev-parse","--show-toplevel"],e),d=r.status===0?r.stdout.trim():e,s=i("git",["worktree","list","--porcelain"],e);let n=d;if(s.status===0){const t=s.stdout.split(`
+`).find(f=>f.startsWith("worktree "));t&&(n=t.slice(9).trim())}return D(p(d),p(n))}function E(i){const{runSync:e,cwd:u}=i,r=u();if(e("git",["rev-parse","--show-toplevel"],r).status!==0)return{kind:"error",reason:`not in a git repository (cwd: ${r})`};const d=e("git",["status","--porcelain"],r);if(d.status!==0)return{kind:"error",reason:`git status failed: ${d.stderr.trim()}`};const s=d.stdout.split(`
+`).map(g=>g.trim()).filter(g=>g.length>0);if(s.length>0)return{kind:"dirty",files:s};const n=e("git",["rev-parse","--abbrev-ref","HEAD"],r);if(n.status!==0)return{kind:"error",reason:`cannot resolve current branch: ${n.stderr.trim()}`};const t=n.stdout.trim();if(t==="HEAD")return{kind:"error",reason:"detached HEAD; run `borg assimilate` to adopt a wt- branch first"};const f=e("git",["fetch","origin","--prune"],r);if(f.status!==0)return{kind:"error",reason:`git fetch origin failed: ${f.stderr.trim()}`};const a=x(e,r,t);if(t.startsWith("wt-"))return{kind:"on-wt",branch:t,wtBranch:t};if(t==="main"||t==="master")return{kind:"on-main",branch:t,wtBranch:a};if(A(e,r,"HEAD",c))return{kind:"feature-merged",branch:t,wtBranch:a};const l=e("git",["merge-base","HEAD",c],r),m=l.status===0?l.stdout.trim():"",w=e("git",["rev-list","--count",`${m}..${c}`],r),$=parseInt(w.stdout.trim(),10)||0;return{kind:"feature-mid-sprint",branch:t,wtBranch:a,commits:$}}async function O(i={},e={prune:!1}){const u={...W,...i},{runSync:r,cwd:d,stderr:s,stdout:n}=u,t=E(u);if(t.kind==="error")return s(o.red(`\u25FC borg sync: ${t.reason}
+`)),1;if(t.kind==="dirty"){s(o.yellow(`\u25FC Working tree has uncommitted changes.
+`));for(const a of t.files.slice(0,5))s(o.gray(`  ${a}
+`));return t.files.length>5&&s(o.gray(`  ... and ${t.files.length-5} more
+`)),s(o.yellow("\u25FC Commit, stash, or restore before running `borg sync`. Nothing was changed.\n")),1}if(t.kind==="on-wt"){const a=k(r,d(),t.wtBranch,c);return a.action==="fast-forwarded"?(n(o.blue(`\u25FC On \`${t.wtBranch}\`; fast-forwarded to ${c}.
+`)),0):a.action==="already-current"?(n(o.blue(`\u25FC On \`${t.wtBranch}\`; up to date with ${c}.
+`)),0):(s(o.yellow(`\u25FC ${a.message??"sync skipped"}.
+`)),1)}if(t.kind==="on-main")return h(t.wtBranch,r,d,n,s);if(t.kind==="feature-mid-sprint"){if(t.commits===0)return n(o.blue(`\u25FC On \`${t.branch}\` (feature branch); up to date with ${c}.
+`)),n(o.gray(`\u25FC Continue your sprint, or post REVIEW-READY when complete.
+`)),0;const a=r("git",["merge","--no-edit",c],d());return a.status!==0?(s(o.red(`\u25FC borg sync: git merge ${c} failed (likely conflict). Resolve manually:
+${a.stderr.trim()}
+`)),1):(n(o.blue(`\u25FC On \`${t.branch}\`; merged ${t.commits} commit${t.commits===1?"":"s"} from ${c} (no rebase).
+`)),n(o.gray(`\u25FC Re-run tests; continue your sprint.
+`)),0)}if(t.kind==="feature-merged"){const a=t.branch,l=h(t.wtBranch,r,d,n,s,{adoptedPrefix:`\u25FC \`${a}\` is merged into ${c};`});if(l!==0)return l;const m=v(r,d(),a,c,{prune:e.prune});return m.action==="pruned"?n(o.blue(`\u25FC Pruned merged branch \`${a}\`.
+`)):m.action==="announced"&&n(o.gray(`\u25FC ${m.message}
+`)),0}const f=t;return s(o.red(`\u25FC borg sync: unhandled state
+`)),1}function h(i,e,u,r,d,s={}){const n=b(e,u(),i,c);return n.action==="adopted"?(s.adoptedPrefix?r(o.blue(`${s.adoptedPrefix} switched to \`${i}\` at ${c}.
+`)):r(o.blue(`\u25FC On \`${i}\` at ${c}.
+`)),0):(d(o.yellow(`\u25FC borg sync: ${n.message??"not adopted"}. Nothing was changed.
+`)),1)}function P(i){let e=!1;for(const u of i)if(u==="--prune")e=!0;else return{ok:!1,error:`unexpected argument: ${u}. Usage: borg sync [--prune]`};return{ok:!0,options:{prune:e}}}export{E as detectState,P as parseSyncArgs,x as resolveWtBranch,O as runSync};