@gogd-core/ggd 0.1.1 → 0.1.3

package/main.js

@@ -24,7 +24,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // apps/ggd/src/main.ts
-var import_commander4 = require("commander");
+var import_commander6 = require("commander");
 
 // apps/ggd/src/commands/env.ts
 var import_commander = require("commander");
@@ -81,8 +81,156 @@ function createRunCommand() {
   return run;
 }
 
-// apps/ggd/src/commands/completion.ts
+// apps/ggd/src/commands/rsh.ts
 var import_commander3 = require("commander");
+var import_execa2 = __toESM(require("execa"));
+var readline = __toESM(require("readline"));
+async function getCurrentBranch() {
+  const { stdout } = await (0, import_execa2.default)("git", ["symbolic-ref", "--short", "HEAD"]);
+  return stdout.trim();
+}
+async function getUncommittedChangeCount() {
+  const { stdout } = await (0, import_execa2.default)("git", ["status", "--porcelain"]);
+  if (!stdout.trim())
+    return 0;
+  return stdout.trim().split("\n").length;
+}
+function confirm(message) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stderr
+  });
+  return new Promise((resolve) => {
+    rl.question(message, (answer) => {
+      rl.close();
+      const normalized = (answer || "Y").trim().toLowerCase();
+      resolve(normalized === "y" || normalized === "yes");
+    });
+  });
+}
+async function resetHard(branch) {
+  try {
+    await (0, import_execa2.default)("git", ["fetch", "origin", branch], { stdio: "inherit" });
+    await (0, import_execa2.default)("git", ["reset", "--hard", `origin/${branch}`], { stdio: "inherit" });
+    return 0;
+  } catch {
+    return 1;
+  }
+}
+function createRshCommand() {
+  const rsh = new import_commander3.Command("rsh").description("Reset current branch to origin (git reset --hard)").option("-y, --yes", "Skip confirmation prompt").action(async (opts) => {
+    try {
+      const branch = await getCurrentBranch();
+      const changeCount = await getUncommittedChangeCount();
+      console.error(`\x1B[36mBranch:\x1B[0m ${branch}`);
+      if (changeCount > 0) {
+        console.error(`\x1B[33mUncommitted changes: ${changeCount} file(s) will be lost\x1B[0m`);
+      }
+      console.error(`\x1B[31mTarget: git reset --hard origin/${branch}\x1B[0m`);
+      if (!opts.yes) {
+        const ok = await confirm("\nProceed? (Y/n): ");
+        if (!ok) {
+          console.error("Reset aborted.");
+          return;
+        }
+      }
+      const exitCode = await resetHard(branch);
+      if (exitCode !== 0) {
+        process.exitCode = exitCode;
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`\x1B[31mError: ${message}\x1B[0m`);
+      process.exitCode = 1;
+    }
+  });
+  return rsh;
+}
+
+// apps/ggd/src/commands/mt.ts
+var import_commander4 = require("commander");
+var import_execa3 = __toESM(require("execa"));
+async function localBranchExists(branch) {
+  try {
+    await (0, import_execa3.default)("git", ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function deleteLocalBranch(branch) {
+  await (0, import_execa3.default)("git", ["branch", "-D", branch], { stdio: "inherit" });
+}
+async function switchBranch(branch) {
+  await (0, import_execa3.default)("git", ["switch", branch], { stdio: "inherit" });
+}
+async function mergeBranch(source) {
+  try {
+    await (0, import_execa3.default)("git", ["merge", source], { stdio: "inherit" });
+    return 0;
+  } catch {
+    return 1;
+  }
+}
+async function pushBranch(branch) {
+  try {
+    await (0, import_execa3.default)("git", ["push", "origin", branch], { stdio: "inherit" });
+    return 0;
+  } catch {
+    return 1;
+  }
+}
+function createMtCommand() {
+  const mt = new import_commander4.Command("mt").description("Merge current branch into target branch").argument("<branch>", "Target branch to merge into").option("-y, --yes", "Skip confirmation prompt").action(async (targetBranch, opts) => {
+    try {
+      const sourceBranch = await getCurrentBranch();
+      if (sourceBranch === targetBranch) {
+        console.error("\x1B[31mError: Cannot merge a branch into itself\x1B[0m");
+        process.exitCode = 1;
+        return;
+      }
+      console.error(`\x1B[36mSource:\x1B[0m ${sourceBranch}`);
+      console.error(`\x1B[36mTarget:\x1B[0m ${targetBranch}`);
+      console.error(`\x1B[33mWill: delete local ${targetBranch} (if exists), switch to it, merge ${sourceBranch}\x1B[0m`);
+      if (!opts.yes) {
+        const ok = await confirm(`
+Merge ${sourceBranch} into ${targetBranch}? (Y/n): `);
+        if (!ok) {
+          console.error("Merge aborted.");
+          return;
+        }
+      }
+      if (await localBranchExists(targetBranch)) {
+        console.error(`\x1B[33mDeleting local ${targetBranch}...\x1B[0m`);
+        await deleteLocalBranch(targetBranch);
+      }
+      await switchBranch(targetBranch);
+      const exitCode = await mergeBranch(sourceBranch);
+      if (exitCode !== 0) {
+        console.error(`\x1B[31mMerge failed. You are now on ${targetBranch}.\x1B[0m`);
+        process.exitCode = exitCode;
+        return;
+      }
+      console.error(`\x1B[32mMerge successful!\x1B[0m`);
+      const shouldPush = await confirm(`Push ${targetBranch} to origin? (Y/n): `);
+      if (shouldPush) {
+        const pushExit = await pushBranch(targetBranch);
+        if (pushExit !== 0) {
+          console.error(`\x1B[31mPush failed.\x1B[0m`);
+          process.exitCode = pushExit;
+        }
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`\x1B[31mError: ${message}\x1B[0m`);
+      process.exitCode = 1;
+    }
+  });
+  return mt;
+}
+
+// apps/ggd/src/commands/completion.ts
+var import_commander5 = require("commander");
 function detectShell() {
   const shell = process.env["SHELL"] || "";
   if (shell.includes("zsh"))
@@ -152,7 +300,7 @@ function getCompletions(program2, args) {
 }
 var VALID_SHELLS = ["bash", "zsh", "powershell"];
 function createCompletionCommand() {
-  const completion = new import_commander3.Command("completion").description("Output shell completion script").argument("[shell]", "Shell type: bash, zsh, powershell (auto-detected if omitted)").action((shell) => {
+  const completion = new import_commander5.Command("completion").description("Output shell completion script").argument("[shell]", "Shell type: bash, zsh, powershell (auto-detected if omitted)").action((shell) => {
     const resolved = shell ? validateShell(shell) : detectShell();
     console.log(getCompletionScript(resolved));
   });
@@ -168,10 +316,12 @@ function validateShell(shell) {
 }
 
 // apps/ggd/src/main.ts
-var program = new import_commander4.Command();
-program.name("ggd").description("GoGoodDev workspace CLI").version("0.1.0");
+var program = new import_commander6.Command();
+program.name("ggd").description("GoGoodDev workspace CLI").version("0.1.3");
 program.addCommand(createEnvCommand());
 program.addCommand(createRunCommand());
+program.addCommand(createRshCommand());
+program.addCommand(createMtCommand());
 program.addCommand(createCompletionCommand());
 if (process.argv.includes("--get-completions")) {
   const args = process.argv.slice(process.argv.indexOf("--get-completions") + 1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gogd-core/ggd",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "dependencies": {
     "commander": "12.1.0",
     "execa": "5.1.1"

package/src/commands/index.d.ts

@@ -1,3 +1,5 @@
 export { createEnvCommand } from './env';
 export { createRunCommand } from './run';
+export { createRshCommand } from './rsh';
+export { createMtCommand } from './mt';
 export { createCompletionCommand, getCompletions } from './completion';

package/src/commands/mt.d.ts

@@ -0,0 +1,32 @@
+/**
+ * `ggd mt` command — merge current branch into a target branch.
+ *
+ * Switches to target branch (re-creating from origin if it exists locally),
+ * then merges the source branch into it with confirmation.
+ */
+import { Command } from 'commander';
+/**
+ * Checks if a local branch exists.
+ */
+export declare function localBranchExists(branch: string): Promise<boolean>;
+/**
+ * Deletes a local branch.
+ */
+export declare function deleteLocalBranch(branch: string): Promise<void>;
+/**
+ * Switches to a branch.
+ */
+export declare function switchBranch(branch: string): Promise<void>;
+/**
+ * Merges a source branch into the current branch.
+ */
+export declare function mergeBranch(source: string): Promise<number>;
+/**
+ * Pushes the current branch to origin.
+ */
+export declare function pushBranch(branch: string): Promise<number>;
+/**
+ * Creates the `mt` command.
+ * Merges current branch into a target branch with confirmation.
+ */
+export declare function createMtCommand(): Command;

package/src/commands/rsh.d.ts

@@ -0,0 +1,27 @@
+/**
+ * `ggd rsh` command — safe git reset --hard to origin/<current-branch>.
+ *
+ * Shows branch name and uncommitted change count before prompting for confirmation.
+ */
+import { Command } from 'commander';
+/**
+ * Returns the current git branch name.
+ */
+export declare function getCurrentBranch(): Promise<string>;
+/**
+ * Returns the number of uncommitted changes (staged + unstaged + untracked).
+ */
+export declare function getUncommittedChangeCount(): Promise<number>;
+/**
+ * Prompts the user with a yes/no question. Returns true for yes.
+ */
+export declare function confirm(message: string): Promise<boolean>;
+/**
+ * Executes git reset --hard origin/<branch>.
+ */
+export declare function resetHard(branch: string): Promise<number>;
+/**
+ * Creates the `rsh` command.
+ * Resets current branch to origin/<branch> with confirmation.
+ */
+export declare function createRshCommand(): Command;