@gogd-core/ggd 0.1.0 → 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_commander3 = require("commander");
+var import_commander6 = require("commander");
 
 // apps/ggd/src/commands/env.ts
 var import_commander = require("commander");
@@ -81,9 +81,252 @@ function createRunCommand() {
   return run;
 }
 
+// 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"))
+    return "zsh";
+  if (shell.includes("bash"))
+    return "bash";
+  if (process.platform === "win32")
+    return "powershell";
+  return "bash";
+}
+function generateBashCompletion() {
+  return `###-begin-ggd-completions-###
+_ggd_completions() {
+  local cur commands
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  commands="$(ggd --get-completions "\${COMP_WORDS[@]}")"
+  COMPREPLY=($(compgen -W "$commands" -- "$cur"))
+}
+complete -F _ggd_completions ggd
+###-end-ggd-completions-###`;
+}
+function generateZshCompletion() {
+  return `###-begin-ggd-completions-###
+_ggd_completions() {
+  local commands
+  commands="$(ggd --get-completions "\${words[@]}")"
+  reply=(\${=commands})
+}
+compctl -K _ggd_completions ggd
+###-end-ggd-completions-###`;
+}
+function generatePowershellCompletion() {
+  return `# begin-ggd-completions
+Register-ArgumentCompleter -Native -CommandName ggd -ScriptBlock {
+  param($wordToComplete, $commandAst, $cursorPosition)
+  $words = $commandAst.ToString().Split(' ')
+  $completions = & ggd --get-completions @words 2>$null
+  $completions -split '\\s+' | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+    [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+  }
+}
+# end-ggd-completions`;
+}
+function getCompletionScript(shell) {
+  switch (shell) {
+    case "bash":
+      return generateBashCompletion();
+    case "zsh":
+      return generateZshCompletion();
+    case "powershell":
+      return generatePowershellCompletion();
+  }
+}
+function getCompletions(program2, args) {
+  const commandNames = program2.commands.map((cmd) => cmd.name());
+  const current = args[args.length - 1] || "";
+  if (args.length <= 2) {
+    return commandNames.filter((name) => name.startsWith(current));
+  }
+  const subcommandName = args[1];
+  const subcommand = program2.commands.find((cmd) => cmd.name() === subcommandName);
+  if (subcommand && subcommand.commands.length > 0) {
+    const subNames = subcommand.commands.map((cmd) => cmd.name());
+    return subNames.filter((name) => name.startsWith(current));
+  }
+  return [];
+}
+var VALID_SHELLS = ["bash", "zsh", "powershell"];
+function createCompletionCommand() {
+  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));
+  });
+  return completion;
+}
+function validateShell(shell) {
+  if (!VALID_SHELLS.includes(shell)) {
+    console.error(`Unknown shell: ${shell}. Supported: ${VALID_SHELLS.join(", ")}`);
+    process.exitCode = 1;
+    return "bash";
+  }
+  return shell;
+}
+
 // apps/ggd/src/main.ts
-var program = new import_commander3.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);
+  const suggestions = getCompletions(program, args);
+  console.log(suggestions.join(" "));
+  process.exit(0);
+}
 program.parse(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gogd-core/ggd",
-  "version": "0.1.0",
+  "version": "0.1.3",
   "dependencies": {
     "commander": "12.1.0",
     "execa": "5.1.1"
@@ -10,6 +10,9 @@
   "bin": {
     "ggd": "./main.js"
   },
+  "scripts": {
+    "postinstall": "node ./postinstall.js"
+  },
   "description": "GoGoodDev workspace CLI",
   "repository": {
     "type": "git",

package/postinstall.js

@@ -0,0 +1,201 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// apps/ggd/src/postinstall.ts
+var postinstall_exports = {};
+__export(postinstall_exports, {
+  detectShellForInstall: () => detectShellForInstall,
+  getCompletionScriptForShell: () => getCompletionScriptForShell,
+  getShellConfigPath: () => getShellConfigPath,
+  installCompletions: () => installCompletions,
+  removeExistingCompletions: () => removeExistingCompletions,
+  runPostinstall: () => runPostinstall
+});
+module.exports = __toCommonJS(postinstall_exports);
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var os = __toESM(require("os"));
+
+// apps/ggd/src/commands/completion.ts
+var import_commander = require("commander");
+function generateBashCompletion() {
+  return `###-begin-ggd-completions-###
+_ggd_completions() {
+  local cur commands
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  commands="$(ggd --get-completions "\${COMP_WORDS[@]}")"
+  COMPREPLY=($(compgen -W "$commands" -- "$cur"))
+}
+complete -F _ggd_completions ggd
+###-end-ggd-completions-###`;
+}
+function generateZshCompletion() {
+  return `###-begin-ggd-completions-###
+_ggd_completions() {
+  local commands
+  commands="$(ggd --get-completions "\${words[@]}")"
+  reply=(\${=commands})
+}
+compctl -K _ggd_completions ggd
+###-end-ggd-completions-###`;
+}
+function generatePowershellCompletion() {
+  return `# begin-ggd-completions
+Register-ArgumentCompleter -Native -CommandName ggd -ScriptBlock {
+  param($wordToComplete, $commandAst, $cursorPosition)
+  $words = $commandAst.ToString().Split(' ')
+  $completions = & ggd --get-completions @words 2>$null
+  $completions -split '\\s+' | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+    [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+  }
+}
+# end-ggd-completions`;
+}
+
+// apps/ggd/src/postinstall.ts
+var COMPLETION_MARKERS = ["###-begin-ggd-completions-###", "# begin-ggd-completions"];
+var COMPLETION_END_MARKERS = ["###-end-ggd-completions-###", "# end-ggd-completions"];
+function detectShellForInstall() {
+  const shellEnv = process.env["SHELL"] || "";
+  if (shellEnv.includes("zsh"))
+    return "zsh";
+  if (shellEnv.includes("bash"))
+    return "bash";
+  if (process.platform === "win32")
+    return "powershell";
+  if (shellEnv)
+    return "bash";
+  return "unknown";
+}
+function getShellConfigPath(shell) {
+  const home = os.homedir();
+  switch (shell) {
+    case "bash":
+      return path.join(home, ".bashrc");
+    case "zsh":
+      return path.join(home, ".zshrc");
+    case "powershell": {
+      const psProfile = process.env["USERPROFILE"] ? path.join(process.env["USERPROFILE"], "Documents", "PowerShell", "Microsoft.PowerShell_profile.ps1") : null;
+      return psProfile;
+    }
+    default:
+      return null;
+  }
+}
+function getCompletionScriptForShell(shell) {
+  switch (shell) {
+    case "bash":
+      return generateBashCompletion();
+    case "zsh":
+      return generateZshCompletion();
+    case "powershell":
+      return generatePowershellCompletion();
+    default:
+      return null;
+  }
+}
+function removeExistingCompletions(content) {
+  let startIdx = -1;
+  let startMarkerLen = 0;
+  for (const marker of COMPLETION_MARKERS) {
+    const idx = content.indexOf(marker);
+    if (idx !== -1) {
+      startIdx = idx;
+      startMarkerLen = marker.length;
+      break;
+    }
+  }
+  if (startIdx === -1)
+    return content;
+  let endIdx = -1;
+  let endMarkerLen = 0;
+  for (const marker of COMPLETION_END_MARKERS) {
+    const idx = content.indexOf(marker, startIdx + startMarkerLen);
+    if (idx !== -1) {
+      endIdx = idx;
+      endMarkerLen = marker.length;
+      break;
+    }
+  }
+  if (endIdx === -1)
+    return content;
+  const before = content.substring(0, startIdx).trimEnd();
+  const after = content.substring(endIdx + endMarkerLen).trimStart();
+  return before + (after ? "\n" + after : "") + "\n";
+}
+function installCompletions(shell) {
+  const configPath = getShellConfigPath(shell);
+  if (!configPath)
+    return false;
+  const script = getCompletionScriptForShell(shell);
+  if (!script)
+    return false;
+  try {
+    const dir = path.dirname(configPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    let existing = "";
+    if (fs.existsSync(configPath)) {
+      existing = fs.readFileSync(configPath, "utf8");
+    }
+    const cleaned = removeExistingCompletions(existing);
+    const updated = cleaned.trimEnd() + "\n\n" + script + "\n";
+    fs.writeFileSync(configPath, updated, "utf8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function runPostinstall() {
+  if (process.env["CI"] || process.env["CONTINUOUS_INTEGRATION"]) {
+    return;
+  }
+  const shell = detectShellForInstall();
+  if (shell === "unknown") {
+    return;
+  }
+  const success = installCompletions(shell);
+  if (success) {
+    console.log(`ggd: shell completions installed for ${shell}. Restart your shell to activate.`);
+  }
+}
+if (require.main === module) {
+  runPostinstall();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  detectShellForInstall,
+  getCompletionScriptForShell,
+  getShellConfigPath,
+  installCompletions,
+  removeExistingCompletions,
+  runPostinstall
+});

package/src/commands/completion.d.ts

@@ -0,0 +1,36 @@
+/**
+ * `ggd completion` command — outputs shell completion scripts.
+ */
+import { Command } from 'commander';
+type ShellType = 'bash' | 'zsh' | 'powershell';
+/**
+ * Auto-detects the current shell from environment variables.
+ */
+export declare function detectShell(): ShellType;
+/**
+ * Generates a Bash completion script for ggd.
+ */
+export declare function generateBashCompletion(): string;
+/**
+ * Generates a Zsh completion script for ggd.
+ */
+export declare function generateZshCompletion(): string;
+/**
+ * Generates a PowerShell completion script for ggd.
+ */
+export declare function generatePowershellCompletion(): string;
+/**
+ * Returns the completion script for the given shell type.
+ */
+export declare function getCompletionScript(shell: ShellType): string;
+/**
+ * Returns completion suggestions for the given CLI arguments.
+ * Used internally by `--get-completions`.
+ */
+export declare function getCompletions(program: Command, args: string[]): string[];
+/**
+ * Creates the `completion` command.
+ * Outputs a shell completion script to stdout.
+ */
+export declare function createCompletionCommand(): Command;
+export {};

package/src/commands/index.d.ts

@@ -1,2 +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;

package/src/index.d.ts

@@ -1,2 +1,2 @@
-export { createEnvCommand, createRunCommand } from './commands';
+export { createEnvCommand, createRunCommand, createCompletionCommand } from './commands';
 export { exec, isWindows, defaultShell } from './core';

package/src/postinstall.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Postinstall script for ggd CLI.
+ *
+ * Auto-installs shell completion on `npm install -g @gogd-core/ggd`.
+ * Gracefully skips if it cannot detect the shell or write to config files.
+ */
+type ShellType = 'bash' | 'zsh' | 'powershell' | 'unknown';
+/**
+ * Detects the user's shell for postinstall context.
+ */
+export declare function detectShellForInstall(): ShellType;
+/**
+ * Returns the shell config file path for the given shell.
+ */
+export declare function getShellConfigPath(shell: ShellType): string | null;
+/**
+ * Returns the completion script for the given shell.
+ */
+export declare function getCompletionScriptForShell(shell: ShellType): string | null;
+/**
+ * Removes any existing ggd completion block from content.
+ */
+export declare function removeExistingCompletions(content: string): string;
+/**
+ * Installs shell completions by appending to the shell config file.
+ * Returns true on success, false on skip/failure.
+ */
+export declare function installCompletions(shell: ShellType): boolean;
+/**
+ * Main postinstall entry point.
+ */
+export declare function runPostinstall(): void;
+export {};