unirepo-cli 0.4.1 → 0.5.1

package/README.md

@@ -6,7 +6,7 @@
 
 ### One workspace to refactor your whole stack in one go
 
-Work across multiple repos like they’re one. Unirepo turns multiple GitHub repositories into a single unified workspace. Edit backend, frontend, and shared code in one tree, commit from one place, and push changes back to each repo using the same branch.
+Work across multiple repos like they’re one. Unirepo turns multiple GitHub repositories into a single unified workspace. Edit backend, frontend, and shared code in one tree, commit from one place, and push changes back to each repo using the same branch by default.
 
 ### Built for AI coding agents
 
@@ -140,7 +140,7 @@ AI coding agents work best when they can see the full change at once.
 | `add <repo>` | Add another repo to the workspace |
 | `pull [subtree...]` | Pull upstream changes into tracked subtrees |
 | `status` | Show subtrees, branches, and what changed |
-| `branch [name]` | Create or show the current push branch |
+| `branch [name]` | Create or show the current workspace branch |
 | `push [subtree...]` | Push changed subtrees upstream |
 | `pr [subtree...]` | Open pull requests for changed subtree repos |
 
@@ -191,7 +191,7 @@ Pulls upstream changes. Without arguments, pulls all tracked subtrees. When you
 unirepo status [--json]
 ```
 
-Shows tracked subtrees, their upstream branches, the current push branch, and which subtrees have changes.
+Shows tracked subtrees, their upstream branches, the current workspace branch, each subtree's effective push branch, and which subtrees have changes.
 
 ### branch
 
@@ -199,7 +199,25 @@ Shows tracked subtrees, their upstream branches, the current push branch, and wh
 unirepo branch [name]
 ```
 
-With a name: creates and switches to a new branch. Without: shows the current branch and push targets.
+With a name: creates and switches to a new branch. That branch becomes the default push target for subtrees that do not have their own configured override. Without: shows the current branch and effective push targets.
+
+### Per-subtree push branches
+
+By default, `unirepo branch <name>` sets the workspace branch and subtrees push and open PRs from that same branch.
+
+If one subtree repo needs a different branch target, configure it in local git config:
+
+```bash
+git config unirepo.subtree.api.pushBranch feature-api
+git config unirepo.subtree.web.pushBranch feature/web-auth
+unirepo status
+```
+
+Remove an override and go back to the workspace branch default:
+
+```bash
+git config --unset unirepo.subtree.api.pushBranch
+```
 
 ### push
 
@@ -207,11 +225,11 @@ With a name: creates and switches to a new branch. Without: shows the current br
 unirepo push [subtree...] [--dry-run]
 ```
 
-Pushes changed subtrees upstream. Without arguments, auto-detects which subtrees have changes.
+Pushes changed subtrees upstream. Without arguments, auto-detects which subtrees have changes. Each subtree pushes to its configured push branch or the current workspace branch by default.
 
 | Flag | Effect |
 | --- | --- |
-| `--branch <name>` | Override the upstream branch name |
+| `--branch <name>` | Override the push branch name for all selected subtrees |
 | `--dry-run` | Show what would run without executing |
 
 ### pr
@@ -220,7 +238,7 @@ Pushes changed subtrees upstream. Without arguments, auto-detects which subtrees
 unirepo pr [subtree...] --title <title> [--body <text>]
 ```
 
-Opens one GitHub pull request per changed subtree repo. Without subtree arguments, `unirepo` auto-detects changed subtrees. Use explicit subtree names when you want PRs for only part of the workspace.
+Opens one GitHub pull request per changed subtree repo. Without subtree arguments, `unirepo` auto-detects changed subtrees. Use explicit subtree names when you want PRs for only part of the workspace. By default, each PR head matches that subtree's effective push branch.
 
 
 | Flag | Effect |
@@ -228,7 +246,7 @@ Opens one GitHub pull request per changed subtree repo. Without subtree argument
 | `--title <title>` | Shared PR title for all selected repos |
 | `--body <text>` | Shared PR description |
 | `--base <name>` | Override the base branch for all selected repos |
-| `--head <name>` | Override the head branch name (default: current branch) |
+| `--head <name>` | Override the head branch name for all selected subtrees |
 | `--draft` | Create draft pull requests |
 | `--dry-run` | Show the `gh pr create` commands without executing |
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unirepo-cli",
-  "version": "0.4.1",
+  "version": "0.5.1",
   "description": "CLI tool for creating and managing git-subtree monorepos — run your agents across repos",
   "type": "module",
   "bin": {
@@ -38,6 +38,7 @@
   "dependencies": {
     "@inquirer/core": "^10.0.0",
     "@inquirer/prompts": "^7.0.0",
-    "chalk": "^5.3.0"
+    "chalk": "^5.3.0",
+    "unirepo-cli": "^0.4.1"
   }
 }

package/src/commands/branch.js

@@ -1,4 +1,11 @@
-import { git, getCurrentBranch, getSubtreePrefixes, getTrackedSubtreeBranch } from '../git.js';
+import {
+  git,
+  getConfiguredSubtreePushBranch,
+  getCurrentBranch,
+  getSubtreePrefixes,
+  getTrackedSubtreeBranch,
+  resolveSubtreePushBranch,
+} from '../git.js';
 import { validateInsideMonorepo } from '../validate.js';
 import * as ui from '../ui.js';
 
@@ -18,10 +25,16 @@ export async function runBranch({ name }) {
     ui.blank();
     for (const s of subtrees) {
       const upstream = getTrackedSubtreeBranch(cwd, s.name) || 'unknown';
-      ui.info(`  ${s.name}  upstream: ${upstream}  push target: ${currentBranch}`);
+      const configuredPushBranch = getConfiguredSubtreePushBranch(cwd, s.name);
+      const pushBranch = resolveSubtreePushBranch({
+        configuredBranch: configuredPushBranch,
+        currentBranch,
+      });
+      const suffix = configuredPushBranch ? ' (configured)' : '';
+      ui.info(`  ${s.name}  upstream: ${upstream}  push target: ${pushBranch}${suffix}`);
     }
     ui.blank();
-    ui.info('Use "unirepo branch <name>" to switch all subtrees to a new branch.');
+    ui.info('Use "unirepo branch <name>" to switch the workspace branch. Subtrees without a configured override use that branch by default.');
     ui.blank();
     return;
   }
@@ -41,7 +54,16 @@ export async function runBranch({ name }) {
   ui.blank();
 
   for (const s of subtrees) {
-    ui.success(`${s.name} → push will target "${name}" upstream`);
+    const configuredPushBranch = getConfiguredSubtreePushBranch(cwd, s.name);
+    const pushBranch = resolveSubtreePushBranch({
+      configuredBranch: configuredPushBranch,
+      currentBranch: name,
+    });
+    if (configuredPushBranch && configuredPushBranch !== name) {
+      ui.success(`${s.name} → push will target "${pushBranch}" upstream (configured override)`);
+    } else {
+      ui.success(`${s.name} → push will target "${pushBranch}" upstream`);
+    }
   }
 
   ui.blank();

package/src/commands/pr.js

@@ -1,9 +1,11 @@
 import {
+  getConfiguredSubtreePushBranch,
   getCurrentBranch,
   getSubtreePrefixes,
   getChangedSubtrees,
   getTrackedSubtreeBranch,
   hasRemoteBranch,
+  resolveSubtreePushBranch,
 } from '../git.js';
 import { isGhAvailable, getGitHubRepoSlugFromUrl, createPullRequest } from '../github.js';
 import { validateInsideMonorepo } from '../validate.js';
@@ -37,8 +39,10 @@ export function planPrTargets({
   changedPrefixes,
   requestedSubtrees,
   requestedBase,
-  headBranch,
+  requestedHead,
+  currentBranch,
   getTrackedBranchFn = () => null,
+  getConfiguredPushBranchFn = () => null,
   getRepoSlugFn = () => null,
 }) {
   return selectPrSubtrees(allPrefixes, changedPrefixes, requestedSubtrees).map((prefix) => ({
@@ -49,7 +53,11 @@ export function planPrTargets({
       requestedBase,
       trackedBranch: getTrackedBranchFn(prefix.name),
     }),
-    head: headBranch,
+    head: resolveSubtreePushBranch({
+      requestedBranch: requestedHead,
+      configuredBranch: getConfiguredPushBranchFn(prefix.name),
+      currentBranch,
+    }),
   }));
 }
 
@@ -66,7 +74,6 @@ export async function runPr({ subtrees: requestedSubtrees, title, body, base, he
   }
 
   const currentBranch = getCurrentBranch(cwd);
-  const headBranch = head || currentBranch;
   const allPrefixes = getSubtreePrefixes(cwd);
   const changedPrefixes = getChangedSubtrees(cwd);
   const targets = planPrTargets({
@@ -74,8 +81,10 @@ export async function runPr({ subtrees: requestedSubtrees, title, body, base, he
     changedPrefixes,
     requestedSubtrees,
     requestedBase: base,
-    headBranch,
+    requestedHead: head,
+    currentBranch,
     getTrackedBranchFn: (prefixName) => getTrackedSubtreeBranch(cwd, prefixName),
+    getConfiguredPushBranchFn: (prefixName) => getConfiguredSubtreePushBranch(cwd, prefixName),
     getRepoSlugFn: getGitHubRepoSlugFromUrl,
   });
 
@@ -86,7 +95,12 @@ export async function runPr({ subtrees: requestedSubtrees, title, body, base, he
     return;
   }
 
-  ui.info(`Head branch: ${headBranch}`);
+  const uniqueHeadBranches = [...new Set(targets.map((target) => target.head))];
+  if (uniqueHeadBranches.length === 1) {
+    ui.info(`Head branch: ${uniqueHeadBranches[0]}`);
+  } else {
+    ui.info('Head branches: per subtree');
+  }
   ui.info(`Subtrees: ${targets.map((target) => target.name).join(', ')}`);
   ui.blank();
 

package/src/commands/push.js

@@ -1,4 +1,12 @@
-import { git, getCurrentBranch, getSubtreePrefixes, getChangedSubtrees, hasUncommittedChanges } from '../git.js';
+import {
+  git,
+  getConfiguredSubtreePushBranch,
+  getCurrentBranch,
+  getSubtreePrefixes,
+  getChangedSubtrees,
+  hasUncommittedChanges,
+  resolveSubtreePushBranch,
+} from '../git.js';
 import { validateGitSubtree, validateInsideMonorepo } from '../validate.js';
 import * as ui from '../ui.js';
 
@@ -13,7 +21,6 @@ export async function runPush({ subtrees: requestedSubtrees, branch, dryRun }) {
   validateInsideMonorepo(cwd);
 
   const currentBranch = getCurrentBranch(cwd);
-  const pushBranch = branch || currentBranch;
 
   // ── Check for uncommitted work ────────────────────────────────────────────
   const hasUncommitted = hasUncommittedChanges(cwd);
@@ -49,14 +56,28 @@ export async function runPush({ subtrees: requestedSubtrees, branch, dryRun }) {
     }
   }
 
-  ui.info(`Branch: ${pushBranch}`);
-  ui.info(`Subtrees to push: ${toPush.map((p) => p.name).join(', ')}`);
+  const targets = toPush.map((prefix) => ({
+    ...prefix,
+    pushBranch: resolveSubtreePushBranch({
+      requestedBranch: branch,
+      configuredBranch: getConfiguredSubtreePushBranch(cwd, prefix.name),
+      currentBranch,
+    }),
+  }));
+  const uniqueBranches = [...new Set(targets.map((target) => target.pushBranch))];
+
+  if (uniqueBranches.length === 1) {
+    ui.info(`Branch: ${uniqueBranches[0]}`);
+  } else {
+    ui.info('Branches: per subtree');
+  }
+  ui.info(`Subtrees to push: ${targets.map((target) => `${target.name}:${target.pushBranch}`).join(', ')}`);
   ui.blank();
 
   // ── Dry run ──────────────────────────────────────────────────────────────
   if (dryRun) {
-    const commands = toPush.map(
-      (p) => `git subtree push --prefix="${p.name}" "${p.name}" "${pushBranch}"`
+    const commands = targets.map(
+      (target) => `git subtree push --prefix="${target.name}" "${target.name}" "${target.pushBranch}"`
     );
     ui.dryRun(commands);
     return;
@@ -66,15 +87,15 @@ export async function runPush({ subtrees: requestedSubtrees, branch, dryRun }) {
   let succeeded = 0;
   let failed = 0;
 
-  for (const prefix of toPush) {
-    ui.pushStart(prefix.name, pushBranch);
+  for (const target of targets) {
+    ui.pushStart(target.name, target.pushBranch);
     ui.pushSlow();
     try {
-      git(`subtree push --prefix="${prefix.name}" "${prefix.name}" "${pushBranch}"`, { cwd });
-      ui.success(`${prefix.name} pushed`);
+      git(`subtree push --prefix="${target.name}" "${target.name}" "${target.pushBranch}"`, { cwd });
+      ui.success(`${target.name} pushed`);
       succeeded++;
     } catch (err) {
-      ui.error(`Failed to push ${prefix.name}: ${err.message}`);
+      ui.error(`Failed to push ${target.name}: ${err.message}`);
       failed++;
     }
   }
@@ -82,7 +103,11 @@ export async function runPush({ subtrees: requestedSubtrees, branch, dryRun }) {
   // ── Summary ──────────────────────────────────────────────────────────────
   ui.blank();
   if (failed === 0) {
-    ui.success(`All ${succeeded} subtree(s) pushed to branch "${pushBranch}"`);
+    if (uniqueBranches.length === 1) {
+      ui.success(`All ${succeeded} subtree(s) pushed to branch "${uniqueBranches[0]}"`);
+    } else {
+      ui.success(`All ${succeeded} subtree(s) pushed`);
+    }
   } else {
     ui.warning(`${succeeded} pushed, ${failed} failed`);
   }

package/src/commands/status.js

@@ -1,29 +1,55 @@
-import { getCurrentBranch, getSubtreePrefixes, getChangedSubtrees, getTrackedSubtreeBranch } from '../git.js';
+import {
+  getConfiguredSubtreePushBranch,
+  getCurrentBranch,
+  getSubtreePrefixes,
+  getChangedSubtrees,
+  getTrackedSubtreeBranch,
+  resolveSubtreePushBranch,
+} from '../git.js';
 import { validateInsideMonorepo } from '../validate.js';
 import * as ui from '../ui.js';
 
+export function buildStatusSubtrees({
+  prefixes,
+  changedPrefixes,
+  currentBranch,
+  getTrackedBranchFn = () => null,
+  getConfiguredPushBranchFn = () => null,
+}) {
+  const changedNames = new Set(changedPrefixes.map((prefix) => prefix.name));
+
+  return prefixes.map((prefix) => ({
+    name: prefix.name,
+    url: prefix.url,
+    upstream: getTrackedBranchFn(prefix.name) || 'unknown',
+    pushBranch: resolveSubtreePushBranch({
+      configuredBranch: getConfiguredPushBranchFn(prefix.name),
+      currentBranch,
+    }),
+    changed: changedNames.has(prefix.name),
+  }));
+}
+
 export async function runStatus({ json }) {
   const cwd = process.cwd();
 
   validateInsideMonorepo(cwd);
 
-  const branch = getCurrentBranch(cwd);
+  const currentBranch = getCurrentBranch(cwd);
   const prefixes = getSubtreePrefixes(cwd);
   const changed = getChangedSubtrees(cwd);
-  const changedNames = new Set(changed.map((c) => c.name));
-
-  const subtrees = prefixes.map((p) => ({
-    name: p.name,
-    url: p.url,
-    upstream: getTrackedSubtreeBranch(cwd, p.name) || 'unknown',
-    pushBranch: branch,
-    changed: changedNames.has(p.name),
-  }));
+  const subtrees = buildStatusSubtrees({
+    prefixes,
+    changedPrefixes: changed,
+    currentBranch,
+    getTrackedBranchFn: (prefixName) => getTrackedSubtreeBranch(cwd, prefixName),
+    getConfiguredPushBranchFn: (prefixName) => getConfiguredSubtreePushBranch(cwd, prefixName),
+  });
 
   if (json) {
-    console.log(JSON.stringify({ pushBranch: branch, subtrees }, null, 2));
+    console.log(JSON.stringify({ workspaceBranch: currentBranch, subtrees }, null, 2));
     return;
   }
 
-  ui.subtreeTable(subtrees, branch);
+  ui.subtreeTable(subtrees, currentBranch);
 }

package/src/git.js

@@ -10,6 +10,10 @@ function getSubtreeBranchConfigKey(prefixName) {
   return `unirepo.subtree.${prefixName}.branch`;
 }
 
+function getSubtreePushBranchConfigKey(prefixName) {
+  return `unirepo.subtree.${prefixName}.pushBranch`;
+}
+
 /**
  * Execute a git command and return trimmed stdout.
  * @param {string} args - git arguments
@@ -286,6 +290,35 @@ export function setConfiguredSubtreeBranch(cwd, prefixName, branch) {
   );
 }
 
+/**
+ * Get the push/head branch explicitly configured for a subtree in local git config.
+ */
+export function getConfiguredSubtreePushBranch(cwd, prefixName) {
+  const branch = git(`config --get ${quoteShellArg(getSubtreePushBranchConfigKey(prefixName))}`, {
+    cwd,
+    silent: true,
+    allowFailure: true,
+  });
+  return branch || null;
+}
+
+/**
+ * Persist the push/head branch override for a subtree in local git config.
+ */
+export function setConfiguredSubtreePushBranch(cwd, prefixName, branch) {
+  git(
+    `config ${quoteShellArg(getSubtreePushBranchConfigKey(prefixName))} ${quoteShellArg(branch)}`,
+    { cwd, silent: true }
+  );
+}
+
+/**
+ * Resolve the effective push/head branch for a subtree.
+ */
+export function resolveSubtreePushBranch({ requestedBranch, configuredBranch, currentBranch }) {
+  return requestedBranch || configuredBranch || currentBranch;
+}
+
 /**
  * Get the branch unirepo should treat as the subtree's upstream branch.
  */

package/src/templates.js

@@ -11,12 +11,12 @@ This repository is a git-subtree monorepo.
 ## Rules
 
 - Never use regular \`git push\` to publish the monorepo itself as a deployment target.
-- Work in a single monorepo branch and reuse that branch name when pushing subtree branches upstream.
+- Work in a single monorepo branch by default. A subtree may use a different push branch when local git config explicitly overrides it.
 - Keep changes scoped to the subtree or subtrees you intend to update.
 - Edit files inside subtree directories, not in unrelated top-level folders.
 - Prefer separate commits per subtree unless the change is tightly coupled across repos.
 - Push only subtrees that actually changed.
-- Keep subtree directory, remote name, and pushed branch consistent.
+- Keep subtree directory, remote name, and configured push branch consistent.
 - Do not mix files from different subtrees in a subtree PR.
 
 ## CLI
@@ -34,17 +34,17 @@ unirepo pr --title "feat: ..." --body "..."
 unirepo add <repo-url> --branch <branch>
 \`\`\`
 
-- \`status\` shows tracked subtrees, upstream branches, the current push branch, and changed files.
-- \`branch <name>\` creates the local branch name you should reuse when pushing subtrees upstream.
+- \`status\` shows tracked subtrees, upstream branches, the current workspace branch, each subtree's effective push branch, and changed files.
+- \`branch <name>\` creates the default local branch to reuse when pushing subtrees upstream.
 - \`pull\` updates one or more tracked subtrees from upstream before or during your work. Use \`--prefix\` when you want a branch-specific pull for just one subtree.
 - \`push --dry-run\` is the safe first step before a real push.
 - \`push\` without subtree names auto-detects changed subtrees. \`push <subtree>\` pushes one subtree.
-- \`pr\` opens one PR per changed or explicitly selected subtree repo after those branches have been pushed.
+- \`pr\` opens one PR per changed or explicitly selected subtree repo after those branches have been pushed, using each subtree's effective push branch as the default PR head.
 - \`add\` imports another repository as a subtree. Use \`--branch\` to import from a non-default upstream branch.
 
 ## Workflow
 
-1. Create or reuse one branch name for the work.
+1. Create or reuse one default branch name for the work.
 CLI:
 \`\`\`bash
 unirepo branch <branch>
@@ -118,12 +118,12 @@ git subtree push --prefix=libfoo https://github.com/example/libfoo.git <branch>
 \`\`\`
 
 - If subtree directory and remote name match, the remote name often works in place of the full URL.
-- Reuse the same branch name across the monorepo and each upstream subtree repo.
+- By default, subtrees reuse the monorepo branch name. To override one subtree, set \`git config unirepo.subtree.<subtree>.pushBranch <branch>\`.
 
 ## PRs
 
 - Open one PR per upstream subtree repo.
-- Use the same branch name in each upstream repo.
+- By default, PR heads follow each subtree's effective push branch.
 - Target the default branch of the upstream repo unless that repo's workflow says otherwise.
 - Run \`unirepo pr\` only after the head branch exists upstream for that subtree repo.
 - Ensure each PR contains only changes from its own subtree.

package/src/ui.js

@@ -78,7 +78,7 @@ export function subtreeTable(subtrees, currentBranch) {
   header('Monorepo Status');
   blank();
   console.log(`  ${ICON.folder} Subtrees: ${chalk.bold(subtrees.length)}`);
-  console.log(`  ${ICON.rocket} Push branch: ${chalk.bold.cyan(currentBranch)}`);
+  console.log(`  ${ICON.branch} Workspace branch: ${chalk.bold.cyan(currentBranch)}`);
   blank();
 
   if (subtrees.length === 0) {
@@ -90,7 +90,7 @@ export function subtreeTable(subtrees, currentBranch) {
   // Column widths
   const nameWidth = Math.max(12, ...subtrees.map((s) => s.name.length)) + 2;
   const upstreamWidth = Math.max(10, ...subtrees.map((s) => (s.upstream || '').length)) + 2;
-  const pushWidth = Math.max(12, currentBranch.length) + 2;
+  const pushWidth = Math.max(12, ...subtrees.map((s) => (s.pushBranch || currentBranch).length)) + 2;
   const urlWidth = Math.max(10, ...subtrees.map((s) => s.url.length)) + 2;
   const headerRow =
     'Subtree'.padEnd(nameWidth) +
@@ -107,7 +107,7 @@ export function subtreeTable(subtrees, currentBranch) {
       ? chalk.yellow('● yes')
       : chalk.dim('○ no');
     const upstreamStr = chalk.dim((s.upstream || 'unknown').padEnd(upstreamWidth));
-    const pushStr = chalk.cyan(currentBranch.padEnd(pushWidth));
+    const pushStr = chalk.cyan((s.pushBranch || currentBranch).padEnd(pushWidth));
     console.log(
       `  ${chalk.bold(s.name.padEnd(nameWidth))}${upstreamStr}${pushStr}${chalk.dim(s.url.padEnd(urlWidth))}${changed}`
     );
@@ -177,10 +177,10 @@ ${chalk.bold('Commands:')}
   ${chalk.green('init')} <dir> <repo-url...>    Create a new monorepo from repo URLs
   ${chalk.green('add')}  <repo-url>             Add a repo to the current monorepo
   ${chalk.green('pull')} [subtree...]            Pull subtree updates from upstream
-  ${chalk.green('status')}                      Show tracked subtrees and changes
+  ${chalk.green('status')}                      Show tracked subtrees, branches, and changes
   ${chalk.green('push')} [subtree...]            Push changed subtrees upstream
   ${chalk.green('pr')}   [subtree...]            Open PRs for changed subtree repos
-  ${chalk.green('branch')} [name]               Create a branch on all upstream repos
+  ${chalk.green('branch')} [name]               Create or show the workspace branch
   ${chalk.green('version')}                     Show the installed CLI version
 
 ${chalk.bold('Global options:')}
@@ -204,14 +204,14 @@ ${chalk.bold('Status options:')}
   --json                      Output machine-readable JSON
 
 ${chalk.bold('Push options:')}
-  --branch <name>             Branch name for upstream push (default: current)
+  --branch <name>             Branch name for all selected subtree pushes
   --dry-run                   Show commands without executing
 
 ${chalk.bold('PR options:')}
   --title <title>             Shared PR title (required)
   --body <text>               Shared PR description
   --base <name>               Override the base branch for all selected repos
-  --head <name>               Override the head branch (default: current branch)
+  --head <name>               Override the head branch for all selected repos
   --draft                     Create draft PRs
   --dry-run                   Show gh pr create commands without executing
 
@@ -232,9 +232,12 @@ ${chalk.bold('Examples:')}
   ${chalk.dim('# Check status')}
   npx unirepo status
 
-  ${chalk.dim('# Create a branch (used as target when pushing all subtrees)')}
+  ${chalk.dim('# Create the default workspace branch for subtree pushes')}
   npx unirepo branch feature-x
 
+  ${chalk.dim('# Override one subtree push/PR branch via local git config')}
+  git config unirepo.subtree.api.pushBranch feature-api
+
   ${chalk.dim('# Push changes upstream')}
   npx unirepo push --dry-run