@aria_asi/cli 0.2.39 → 0.2.41

package/scripts/sync-local-main-on-task-complete.mjs

@@ -0,0 +1,278 @@
+#!/usr/bin/env node
+import { existsSync, mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const here = dirname(fileURLToPath(import.meta.url));
+const packageRoot = resolve(here, '..');
+const defaultRepoRoot = resolve(packageRoot, '..', '..');
+
+function usage() {
+  console.log(`Usage:
+  node scripts/sync-local-main-on-task-complete.mjs [options]
+
+Options:
+  --repo <path>              Git repository root. Defaults to this checkout.
+  --source <ref>             Source task branch or commit. Defaults to current branch.
+  --main <branch>            Local main branch name. Defaults to main.
+  --remote <name>            Remote name. Defaults to origin.
+  --qa <command>             QA command to run after merge. May be repeated.
+  --skip-qa                  Skip QA commands. Requires deliberate operator choice.
+  --push                     Push merged local main to the remote after QA.
+  --dry-run                  Merge and QA in a temporary worktree but do not push. Default.
+  --skip-remote-check        Do not inspect the remote before dry-run testing.
+  --keep-worktree            Leave the temporary worktree for inspection.
+  --help                     Show this help.
+
+This script never fetches, pulls, or rebases. Local main is treated as the source of truth.`);
+}
+
+function parseArgs(argv) {
+  const args = {
+    repo: defaultRepoRoot,
+    source: null,
+    main: 'main',
+    remote: 'origin',
+    qa: [],
+    skipQa: false,
+    push: false,
+    skipRemoteCheck: false,
+    keepWorktree: false,
+  };
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    const next = () => {
+      i += 1;
+      if (i >= argv.length || argv[i].startsWith('--')) {
+        throw new Error(`${arg} requires a value`);
+      }
+      return argv[i];
+    };
+    if (arg === '--repo') args.repo = resolve(next());
+    else if (arg === '--source') args.source = next();
+    else if (arg === '--main') args.main = next();
+    else if (arg === '--remote') args.remote = next();
+    else if (arg === '--qa') args.qa.push(next());
+    else if (arg === '--skip-qa') args.skipQa = true;
+    else if (arg === '--push') args.push = true;
+    else if (arg === '--dry-run') args.push = false;
+    else if (arg === '--skip-remote-check') args.skipRemoteCheck = true;
+    else if (arg === '--keep-worktree') args.keepWorktree = true;
+    else if (arg === '--help' || arg === '-h') {
+      usage();
+      process.exit(0);
+    } else {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+  }
+
+  if (args.skipQa && args.qa.length > 0) {
+    throw new Error('--skip-qa cannot be combined with --qa');
+  }
+  if (!args.skipQa && args.qa.length === 0) {
+    args.qa.push('npm --prefix packages/aria-connector run check:release');
+  }
+  if (args.push && args.skipRemoteCheck) {
+    throw new Error('--push requires remote verification; remove --skip-remote-check');
+  }
+  return args;
+}
+
+function run(command, commandArgs, options = {}) {
+  const result = spawnSync(command, commandArgs, {
+    cwd: options.cwd,
+    encoding: 'utf8',
+    stdio: options.capture ? ['ignore', 'pipe', 'pipe'] : 'inherit',
+    shell: false,
+  });
+  if (result.status !== 0) {
+    const detail = options.capture ? `${result.stderr || ''}${result.stdout || ''}`.trim() : '';
+    throw new Error(`${command} ${commandArgs.join(' ')} failed${detail ? `: ${detail}` : ''}`);
+  }
+  return options.capture ? result.stdout.trim() : '';
+}
+
+function git(repo, commandArgs, options = {}) {
+  return run('git', commandArgs, { ...options, cwd: repo });
+}
+
+function runQa(command, cwd) {
+  const result = spawnSync(command, {
+    cwd,
+    encoding: 'utf8',
+    stdio: 'inherit',
+    shell: true,
+  });
+  if (result.status !== 0) {
+    throw new Error(`QA command failed: ${command}`);
+  }
+}
+
+function getCurrentBranch(repo) {
+  try {
+    return git(repo, ['symbolic-ref', '--quiet', '--short', 'HEAD'], { capture: true });
+  } catch {
+    return null;
+  }
+}
+
+function getRemoteHead(repo, remote, branch) {
+  const out = git(repo, ['ls-remote', '--heads', remote, branch], { capture: true });
+  if (!out) return null;
+  const [sha] = out.split(/\s+/);
+  return sha || null;
+}
+
+function listWorktrees(repo) {
+  const raw = git(repo, ['worktree', 'list', '--porcelain'], { capture: true });
+  const entries = [];
+  let current = null;
+  for (const line of raw.split('\n')) {
+    if (line.startsWith('worktree ')) {
+      current = { path: line.slice('worktree '.length), branch: null, head: null };
+      entries.push(current);
+    } else if (current && line.startsWith('branch ')) {
+      current.branch = line.slice('branch '.length);
+    } else if (current && line.startsWith('HEAD ')) {
+      current.head = line.slice('HEAD '.length);
+    }
+  }
+  return entries;
+}
+
+function findBranchWorktree(repo, branch) {
+  const ref = `refs/heads/${branch}`;
+  return listWorktrees(repo).find((entry) => entry.branch === ref) || null;
+}
+
+function isAncestor(repo, ancestor, descendant) {
+  const result = spawnSync('git', ['merge-base', '--is-ancestor', ancestor, descendant], {
+    cwd: repo,
+    stdio: 'ignore',
+  });
+  return result.status === 0;
+}
+
+function assertClean(repo, label) {
+  const status = git(repo, ['status', '--porcelain'], { capture: true });
+  if (status.trim()) {
+    throw new Error(`${label} has uncommitted changes; commit or move them before syncing local main`);
+  }
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const repo = resolve(args.repo);
+  if (!existsSync(join(repo, '.git'))) {
+    throw new Error(`Not a git repository root: ${repo}`);
+  }
+
+  assertClean(repo, 'source worktree');
+  const currentBranch = getCurrentBranch(repo);
+  const source = args.source || currentBranch;
+  if (!source) {
+    throw new Error('Detached HEAD requires --source <ref>');
+  }
+
+  const sourceSha = git(repo, ['rev-parse', '--verify', `${source}^{commit}`], { capture: true });
+  git(repo, ['show-ref', '--verify', `refs/heads/${args.main}`], { capture: true });
+  const localMainShaBefore = git(repo, ['rev-parse', '--verify', `${args.main}^{commit}`], { capture: true });
+  const mainWorktree = findBranchWorktree(repo, args.main);
+
+  let remoteShaBefore = null;
+  if (!args.skipRemoteCheck) {
+    remoteShaBefore = getRemoteHead(repo, args.remote, args.main);
+    if (remoteShaBefore && !isAncestor(repo, remoteShaBefore, localMainShaBefore)) {
+      throw new Error(`remote ${args.remote}/${args.main} is not an ancestor of local ${args.main}; refusing to pull, fetch, rebase, or overwrite`);
+    }
+  }
+
+  const tempWorktree = mkdtempSync(join(tmpdir(), 'aria-local-main-sync-'));
+  const targetWorktree = args.push && mainWorktree ? mainWorktree.path : tempWorktree;
+  const usesExistingMainWorktree = args.push && Boolean(mainWorktree);
+  const qaCommands = args.skipQa ? [] : args.qa;
+  const backupRef =
+    remoteShaBefore && args.push
+      ? `backup/${args.remote}-${args.main}-before-local-sync-${new Date().toISOString().replace(/[-:.TZ]/g, '').slice(0, 14)}`
+      : null;
+  let mainShaAfter = null;
+  let merged = false;
+  let pushed = false;
+
+  try {
+    if (usesExistingMainWorktree) {
+      assertClean(targetWorktree, 'local main worktree');
+    } else if (args.push) {
+      git(repo, ['worktree', 'add', '--checkout', tempWorktree, args.main]);
+      assertClean(targetWorktree, 'temporary main worktree');
+    } else {
+      git(repo, ['worktree', 'add', '--detach', tempWorktree, localMainShaBefore]);
+      assertClean(targetWorktree, 'temporary dry-run worktree');
+    }
+
+    if (!isAncestor(targetWorktree, sourceSha, 'HEAD')) {
+      git(targetWorktree, ['merge', '--no-ff', '--no-edit', sourceSha]);
+      merged = true;
+    }
+
+    for (const command of qaCommands) {
+      runQa(command, targetWorktree);
+    }
+
+    mainShaAfter = git(targetWorktree, ['rev-parse', '--verify', 'HEAD'], { capture: true });
+
+    if (args.push) {
+      if (backupRef) {
+        git(targetWorktree, ['push', args.remote, `${remoteShaBefore}:refs/heads/${backupRef}`]);
+      }
+      git(targetWorktree, ['push', args.remote, `HEAD:refs/heads/${args.main}`]);
+      pushed = true;
+    }
+  } finally {
+    if (!args.keepWorktree && !usesExistingMainWorktree) {
+      try {
+        git(repo, ['worktree', 'remove', '--force', tempWorktree]);
+      } catch {
+        rmSync(tempWorktree, { recursive: true, force: true });
+      }
+    } else if (!usesExistingMainWorktree) {
+      console.error(`[sync-local-main] kept worktree: ${tempWorktree}`);
+    }
+  }
+
+  console.log(
+    JSON.stringify(
+      {
+        ok: true,
+        mode: args.push ? 'push' : 'dry-run',
+        repo,
+        source,
+        sourceSha,
+        main: args.main,
+        localMainShaBefore,
+        mainShaAfter,
+        remote: args.remote,
+        remoteShaBefore,
+        backupRef,
+        targetWorktree,
+        usedExistingMainWorktree: usesExistingMainWorktree,
+        merged,
+        qaCommands,
+        pushed,
+        policy: 'no fetch, no pull, no rebase',
+      },
+      null,
+      2,
+    ),
+  );
+}
+
+try {
+  main();
+} catch (error) {
+  console.error(`[sync-local-main] ERROR: ${error.message}`);
+  process.exit(1);
+}