unirepo-cli 0.3.0 → 0.4.1

package/README.md

@@ -142,6 +142,7 @@ AI coding agents work best when they can see the full change at once.
 | `status` | Show subtrees, branches, and what changed |
 | `branch [name]` | Create or show the current push branch |
 | `push [subtree...]` | Push changed subtrees upstream |
+| `pr [subtree...]` | Open pull requests for changed subtree repos |
 
 
 ### init
@@ -213,6 +214,24 @@ Pushes changed subtrees upstream. Without arguments, auto-detects which subtrees
 | `--branch <name>` | Override the upstream branch name |
 | `--dry-run` | Show what would run without executing |
 
+### pr
+
+```bash
+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.
+
+
+| Flag | Effect |
+| --- | --- |
+| `--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) |
+| `--draft` | Create draft pull requests |
+| `--dry-run` | Show the `gh pr create` commands without executing |
+
 
 ## How It Works
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unirepo-cli",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "CLI tool for creating and managing git-subtree monorepos — run your agents across repos",
   "type": "module",
   "bin": {

package/src/commands/branch.js

@@ -49,6 +49,6 @@ export async function runBranch({ name }) {
   ui.info('  1. Make changes in subtree directories');
   ui.info('  2. Commit in the monorepo');
   ui.info(`  3. unirepo push`);
-  ui.info('  4. Open one PR per upstream repo');
+  ui.info('  4. unirepo pr --title "..." --body "..."');
   ui.blank();
 }

package/src/commands/pr.js

@@ -0,0 +1,175 @@
+import {
+  getCurrentBranch,
+  getSubtreePrefixes,
+  getChangedSubtrees,
+  getTrackedSubtreeBranch,
+  hasRemoteBranch,
+} from '../git.js';
+import { isGhAvailable, getGitHubRepoSlugFromUrl, createPullRequest } from '../github.js';
+import { validateInsideMonorepo } from '../validate.js';
+import * as ui from '../ui.js';
+
+function quoteShellArg(value) {
+  return JSON.stringify(value);
+}
+
+export function selectPrSubtrees(allPrefixes, changedPrefixes, requestedSubtrees) {
+  if (!requestedSubtrees || requestedSubtrees.length === 0) {
+    return changedPrefixes;
+  }
+
+  const prefixNames = new Set(allPrefixes.map((prefix) => prefix.name));
+  for (const name of requestedSubtrees) {
+    if (!prefixNames.has(name)) {
+      throw new Error(`"${name}" is not a tracked subtree. Run "unirepo status" to see available subtrees.`);
+    }
+  }
+
+  return allPrefixes.filter((prefix) => requestedSubtrees.includes(prefix.name));
+}
+
+export function resolvePrBaseBranch({ requestedBase, trackedBranch }) {
+  return requestedBase || trackedBranch || 'main';
+}
+
+export function planPrTargets({
+  allPrefixes,
+  changedPrefixes,
+  requestedSubtrees,
+  requestedBase,
+  headBranch,
+  getTrackedBranchFn = () => null,
+  getRepoSlugFn = () => null,
+}) {
+  return selectPrSubtrees(allPrefixes, changedPrefixes, requestedSubtrees).map((prefix) => ({
+    name: prefix.name,
+    repo: getRepoSlugFn(prefix.url),
+    url: prefix.url,
+    base: resolvePrBaseBranch({
+      requestedBase,
+      trackedBranch: getTrackedBranchFn(prefix.name),
+    }),
+    head: headBranch,
+  }));
+}
+
+export async function runPr({ subtrees: requestedSubtrees, title, body, base, head, draft, dryRun }) {
+  const cwd = process.cwd();
+
+  ui.header('Creating pull requests');
+  ui.blank();
+
+  validateInsideMonorepo(cwd);
+
+  if (!isGhAvailable()) {
+    throw new Error('GitHub CLI is not available or not authenticated. Install gh and run "gh auth login".');
+  }
+
+  const currentBranch = getCurrentBranch(cwd);
+  const headBranch = head || currentBranch;
+  const allPrefixes = getSubtreePrefixes(cwd);
+  const changedPrefixes = getChangedSubtrees(cwd);
+  const targets = planPrTargets({
+    allPrefixes,
+    changedPrefixes,
+    requestedSubtrees,
+    requestedBase: base,
+    headBranch,
+    getTrackedBranchFn: (prefixName) => getTrackedSubtreeBranch(cwd, prefixName),
+    getRepoSlugFn: getGitHubRepoSlugFromUrl,
+  });
+
+  if (targets.length === 0) {
+    ui.info('No changed subtrees detected. Nothing to open PRs for.');
+    ui.info('Push a changed subtree first or pass explicit subtree names.');
+    ui.blank();
+    return;
+  }
+
+  ui.info(`Head branch: ${headBranch}`);
+  ui.info(`Subtrees: ${targets.map((target) => target.name).join(', ')}`);
+  ui.blank();
+
+  const dryRunCommands = [];
+  let succeeded = 0;
+  let failed = 0;
+
+  for (let i = 0; i < targets.length; i++) {
+    const target = targets[i];
+
+    ui.repoStep(i + 1, targets.length, target.name, dryRun ? 'Planning PR for' : 'Opening PR for');
+    ui.repoDetail('Repo', target.repo || target.url);
+    ui.repoDetail('Base', target.base);
+    ui.repoDetail('Head', target.head);
+
+    if (!target.repo) {
+      ui.error(`Failed to open PR for ${target.name}: remote URL is not a GitHub repository.`);
+      failed++;
+      ui.blank();
+      continue;
+    }
+
+    if (!hasRemoteBranch(cwd, target.name, target.head)) {
+      ui.error(`Failed to open PR for ${target.name}: upstream branch "${target.head}" does not exist. Run "unirepo push ${target.name}" first.`);
+      failed++;
+      ui.blank();
+      continue;
+    }
+
+    if (!hasRemoteBranch(cwd, target.name, target.base)) {
+      ui.error(`Failed to open PR for ${target.name}: base branch "${target.base}" does not exist upstream.`);
+      failed++;
+      ui.blank();
+      continue;
+    }
+
+    const ghCommand = [
+      'gh pr create',
+      `--repo ${quoteShellArg(target.repo)}`,
+      `--base ${quoteShellArg(target.base)}`,
+      `--head ${quoteShellArg(target.head)}`,
+      `--title ${quoteShellArg(title)}`,
+      `--body ${quoteShellArg(body)}`,
+      draft ? '--draft' : '',
+    ]
+      .filter(Boolean)
+      .join(' ');
+
+    if (dryRun) {
+      dryRunCommands.push(ghCommand);
+      succeeded++;
+      ui.success(`${target.name} PR planned`);
+      ui.blank();
+      continue;
+    }
+
+    try {
+      const url = createPullRequest({
+        repo: target.repo,
+        base: target.base,
+        head: target.head,
+        title,
+        body,
+        draft,
+      });
+      ui.success(`${target.name} PR opened${url ? `: ${url}` : ''}`);
+      succeeded++;
+    } catch (err) {
+      ui.error(`Failed to open PR for ${target.name}: ${err.message}`);
+      failed++;
+    }
+
+    ui.blank();
+  }
+
+  if (dryRunCommands.length > 0) {
+    ui.dryRun(dryRunCommands);
+  }
+
+  if (failed === 0) {
+    ui.success(`${dryRun ? 'Planned' : 'Opened'} ${succeeded} pull request(s)`);
+  } else {
+    ui.warning(`${dryRun ? 'Planned' : 'Opened'} ${succeeded}, ${failed} failed`);
+  }
+  ui.blank();
+}

package/src/github.js

@@ -1,4 +1,4 @@
-import { execSync } from 'node:child_process';
+import { execFileSync, execSync } from 'node:child_process';
 
 /**
  * Thin wrapper around the `gh` CLI. We shell out rather than hitting the
@@ -23,6 +23,19 @@ function runGh(args, { timeout = 30000 } = {}) {
   }
 }
 
+function runGhArgs(args, { timeout = 30000 } = {}) {
+  try {
+    return execFileSync('gh', args, {
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout,
+    });
+  } catch (err) {
+    const stderr = (err.stderr || '').toString().trim();
+    throw new Error(stderr || err.message);
+  }
+}
+
 function runGhJson(args, opts) {
   const out = runGh(args, opts);
   if (!out.trim()) return [];
@@ -111,3 +124,49 @@ export function searchRepos(query, limit = SEARCH_LIMIT) {
     isPrivate: r.isPrivate,
   }));
 }
+
+export function getGitHubRepoSlugFromUrl(url) {
+  const trimmed = url.replace(/\/$/, '').replace(/\.git$/, '');
+  const patterns = [
+    /^https?:\/\/github\.com\/([^/]+)\/([^/]+)$/i,
+    /^git@github\.com:([^/]+)\/([^/]+)$/i,
+    /^ssh:\/\/git@github\.com\/([^/]+)\/([^/]+)$/i,
+  ];
+
+  for (const pattern of patterns) {
+    const match = trimmed.match(pattern);
+    if (match) {
+      return `${match[1]}/${match[2]}`;
+    }
+  }
+
+  return null;
+}
+
+export function createPullRequest({ repo, base, head, title, body, draft = false }) {
+  const args = [
+    'pr',
+    'create',
+    '--repo',
+    repo,
+    '--base',
+    base,
+    '--head',
+    head,
+    '--title',
+    title,
+    '--body',
+    body,
+  ];
+
+  if (draft) {
+    args.push('--draft');
+  }
+
+  const output = runGhArgs(args);
+  const lines = output
+    .split('\n')
+    .map((line) => line.trim())
+    .filter(Boolean);
+  return lines.at(-1) || '';
+}

package/src/index.js

@@ -8,6 +8,7 @@ import { runPull } from './commands/pull.js';
 import { runStatus } from './commands/status.js';
 import { runPush } from './commands/push.js';
 import { runBranch } from './commands/branch.js';
+import { runPr } from './commands/pr.js';
 import { pathToFileURL } from 'node:url';
 import { realpathSync } from 'node:fs';
 
@@ -37,10 +38,20 @@ export function parseArgs(argv) {
       flags.json = true;
     } else if (arg === '--dry-run') {
       flags.dryRun = true;
+    } else if (arg === '--draft') {
+      flags.draft = true;
     } else if (arg === '--prefix' && i + 1 < args.length) {
       flags.prefix = args[++i];
     } else if (arg === '--branch' && i + 1 < args.length) {
       flags.branch = args[++i];
+    } else if (arg === '--title' && i + 1 < args.length) {
+      flags.title = args[++i];
+    } else if (arg === '--body' && i + 1 < args.length) {
+      flags.body = args[++i];
+    } else if (arg === '--base' && i + 1 < args.length) {
+      flags.base = args[++i];
+    } else if (arg === '--head' && i + 1 < args.length) {
+      flags.head = args[++i];
     } else if (arg === '--help' || arg === '-h') {
       flags.help = true;
     } else if (arg.startsWith('-')) {
@@ -61,6 +72,7 @@ const COMMAND_USAGE = {
   status: 'Usage: unirepo status [--json]',
   push: 'Usage: unirepo push [subtree...] [--branch <name>] [--dry-run]',
   branch: 'Usage: unirepo branch [name]',
+  pr: 'Usage: unirepo pr [subtree...] --title <title> [--body <text>] [--base <name>] [--head <name>] [--draft] [--dry-run]',
 };
 
 const COMMAND_FLAGS = {
@@ -71,6 +83,7 @@ const COMMAND_FLAGS = {
   status: new Set(['json']),
   push: new Set(['branch', 'dryRun']),
   branch: new Set(),
+  pr: new Set(['title', 'body', 'base', 'head', 'draft', 'dryRun']),
 };
 
 const FLAG_NAMES = {
@@ -79,6 +92,11 @@ const FLAG_NAMES = {
   dryRun: '--dry-run',
   prefix: '--prefix',
   branch: '--branch',
+  title: '--title',
+  body: '--body',
+  base: '--base',
+  head: '--head',
+  draft: '--draft',
 };
 
 export function validateCommandFlags(command, flags) {
@@ -191,6 +209,24 @@ export async function main() {
       break;
     }
 
+    case 'pr': {
+      if (!flags.title) {
+        ui.error('Usage: unirepo pr [subtree...] --title <title> [--body <text>] [--base <name>] [--head <name>] [--draft] [--dry-run]');
+        ui.info('Provide a shared PR title with --title. Use --body to set the description.');
+        process.exit(1);
+      }
+      await runPr({
+        subtrees: positional.length > 0 ? positional : undefined,
+        title: flags.title,
+        body: flags.body || '',
+        base: flags.base,
+        head: flags.head,
+        draft: flags.draft || false,
+        dryRun: flags.dryRun || false,
+      });
+      break;
+    }
+
     default:
       ui.error(`Unknown command: ${command}`);
       ui.blank();

package/src/templates.js

@@ -30,6 +30,7 @@ unirepo branch <branch>
 unirepo pull
 unirepo push --dry-run
 unirepo push
+unirepo pr --title "feat: ..." --body "..."
 unirepo add <repo-url> --branch <branch>
 \`\`\`
 
@@ -38,6 +39,7 @@ unirepo add <repo-url> --branch <branch>
 - \`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.
 - \`add\` imports another repository as a subtree. Use \`--branch\` to import from a non-default upstream branch.
 
 ## Workflow
@@ -93,6 +95,13 @@ Git:
 git subtree push --prefix=<subtree> <remote-or-url> <branch>
 \`\`\`
 
+7. Open one PR per upstream subtree repo after push.
+CLI:
+\`\`\`bash
+unirepo pr --title "feat: ..." --body "..."
+unirepo pr <subtree> --title "feat: ..."
+\`\`\`
+
 ## Raw Git Subtree
 
 Use these when operating without the CLI:
@@ -116,6 +125,7 @@ git subtree push --prefix=libfoo https://github.com/example/libfoo.git <branch>
 - Open one PR per upstream subtree repo.
 - Use the same branch name in each upstream repo.
 - 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

@@ -179,6 +179,7 @@ ${chalk.bold('Commands:')}
   ${chalk.green('pull')} [subtree...]            Pull subtree updates from upstream
   ${chalk.green('status')}                      Show tracked subtrees 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('version')}                     Show the installed CLI version
 
@@ -206,6 +207,14 @@ ${chalk.bold('Push options:')}
   --branch <name>             Branch name for upstream push (default: current)
   --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)
+  --draft                     Create draft PRs
+  --dry-run                   Show gh pr create commands without executing
+
 ${chalk.bold('Examples:')}
   ${chalk.dim('# Create monorepo from multiple repos')}
   npx unirepo init my-monorepo https://github.com/org/api.git https://github.com/org/web.git
@@ -228,5 +237,8 @@ ${chalk.bold('Examples:')}
 
   ${chalk.dim('# Push changes upstream')}
   npx unirepo push --dry-run
+
+  ${chalk.dim('# Open PRs for changed subtree repos')}
+  npx unirepo pr --title "feat: add auth flow" --body "Cross-repo auth changes"
 `);
 }