@gogd-core/ggd 0.1.0 → 0.1.1

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_commander4 = require("commander");
 
 // apps/ggd/src/commands/env.ts
 var import_commander = require("commander");
@@ -81,9 +81,102 @@ function createRunCommand() {
   return run;
 }
 
+// apps/ggd/src/commands/completion.ts
+var import_commander3 = 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_commander3.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();
+var program = new import_commander4.Command();
 program.name("ggd").description("GoGoodDev workspace CLI").version("0.1.0");
 program.addCommand(createEnvCommand());
 program.addCommand(createRunCommand());
+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.1",
   "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,3 @@
 export { createEnvCommand } from './env';
 export { createRunCommand } from './run';
+export { createCompletionCommand, getCompletions } from './completion';

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 {};