@imdeadpool/guardex 7.0.18 → 7.0.20

package/src/finish/index.js

@@ -0,0 +1,425 @@
+function createFinishApi(deps) {
+  const {
+    TOOL_NAME,
+    LOCK_FILE_RELATIVE,
+    path,
+    fs,
+    run,
+    runPackageAsset,
+    resolveRepoRoot,
+    parseCleanupArgs,
+    parseMergeArgs,
+    parseFinishArgs,
+    parseSyncArgs,
+    listAgentWorktrees,
+    listLocalAgentBranchesForFinish,
+    uniquePreserveOrder,
+    branchExists,
+    resolveFinishBaseBranch,
+    worktreeHasLocalChanges,
+    branchMergedIntoBase,
+    autoCommitWorktreeForFinish,
+    resolveBaseBranch,
+    resolveSyncStrategy,
+    ensureOriginBaseRef,
+    gitRun,
+    currentBranchName,
+    workingTreeIsDirty,
+    aheadBehind,
+    lockRegistryStatus,
+    syncOperation,
+  } = deps;
+
+  function cleanup(rawArgs) {
+    const options = parseCleanupArgs(rawArgs);
+    const repoRoot = resolveRepoRoot(options.target);
+
+    const args = [];
+    if (options.base) {
+      args.push('--base', options.base);
+    }
+    if (options.branch) {
+      args.push('--branch', options.branch);
+    }
+    if (options.forceDirty) {
+      args.push('--force-dirty');
+    }
+    if (options.dryRun) {
+      args.push('--dry-run');
+    }
+    if (!options.keepCleanWorktrees) {
+      args.push('--only-dirty-worktrees');
+    }
+    if (options.includePrMerged) {
+      args.push('--include-pr-merged');
+    }
+    if (options.idleMinutes > 0) {
+      args.push('--idle-minutes', String(options.idleMinutes));
+    }
+    if (options.maxBranches > 0) {
+      args.push('--max-branches', String(options.maxBranches));
+    }
+    args.push('--delete-branches');
+    if (!options.keepRemote) {
+      args.push('--delete-remote-branches');
+    }
+
+    const runCleanupCycle = () => {
+      const runResult = runPackageAsset('worktreePrune', args, { cwd: repoRoot, stdio: 'inherit' });
+      if (runResult.status !== 0) {
+        throw new Error('Cleanup command failed');
+      }
+    };
+
+    if (options.watch) {
+      let cycle = 0;
+      while (true) {
+        cycle += 1;
+        console.log(
+          `[${TOOL_NAME}] Cleanup watch cycle=${cycle} (interval=${options.intervalSeconds}s, idleMinutes=${options.idleMinutes}, maxBranches=${options.maxBranches > 0 ? options.maxBranches : 'unbounded'}).`,
+        );
+        runCleanupCycle();
+        if (options.once) {
+          break;
+        }
+        const sleepResult = run('sleep', [String(options.intervalSeconds)], { cwd: repoRoot });
+        if (sleepResult.status !== 0) {
+          throw new Error(`Cleanup watch sleep failed (interval=${options.intervalSeconds}s)`);
+        }
+      }
+      process.exitCode = 0;
+      return;
+    }
+
+    runCleanupCycle();
+    process.exitCode = 0;
+  }
+
+  function merge(rawArgs) {
+    const options = parseMergeArgs(rawArgs);
+    const repoRoot = resolveRepoRoot(options.target);
+
+    const args = [];
+    if (options.base) {
+      args.push('--base', options.base);
+    }
+    if (options.into) {
+      args.push('--into', options.into);
+    }
+    if (options.task) {
+      args.push('--task', options.task);
+    }
+    if (options.agent) {
+      args.push('--agent', options.agent);
+    }
+    for (const branch of options.branches) {
+      args.push('--branch', branch);
+    }
+
+    const mergeResult = runPackageAsset('branchMerge', args, { cwd: repoRoot, stdio: 'pipe' });
+    if (mergeResult.stdout) {
+      process.stdout.write(mergeResult.stdout);
+    }
+    if (mergeResult.stderr) {
+      process.stderr.write(mergeResult.stderr);
+    }
+    if (mergeResult.status !== 0) {
+      throw new Error(`merge command failed with status ${mergeResult.status}`);
+    }
+
+    process.exitCode = 0;
+  }
+
+  function finish(rawArgs, defaults = {}) {
+    const options = parseFinishArgs(rawArgs, defaults);
+    const repoRoot = resolveRepoRoot(options.target);
+
+    const worktreeEntries = listAgentWorktrees(repoRoot);
+    const worktreeByBranch = new Map(worktreeEntries.map((entry) => [entry.branch, entry.worktreePath]));
+
+    let candidateBranches = [];
+    if (options.branch) {
+      if (!branchExists(repoRoot, options.branch)) {
+        throw new Error(`Local branch not found: ${options.branch}`);
+      }
+      candidateBranches = [options.branch];
+    } else {
+      candidateBranches = uniquePreserveOrder([
+        ...listLocalAgentBranchesForFinish(repoRoot),
+        ...worktreeEntries.map((entry) => entry.branch),
+      ]);
+    }
+
+    const candidates = [];
+    for (const branch of candidateBranches) {
+      const worktreePath = worktreeByBranch.get(branch) || '';
+      const baseBranch = resolveFinishBaseBranch(repoRoot, branch, options.base);
+      const hasChanges = worktreePath ? worktreeHasLocalChanges(worktreePath) : false;
+      const alreadyMerged = branchMergedIntoBase(repoRoot, branch, baseBranch);
+      if (options.all || options.branch || hasChanges || !alreadyMerged) {
+        candidates.push({
+          branch,
+          baseBranch,
+          worktreePath,
+          hasChanges,
+          alreadyMerged,
+        });
+      }
+    }
+
+    if (candidates.length === 0) {
+      console.log(`[${TOOL_NAME}] No pending agent branches to finish.`);
+      process.exitCode = 0;
+      return;
+    }
+
+    let succeeded = 0;
+    let failed = 0;
+    let autoCommitted = 0;
+
+    for (const candidate of candidates) {
+      const { branch, baseBranch, worktreePath } = candidate;
+      console.log(
+        `[${TOOL_NAME}] Finishing '${branch}' -> '${baseBranch}'${worktreePath ? ` (${worktreePath})` : ''}...`,
+      );
+
+      try {
+        let commitState = { changed: false, committed: false };
+        if (worktreePath) {
+          commitState = autoCommitWorktreeForFinish(repoRoot, worktreePath, branch, options);
+        }
+
+        if (commitState.committed) {
+          autoCommitted += 1;
+          console.log(`[${TOOL_NAME}] Auto-committed '${branch}' before finish.`);
+        } else if (commitState.changed && commitState.dryRun) {
+          console.log(`[${TOOL_NAME}] [dry-run] Would auto-commit pending changes on '${branch}'.`);
+        }
+
+        const finishArgs = [
+          '--branch',
+          branch,
+          '--base',
+          baseBranch,
+          options.waitForMerge ? '--wait-for-merge' : '--no-wait-for-merge',
+          options.cleanup ? '--cleanup' : '--no-cleanup',
+        ];
+        if (options.mergeMode === 'pr') {
+          finishArgs.push('--via-pr');
+        } else if (options.mergeMode === 'direct') {
+          finishArgs.push('--direct-only');
+        } else {
+          finishArgs.push('--mode', 'auto');
+        }
+        if (options.keepRemote) {
+          finishArgs.push('--keep-remote-branch');
+        }
+
+        if (options.dryRun) {
+          console.log(`[${TOOL_NAME}] [dry-run] Would run: gx branch finish ${finishArgs.join(' ')}`);
+          succeeded += 1;
+          continue;
+        }
+
+        const finishResult = runPackageAsset('branchFinish', finishArgs, { cwd: repoRoot, stdio: 'pipe' });
+        if (finishResult.stdout) {
+          process.stdout.write(finishResult.stdout);
+        }
+        if (finishResult.stderr) {
+          process.stderr.write(finishResult.stderr);
+        }
+        if (finishResult.status !== 0) {
+          throw new Error(`agent-branch-finish exited with status ${finishResult.status}`);
+        }
+
+        succeeded += 1;
+      } catch (error) {
+        failed += 1;
+        console.error(`[${TOOL_NAME}] Finish failed for '${branch}': ${error.message}`);
+        if (options.failFast) {
+          break;
+        }
+      }
+    }
+
+    console.log(
+      `[${TOOL_NAME}] Finish summary: total=${candidates.length}, success=${succeeded}, failed=${failed}, autoCommitted=${autoCommitted}`,
+    );
+
+    if (failed > 0) {
+      throw new Error('finish command failed for one or more agent branches');
+    }
+
+    process.exitCode = 0;
+  }
+
+  function sync(rawArgs) {
+    const options = parseSyncArgs(rawArgs);
+    const repoRoot = resolveRepoRoot(options.target);
+    const baseBranch = resolveBaseBranch(repoRoot, options.base);
+    const strategy = resolveSyncStrategy(repoRoot, options.strategy);
+    const baseRef = `origin/${baseBranch}`;
+
+    ensureOriginBaseRef(repoRoot, baseBranch);
+
+    if (options.allAgentBranches) {
+      const refs = gitRun(repoRoot, ['for-each-ref', '--format=%(refname:short)', 'refs/heads/agent/*'], { allowFailure: true });
+      if (refs.status !== 0) {
+        throw new Error('Unable to list local agent branches');
+      }
+      const branches = (refs.stdout || '').split('\n').map((item) => item.trim()).filter(Boolean);
+      const rows = branches.map((branch) => {
+        const counts = aheadBehind(repoRoot, branch, baseRef);
+        return {
+          branch,
+          base: baseRef,
+          ahead: counts.ahead,
+          behind: counts.behind,
+          syncRequired: counts.behind > 0,
+        };
+      });
+
+      if (options.json) {
+        process.stdout.write(`${JSON.stringify({
+          repoRoot,
+          base: baseRef,
+          branchCount: rows.length,
+          rows,
+        }, null, 2)}\n`);
+      } else {
+        console.log(`[${TOOL_NAME}] Sync report target: ${repoRoot}`);
+        console.log(`[${TOOL_NAME}] Base: ${baseRef}`);
+        if (rows.length === 0) {
+          console.log(`[${TOOL_NAME}] No local agent branches found.`);
+        } else {
+          for (const row of rows) {
+            console.log(`  - ${row.branch} | ahead ${row.ahead} | behind ${row.behind} | syncRequired=${row.syncRequired}`);
+          }
+        }
+      }
+
+      const hasBehind = rows.some((row) => row.behind > 0);
+      process.exitCode = options.check && hasBehind ? 1 : 0;
+      return;
+    }
+
+    const branch = currentBranchName(repoRoot);
+    if (!options.allowNonAgent && !branch.startsWith('agent/')) {
+      throw new Error(`sync is limited to agent/* branches by default (current: ${branch}). Use --allow-non-agent to override.`);
+    }
+
+    const dirty = workingTreeIsDirty(repoRoot);
+    if (!options.check && !options.allowDirty && dirty) {
+      throw new Error('Sync blocked: working tree is not clean. Commit or stash changes first, or pass --allow-dirty.');
+    }
+
+    const before = aheadBehind(repoRoot, branch, baseRef);
+
+    const payload = {
+      repoRoot,
+      branch,
+      base: baseRef,
+      strategy,
+      dirty,
+      aheadBefore: before.ahead,
+      behindBefore: before.behind,
+      syncRequired: before.behind > 0,
+      status: 'checked',
+    };
+
+    if (options.check) {
+      if (options.json) {
+        process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+      } else {
+        console.log(`[${TOOL_NAME}] Sync check target: ${repoRoot}`);
+        console.log(`[${TOOL_NAME}] Branch: ${branch}`);
+        console.log(`[${TOOL_NAME}] Base: ${baseRef}`);
+        console.log(`[${TOOL_NAME}] Ahead: ${before.ahead}`);
+        console.log(`[${TOOL_NAME}] Behind: ${before.behind}`);
+        console.log(`[${TOOL_NAME}] Sync required: ${before.behind > 0 ? 'yes' : 'no'}`);
+      }
+      process.exitCode = before.behind > 0 ? 1 : 0;
+      return;
+    }
+
+    if (before.behind === 0) {
+      const result = { ...payload, status: 'no-op', aheadAfter: before.ahead, behindAfter: before.behind };
+      if (options.json) {
+        process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+      } else {
+        console.log(`[${TOOL_NAME}] Branch '${branch}' is already up to date with ${baseRef}.`);
+      }
+      process.exitCode = 0;
+      return;
+    }
+
+    if (options.dryRun) {
+      const result = { ...payload, status: 'dry-run' };
+      if (options.json) {
+        process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+      } else {
+        console.log(`[${TOOL_NAME}] Dry run: would sync '${branch}' onto ${baseRef} via ${strategy}.`);
+      }
+      process.exitCode = 0;
+      return;
+    }
+
+    const lockPath = path.join(repoRoot, LOCK_FILE_RELATIVE);
+    const lockState = lockRegistryStatus(repoRoot);
+    let lockBackup = null;
+    if (lockState.dirty && fs.existsSync(lockPath)) {
+      lockBackup = fs.readFileSync(lockPath, 'utf8');
+    }
+
+    if (lockState.dirty) {
+      if (lockState.untracked) {
+        fs.rmSync(lockPath, { force: true });
+      } else {
+        const resetLock = gitRun(repoRoot, ['checkout', '--', LOCK_FILE_RELATIVE], { allowFailure: true });
+        if (resetLock.status !== 0) {
+          throw new Error(`Unable to temporarily reset ${LOCK_FILE_RELATIVE} before sync`);
+        }
+      }
+    }
+
+    try {
+      syncOperation(repoRoot, strategy, baseRef, options.ffOnly);
+    } finally {
+      if (lockBackup !== null) {
+        fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+        fs.writeFileSync(lockPath, lockBackup, 'utf8');
+      }
+    }
+    const after = aheadBehind(repoRoot, branch, baseRef);
+    const result = {
+      ...payload,
+      status: 'success',
+      aheadAfter: after.ahead,
+      behindAfter: after.behind,
+    };
+
+    if (options.json) {
+      process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    } else {
+      console.log(`[${TOOL_NAME}] Sync target: ${repoRoot}`);
+      console.log(`[${TOOL_NAME}] Branch: ${branch}`);
+      console.log(`[${TOOL_NAME}] Base: ${baseRef}`);
+      console.log(`[${TOOL_NAME}] Strategy: ${strategy}`);
+      console.log(`[${TOOL_NAME}] Behind before sync: ${before.behind}`);
+      console.log(`[${TOOL_NAME}] Result: success (behind now: ${after.behind})`);
+    }
+
+    process.exitCode = 0;
+  }
+
+  return {
+    cleanup,
+    merge,
+    finish,
+    sync,
+  };
+}
+
+module.exports = {
+  createFinishApi,
+};

package/src/git/index.js

@@ -0,0 +1,112 @@
+const { path } = require('../context');
+const { run } = require('../core/runtime');
+
+function gitRun(repoRoot, args, { allowFailure = false } = {}) {
+  const result = run('git', ['-C', repoRoot, ...args]);
+  if (!allowFailure && result.status !== 0) {
+    throw new Error(`git ${args.join(' ')} failed: ${(result.stderr || '').trim()}`);
+  }
+  return result;
+}
+
+function resolveRepoRoot(targetPath) {
+  const resolvedTarget = path.resolve(targetPath || process.cwd());
+  const result = run('git', ['-C', resolvedTarget, 'rev-parse', '--show-toplevel']);
+  if (result.status !== 0) {
+    const stderr = (result.stderr || '').trim();
+    throw new Error(
+      `Target is not inside a git repository: ${resolvedTarget}${stderr ? `\n${stderr}` : ''}`,
+    );
+  }
+  return result.stdout.trim();
+}
+
+function isGitRepo(targetPath) {
+  const resolvedTarget = path.resolve(targetPath || process.cwd());
+  const result = run('git', ['-C', resolvedTarget, 'rev-parse', '--show-toplevel']);
+  return result.status === 0;
+}
+
+const NESTED_REPO_DEFAULT_MAX_DEPTH = 6;
+const NESTED_REPO_DEFAULT_SKIP_DIRS = new Set([
+  'node_modules',
+  '.git',
+  'dist',
+  'build',
+  '.next',
+  '.cache',
+  'target',
+  'vendor',
+  '.venv',
+  '.pnpm-store',
+]);
+
+function discoverNestedGitRepos(rootPath, opts = {}) {
+  const maxDepth = Number.isFinite(opts.maxDepth)
+    ? Math.max(1, opts.maxDepth)
+    : NESTED_REPO_DEFAULT_MAX_DEPTH;
+  const extraSkip = new Set(Array.isArray(opts.extraSkip) ? opts.extraSkip : []);
+  const includeSubmodules = Boolean(opts.includeSubmodules);
+  const resolvedRoot = path.resolve(rootPath);
+
+  if (!isGitRepo(resolvedRoot)) {
+    throw new Error(`Target is not inside a git repository: ${resolvedRoot}`);
+  }
+
+  const results = [];
+  const seen = new Set();
+
+  function visit(directoryPath, depth) {
+    const repoRoot = resolveRepoRoot(directoryPath);
+    if (!seen.has(repoRoot)) {
+      seen.add(repoRoot);
+      results.push(repoRoot);
+    }
+
+    if (depth >= maxDepth) {
+      return;
+    }
+
+    let entries = [];
+    try {
+      entries = require('node:fs').readdirSync(directoryPath, { withFileTypes: true });
+    } catch {
+      return;
+    }
+
+    for (const entry of entries) {
+      if (!entry.isDirectory()) {
+        continue;
+      }
+      if (NESTED_REPO_DEFAULT_SKIP_DIRS.has(entry.name) || extraSkip.has(entry.name)) {
+        continue;
+      }
+
+      const childPath = path.join(directoryPath, entry.name);
+      const gitDir = path.join(childPath, '.git');
+      if (require('node:fs').existsSync(gitDir)) {
+        if (!includeSubmodules) {
+          const gitInfo = require('node:fs').lstatSync(gitDir);
+          if (gitInfo.isFile()) {
+            continue;
+          }
+        }
+        visit(childPath, depth + 1);
+        continue;
+      }
+
+      visit(childPath, depth + 1);
+    }
+  }
+
+  visit(resolvedRoot, 0);
+  return results;
+}
+
+module.exports = {
+  DEFAULT_NESTED_REPO_MAX_DEPTH: NESTED_REPO_DEFAULT_MAX_DEPTH,
+  gitRun,
+  resolveRepoRoot,
+  isGitRepo,
+  discoverNestedGitRepos,
+};

package/src/hooks/index.js

@@ -0,0 +1,74 @@
+const path = require('node:path');
+
+function hook(rawArgs, deps) {
+  const {
+    extractTargetedArgs,
+    run,
+    resolveRepoRoot,
+    packageAssetEnv,
+    configureHooks,
+    TEMPLATE_ROOT,
+    HOOK_NAMES,
+    TOOL_NAME,
+    SHORT_TOOL_NAME,
+  } = deps;
+
+  const [subcommand, ...rest] = rawArgs;
+  if (subcommand === 'run') {
+    const [hookName, ...hookArgs] = rest;
+    if (!HOOK_NAMES.includes(hookName)) {
+      throw new Error(`Unknown hook name: ${hookName || '(missing)'}`);
+    }
+    const { target, passthrough } = extractTargetedArgs(hookArgs);
+    const hookAssetPath = path.join(TEMPLATE_ROOT, 'githooks', hookName);
+    const result = run('bash', [hookAssetPath, ...passthrough], {
+      cwd: resolveRepoRoot(target),
+      stdio: hookName === 'pre-push' ? 'inherit' : 'pipe',
+      env: packageAssetEnv(),
+    });
+    if (result.stdout) process.stdout.write(result.stdout);
+    if (result.stderr) process.stderr.write(result.stderr);
+    process.exitCode = result.status;
+    return;
+  }
+  if (subcommand === 'install') {
+    const { target, passthrough } = extractTargetedArgs(rest);
+    if (passthrough.length > 0) {
+      throw new Error(`Unknown hook install option: ${passthrough[0]}`);
+    }
+    const repoRoot = resolveRepoRoot(target);
+    const hookResult = configureHooks(repoRoot, false);
+    console.log(`[${TOOL_NAME}] Hook install target: ${repoRoot}`);
+    console.log(`  - hooksPath    ${hookResult.status} ${hookResult.key}=${hookResult.value}`);
+    process.exitCode = 0;
+    return;
+  }
+  throw new Error(`Usage: ${SHORT_TOOL_NAME} hook <run|install> ...`);
+}
+
+function internal(rawArgs, deps) {
+  const {
+    extractTargetedArgs,
+    resolveRepoRoot,
+    runReviewBotCommand,
+    runPackageAsset,
+  } = deps;
+
+  const [subcommand, assetKey, ...rest] = rawArgs;
+  if (subcommand !== 'run-shell') {
+    throw new Error(`Unknown internal command: ${subcommand || '(missing)'}`);
+  }
+  const { target, passthrough } = extractTargetedArgs(rest);
+  const repoRoot = resolveRepoRoot(target);
+  const result = assetKey === 'reviewBot'
+    ? runReviewBotCommand(repoRoot, passthrough)
+    : runPackageAsset(assetKey, passthrough, { cwd: repoRoot });
+  if (result.stdout) process.stdout.write(result.stdout);
+  if (result.stderr) process.stderr.write(result.stderr);
+  process.exitCode = result.status;
+}
+
+module.exports = {
+  hook,
+  internal,
+};