npm - git-coco - Versions diffs - 0.58.0 → 0.58.1 - Mend

git-coco 0.58.0 → 0.58.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/README.md CHANGED Viewed

@@ -19,6 +19,8 @@ An AI-powered git assistant that generates meaningful commit messages, creates c
 - 🔧 **Commitlint Integration** - Seamless integration with your existing commitlint configuration
 - 🏠 **Local AI Support** - Run completely offline with Ollama (no API costs, full privacy)
 - 🖥️ **Coco UI Git Workstation** - Sixteen top-level views (history, status, diff, compose, branches, tags, stash, worktrees, pull-request, PR triage, issues, conflicts, reflog, bisect, submodules, changelog) reachable via `g`-prefixed chords, with an interactive command palette (`:`), global search (`/`), and one-keystroke workflows: `S` split staged changes, `L` generate a changelog, `C` create a PR seeded from changelog, `E` open the commit draft in `$EDITOR`
+- 🗂️ **Multi-Repo Workspace** - `coco workspace` (alias `ws`) scans your current directory for git repos and gives you a sortable, filterable overview — branch, dirty count, ahead/behind, open PR count — then `Enter` drills into any one as a full `coco ui` session
+- 🎨 **49 Color Themes** - Catppuccin, Gruvbox, Dracula, Tokyo Night, Solarized, and more (17 light) — browse and **live-preview** them with the in-app theme picker (`gC`), then apply with one keystroke; or set one via `coco ui --theme <name>` / config. `NO_COLOR` honored
 - 🎯 **`--repo <dir>` global flag** - Drive any coco command against any repository without `cd`-ing first
 - 📦 **Package Manager Friendly** - Works with npm, yarn, and pnpm
 - 👥 **Team Ready** - Shared configurations and enterprise deployment
@@ -48,6 +50,9 @@ coco commit -i
 - **`coco review`** - AI-powered code review of your changes
 - **`coco log`** - Explore commit history with graph, filters, JSON output, and commit details
 - **`coco ui`** - Open the full-screen Git workstation TUI
+- **`coco workspace`** (alias `ws`) - Multi-repo overview TUI; drill into any repo as a `coco ui` session
+- **`coco issues`** / **`coco prs`** - List GitHub issues / pull requests (stdout or interactive triage)
+- **`coco doctor`** - Diagnose your environment, config, and provider setup
 - **`coco init`** - Interactive setup wizard
 > **Smart default (0.57.0+):** running `coco` with **no subcommand** routes by environment — `coco ui` inside a git repo, `coco workspace` outside one, or `coco init` on a fresh install. It no longer defaults to `commit`; use `coco commit` for messages (or `--commit` / `COCO_DEFAULT=commit` to restore the old default).
@@ -111,10 +116,11 @@ coco log --format json
 ```text
 g h   history          g c   compose         g x   conflicts
 g s   status           g b   branches        g r   reflog
-g d   diff             g t   tags            <     back
-                       g z   stash           Esc   back / close modal
-                       g w   worktrees       ?     help overlay
-                       g p   pull request    :     command palette
+g d   diff             g t   tags            g C   theme picker
+g w   worktrees        g z   stash           <     back
+g p   pull request                           Esc   back / close modal
+                                              ?     help overlay
+                                              :     command palette
 ```
 The command palette (`:`) is an interactive launcher with fuzzy filter and recently-used at the top — every keybinding and workflow action is reachable from there. `/` searches the active view (history, branches, tags, stash, or reflog). On branches, tags, and history, press `m` to mark a ref as the compare base — then `Enter` on a second ref opens a `git diff <base>..<head>` view. See the [Coco UI](https://github.com/gfargo/coco/wiki/Coco-UI) and [TUI Navigation](https://github.com/gfargo/coco/wiki/TUI-Navigation) wiki pages for the full keymap.

package/dist/index.esm.mjs CHANGED Viewed

@@ -61,7 +61,7 @@ import { pathToFileURL } from 'url';
 /**
  * Current build version from package.json
  */
-const BUILD_VERSION = "0.58.0";
+const BUILD_VERSION = "0.58.1";
 const isInteractive = (config) => {
     return config?.mode === 'interactive' || !!config?.interactive;
@@ -25305,6 +25305,11 @@ function applyLogInkAction(state, action) {
                 bootLoading: action.value,
                 pendingKey: undefined,
             };
+        case 'setRemoteOp':
+            return {
+                ...state,
+                remoteOp: action.value,
+            };
         case 'moveTag':
             return {
                 ...state,
@@ -29964,6 +29969,35 @@ async function runAction$5(action, successMessage) {
         };
     }
 }
+/** Configured remote names (best-effort; `[]` if the call fails). */
+async function listRemotes(git) {
+    try {
+        return (await git.getRemotes()).map((remote) => remote.name).filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Remote to push a not-yet-tracked branch to: `origin` when it exists,
+ * else the first configured remote, else `undefined` (no remotes).
+ */
+async function resolveDefaultRemote(git) {
+    const remotes = await listRemotes(git);
+    if (remotes.length === 0)
+        return undefined;
+    return remotes.includes('origin') ? 'origin' : remotes[0];
+}
+/** Whether the remote-tracking ref `refs/remotes/<remote>/<branch>` exists locally. */
+async function remoteBranchExists(git, remote, branch) {
+    try {
+        await git.raw(['show-ref', '--verify', '--quiet', `refs/remotes/${remote}/${branch}`]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function checkoutBranch(git, branch) {
     const refs = getBranchActionRefs(branch);
     if (branch.type === 'remote') {
@@ -29998,11 +30032,58 @@ function fetchRemotes(git) {
 function pullCurrentBranch(git) {
     return runAction$5(() => git.raw(['pull', '--ff-only']), 'Pulled current branch');
 }
-function pushCurrentBranch(git) {
-    return runAction$5(() => git.raw(['push']), 'Pushed current branch');
-}
-function setUpstream(git, localBranch, upstreamBranch) {
-    return runAction$5(() => git.raw(['branch', '--set-upstream-to', upstreamBranch, localBranch]), `Set ${localBranch} upstream to ${upstreamBranch}`);
+async function pushCurrentBranch(git) {
+    const hasUpstream = await git
+        .raw(['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{upstream}'])
+        .then(() => true)
+        .catch(() => false);
+    if (hasUpstream) {
+        return runAction$5(() => git.raw(['push']), 'Pushed current branch');
+    }
+    // No upstream yet — push with `-u` to create the remote branch AND set
+    // tracking, instead of failing with git's bare "has no upstream" error.
+    const remote = await resolveDefaultRemote(git);
+    if (!remote) {
+        return { ok: false, message: 'No upstream and no remote configured — add one with `git remote add origin <url>`.' };
+    }
+    const current = (await git.raw(['rev-parse', '--abbrev-ref', 'HEAD'])).trim();
+    return runAction$5(() => git.raw(['push', '-u', remote, current]), `Pushed ${current} and set upstream to ${remote}/${current}`);
+}
+/**
+ * Set (or create) the upstream for a local branch from a user-typed target.
+ *
+ * The target may be a bare branch name (`main` → `<default-remote>/main`) or
+ * a `remote/branch` ref (`origin/main`). If that remote-tracking branch
+ * already exists, we just link to it (`git branch --set-upstream-to`). If it
+ * does NOT exist yet — the common "I just created this branch" case — we
+ * `git push -u` to create the remote branch and set tracking in one step.
+ * The old behavior ran `--set-upstream-to <bare-name>`, which silently
+ * resolved `main` to the *local* branch and left push still complaining.
+ */
+async function setUpstream(git, localBranch, target) {
+    const cleaned = target.trim();
+    if (!cleaned)
+        return { ok: false, message: 'Upstream ref required' };
+    const remotes = await listRemotes(git);
+    const slash = cleaned.indexOf('/');
+    let remote;
+    let remoteBranch;
+    if (slash > 0 && remotes.includes(cleaned.slice(0, slash))) {
+        remote = cleaned.slice(0, slash);
+        remoteBranch = cleaned.slice(slash + 1);
+    }
+    else {
+        remote = remotes.includes('origin') ? 'origin' : remotes[0];
+        remoteBranch = cleaned;
+    }
+    if (!remote) {
+        return { ok: false, message: 'No remote configured — add one with `git remote add origin <url>` first.' };
+    }
+    if (await remoteBranchExists(git, remote, remoteBranch)) {
+        return runAction$5(() => git.raw(['branch', '--set-upstream-to', `${remote}/${remoteBranch}`, localBranch]), `Set ${localBranch} to track ${remote}/${remoteBranch}`);
+    }
+    // Remote branch doesn't exist yet — push it and set upstream in one step.
+    return runAction$5(() => git.raw(['push', '-u', remote, `${localBranch}:${remoteBranch}`]), `Pushed ${localBranch} → ${remote}/${remoteBranch} and set upstream`);
 }
 /**
  * Push an arbitrary local branch (need not be the current branch) to
@@ -30013,18 +30094,21 @@ function setUpstream(git, localBranch, upstreamBranch) {
  * Pairs with `pushCurrentBranch` (no-arg variant); the workstation
  * dispatcher picks one or the other based on where the cursor is.
  */
-function pushBranch(git, branch) {
+async function pushBranch(git, branch) {
     if (branch.type !== 'local') {
-        return Promise.resolve({
-            ok: false,
-            message: 'Only local branches can be pushed.',
-        });
+        return { ok: false, message: 'Only local branches can be pushed.' };
     }
     if (!branch.upstream || !branch.remote) {
-        return Promise.resolve({
-            ok: false,
-            message: `${branch.shortName} has no upstream — checkout the branch and run \`git push -u <remote> ${branch.shortName}\` first.`,
-        });
+        // No upstream yet — push with `-u` to create the remote branch AND set
+        // tracking, rather than refusing and sending the user to the shell.
+        const remote = await resolveDefaultRemote(git);
+        if (!remote) {
+            return {
+                ok: false,
+                message: `${branch.shortName} has no upstream and no remote is configured — add one with \`git remote add origin <url>\`.`,
+            };
+        }
+        return runAction$5(() => git.raw(['push', '-u', remote, branch.shortName]), `Pushed ${branch.shortName} and set upstream to ${remote}/${branch.shortName}`);
     }
     return runAction$5(() => git.raw(['push', branch.remote, branch.shortName]), `Pushed ${branch.shortName} to ${branch.upstream}`);
 }
@@ -35396,9 +35480,55 @@ function renderPendingCommitRow(h, Text, worktree, selected, theme) {
         backgroundColor: selected && !theme.noColor ? theme.colors.selection : undefined,
     }, truncateCells(label, 140));
 }
-function renderHistoryPanel(h, components, state, context, bodyRows, width, theme, hasMoreCommits, loadingMoreCommits, density, rowMode, dateBucketingEnabled = false, now = getRenderNow()) {
+/**
+ * Full-panel loader shown over the history surface while a remote
+ * operation (fetch / pull / push) is in flight. Same bordered frame
+ * and `Commits` title row as the real panel so the swap in/out is
+ * seamless: a centered spinner + label + a travelling arrow track
+ * give the user an unmistakable "we're talking to the remote" beat in
+ * place of a frozen, soon-to-abruptly-repaint commit list.
+ */
+function renderRemoteOpLoader(h, components, state, width, bodyRows, theme, focused, spinnerFrame) {
+    const { Box, Text } = components;
+    const op = state.remoteOp;
+    if (!op) {
+        return h(Box, { width });
+    }
+    const spinner = pickSpinnerFrame(spinnerFrame);
+    // Directional glyph hints which way the bits are flowing.
+    const glyph = op.kind === 'push' ? '↑' : op.kind === 'pull' ? '↓' : '↕';
+    // A single glyph "travels" along a dotted track each tick so the
+    // motion reads even on terminals that render braille spinners poorly.
+    const trackWidth = 9;
+    const pos = Math.max(0, spinnerFrame) % trackWidth;
+    const track = Array.from({ length: trackWidth }, (_, i) => (i === pos ? glyph : '·')).join(' ');
+    const accent = theme.noColor ? undefined : theme.colors.accent;
+    const innerHeight = Math.max(3, bodyRows - 2);
+    return h(Box, {
+        borderColor: focusBorderColor(theme, focused),
+        borderStyle: theme.borderStyle,
+        flexDirection: 'column',
+        flexShrink: 0,
+        paddingX: 1,
+        width,
+    }, h(Box, { justifyContent: 'space-between' }, h(Text, { bold: true }, panelTitle('Commits', focused)), h(Text, { dimColor: true }, `${op.kind} in progress`)), h(Box, {
+        flexDirection: 'column',
+        alignItems: 'center',
+        justifyContent: 'center',
+        height: innerHeight,
+    }, h(Text, { color: accent, bold: true }, `${spinner}  ${op.label}`), h(Text, undefined, ''), h(Text, { color: accent }, track), h(Text, undefined, ''), h(Text, { dimColor: true }, 'Talking to the remote — history refreshes automatically.')));
+}
+function renderHistoryPanel(h, components, state, context, bodyRows, width, theme, hasMoreCommits, loadingMoreCommits, density, rowMode, dateBucketingEnabled = false, now = getRenderNow(), spinnerFrame = 0) {
     const { Box, Text } = components;
     const focused = state.focus === 'commits';
+    // Remote op in flight (fetch / pull / push) → swap the commit list
+    // for a centered, animated loader. Keeping the same bordered panel
+    // (same width, same title row) means that when the op completes and
+    // `remoteOp` clears, the fresh rows paint in place without the panel
+    // jumping — smoothing over the "frozen list → sudden repaint" feel.
+    if (state.remoteOp) {
+        return renderRemoteOpLoader(h, components, state, width, bodyRows, theme, focused, spinnerFrame);
+    }
     const worktree = context.worktree;
     // Distinct remote names seen across the repo's remote-tracking
     // branches — `['origin']` for a typical fork, `['origin', 'upstream']`
@@ -37279,7 +37409,7 @@ function renderMainPanel(h, components, state, context, contextStatus, worktreeD
     if (state.activeView === 'changelog') {
         return renderChangelogSurface(h, components, state, context, contextStatus, bodyRows, width, theme);
     }
-    return renderHistoryPanel(h, components, state, context, bodyRows, width, theme, hasMoreCommits, loadingMoreCommits, density, rowMode, dateBucketingEnabled);
+    return renderHistoryPanel(h, components, state, context, bodyRows, width, theme, hasMoreCommits, loadingMoreCommits, density, rowMode, dateBucketingEnabled, undefined, spinnerFrame);
 }
 /**
@@ -38541,6 +38671,18 @@ function loadLogInkContextEntries(git) {
         },
     ];
 }
+// Workflow action ids that hit the network (fetch / pull / push) →
+// the loader copy shown over the history surface while they run. Any
+// id NOT in this map runs without the full-screen loader (local-only
+// mutations repaint fast enough that a loader would just flicker).
+const REMOTE_OP_LOADERS = {
+    'fetch-remotes': { kind: 'fetch', label: 'Fetching all remotes…' },
+    'pull-current-branch': { kind: 'pull', label: 'Pulling from origin…' },
+    'push-current-branch': { kind: 'push', label: 'Pushing to origin…' },
+    'fetch-selected-branch': { kind: 'fetch', label: 'Fetching branch from remote…' },
+    'pull-selected-branch': { kind: 'pull', label: 'Pulling branch from remote…' },
+    'push-selected-branch': { kind: 'push', label: 'Pushing branch to remote…' },
+};
 function predictNextFilter(action, currentFilter) {
     switch (action.type) {
         case 'appendFilter':
@@ -38847,6 +38989,7 @@ function LogInkApp(deps) {
         state.splitPlan?.status === 'applying' ||
         state.changelogView.status === 'loading' ||
         state.commitCompose.loading ||
+        Boolean(state.remoteOp) ||
         Boolean(state.statusLoading);
     React.useEffect(() => {
         if (!anyLoading) {
@@ -41637,76 +41780,96 @@ function LogInkApp(deps) {
             dispatch({ type: 'setStatus', value: `Workflow action ${id} not yet wired`, kind: 'warning' });
             return;
         }
-        const result = await handler();
-        dispatch({ type: 'setStatus', value: result?.message || 'Workflow action complete' });
-        // Refresh history rows AS WELL when the workflow could have
-        // changed the commits the user sees (#945 follow-up). The
-        // workflow IDs below all either create/rewrite local commits or
-        // change which branch's history is being viewed — without this
-        // the history pane shows stale data even after the operation
-        // succeeds. Cheap one-off `git log` call; doesn't fire on
-        // metadata-only mutations (delete-tag, set-upstream, etc.).
-        const historyMutatingIds = new Set([
-            'checkout-branch',
-            'continue-operation',
-            'pull-current-branch',
-            'cherry-pick-commit',
-            'revert-commit',
-            'reset-hard-to-commit',
-            'reset-soft-to-commit',
-            'reset-mixed-to-commit',
-            'interactive-rebase-to-commit',
-            'bisect-good',
-            'bisect-bad',
-            'bisect-skip',
-            'bisect-reset',
-        ]);
-        if (result?.ok && historyMutatingIds.has(id)) {
-            await refreshHistoryRows();
-        }
-        // Checkout-branch is the one workflow where we want a *visible*
-        // refresh so the user sees the branches sidebar repaint with the
-        // new current branch (per #806 follow-up). Snap the cursor to
-        // position 0 first so when the refresh completes and the new
-        // current branch lands at the top (per #809's pin-current rule),
-        // the cursor is already there waiting.
-        if (id === 'checkout-branch' && result?.ok) {
-            dispatch({ type: 'resetBranchSelection' });
-            await refreshContext();
+        // Remote network ops (fetch / pull / push) get a full-screen
+        // history loader while in flight so the commit list doesn't sit
+        // frozen and then abruptly repaint when the call returns. Cleared
+        // in `finally` *after* the post-op refresh below so the loader
+        // hands straight off to the freshly-fetched rows instead of
+        // flashing the stale list for a frame in between.
+        const remoteOp = REMOTE_OP_LOADERS[id];
+        if (remoteOp) {
+            dispatch({ type: 'setRemoteOp', value: remoteOp });
         }
-        else {
-            // Silent refresh so the deleted item disappears from the list
-            // without flickering the surfaces through a 'loading' phase.
-            await refreshContext({ silent: true });
-        }
-        // Stash workflow follow-up. Two distinct behaviours.
-        //
-        // **apply / pop**: the user brought stashed content back into the
-        // worktree, but the sidebar still has them on the stash view.
-        // Expected next move is "look at what landed in my worktree", so
-        // jump them to history view (where the worktree counts in the
-        // sidebar are visible) AND refresh worktree context explicitly so
-        // the staged / unstaged / untracked numbers reflect the changes.
-        //
-        // **drop**: the silent context refresh above already re-fetched
-        // the stash list, BUT users reported it feeling like nothing
-        // happened. Fix two things: refresh worktree alongside (drops can
-        // affect untracked files when the stash held `-u` state), and
-        // surface the new stash count on the status line so there's
-        // unambiguous feedback that the drop landed and the list shrank.
-        if (result?.ok && (id === 'apply-stash' || id === 'pop-stash')) {
-            dispatch({ type: 'pushView', value: 'history' });
-            await refreshWorktreeContext();
+        try {
+            const result = await handler();
+            dispatch({ type: 'setStatus', value: result?.message || 'Workflow action complete' });
+            // Refresh history rows AS WELL when the workflow could have
+            // changed the commits the user sees (#945 follow-up). The
+            // workflow IDs below all either create/rewrite local commits or
+            // change which branch's history is being viewed — without this
+            // the history pane shows stale data even after the operation
+            // succeeds. Cheap one-off `git log` call; doesn't fire on
+            // metadata-only mutations (delete-tag, set-upstream, etc.).
+            const historyMutatingIds = new Set([
+                'checkout-branch',
+                'continue-operation',
+                'pull-current-branch',
+                'cherry-pick-commit',
+                'revert-commit',
+                'reset-hard-to-commit',
+                'reset-soft-to-commit',
+                'reset-mixed-to-commit',
+                'interactive-rebase-to-commit',
+                'bisect-good',
+                'bisect-bad',
+                'bisect-skip',
+                'bisect-reset',
+            ]);
+            if (result?.ok && historyMutatingIds.has(id)) {
+                await refreshHistoryRows();
+            }
+            // Checkout-branch is the one workflow where we want a *visible*
+            // refresh so the user sees the branches sidebar repaint with the
+            // new current branch (per #806 follow-up). Snap the cursor to
+            // position 0 first so when the refresh completes and the new
+            // current branch lands at the top (per #809's pin-current rule),
+            // the cursor is already there waiting.
+            if (id === 'checkout-branch' && result?.ok) {
+                dispatch({ type: 'resetBranchSelection' });
+                await refreshContext();
+            }
+            else {
+                // Silent refresh so the deleted item disappears from the list
+                // without flickering the surfaces through a 'loading' phase.
+                await refreshContext({ silent: true });
+            }
+            // Stash workflow follow-up. Two distinct behaviours.
+            //
+            // **apply / pop**: the user brought stashed content back into the
+            // worktree, but the sidebar still has them on the stash view.
+            // Expected next move is "look at what landed in my worktree", so
+            // jump them to history view (where the worktree counts in the
+            // sidebar are visible) AND refresh worktree context explicitly so
+            // the staged / unstaged / untracked numbers reflect the changes.
+            //
+            // **drop**: the silent context refresh above already re-fetched
+            // the stash list, BUT users reported it feeling like nothing
+            // happened. Fix two things: refresh worktree alongside (drops can
+            // affect untracked files when the stash held `-u` state), and
+            // surface the new stash count on the status line so there's
+            // unambiguous feedback that the drop landed and the list shrank.
+            if (result?.ok && (id === 'apply-stash' || id === 'pop-stash')) {
+                dispatch({ type: 'pushView', value: 'history' });
+                await refreshWorktreeContext();
+            }
+            if (result?.ok && id === 'drop-stash') {
+                // Explicit worktree refresh in case the dropped stash carried
+                // untracked-file state that's now collected.
+                await refreshWorktreeContext();
+                // The silent context refresh already replaced `context.stashes`;
+                // reading the count back here would be stale because closures
+                // capture the pre-refresh value. Status message stays generic
+                // ("Dropped stash@{N}") — the visible list shrinking is the
+                // unambiguous signal that the operation landed.
+            }
         }
-        if (result?.ok && id === 'drop-stash') {
-            // Explicit worktree refresh in case the dropped stash carried
-            // untracked-file state that's now collected.
-            await refreshWorktreeContext();
-            // The silent context refresh already replaced `context.stashes`;
-            // reading the count back here would be stale because closures
-            // capture the pre-refresh value. Status message stays generic
-            // ("Dropped stash@{N}") — the visible list shrinking is the
-            // unambiguous signal that the operation landed.
+        finally {
+            // Always clear the loader — even if a refresh threw — so a
+            // failed fetch/pull can't leave the history surface stuck behind
+            // the spinner.
+            if (remoteOp) {
+                dispatch({ type: 'setRemoteOp', value: undefined });
+            }
         }
     }, [context, dispatch, git, refreshContext, refreshHistoryRows, refreshWorktreeContext,
         state.branchSort, state.filter, state.selectedBranchIndex,

package/dist/index.js CHANGED Viewed

@@ -78,7 +78,7 @@ var readline__namespace = /*#__PURE__*/_interopNamespaceDefault(readline);
 /**
  * Current build version from package.json
  */
-const BUILD_VERSION = "0.58.0";
+const BUILD_VERSION = "0.58.1";
 const isInteractive = (config) => {
     return config?.mode === 'interactive' || !!config?.interactive;
@@ -25322,6 +25322,11 @@ function applyLogInkAction(state, action) {
                 bootLoading: action.value,
                 pendingKey: undefined,
             };
+        case 'setRemoteOp':
+            return {
+                ...state,
+                remoteOp: action.value,
+            };
         case 'moveTag':
             return {
                 ...state,
@@ -29981,6 +29986,35 @@ async function runAction$5(action, successMessage) {
         };
     }
 }
+/** Configured remote names (best-effort; `[]` if the call fails). */
+async function listRemotes(git) {
+    try {
+        return (await git.getRemotes()).map((remote) => remote.name).filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Remote to push a not-yet-tracked branch to: `origin` when it exists,
+ * else the first configured remote, else `undefined` (no remotes).
+ */
+async function resolveDefaultRemote(git) {
+    const remotes = await listRemotes(git);
+    if (remotes.length === 0)
+        return undefined;
+    return remotes.includes('origin') ? 'origin' : remotes[0];
+}
+/** Whether the remote-tracking ref `refs/remotes/<remote>/<branch>` exists locally. */
+async function remoteBranchExists(git, remote, branch) {
+    try {
+        await git.raw(['show-ref', '--verify', '--quiet', `refs/remotes/${remote}/${branch}`]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function checkoutBranch(git, branch) {
     const refs = getBranchActionRefs(branch);
     if (branch.type === 'remote') {
@@ -30015,11 +30049,58 @@ function fetchRemotes(git) {
 function pullCurrentBranch(git) {
     return runAction$5(() => git.raw(['pull', '--ff-only']), 'Pulled current branch');
 }
-function pushCurrentBranch(git) {
-    return runAction$5(() => git.raw(['push']), 'Pushed current branch');
-}
-function setUpstream(git, localBranch, upstreamBranch) {
-    return runAction$5(() => git.raw(['branch', '--set-upstream-to', upstreamBranch, localBranch]), `Set ${localBranch} upstream to ${upstreamBranch}`);
+async function pushCurrentBranch(git) {
+    const hasUpstream = await git
+        .raw(['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{upstream}'])
+        .then(() => true)
+        .catch(() => false);
+    if (hasUpstream) {
+        return runAction$5(() => git.raw(['push']), 'Pushed current branch');
+    }
+    // No upstream yet — push with `-u` to create the remote branch AND set
+    // tracking, instead of failing with git's bare "has no upstream" error.
+    const remote = await resolveDefaultRemote(git);
+    if (!remote) {
+        return { ok: false, message: 'No upstream and no remote configured — add one with `git remote add origin <url>`.' };
+    }
+    const current = (await git.raw(['rev-parse', '--abbrev-ref', 'HEAD'])).trim();
+    return runAction$5(() => git.raw(['push', '-u', remote, current]), `Pushed ${current} and set upstream to ${remote}/${current}`);
+}
+/**
+ * Set (or create) the upstream for a local branch from a user-typed target.
+ *
+ * The target may be a bare branch name (`main` → `<default-remote>/main`) or
+ * a `remote/branch` ref (`origin/main`). If that remote-tracking branch
+ * already exists, we just link to it (`git branch --set-upstream-to`). If it
+ * does NOT exist yet — the common "I just created this branch" case — we
+ * `git push -u` to create the remote branch and set tracking in one step.
+ * The old behavior ran `--set-upstream-to <bare-name>`, which silently
+ * resolved `main` to the *local* branch and left push still complaining.
+ */
+async function setUpstream(git, localBranch, target) {
+    const cleaned = target.trim();
+    if (!cleaned)
+        return { ok: false, message: 'Upstream ref required' };
+    const remotes = await listRemotes(git);
+    const slash = cleaned.indexOf('/');
+    let remote;
+    let remoteBranch;
+    if (slash > 0 && remotes.includes(cleaned.slice(0, slash))) {
+        remote = cleaned.slice(0, slash);
+        remoteBranch = cleaned.slice(slash + 1);
+    }
+    else {
+        remote = remotes.includes('origin') ? 'origin' : remotes[0];
+        remoteBranch = cleaned;
+    }
+    if (!remote) {
+        return { ok: false, message: 'No remote configured — add one with `git remote add origin <url>` first.' };
+    }
+    if (await remoteBranchExists(git, remote, remoteBranch)) {
+        return runAction$5(() => git.raw(['branch', '--set-upstream-to', `${remote}/${remoteBranch}`, localBranch]), `Set ${localBranch} to track ${remote}/${remoteBranch}`);
+    }
+    // Remote branch doesn't exist yet — push it and set upstream in one step.
+    return runAction$5(() => git.raw(['push', '-u', remote, `${localBranch}:${remoteBranch}`]), `Pushed ${localBranch} → ${remote}/${remoteBranch} and set upstream`);
 }
 /**
  * Push an arbitrary local branch (need not be the current branch) to
@@ -30030,18 +30111,21 @@ function setUpstream(git, localBranch, upstreamBranch) {
  * Pairs with `pushCurrentBranch` (no-arg variant); the workstation
  * dispatcher picks one or the other based on where the cursor is.
  */
-function pushBranch(git, branch) {
+async function pushBranch(git, branch) {
     if (branch.type !== 'local') {
-        return Promise.resolve({
-            ok: false,
-            message: 'Only local branches can be pushed.',
-        });
+        return { ok: false, message: 'Only local branches can be pushed.' };
     }
     if (!branch.upstream || !branch.remote) {
-        return Promise.resolve({
-            ok: false,
-            message: `${branch.shortName} has no upstream — checkout the branch and run \`git push -u <remote> ${branch.shortName}\` first.`,
-        });
+        // No upstream yet — push with `-u` to create the remote branch AND set
+        // tracking, rather than refusing and sending the user to the shell.
+        const remote = await resolveDefaultRemote(git);
+        if (!remote) {
+            return {
+                ok: false,
+                message: `${branch.shortName} has no upstream and no remote is configured — add one with \`git remote add origin <url>\`.`,
+            };
+        }
+        return runAction$5(() => git.raw(['push', '-u', remote, branch.shortName]), `Pushed ${branch.shortName} and set upstream to ${remote}/${branch.shortName}`);
     }
     return runAction$5(() => git.raw(['push', branch.remote, branch.shortName]), `Pushed ${branch.shortName} to ${branch.upstream}`);
 }
@@ -35413,9 +35497,55 @@ function renderPendingCommitRow(h, Text, worktree, selected, theme) {
         backgroundColor: selected && !theme.noColor ? theme.colors.selection : undefined,
     }, truncateCells(label, 140));
 }
-function renderHistoryPanel(h, components, state, context, bodyRows, width, theme, hasMoreCommits, loadingMoreCommits, density, rowMode, dateBucketingEnabled = false, now = getRenderNow()) {
+/**
+ * Full-panel loader shown over the history surface while a remote
+ * operation (fetch / pull / push) is in flight. Same bordered frame
+ * and `Commits` title row as the real panel so the swap in/out is
+ * seamless: a centered spinner + label + a travelling arrow track
+ * give the user an unmistakable "we're talking to the remote" beat in
+ * place of a frozen, soon-to-abruptly-repaint commit list.
+ */
+function renderRemoteOpLoader(h, components, state, width, bodyRows, theme, focused, spinnerFrame) {
+    const { Box, Text } = components;
+    const op = state.remoteOp;
+    if (!op) {
+        return h(Box, { width });
+    }
+    const spinner = pickSpinnerFrame(spinnerFrame);
+    // Directional glyph hints which way the bits are flowing.
+    const glyph = op.kind === 'push' ? '↑' : op.kind === 'pull' ? '↓' : '↕';
+    // A single glyph "travels" along a dotted track each tick so the
+    // motion reads even on terminals that render braille spinners poorly.
+    const trackWidth = 9;
+    const pos = Math.max(0, spinnerFrame) % trackWidth;
+    const track = Array.from({ length: trackWidth }, (_, i) => (i === pos ? glyph : '·')).join(' ');
+    const accent = theme.noColor ? undefined : theme.colors.accent;
+    const innerHeight = Math.max(3, bodyRows - 2);
+    return h(Box, {
+        borderColor: focusBorderColor(theme, focused),
+        borderStyle: theme.borderStyle,
+        flexDirection: 'column',
+        flexShrink: 0,
+        paddingX: 1,
+        width,
+    }, h(Box, { justifyContent: 'space-between' }, h(Text, { bold: true }, panelTitle('Commits', focused)), h(Text, { dimColor: true }, `${op.kind} in progress`)), h(Box, {
+        flexDirection: 'column',
+        alignItems: 'center',
+        justifyContent: 'center',
+        height: innerHeight,
+    }, h(Text, { color: accent, bold: true }, `${spinner}  ${op.label}`), h(Text, undefined, ''), h(Text, { color: accent }, track), h(Text, undefined, ''), h(Text, { dimColor: true }, 'Talking to the remote — history refreshes automatically.')));
+}
+function renderHistoryPanel(h, components, state, context, bodyRows, width, theme, hasMoreCommits, loadingMoreCommits, density, rowMode, dateBucketingEnabled = false, now = getRenderNow(), spinnerFrame = 0) {
     const { Box, Text } = components;
     const focused = state.focus === 'commits';
+    // Remote op in flight (fetch / pull / push) → swap the commit list
+    // for a centered, animated loader. Keeping the same bordered panel
+    // (same width, same title row) means that when the op completes and
+    // `remoteOp` clears, the fresh rows paint in place without the panel
+    // jumping — smoothing over the "frozen list → sudden repaint" feel.
+    if (state.remoteOp) {
+        return renderRemoteOpLoader(h, components, state, width, bodyRows, theme, focused, spinnerFrame);
+    }
     const worktree = context.worktree;
     // Distinct remote names seen across the repo's remote-tracking
     // branches — `['origin']` for a typical fork, `['origin', 'upstream']`
@@ -37296,7 +37426,7 @@ function renderMainPanel(h, components, state, context, contextStatus, worktreeD
     if (state.activeView === 'changelog') {
         return renderChangelogSurface(h, components, state, context, contextStatus, bodyRows, width, theme);
     }
-    return renderHistoryPanel(h, components, state, context, bodyRows, width, theme, hasMoreCommits, loadingMoreCommits, density, rowMode, dateBucketingEnabled);
+    return renderHistoryPanel(h, components, state, context, bodyRows, width, theme, hasMoreCommits, loadingMoreCommits, density, rowMode, dateBucketingEnabled, undefined, spinnerFrame);
 }
 /**
@@ -38558,6 +38688,18 @@ function loadLogInkContextEntries(git) {
         },
     ];
 }
+// Workflow action ids that hit the network (fetch / pull / push) →
+// the loader copy shown over the history surface while they run. Any
+// id NOT in this map runs without the full-screen loader (local-only
+// mutations repaint fast enough that a loader would just flicker).
+const REMOTE_OP_LOADERS = {
+    'fetch-remotes': { kind: 'fetch', label: 'Fetching all remotes…' },
+    'pull-current-branch': { kind: 'pull', label: 'Pulling from origin…' },
+    'push-current-branch': { kind: 'push', label: 'Pushing to origin…' },
+    'fetch-selected-branch': { kind: 'fetch', label: 'Fetching branch from remote…' },
+    'pull-selected-branch': { kind: 'pull', label: 'Pulling branch from remote…' },
+    'push-selected-branch': { kind: 'push', label: 'Pushing branch to remote…' },
+};
 function predictNextFilter(action, currentFilter) {
     switch (action.type) {
         case 'appendFilter':
@@ -38864,6 +39006,7 @@ function LogInkApp(deps) {
         state.splitPlan?.status === 'applying' ||
         state.changelogView.status === 'loading' ||
         state.commitCompose.loading ||
+        Boolean(state.remoteOp) ||
         Boolean(state.statusLoading);
     React.useEffect(() => {
         if (!anyLoading) {
@@ -41654,76 +41797,96 @@ function LogInkApp(deps) {
             dispatch({ type: 'setStatus', value: `Workflow action ${id} not yet wired`, kind: 'warning' });
             return;
         }
-        const result = await handler();
-        dispatch({ type: 'setStatus', value: result?.message || 'Workflow action complete' });
-        // Refresh history rows AS WELL when the workflow could have
-        // changed the commits the user sees (#945 follow-up). The
-        // workflow IDs below all either create/rewrite local commits or
-        // change which branch's history is being viewed — without this
-        // the history pane shows stale data even after the operation
-        // succeeds. Cheap one-off `git log` call; doesn't fire on
-        // metadata-only mutations (delete-tag, set-upstream, etc.).
-        const historyMutatingIds = new Set([
-            'checkout-branch',
-            'continue-operation',
-            'pull-current-branch',
-            'cherry-pick-commit',
-            'revert-commit',
-            'reset-hard-to-commit',
-            'reset-soft-to-commit',
-            'reset-mixed-to-commit',
-            'interactive-rebase-to-commit',
-            'bisect-good',
-            'bisect-bad',
-            'bisect-skip',
-            'bisect-reset',
-        ]);
-        if (result?.ok && historyMutatingIds.has(id)) {
-            await refreshHistoryRows();
-        }
-        // Checkout-branch is the one workflow where we want a *visible*
-        // refresh so the user sees the branches sidebar repaint with the
-        // new current branch (per #806 follow-up). Snap the cursor to
-        // position 0 first so when the refresh completes and the new
-        // current branch lands at the top (per #809's pin-current rule),
-        // the cursor is already there waiting.
-        if (id === 'checkout-branch' && result?.ok) {
-            dispatch({ type: 'resetBranchSelection' });
-            await refreshContext();
+        // Remote network ops (fetch / pull / push) get a full-screen
+        // history loader while in flight so the commit list doesn't sit
+        // frozen and then abruptly repaint when the call returns. Cleared
+        // in `finally` *after* the post-op refresh below so the loader
+        // hands straight off to the freshly-fetched rows instead of
+        // flashing the stale list for a frame in between.
+        const remoteOp = REMOTE_OP_LOADERS[id];
+        if (remoteOp) {
+            dispatch({ type: 'setRemoteOp', value: remoteOp });
         }
-        else {
-            // Silent refresh so the deleted item disappears from the list
-            // without flickering the surfaces through a 'loading' phase.
-            await refreshContext({ silent: true });
-        }
-        // Stash workflow follow-up. Two distinct behaviours.
-        //
-        // **apply / pop**: the user brought stashed content back into the
-        // worktree, but the sidebar still has them on the stash view.
-        // Expected next move is "look at what landed in my worktree", so
-        // jump them to history view (where the worktree counts in the
-        // sidebar are visible) AND refresh worktree context explicitly so
-        // the staged / unstaged / untracked numbers reflect the changes.
-        //
-        // **drop**: the silent context refresh above already re-fetched
-        // the stash list, BUT users reported it feeling like nothing
-        // happened. Fix two things: refresh worktree alongside (drops can
-        // affect untracked files when the stash held `-u` state), and
-        // surface the new stash count on the status line so there's
-        // unambiguous feedback that the drop landed and the list shrank.
-        if (result?.ok && (id === 'apply-stash' || id === 'pop-stash')) {
-            dispatch({ type: 'pushView', value: 'history' });
-            await refreshWorktreeContext();
+        try {
+            const result = await handler();
+            dispatch({ type: 'setStatus', value: result?.message || 'Workflow action complete' });
+            // Refresh history rows AS WELL when the workflow could have
+            // changed the commits the user sees (#945 follow-up). The
+            // workflow IDs below all either create/rewrite local commits or
+            // change which branch's history is being viewed — without this
+            // the history pane shows stale data even after the operation
+            // succeeds. Cheap one-off `git log` call; doesn't fire on
+            // metadata-only mutations (delete-tag, set-upstream, etc.).
+            const historyMutatingIds = new Set([
+                'checkout-branch',
+                'continue-operation',
+                'pull-current-branch',
+                'cherry-pick-commit',
+                'revert-commit',
+                'reset-hard-to-commit',
+                'reset-soft-to-commit',
+                'reset-mixed-to-commit',
+                'interactive-rebase-to-commit',
+                'bisect-good',
+                'bisect-bad',
+                'bisect-skip',
+                'bisect-reset',
+            ]);
+            if (result?.ok && historyMutatingIds.has(id)) {
+                await refreshHistoryRows();
+            }
+            // Checkout-branch is the one workflow where we want a *visible*
+            // refresh so the user sees the branches sidebar repaint with the
+            // new current branch (per #806 follow-up). Snap the cursor to
+            // position 0 first so when the refresh completes and the new
+            // current branch lands at the top (per #809's pin-current rule),
+            // the cursor is already there waiting.
+            if (id === 'checkout-branch' && result?.ok) {
+                dispatch({ type: 'resetBranchSelection' });
+                await refreshContext();
+            }
+            else {
+                // Silent refresh so the deleted item disappears from the list
+                // without flickering the surfaces through a 'loading' phase.
+                await refreshContext({ silent: true });
+            }
+            // Stash workflow follow-up. Two distinct behaviours.
+            //
+            // **apply / pop**: the user brought stashed content back into the
+            // worktree, but the sidebar still has them on the stash view.
+            // Expected next move is "look at what landed in my worktree", so
+            // jump them to history view (where the worktree counts in the
+            // sidebar are visible) AND refresh worktree context explicitly so
+            // the staged / unstaged / untracked numbers reflect the changes.
+            //
+            // **drop**: the silent context refresh above already re-fetched
+            // the stash list, BUT users reported it feeling like nothing
+            // happened. Fix two things: refresh worktree alongside (drops can
+            // affect untracked files when the stash held `-u` state), and
+            // surface the new stash count on the status line so there's
+            // unambiguous feedback that the drop landed and the list shrank.
+            if (result?.ok && (id === 'apply-stash' || id === 'pop-stash')) {
+                dispatch({ type: 'pushView', value: 'history' });
+                await refreshWorktreeContext();
+            }
+            if (result?.ok && id === 'drop-stash') {
+                // Explicit worktree refresh in case the dropped stash carried
+                // untracked-file state that's now collected.
+                await refreshWorktreeContext();
+                // The silent context refresh already replaced `context.stashes`;
+                // reading the count back here would be stale because closures
+                // capture the pre-refresh value. Status message stays generic
+                // ("Dropped stash@{N}") — the visible list shrinking is the
+                // unambiguous signal that the operation landed.
+            }
         }
-        if (result?.ok && id === 'drop-stash') {
-            // Explicit worktree refresh in case the dropped stash carried
-            // untracked-file state that's now collected.
-            await refreshWorktreeContext();
-            // The silent context refresh already replaced `context.stashes`;
-            // reading the count back here would be stale because closures
-            // capture the pre-refresh value. Status message stays generic
-            // ("Dropped stash@{N}") — the visible list shrinking is the
-            // unambiguous signal that the operation landed.
+        finally {
+            // Always clear the loader — even if a refresh threw — so a
+            // failed fetch/pull can't leave the history surface stuck behind
+            // the spinner.
+            if (remoteOp) {
+                dispatch({ type: 'setRemoteOp', value: undefined });
+            }
         }
     }, [context, dispatch, git, refreshContext, refreshHistoryRows, refreshWorktreeContext,
         state.branchSort, state.filter, state.selectedBranchIndex,

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "git-coco",
-  "version": "0.58.0",
+  "version": "0.58.1",
   "description": "zero-effort git commits with coco.",
   "author": "gfargo <ghfargo@gmail.com>",
   "license": "MIT",
@@ -79,7 +79,7 @@
     "@types/ini": "^4.1.1",
     "@types/jest": "^30.0.0",
     "@types/node": "^25.0.10",
-    "@types/react": "19.2.14",
+    "@types/react": "19.2.15",
     "@types/yargs": "^17.0.33",
     "@typescript-eslint/eslint-plugin": "^7.13.1",
     "@typescript-eslint/parser": "^7.13.1",
@@ -114,13 +114,13 @@
     "chalk": "4.1.2",
     "diff": "9.0.0",
     "ini": "7.0.0",
-    "ink": "7.0.3",
+    "ink": "7.0.5",
     "minimatch": "^10.2.5",
     "ora": "5.4.1",
     "p-queue": "5.0.0",
     "performance-now": "2.1.0",
     "pretty-ms": "7.0.1",
-    "react": "19.2.5",
+    "react": "19.2.6",
     "react-devtools-core": "7.0.1",
     "simple-git": "3.36.0",
     "tiktoken": "^1.0.21",