@g-abhishek/gitx 0.1.1 → 0.1.4

package/dist/cli/commands/push.js

@@ -0,0 +1,166 @@
+/**
+ * gitx push
+ *
+ * The single-command workflow: stage everything → AI-generate a conventional
+ * commit message → commit → push to origin.  No flags needed.
+ *
+ * Usage:
+ *   gitx push                  # full auto: stage + AI commit + push
+ *   gitx push --staged         # commit only already-staged changes, leave the rest untouched
+ *   gitx push -m "fix: typo"   # use a custom message, skip AI
+ *   gitx push --dry-run        # preview message without committing or pushing
+ *   gitx push --branch feat    # push to a specific branch instead of current
+ */
+import inquirer from "inquirer";
+import ora from "ora";
+import { logger } from "../../logger/logger.js";
+import { Gitx } from "../../core/gitx.js";
+import { stageAll, hasStagedChanges, isWorkingTreeDirty, getWorkingDiff, getWorkingDiffStat, getStagedDiff, getStagedDiffStat, commitChanges, pushBranch, getCurrentBranch, } from "../../utils/gitOps.js";
+import { isInsideGitRepo } from "../../utils/git.js";
+import { GitxError } from "../../utils/errors.js";
+import { withLockRetry } from "../../utils/lockFile.js";
+export function registerPushCommand(program) {
+    program
+        .command("push")
+        .description("🚀 Stage, AI-commit, and push to origin in one step")
+        .option("-m, --message <msg>", "Use a custom commit message (skips AI generation)")
+        .option("--staged", "Commit only already-staged changes — leave unstaged files untouched")
+        .option("--dry-run", "Preview the commit message without committing or pushing")
+        .option("-b, --branch <name>", "Push to this branch instead of the current branch")
+        .action(async (opts) => {
+        const cwd = process.cwd();
+        // ── Guards ─────────────────────────────────────────────────────────────
+        if (!(await isInsideGitRepo(cwd))) {
+            throw new GitxError("Not inside a git repository. cd into your project folder first.", { exitCode: 2 });
+        }
+        const dirty = await isWorkingTreeDirty(cwd);
+        if (!dirty) {
+            logger.info("✨ Nothing to commit — working tree is clean.");
+            return;
+        }
+        // ── Stage changes ──────────────────────────────────────────────────────
+        if (opts.staged) {
+            // --staged: only commit what's already in the index, leave the rest alone
+            const alreadyStaged = await hasStagedChanges(cwd);
+            if (!alreadyStaged) {
+                logger.warn("⚠️  No staged changes found. Stage files first with `git add <files>` then retry.");
+                return;
+            }
+            logger.info("📦 Using already-staged changes only (--staged).");
+        }
+        else {
+            // Default: stage everything
+            const stageSpinner = ora("Staging all changes…").start();
+            await withLockRetry(() => stageAll(cwd), cwd);
+            stageSpinner.succeed("All changes staged.");
+            const staged = await hasStagedChanges(cwd);
+            if (!staged) {
+                logger.warn("No staged changes found after staging. Aborting.");
+                return;
+            }
+        }
+        // ── Get diff for AI ────────────────────────────────────────────────────
+        // stat = compact file list (always complete, never truncated)
+        // diff = full patch (may be large — we truncate later in the AI call)
+        const [stat, diff] = await Promise.all([
+            opts.staged ? getStagedDiffStat(cwd) : getWorkingDiffStat(cwd),
+            opts.staged ? getStagedDiff(cwd) : getWorkingDiff(cwd),
+        ]);
+        // ── Generate or use custom commit message ──────────────────────────────
+        let commitMsg;
+        if (opts.message) {
+            commitMsg = opts.message;
+            logger.info(`📝 Using provided message: ${commitMsg}`);
+        }
+        else {
+            const gitx = await Gitx.fromCwd(cwd);
+            if (!await Gitx.isAiAvailable(gitx.config)) {
+                logger.warn("⚠️  No AI provider configured. Run `gitx config` to set one up.");
+                logger.warn("   Falling back to manual commit message entry.\n");
+                const { manualMsg } = await inquirer.prompt([
+                    {
+                        type: "input",
+                        name: "manualMsg",
+                        message: "Commit message:",
+                        validate: (v) => v.trim().length > 0 || "Message cannot be empty",
+                    },
+                ]);
+                commitMsg = manualMsg.trim();
+            }
+            else {
+                const aiSpinner = ora("🤖 Generating commit message…").start();
+                try {
+                    // Build AI input: complete file summary first, then detailed patch.
+                    // The stat ensures the AI sees every changed file even when the
+                    // full diff is truncated by the 12 000 char safety limit.
+                    const aiInput = stat
+                        ? `=== Changed files (complete list) ===\n${stat}\n\n=== Detailed diff ===\n${diff}`
+                        : diff;
+                    const result = await gitx.ai.generateCommitMessage(aiInput);
+                    commitMsg = result.body
+                        ? `${result.subject}\n\n${result.body}`
+                        : result.subject;
+                    aiSpinner.succeed("Commit message generated.");
+                }
+                catch (err) {
+                    aiSpinner.fail("AI generation failed.");
+                    logger.warn(`   ${err instanceof Error ? err.message : String(err)}`);
+                    logger.warn("   Falling back to manual entry.\n");
+                    const { manualMsg } = await inquirer.prompt([
+                        {
+                            type: "input",
+                            name: "manualMsg",
+                            message: "Commit message:",
+                            validate: (v) => v.trim().length > 0 || "Message cannot be empty",
+                        },
+                    ]);
+                    commitMsg = manualMsg.trim();
+                }
+            }
+        }
+        // ── Preview + confirm ──────────────────────────────────────────────────
+        logger.info("\n📋 Commit message preview:\n");
+        logger.info("─".repeat(60));
+        logger.info(commitMsg);
+        logger.info("─".repeat(60));
+        if (opts.dryRun) {
+            logger.info("\n🔍 Dry run — nothing committed or pushed.");
+            return;
+        }
+        const { confirmed } = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: "confirmed",
+                message: "Commit and push with this message?",
+                default: true,
+            },
+        ]);
+        if (!confirmed) {
+            // Give the user a chance to edit before we proceed
+            const { editedMsg } = await inquirer.prompt([
+                {
+                    type: "editor",
+                    name: "editedMsg",
+                    message: "Edit commit message:",
+                    default: commitMsg,
+                },
+            ]);
+            commitMsg = editedMsg.trim();
+            if (!commitMsg) {
+                logger.warn("Empty message — aborted.");
+                return;
+            }
+        }
+        // ── Commit ─────────────────────────────────────────────────────────────
+        const commitSpinner = ora("Committing…").start();
+        await withLockRetry(() => commitChanges(commitMsg, cwd), cwd);
+        commitSpinner.succeed("Committed ✓");
+        // ── Push ───────────────────────────────────────────────────────────────
+        const branch = opts.branch ?? (await getCurrentBranch(cwd));
+        const pushSpinner = ora(`Pushing ${branch} to origin…`).start();
+        await pushBranch(branch, cwd);
+        pushSpinner.succeed(`Pushed to origin/${branch} ✓`);
+        logger.success(`\n✅ Done! Changes are live on origin/${branch}.`);
+    });
+}
+//# sourceMappingURL=push.js.map

package/dist/cli/commands/push.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"push.js","sourceRoot":"","sources":["../../../src/cli/commands/push.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,QAAQ,MAAM,UAAU,CAAC;AAChC,OAAO,GAAG,MAAM,KAAK,CAAC;AACtB,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAChD,OAAO,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAC1C,OAAO,EACL,QAAQ,EACR,gBAAgB,EAChB,kBAAkB,EAClB,cAAc,EACd,kBAAkB,EAClB,aAAa,EACb,iBAAiB,EACjB,aAAa,EACb,UAAU,EACV,gBAAgB,GACjB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAExD,MAAM,UAAU,mBAAmB,CAAC,OAAgB;IAClD,OAAO;SACJ,OAAO,CAAC,MAAM,CAAC;SACf,WAAW,CAAC,qDAAqD,CAAC;SAClE,MAAM,CAAC,qBAAqB,EAAE,mDAAmD,CAAC;SAClF,MAAM,CAAC,UAAU,EAAE,qEAAqE,CAAC;SACzF,MAAM,CAAC,WAAW,EAAE,0DAA0D,CAAC;SAC/E,MAAM,CAAC,qBAAqB,EAAE,mDAAmD,CAAC;SAClF,MAAM,CAAC,KAAK,EAAE,IAKd,EAAE,EAAE;QACH,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC;QAE1B,0EAA0E;QAC1E,IAAI,CAAC,CAAC,MAAM,eAAe,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;YAClC,MAAM,IAAI,SAAS,CAAC,iEAAiE,EAAE,EAAE,QAAQ,EAAE,CAAC,EAAE,CAAC,CAAC;QAC1G,CAAC;QAED,MAAM,KAAK,GAAG,MAAM,kBAAkB,CAAC,GAAG,CAAC,CAAC;QAC5C,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,MAAM,CAAC,IAAI,CAAC,8CAA8C,CAAC,CAAC;YAC5D,OAAO;QACT,CAAC;QAED,0EAA0E;QAC1E,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YAChB,0EAA0E;YAC1E,MAAM,aAAa,GAAG,MAAM,gBAAgB,CAAC,GAAG,CAAC,CAAC;YAClD,IAAI,CAAC,aAAa,EAAE,CAAC;gBACnB,MAAM,CAAC,IAAI,CAAC,mFAAmF,CAAC,CAAC;gBACjG,OAAO;YACT,CAAC;YACD,MAAM,CAAC,IAAI,CAAC,kDAAkD,CAAC,CAAC;QAClE,CAAC;aAAM,CAAC;YACN,4BAA4B;YAC5B,MAAM,YAAY,GAAG,GAAG,CAAC,sBAAsB,CAAC,CAAC,KAAK,EAAE,CAAC;YACzD,MAAM,aAAa,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC;YAC9C,YAAY,CAAC,OAAO,CAAC,qBAAqB,CAAC,CAAC;YAE5C,MAAM,MAAM,GAAG,MAAM,gBAAgB,CAAC,GAAG,CAAC,CAAC;YAC3C,IAAI,CAAC,MAAM,EAAE,CAAC;gBACZ,MAAM,CAAC,IAAI,CAAC,kDAAkD,CAAC,CAAC;gBAChE,OAAO;YACT,CAAC;QACH,CAAC;QAED,0EAA0E;QAC1E,8DAA8D;QAC9D,sEAAsE;QACtE,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;YACrC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,kBAAkB,CAAC,GAAG,CAAC;YAC9D,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,aAAa,CAAC,GAAG,CAAC,CAAK,CAAC,CAAC,cAAc,CAAC,GAAG,CAAC;SAC3D,CAAC,CAAC;QAEH,0EAA0E;QAC1E,IAAI,SAAiB,CAAC;QAEtB,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC;YACzB,MAAM,CAAC,IAAI,CAAC,8BAA8B,SAAS,EAAE,CAAC,CAAC;QACzD,CAAC;aAAM,CAAC;YACN,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;YAErC,IAAI,CAAC,MAAM,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;gBAC3C,MAAM,CAAC,IAAI,CAAC,iEAAiE,CAAC,CAAC;gBAC/E,MAAM,CAAC,IAAI,CAAC,mDAAmD,CAAC,CAAC;gBAEjE,MAAM,EAAE,SAAS,EAAE,GAAG,MAAM,QAAQ,CAAC,MAAM,CAAwB;oBACjE;wBACE,IAAI,EAAE,OAAO;wBACb,IAAI,EAAE,WAAW;wBACjB,OAAO,EAAE,iBAAiB;wBAC1B,QAAQ,EAAE,CAAC,CAAS,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC,IAAI,yBAAyB;qBAC1E;iBACF,CAAC,CAAC;gBACH,SAAS,GAAG,SAAS,CAAC,IAAI,EAAE,CAAC;YAC/B,CAAC;iBAAM,CAAC;gBACN,MAAM,SAAS,GAAG,GAAG,CAAC,+BAA+B,CAAC,CAAC,KAAK,EAAE,CAAC;gBAC/D,IAAI,CAAC;oBACH,oEAAoE;oBACpE,gEAAgE;oBAChE,0DAA0D;oBAC1D,MAAM,OAAO,GAAG,IAAI;wBAClB,CAAC,CAAC,0CAA0C,IAAI,8BAA8B,IAAI,EAAE;wBACpF,CAAC,CAAC,IAAI,CAAC;oBACT,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,EAAE,CAAC,qBAAqB,CAAC,OAAO,CAAC,CAAC;oBAE5D,SAAS,GAAG,MAAM,CAAC,IAAI;wBACrB,CAAC,CAAC,GAAG,MAAM,CAAC,OAAO,OAAO,MAAM,CAAC,IAAI,EAAE;wBACvC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC;oBAEnB,SAAS,CAAC,OAAO,CAAC,2BAA2B,CAAC,CAAC;gBACjD,CAAC;gBAAC,OAAO,GAAG,EAAE,CAAC;oBACb,SAAS,CAAC,IAAI,CAAC,uBAAuB,CAAC,CAAC;oBACxC,MAAM,CAAC,IAAI,CAAC,MAAM,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;oBACtE,MAAM,CAAC,IAAI,CAAC,oCAAoC,CAAC,CAAC;oBAElD,MAAM,EAAE,SAAS,EAAE,GAAG,MAAM,QAAQ,CAAC,MAAM,CAAwB;wBACjE;4BACE,IAAI,EAAE,OAAO;4BACb,IAAI,EAAE,WAAW;4BACjB,OAAO,EAAE,iBAAiB;4BAC1B,QAAQ,EAAE,CAAC,CAAS,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC,IAAI,yBAAyB;yBAC1E;qBACF,CAAC,CAAC;oBACH,SAAS,GAAG,SAAS,CAAC,IAAI,EAAE,CAAC;gBAC/B,CAAC;YACH,CAAC;QACH,CAAC;QAED,0EAA0E;QAC1E,MAAM,CAAC,IAAI,CAAC,gCAAgC,CAAC,CAAC;QAC9C,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC;QAC5B,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACvB,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC;QAE5B,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YAChB,MAAM,CAAC,IAAI,CAAC,6CAA6C,CAAC,CAAC;YAC3D,OAAO;QACT,CAAC;QAED,MAAM,EAAE,SAAS,EAAE,GAAG,MAAM,QAAQ,CAAC,MAAM,CAAyB;YAClE;gBACE,IAAI,EAAE,SAAS;gBACf,IAAI,EAAE,WAAW;gBACjB,OAAO,EAAE,oCAAoC;gBAC7C,OAAO,EAAE,IAAI;aACd;SACF,CAAC,CAAC;QAEH,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,mDAAmD;YACnD,MAAM,EAAE,SAAS,EAAE,GAAG,MAAM,QAAQ,CAAC,MAAM,CAAwB;gBACjE;oBACE,IAAI,EAAE,QAAQ;oBACd,IAAI,EAAE,WAAW;oBACjB,OAAO,EAAE,sBAAsB;oBAC/B,OAAO,EAAE,SAAS;iBACnB;aACF,CAAC,CAAC;YACH,SAAS,GAAG,SAAS,CAAC,IAAI,EAAE,CAAC;YAC7B,IAAI,CAAC,SAAS,EAAE,CAAC;gBACf,MAAM,CAAC,IAAI,CAAC,0BAA0B,CAAC,CAAC;gBACxC,OAAO;YACT,CAAC;QACH,CAAC;QAED,0EAA0E;QAC1E,MAAM,aAAa,GAAG,GAAG,CAAC,aAAa,CAAC,CAAC,KAAK,EAAE,CAAC;QACjD,MAAM,aAAa,CAAC,GAAG,EAAE,CAAC,aAAa,CAAC,SAAS,EAAE,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC;QAC9D,aAAa,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC;QAErC,0EAA0E;QAC1E,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,IAAI,CAAC,MAAM,gBAAgB,CAAC,GAAG,CAAC,CAAC,CAAC;QAC5D,MAAM,WAAW,GAAG,GAAG,CAAC,WAAW,MAAM,aAAa,CAAC,CAAC,KAAK,EAAE,CAAC;QAChE,MAAM,UAAU,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAC9B,WAAW,CAAC,OAAO,CAAC,oBAAoB,MAAM,IAAI,CAAC,CAAC;QAEpD,MAAM,CAAC,OAAO,CAAC,wCAAwC,MAAM,GAAG,CAAC,CAAC;IACpE,CAAC,CAAC,CAAC;AACP,CAAC","sourcesContent":["/**\n * gitx push\n *\n * The single-command workflow: stage everything → AI-generate a conventional\n * commit message → commit → push to origin.  No flags needed.\n *\n * Usage:\n *   gitx push                  # full auto: stage + AI commit + push\n *   gitx push --staged         # commit only already-staged changes, leave the rest untouched\n *   gitx push -m \"fix: typo\"   # use a custom message, skip AI\n *   gitx push --dry-run        # preview message without committing or pushing\n *   gitx push --branch feat    # push to a specific branch instead of current\n */\n\nimport type { Command } from \"commander\";\nimport inquirer from \"inquirer\";\nimport ora from \"ora\";\nimport { logger } from \"../../logger/logger.js\";\nimport { Gitx } from \"../../core/gitx.js\";\nimport {\n  stageAll,\n  hasStagedChanges,\n  isWorkingTreeDirty,\n  getWorkingDiff,\n  getWorkingDiffStat,\n  getStagedDiff,\n  getStagedDiffStat,\n  commitChanges,\n  pushBranch,\n  getCurrentBranch,\n} from \"../../utils/gitOps.js\";\nimport { isInsideGitRepo } from \"../../utils/git.js\";\nimport { GitxError } from \"../../utils/errors.js\";\nimport { withLockRetry } from \"../../utils/lockFile.js\";\n\nexport function registerPushCommand(program: Command): void {\n  program\n    .command(\"push\")\n    .description(\"🚀 Stage, AI-commit, and push to origin in one step\")\n    .option(\"-m, --message <msg>\", \"Use a custom commit message (skips AI generation)\")\n    .option(\"--staged\", \"Commit only already-staged changes — leave unstaged files untouched\")\n    .option(\"--dry-run\", \"Preview the commit message without committing or pushing\")\n    .option(\"-b, --branch <name>\", \"Push to this branch instead of the current branch\")\n    .action(async (opts: {\n      message?: string;\n      staged?: boolean;\n      dryRun?: boolean;\n      branch?: string;\n    }) => {\n      const cwd = process.cwd();\n\n      // ── Guards ─────────────────────────────────────────────────────────────\n      if (!(await isInsideGitRepo(cwd))) {\n        throw new GitxError(\"Not inside a git repository. cd into your project folder first.\", { exitCode: 2 });\n      }\n\n      const dirty = await isWorkingTreeDirty(cwd);\n      if (!dirty) {\n        logger.info(\"✨ Nothing to commit — working tree is clean.\");\n        return;\n      }\n\n      // ── Stage changes ──────────────────────────────────────────────────────\n      if (opts.staged) {\n        // --staged: only commit what's already in the index, leave the rest alone\n        const alreadyStaged = await hasStagedChanges(cwd);\n        if (!alreadyStaged) {\n          logger.warn(\"⚠️  No staged changes found. Stage files first with `git add <files>` then retry.\");\n          return;\n        }\n        logger.info(\"📦 Using already-staged changes only (--staged).\");\n      } else {\n        // Default: stage everything\n        const stageSpinner = ora(\"Staging all changes…\").start();\n        await withLockRetry(() => stageAll(cwd), cwd);\n        stageSpinner.succeed(\"All changes staged.\");\n\n        const staged = await hasStagedChanges(cwd);\n        if (!staged) {\n          logger.warn(\"No staged changes found after staging. Aborting.\");\n          return;\n        }\n      }\n\n      // ── Get diff for AI ────────────────────────────────────────────────────\n      // stat = compact file list (always complete, never truncated)\n      // diff = full patch (may be large — we truncate later in the AI call)\n      const [stat, diff] = await Promise.all([\n        opts.staged ? getStagedDiffStat(cwd) : getWorkingDiffStat(cwd),\n        opts.staged ? getStagedDiff(cwd)     : getWorkingDiff(cwd),\n      ]);\n\n      // ── Generate or use custom commit message ──────────────────────────────\n      let commitMsg: string;\n\n      if (opts.message) {\n        commitMsg = opts.message;\n        logger.info(`📝 Using provided message: ${commitMsg}`);\n      } else {\n        const gitx = await Gitx.fromCwd(cwd);\n\n        if (!await Gitx.isAiAvailable(gitx.config)) {\n          logger.warn(\"⚠️  No AI provider configured. Run `gitx config` to set one up.\");\n          logger.warn(\"   Falling back to manual commit message entry.\\n\");\n\n          const { manualMsg } = await inquirer.prompt<{ manualMsg: string }>([\n            {\n              type: \"input\",\n              name: \"manualMsg\",\n              message: \"Commit message:\",\n              validate: (v: string) => v.trim().length > 0 || \"Message cannot be empty\",\n            },\n          ]);\n          commitMsg = manualMsg.trim();\n        } else {\n          const aiSpinner = ora(\"🤖 Generating commit message…\").start();\n          try {\n            // Build AI input: complete file summary first, then detailed patch.\n            // The stat ensures the AI sees every changed file even when the\n            // full diff is truncated by the 12 000 char safety limit.\n            const aiInput = stat\n              ? `=== Changed files (complete list) ===\\n${stat}\\n\\n=== Detailed diff ===\\n${diff}`\n              : diff;\n            const result = await gitx.ai.generateCommitMessage(aiInput);\n\n            commitMsg = result.body\n              ? `${result.subject}\\n\\n${result.body}`\n              : result.subject;\n\n            aiSpinner.succeed(\"Commit message generated.\");\n          } catch (err) {\n            aiSpinner.fail(\"AI generation failed.\");\n            logger.warn(`   ${err instanceof Error ? err.message : String(err)}`);\n            logger.warn(\"   Falling back to manual entry.\\n\");\n\n            const { manualMsg } = await inquirer.prompt<{ manualMsg: string }>([\n              {\n                type: \"input\",\n                name: \"manualMsg\",\n                message: \"Commit message:\",\n                validate: (v: string) => v.trim().length > 0 || \"Message cannot be empty\",\n              },\n            ]);\n            commitMsg = manualMsg.trim();\n          }\n        }\n      }\n\n      // ── Preview + confirm ──────────────────────────────────────────────────\n      logger.info(\"\\n📋 Commit message preview:\\n\");\n      logger.info(\"─\".repeat(60));\n      logger.info(commitMsg);\n      logger.info(\"─\".repeat(60));\n\n      if (opts.dryRun) {\n        logger.info(\"\\n🔍 Dry run — nothing committed or pushed.\");\n        return;\n      }\n\n      const { confirmed } = await inquirer.prompt<{ confirmed: boolean }>([\n        {\n          type: \"confirm\",\n          name: \"confirmed\",\n          message: \"Commit and push with this message?\",\n          default: true,\n        },\n      ]);\n\n      if (!confirmed) {\n        // Give the user a chance to edit before we proceed\n        const { editedMsg } = await inquirer.prompt<{ editedMsg: string }>([\n          {\n            type: \"editor\",\n            name: \"editedMsg\",\n            message: \"Edit commit message:\",\n            default: commitMsg,\n          },\n        ]);\n        commitMsg = editedMsg.trim();\n        if (!commitMsg) {\n          logger.warn(\"Empty message — aborted.\");\n          return;\n        }\n      }\n\n      // ── Commit ─────────────────────────────────────────────────────────────\n      const commitSpinner = ora(\"Committing…\").start();\n      await withLockRetry(() => commitChanges(commitMsg, cwd), cwd);\n      commitSpinner.succeed(\"Committed ✓\");\n\n      // ── Push ───────────────────────────────────────────────────────────────\n      const branch = opts.branch ?? (await getCurrentBranch(cwd));\n      const pushSpinner = ora(`Pushing ${branch} to origin…`).start();\n      await pushBranch(branch, cwd);\n      pushSpinner.succeed(`Pushed to origin/${branch} ✓`);\n\n      logger.success(`\\n✅ Done! Changes are live on origin/${branch}.`);\n    });\n}\n"]}

package/dist/cli/commands/sync.d.ts

@@ -0,0 +1,24 @@
+/**
+ * gitx sync
+ *
+ * Bring the current branch up to date with its base branch so a PR can be
+ * merged cleanly. Uses rebase by default (keeps a linear history).
+ *
+ * Flow:
+ *   1. Detect base branch (same logic as `gitx pr create`)
+ *   2. git fetch origin
+ *   3. git rebase origin/<base>  (or --merge: git merge origin/<base>)
+ *   4a. No conflicts → git push --force-with-lease → "ready to merge"
+ *   4b. Conflicts  → list conflicting files, instruct user how to resolve,
+ *                    then run `gitx sync --continue` to finish
+ *
+ * Usage:
+ *   gitx sync                  # rebase onto auto-detected base
+ *   gitx sync --base main      # rebase onto a specific base
+ *   gitx sync --strategy merge # merge base into branch instead of rebase
+ *   gitx sync --continue       # after manually resolving conflicts
+ *   gitx sync --abort          # abort an in-progress rebase/merge
+ */
+import type { Command } from "commander";
+export declare function registerSyncCommand(program: Command): void;
+//# sourceMappingURL=sync.d.ts.map

package/dist/cli/commands/sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/sync.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAqEzC,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA0S1D"}

package/dist/cli/commands/sync.js

@@ -0,0 +1,414 @@
+/**
+ * gitx sync
+ *
+ * Bring the current branch up to date with its base branch so a PR can be
+ * merged cleanly. Uses rebase by default (keeps a linear history).
+ *
+ * Flow:
+ *   1. Detect base branch (same logic as `gitx pr create`)
+ *   2. git fetch origin
+ *   3. git rebase origin/<base>  (or --merge: git merge origin/<base>)
+ *   4a. No conflicts → git push --force-with-lease → "ready to merge"
+ *   4b. Conflicts  → list conflicting files, instruct user how to resolve,
+ *                    then run `gitx sync --continue` to finish
+ *
+ * Usage:
+ *   gitx sync                  # rebase onto auto-detected base
+ *   gitx sync --base main      # rebase onto a specific base
+ *   gitx sync --strategy merge # merge base into branch instead of rebase
+ *   gitx sync --continue       # after manually resolving conflicts
+ *   gitx sync --abort          # abort an in-progress rebase/merge
+ */
+import ora from "ora";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { readFile, writeFile } from "node:fs/promises";
+import { resolve as resolvePath } from "node:path";
+import { confirm, select } from "@inquirer/prompts";
+import { logger } from "../../logger/logger.js";
+import { getCurrentBranch, detectBaseBranch } from "../../utils/gitOps.js";
+import { isInsideGitRepo } from "../../utils/git.js";
+import { GitxError } from "../../utils/errors.js";
+import { Gitx } from "../../core/gitx.js";
+import { createProvider } from "../../providers/factory.js";
+import { runAddressWorkflow, filterUnresolvedInlineComments } from "../../workflows/prAddress.js";
+const execFileAsync = promisify(execFile);
+async function git(args, cwd) {
+    try {
+        const result = await execFileAsync("git", args, { cwd });
+        return { stdout: result.stdout.trim(), stderr: "" };
+    }
+    catch (err) {
+        const e = err;
+        return {
+            stdout: e.stdout?.trim() ?? "",
+            stderr: (e.stderr ?? e.message ?? String(err)).trim(),
+        };
+    }
+}
+/** Returns list of files that currently have conflict markers. */
+async function getConflictingFiles(cwd) {
+    const { stdout } = await git(["diff", "--name-only", "--diff-filter=U"], cwd);
+    return stdout.split("\n").map((l) => l.trim()).filter(Boolean);
+}
+/** Check whether a rebase or merge is currently in progress. */
+async function getInProgressOperation(cwd) {
+    const { stdout: gitDir } = await git(["rev-parse", "--git-dir"], cwd);
+    const base = gitDir || ".git";
+    const { stdout: rebaseDir } = await git(["rev-parse", "--git-path", "rebase-merge"], cwd);
+    const { stdout: rebaseApply } = await git(["rev-parse", "--git-path", "rebase-apply"], cwd);
+    const { stdout: mergeHead } = await git(["rev-parse", "--git-path", "MERGE_HEAD"], cwd);
+    // Check if the paths actually exist on disk
+    const { existsSync } = await import("node:fs");
+    if (existsSync(rebaseDir) || existsSync(rebaseApply))
+        return "rebase";
+    if (existsSync(mergeHead) || existsSync(`${base}/MERGE_HEAD`))
+        return "merge";
+    return null;
+}
+export function registerSyncCommand(program) {
+    program
+        .command("sync")
+        .description("🔄 Sync current branch with its base branch (merge by default, or --strategy rebase)")
+        .option("--base <branch>", "Base branch to sync with (auto-detected if omitted)")
+        .option("--strategy <strategy>", "Sync strategy: merge (default) | rebase", "merge")
+        .option("--continue", "Continue after manually resolving conflicts")
+        .option("--abort", "Abort an in-progress rebase or merge")
+        .action(async (opts) => {
+        const cwd = process.cwd();
+        if (!(await isInsideGitRepo(cwd))) {
+            throw new GitxError("Not inside a git repository. cd into your project folder first.", { exitCode: 2 });
+        }
+        const strategy = opts.strategy === "rebase" ? "rebase" : "merge";
+        // ── Handle --abort ─────────────────────────────────────────────────────
+        if (opts.abort) {
+            const op = await getInProgressOperation(cwd);
+            if (!op) {
+                logger.info("No rebase or merge in progress.");
+                return;
+            }
+            const abortSpinner = ora(`Aborting ${op}…`).start();
+            const { stderr } = await git([op, "--abort"], cwd);
+            if (stderr) {
+                abortSpinner.fail(`Abort failed: ${stderr}`);
+                process.exitCode = 1;
+                return;
+            }
+            abortSpinner.succeed(`${op.charAt(0).toUpperCase() + op.slice(1)} aborted. Branch restored to its previous state.`);
+            return;
+        }
+        // ── Handle --continue ──────────────────────────────────────────────────
+        if (opts.continue) {
+            const op = await getInProgressOperation(cwd);
+            if (!op) {
+                logger.info("No rebase or merge in progress — nothing to continue.");
+                return;
+            }
+            // Check if all conflicts are resolved
+            const conflicts = await getConflictingFiles(cwd);
+            if (conflicts.length > 0) {
+                logger.error(`\n❌ There are still unresolved conflicts:\n`);
+                for (const f of conflicts)
+                    logger.info(`   • ${f}`);
+                logger.info(`\n  Fix the conflicts above, then:\n`);
+                logger.info(`    git add <file>          # mark each file as resolved`);
+                logger.info(`    gitx sync --continue    # resume\n`);
+                process.exitCode = 1;
+                return;
+            }
+            // Stage all resolved files and continue
+            await git(["add", "-A"], cwd);
+            const continueSpinner = ora(`Continuing ${op}…`).start();
+            const env = { ...process.env, GIT_EDITOR: "true" }; // skip editor for commit msg
+            const { stderr } = await execFileAsync("git", [op, "--continue"], { cwd, env }).then((r) => ({ stdout: r.stdout, stderr: "" }), (e) => ({
+                stdout: "",
+                stderr: (e.stderr ?? e.message ?? "").trim(),
+            }));
+            if (stderr && !stderr.includes("Successfully")) {
+                continueSpinner.fail(`Could not continue ${op}: ${stderr}`);
+                process.exitCode = 1;
+                return;
+            }
+            continueSpinner.succeed(`${op.charAt(0).toUpperCase() + op.slice(1)} completed ✓`);
+            // Rebase rewrites history; merge does not
+            await pushAfterSync(cwd, op === "rebase");
+            return;
+        }
+        // ── Normal sync flow ───────────────────────────────────────────────────
+        const head = await getCurrentBranch(cwd);
+        // Resolve base
+        let base;
+        if (opts.base) {
+            base = opts.base;
+            logger.info(`📌 Base branch (provided): ${base}`);
+        }
+        else {
+            const detectSpinner = ora("Detecting base branch…").start();
+            base = await detectBaseBranch(cwd);
+            detectSpinner.succeed(`Base branch: ${base}`);
+        }
+        if (head === base) {
+            logger.info(`✨ Already on the base branch "${base}" — nothing to sync.`);
+            return;
+        }
+        // ── Check for unresolved PR review comments BEFORE syncing ────────────
+        // If the current branch has an open PR with unresolved inline comments,
+        // offer to resolve them now. Fixes are committed onto the branch; the
+        // sync then rebases/merges and pushes everything together.
+        await checkAndOfferAddressComments(cwd, head);
+        logger.info(`\n🔄 Syncing  ${head}  onto  origin/${base}\n`);
+        // Fetch latest
+        const fetchSpinner = ora("Fetching latest from origin…").start();
+        const { stderr: fetchErr } = await git(["fetch", "origin"], cwd);
+        if (fetchErr && !fetchErr.includes("->")) {
+            fetchSpinner.fail(`Fetch failed: ${fetchErr}`);
+            process.exitCode = 1;
+            return;
+        }
+        fetchSpinner.succeed("Fetched latest.");
+        // Check if we're already up to date
+        const { stdout: behindCount } = await git(["rev-list", "--count", `HEAD..origin/${base}`], cwd);
+        if (behindCount === "0") {
+            logger.success(`✅ "${head}" is already up to date with origin/${base}. Ready to merge!`);
+            return;
+        }
+        // Run rebase or merge
+        const syncSpinner = ora(strategy === "rebase"
+            ? `Rebasing ${head} onto origin/${base}…`
+            : `Merging origin/${base} into ${head}…`).start();
+        const syncArgs = strategy === "rebase"
+            ? ["rebase", `origin/${base}`]
+            : ["merge", `origin/${base}`, "--no-edit"];
+        const { stderr: syncErr } = await git(syncArgs, cwd);
+        // Detect conflict — try AI resolution first
+        const conflicts = await getConflictingFiles(cwd);
+        if (conflicts.length > 0) {
+            syncSpinner.fail(`Conflicts detected in ${conflicts.length} file(s) — attempting AI resolution…`);
+            // Try to load an AI client
+            let gitx = null;
+            try {
+                gitx = await Gitx.fromCwd(cwd);
+            }
+            catch {
+                // No AI available; fall through to manual instructions
+            }
+            if (gitx && await Gitx.isAiAvailable(gitx.config)) {
+                const resolved = [];
+                const needsManual = [];
+                for (const filePath of conflicts) {
+                    const absPath = resolvePath(cwd, filePath);
+                    let content;
+                    try {
+                        content = await readFile(absPath, "utf8");
+                    }
+                    catch {
+                        needsManual.push(filePath);
+                        continue;
+                    }
+                    // Skip binary files (no conflict markers)
+                    if (!content.includes("<<<<<<<")) {
+                        needsManual.push(filePath);
+                        continue;
+                    }
+                    const resolveSpinner = ora(`  🤖 AI resolving: ${filePath}`).start();
+                    try {
+                        const result = await gitx.ai.resolveConflict(filePath, content);
+                        if (result.confidence === "high") {
+                            await writeFile(absPath, result.resolved, "utf8");
+                            resolveSpinner.succeed(`  ✅ Auto-resolved: ${filePath} — ${result.explanation}`);
+                            resolved.push(filePath);
+                        }
+                        else {
+                            resolveSpinner.warn(`  ⚠️  Low confidence: ${filePath} — ${result.explanation}`);
+                            logger.info(`\n  AI proposed resolution (low confidence). Preview:\n`);
+                            // Show first 40 lines of the resolved content as a preview
+                            const preview = result.resolved.split("\n").slice(0, 40).join("\n");
+                            logger.info(preview);
+                            if (result.resolved.split("\n").length > 40) {
+                                logger.info(`  … (${result.resolved.split("\n").length - 40} more lines)`);
+                            }
+                            logger.info("");
+                            let apply = false;
+                            try {
+                                apply = await confirm({
+                                    message: `Apply AI resolution for ${filePath}?`,
+                                    default: true,
+                                });
+                            }
+                            catch {
+                                apply = false;
+                            }
+                            if (apply) {
+                                await writeFile(absPath, result.resolved, "utf8");
+                                logger.success(`  ✅ Applied: ${filePath}`);
+                                resolved.push(filePath);
+                            }
+                            else {
+                                logger.info(`  ⏭️  Skipped: ${filePath} — resolve manually`);
+                                needsManual.push(filePath);
+                            }
+                        }
+                    }
+                    catch {
+                        resolveSpinner.fail(`  ❌ AI resolution failed for: ${filePath}`);
+                        needsManual.push(filePath);
+                    }
+                }
+                if (needsManual.length > 0) {
+                    logger.error(`\n⚠️  ${needsManual.length} file(s) still need manual resolution:\n`);
+                    for (const f of needsManual)
+                        logger.info(`   • ${f}`);
+                    logger.info(`\n  Steps to finish:\n`);
+                    logger.info(`  1. Open each file and fix the conflict markers (<<<<, ====, >>>>)`);
+                    logger.info(`  2. Mark resolved:   git add <file>`);
+                    logger.info(`  3. Finish sync:     gitx sync --continue`);
+                    logger.info(`  4. Retry merge:     gitx pr merge <number>\n`);
+                    logger.info(`  To give up and go back: gitx sync --abort\n`);
+                    process.exitCode = 1;
+                    return;
+                }
+                // All resolved — stage and continue
+                if (resolved.length > 0) {
+                    logger.success(`\n✅ AI resolved all ${resolved.length} conflict(s). Staging and continuing…\n`);
+                    await git(["add", "-A"], cwd);
+                    const env = { ...process.env, GIT_EDITOR: "true" };
+                    const { stderr: contErr } = await execFileAsync("git", [strategy === "rebase" ? "rebase" : "merge", "--continue"], { cwd, env }).then((r) => ({ stdout: r.stdout, stderr: "" }), (e) => ({
+                        stdout: "",
+                        stderr: (e.stderr ?? e.message ?? "").trim(),
+                    }));
+                    if (contErr && !contErr.toLowerCase().includes("successfully")) {
+                        logger.error(`Could not continue ${strategy}: ${contErr}`);
+                        process.exitCode = 1;
+                        return;
+                    }
+                }
+            }
+            else {
+                // No AI — fall back to manual instructions
+                logger.error(`\n⚠️  Merge conflicts in ${conflicts.length} file(s):\n`);
+                for (const f of conflicts)
+                    logger.info(`   • ${f}`);
+                logger.info(`\n  Steps to resolve:\n`);
+                logger.info(`  1. Open each file and fix the conflict markers (<<<<, ====, >>>>)`);
+                logger.info(`  2. Mark resolved:   git add <file>`);
+                logger.info(`  3. Finish sync:     gitx sync --continue`);
+                logger.info(`  4. Retry merge:     gitx pr merge <number>\n`);
+                logger.info(`  To give up and go back: gitx sync --abort\n`);
+                process.exitCode = 1;
+                return;
+            }
+        }
+        if (syncErr && !syncErr.toLowerCase().includes("successfully")) {
+            syncSpinner.fail(`Sync failed: ${syncErr}`);
+            process.exitCode = 1;
+            return;
+        }
+        syncSpinner.succeed(strategy === "rebase"
+            ? `Rebased ${head} onto origin/${base} ✓`
+            : `Merged origin/${base} into ${head} ✓`);
+        // Rebase rewrites history → force-with-lease; merge → plain push
+        await pushAfterSync(cwd, strategy === "rebase");
+    });
+}
+/**
+ * Before syncing, look up any open PR for the current branch.
+ * If it has unresolved inline review comments, ask the user:
+ *   - "Resolve comments first, then sync"  → address + commit, sync continues
+ *   - "Sync normally"                       → proceed immediately
+ *
+ * Fixes are committed using "commit-no-push" mode so the sync rebase/merge
+ * picks them up and pushes everything together in a single push.
+ */
+async function checkAndOfferAddressComments(cwd, currentBranch) {
+    let gitx = null;
+    try {
+        gitx = await Gitx.fromCwd(cwd);
+        if (!await Gitx.isAiAvailable(gitx.config))
+            return;
+    }
+    catch {
+        return; // no gitx config — skip silently
+    }
+    let prNumber = null;
+    let unresolvedCount = 0;
+    try {
+        const ctx = await gitx.getRepoContext();
+        const provider = createProvider(ctx);
+        // Find the open PR for the current branch
+        const prs = await provider.listPRs(ctx.repoSlug);
+        const openPr = prs.find((p) => p.head === currentBranch && p.state === "open");
+        if (!openPr)
+            return;
+        prNumber = openPr.number;
+        // Use the shared helper: root inline comments with no "✅ Addressed" reply yet
+        const allComments = await provider.getPRComments(ctx.repoSlug, prNumber);
+        unresolvedCount = filterUnresolvedInlineComments(allComments).length;
+        if (unresolvedCount === 0)
+            return;
+    }
+    catch {
+        return; // provider error — don't block the sync
+    }
+    // ── Surface the choice ──────────────────────────────────────────────────────
+    logger.info(`\n💬 PR #${prNumber} has ${unresolvedCount} unresolved review comment(s).\n`);
+    let choice;
+    try {
+        choice = await select({
+            message: "How would you like to proceed?",
+            choices: [
+                {
+                    name: `Resolve comments first, then sync  (AI generates fixes → you approve → commit → sync)`,
+                    value: "resolve",
+                },
+                {
+                    name: `Sync normally  (skip comment resolution, proceed with merge)`,
+                    value: "skip",
+                },
+            ],
+        });
+    }
+    catch {
+        return; // Ctrl-C → skip
+    }
+    if (choice === "skip") {
+        logger.info("⏭️  Skipping comment resolution — proceeding with sync.\n");
+        return;
+    }
+    // ── Resolve comments (commit but don't push — sync handles the push) ───────
+    logger.info(`\n🔧 Resolving ${unresolvedCount} review comment(s) on PR #${prNumber}…\n`);
+    try {
+        const result = await runAddressWorkflow(gitx, prNumber, { mode: "commit-no-push" });
+        const applied = result.addressed.filter((a) => a.applied).length;
+        const skipped = result.addressed.filter((a) => a.skipped).length;
+        if (applied > 0) {
+            logger.success(`✅ ${applied} fix(es) committed.${skipped > 0 ? `  (${skipped} skipped)` : ""}`);
+            logger.info("   Sync will rebase these commits and push everything together.\n");
+        }
+        else {
+            logger.info("   No fixes applied — continuing with normal sync.\n");
+        }
+    }
+    catch (err) {
+        logger.warn(`⚠️  Comment resolution error: ${err.message}\n   Continuing with sync.\n`);
+    }
+}
+async function pushAfterSync(cwd, forceWithLease = false) {
+    // Rebase rewrites history → requires --force-with-lease.
+    // Merge does not rewrite history → plain push is fine.
+    const pushArgs = forceWithLease
+        ? ["push", "--force-with-lease"]
+        : ["push"];
+    const label = forceWithLease ? "Pushing (force-with-lease)…" : "Pushing…";
+    const pushSpinner = ora(label).start();
+    const { stderr } = await git(pushArgs, cwd);
+    if (stderr && stderr.includes("error")) {
+        pushSpinner.fail(`Push failed: ${stderr}`);
+        const hint = forceWithLease ? "git push --force-with-lease" : "git push";
+        logger.info(`  Try: ${hint}`);
+        process.exitCode = 1;
+        return;
+    }
+    pushSpinner.succeed("Pushed ✓");
+    logger.success(`\n✅ Branch is now up to date. Run \`gitx pr merge <number>\` to merge.\n`);
+}
+//# sourceMappingURL=sync.js.map