@gogd-core/ggd 0.1.1 → 0.1.4

package/main.js

@@ -24,9 +24,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // apps/ggd/src/main.ts
-var import_commander4 = require("commander");
+var import_commander7 = require("commander");
 
-// apps/ggd/src/commands/env.ts
+// apps/ggd/src/commands/shell/env.ts
 var import_commander = require("commander");
 function createEnvCommand() {
   const env = new import_commander.Command("env").description("Manage environments");
@@ -36,7 +36,7 @@ function createEnvCommand() {
   return env;
 }
 
-// apps/ggd/src/commands/run.ts
+// apps/ggd/src/commands/shell/run.ts
 var import_commander2 = require("commander");
 
 // apps/ggd/src/core/exec.ts
@@ -69,7 +69,7 @@ function isExecaError(error) {
   return typeof error === "object" && error !== null && "exitCode" in error;
 }
 
-// apps/ggd/src/commands/run.ts
+// apps/ggd/src/commands/shell/run.ts
 function createRunCommand() {
   const run = new import_commander2.Command("run").description("Execute a shell command").argument("<cmd...>", "Command and arguments to execute").allowExcessArguments(true).action(async (cmdParts) => {
     const cmd = cmdParts.join(" ");
@@ -81,8 +81,603 @@ function createRunCommand() {
   return run;
 }
 
-// apps/ggd/src/commands/completion.ts
+// apps/ggd/src/commands/git/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/git/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", "--no-edit", 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/jenkins/jenkins.ts
+var import_commander5 = require("commander");
+var fs2 = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var os = __toESM(require("os"));
+var readline2 = __toESM(require("readline"));
+
+// apps/ggd/src/commands/jenkins/jenkins-build.ts
+var http = __toESM(require("http"));
+var https = __toESM(require("https"));
+var import_child_process = require("child_process");
+function findTarget(name, targets) {
+  return targets.find((t) => t.name === name);
+}
+function listTargetNames(targets) {
+  return targets.map((t) => t.name);
+}
+function parseOverrides(args) {
+  const overrides = {};
+  for (const arg of args) {
+    const match = arg.match(/^--([^=]+)=(.*)$/);
+    if (match && match[1] !== void 0) {
+      overrides[match[1]] = match[2] ?? "";
+    }
+  }
+  return overrides;
+}
+function mergeParams(defaults, overrides) {
+  const merged = { ...defaults };
+  for (const [key, value] of Object.entries(overrides)) {
+    merged[key] = value;
+  }
+  return merged;
+}
+function resolveJobPath(target, config) {
+  if (target.jobPathOverride)
+    return target.jobPathOverride;
+  return config.jobPaths[target.jobPathKey] ?? "";
+}
+function jenkinsRequest(url, method, user, token, headers = {}, body) {
+  return new Promise((resolve, reject) => {
+    const parsedUrl = new URL(url);
+    const isHttps = parsedUrl.protocol === "https:";
+    const lib = isHttps ? https : http;
+    const auth = Buffer.from(`${user}:${token}`).toString("base64");
+    const reqHeaders = {
+      Authorization: `Basic ${auth}`,
+      ...headers
+    };
+    if (body) {
+      reqHeaders["Content-Type"] = "application/x-www-form-urlencoded";
+      reqHeaders["Content-Length"] = Buffer.byteLength(body).toString();
+    }
+    const req = lib.request(
+      {
+        hostname: parsedUrl.hostname,
+        port: parsedUrl.port || (isHttps ? 443 : 80),
+        path: parsedUrl.pathname + parsedUrl.search,
+        method,
+        headers: reqHeaders
+      },
+      (res) => {
+        let data = "";
+        res.on("data", (chunk) => {
+          data += chunk.toString();
+        });
+        res.on("end", () => {
+          resolve({
+            statusCode: res.statusCode ?? 0,
+            headers: res.headers,
+            body: data
+          });
+        });
+      }
+    );
+    req.on("error", reject);
+    if (body)
+      req.write(body);
+    req.end();
+  });
+}
+async function fetchCrumb(config) {
+  try {
+    const res = await jenkinsRequest(
+      `${config.url}/crumbIssuer/api/json`,
+      "GET",
+      config.user,
+      config.token
+    );
+    const json = JSON.parse(res.body);
+    return json.crumb ?? null;
+  } catch {
+    return null;
+  }
+}
+async function triggerBuild(config, jobPath, params) {
+  const crumb = await fetchCrumb(config);
+  const formBody = Object.entries(params).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`).join("&");
+  const headers = {};
+  if (crumb) {
+    headers["Jenkins-Crumb"] = crumb;
+  }
+  const res = await jenkinsRequest(
+    `${config.url}/job/${jobPath}/buildWithParameters`,
+    "POST",
+    config.user,
+    config.token,
+    headers,
+    formBody
+  );
+  const location = res.headers["location"];
+  if (typeof location === "string" && location) {
+    return location;
+  }
+  return null;
+}
+async function waitForBuild(config, queueUrl) {
+  const maxAttempts = 60;
+  for (let i = 0; i < maxAttempts; i++) {
+    try {
+      const res = await jenkinsRequest(
+        `${queueUrl}api/json`,
+        "GET",
+        config.user,
+        config.token
+      );
+      const json = JSON.parse(res.body);
+      if (json.executable?.url) {
+        return json.executable.url;
+      }
+      const why = json.why ?? "Waiting...";
+      const queueId = json.id ?? "?";
+      const blocked = json.blocked ?? false;
+      process.stderr.write(`\r\x1B[33mQueued #${queueId} (blocked: ${blocked}) ${why}\x1B[0m   `);
+    } catch {
+    }
+    await sleep(2e3);
+  }
+  return null;
+}
+async function watchBuild(config, buildUrl) {
+  let lastLines = "";
+  const maxAttempts = 360;
+  for (let i = 0; i < maxAttempts; i++) {
+    try {
+      const buildRes = await jenkinsRequest(
+        `${buildUrl}api/json`,
+        "GET",
+        config.user,
+        config.token
+      );
+      const json = JSON.parse(buildRes.body);
+      const consoleRes = await jenkinsRequest(
+        `${buildUrl}consoleText`,
+        "GET",
+        config.user,
+        config.token
+      );
+      const lines = consoleRes.body.trim().split("\n").slice(-5).join("\n");
+      if (lines !== lastLines) {
+        console.error(`
+${lines}`);
+        lastLines = lines;
+      }
+      if (json.result && json.result !== "null") {
+        const buildNum = json.number ?? "?";
+        return `${json.result} (#${buildNum})`;
+      }
+    } catch {
+    }
+    await sleep(5e3);
+  }
+  return "TIMEOUT";
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function notify(title, message) {
+  try {
+    if (process.platform === "win32") {
+      (0, import_child_process.execSync)(
+        `powershell -Command "New-BurntToastNotification -Text '${title}','${message}'" 2>nul || powershell -Command "[void][System.Reflection.Assembly]::LoadWithPartialName('System.Windows.Forms'); $n = New-Object System.Windows.Forms.NotifyIcon; $n.Icon = [System.Drawing.SystemIcons]::Information; $n.Visible = $true; $n.ShowBalloonTip(5000, '${title}', '${message}', 'Info')"`,
+        { stdio: "ignore" }
+      );
+    } else if (process.platform === "darwin") {
+      (0, import_child_process.execSync)(
+        `osascript -e 'display notification "${message}" with title "${title}"'`,
+        { stdio: "ignore" }
+      );
+    } else {
+      (0, import_child_process.execSync)(`notify-send "${title}" "${message}"`, { stdio: "ignore" });
+    }
+  } catch {
+  }
+}
+
+// apps/ggd/src/commands/jenkins/jenkins-presets.ts
+var fs = __toESM(require("fs"));
+function loadPresetFile(filePath) {
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`Preset file not found: ${filePath}`);
+  }
+  let raw;
+  try {
+    raw = fs.readFileSync(filePath, "utf8");
+  } catch {
+    throw new Error(`Failed to read preset file: ${filePath}`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error(`Invalid JSON in preset file: ${filePath}`);
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error(`Preset file must contain a JSON object: ${filePath}`);
+  }
+  const obj = parsed;
+  if (obj["url"] !== void 0 && typeof obj["url"] !== "string") {
+    throw new Error(`Preset "url" must be a string`);
+  }
+  if (obj["environments"] !== void 0) {
+    if (typeof obj["environments"] !== "object" || obj["environments"] === null || Array.isArray(obj["environments"])) {
+      throw new Error(`Preset "environments" must be an object`);
+    }
+  }
+  if (!Array.isArray(obj["targets"])) {
+    throw new Error(`Preset "targets" must be an array`);
+  }
+  for (const target of obj["targets"]) {
+    if (typeof target !== "object" || target === null || Array.isArray(target)) {
+      throw new Error(`Each target must be an object`);
+    }
+    const t = target;
+    if (typeof t["name"] !== "string" || typeof t["displayName"] !== "string") {
+      throw new Error(`Each target must have "name" and "displayName" strings`);
+    }
+    if (typeof t["jobPathKey"] !== "string") {
+      throw new Error(`Each target must have a "jobPathKey" string`);
+    }
+    if (typeof t["defaults"] !== "object" || t["defaults"] === null || Array.isArray(t["defaults"])) {
+      throw new Error(`Each target must have a "defaults" object`);
+    }
+  }
+  return parsed;
+}
+
+// apps/ggd/src/commands/jenkins/jenkins.ts
+function getConfigDir() {
+  return path.join(os.homedir(), ".ggd");
+}
+function getConfigPath() {
+  return path.join(getConfigDir(), "jenkins.json");
+}
+function readConfig() {
+  const configPath = getConfigPath();
+  try {
+    if (!fs2.existsSync(configPath))
+      return null;
+    const raw = fs2.readFileSync(configPath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function writeConfig(config) {
+  const dir = getConfigDir();
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, { recursive: true });
+  }
+  fs2.writeFileSync(getConfigPath(), JSON.stringify(config, null, 2), "utf8");
+}
+function prompt(question, defaultValue) {
+  const rl = readline2.createInterface({
+    input: process.stdin,
+    output: process.stderr
+  });
+  const display = defaultValue ? `${question} [${defaultValue}]: ` : `${question}: `;
+  return new Promise((resolve) => {
+    rl.question(display, (answer) => {
+      rl.close();
+      resolve(answer.trim() || defaultValue || "");
+    });
+  });
+}
+function maskToken(token) {
+  if (token.length <= 8)
+    return "****";
+  return `${token.slice(0, 4)}...${token.slice(-4)}`;
+}
+async function runSetup(presetPath) {
+  const existing = readConfig();
+  console.error("\x1B[36mJenkins CI Setup\x1B[0m");
+  console.error("\u2500".repeat(40));
+  if (existing) {
+    console.error(`\x1B[33mExisting config found. Press Enter to keep current values.\x1B[0m
+`);
+  }
+  let presetUrl = "";
+  let presetJobPaths = {};
+  let presetTargets = [];
+  if (presetPath) {
+    console.error(`\x1B[36mLoading preset from ${presetPath}\x1B[0m
+`);
+    const preset = loadPresetFile(presetPath);
+    presetUrl = preset.url ?? "";
+    presetTargets = preset.targets;
+    if (preset.environments) {
+      const envNames = Object.keys(preset.environments);
+      console.error(`Available environments: ${envNames.join(", ")}`);
+      const envChoice = await prompt("Environment", envNames[0]);
+      presetJobPaths = preset.environments[envChoice] ?? {};
+      if (!preset.environments[envChoice]) {
+        console.error(`\x1B[31mUnknown environment: ${envChoice}. No job paths loaded.\x1B[0m`);
+      }
+    }
+  }
+  const url = await prompt("Jenkins URL", existing?.url || presetUrl || "");
+  const user = await prompt("API User", existing?.user);
+  const token = await prompt(
+    `API Token${existing?.token ? ` (current: ${maskToken(existing.token)})` : ""}`,
+    existing?.token
+  );
+  let jobPaths;
+  if (Object.keys(presetJobPaths).length > 0) {
+    jobPaths = presetJobPaths;
+  } else if (existing?.jobPaths && Object.keys(existing.jobPaths).length > 0) {
+    jobPaths = existing.jobPaths;
+  } else {
+    const uiPath = await prompt("UI job path", "");
+    const apiPath = await prompt("API job path", "");
+    const lambdaPath = await prompt("Lambda job path", "");
+    jobPaths = {};
+    if (uiPath)
+      jobPaths["ui"] = uiPath;
+    if (apiPath)
+      jobPaths["api"] = apiPath;
+    if (lambdaPath)
+      jobPaths["lambda"] = lambdaPath;
+  }
+  const targets = presetTargets.length > 0 ? presetTargets : existing?.targets ?? [];
+  const config = {
+    url,
+    user,
+    token,
+    jobPaths,
+    targets
+  };
+  writeConfig(config);
+  console.error(`
+\x1B[32mConfig saved to ${getConfigPath()}\x1B[0m`);
+  console.error(`  URL:     ${config.url}`);
+  console.error(`  User:    ${config.user}`);
+  console.error(`  Token:   ${maskToken(config.token)}`);
+  console.error(`  Targets: ${config.targets.length} build target(s)`);
+  console.error(`  Job paths:`);
+  for (const [key, value] of Object.entries(config.jobPaths)) {
+    console.error(`    ${key}: ${value}`);
+  }
+  return config;
+}
+async function ensureConfig() {
+  let config = readConfig();
+  if (config)
+    return config;
+  console.error("\x1B[33mNo Jenkins config found. Starting setup...\x1B[0m\n");
+  config = await runSetup();
+  return config;
+}
+function createJenkinsCommand() {
+  const jenkins = new import_commander5.Command("jenkins").description("Jenkins CI integration");
+  jenkins.command("setup").description("Configure Jenkins connection and environment").option("-p, --preset <path>", "Load configuration from a preset JSON file").action(async (opts) => {
+    await runSetup(opts.preset);
+  });
+  jenkins.command("build").description("Trigger a Jenkins build").argument("[target]", "Build target name").option("-d, --detach", "Run in detached mode (don't watch build)").allowUnknownOption(true).action(async (targetName, opts, cmd) => {
+    const config = await ensureConfig();
+    if (!config)
+      return;
+    const targets = config.targets;
+    if (!targetName) {
+      if (targets.length === 0) {
+        console.error("\x1B[33mNo build targets configured.\x1B[0m");
+        console.error("Add targets via: ggd jenkins setup --preset <file>");
+        return;
+      }
+      console.error("\x1B[36mAvailable build targets:\x1B[0m");
+      for (const t of targets) {
+        console.error(`  ${t.name.padEnd(20)} ${t.displayName}`);
+      }
+      console.error(`
+Usage: ggd jenkins build <target> [--KEY=value ...]`);
+      return;
+    }
+    const target = findTarget(targetName, targets);
+    if (!target) {
+      console.error(`\x1B[31mUnknown target: ${targetName}\x1B[0m`);
+      console.error(`Available: ${listTargetNames(targets).join(", ")}`);
+      process.exitCode = 1;
+      return;
+    }
+    const rawArgs = cmd.args.slice(1);
+    const overrides = parseOverrides(rawArgs);
+    const params = mergeParams(target.defaults, overrides);
+    const jobPath = resolveJobPath(target, config);
+    console.error(`\x1B[36mTarget:\x1B[0m ${target.displayName}`);
+    console.error(`\x1B[36mJob:\x1B[0m ${config.url}/job/${jobPath}`);
+    console.error(`\x1B[36mParams:\x1B[0m`);
+    for (const [k, v] of Object.entries(params)) {
+      console.error(`  ${k}=${v || "<empty>"}`);
+    }
+    console.error("");
+    console.error("\x1B[33mTriggering build...\x1B[0m");
+    const queueUrl = await triggerBuild(config, jobPath, params);
+    if (!queueUrl) {
+      console.error("\x1B[31mFailed to trigger build. Check Jenkins URL / API token.\x1B[0m");
+      process.exitCode = 1;
+      return;
+    }
+    console.error(`\x1B[32mQueued!\x1B[0m ${queueUrl}`);
+    if (opts.detach) {
+      return;
+    }
+    const buildUrl = await waitForBuild(config, queueUrl);
+    if (!buildUrl) {
+      console.error("\n\x1B[31mTimed out waiting for build to start.\x1B[0m");
+      process.exitCode = 1;
+      return;
+    }
+    console.error(`
+\x1B[32mBuild started:\x1B[0m ${buildUrl}`);
+    const result = await watchBuild(config, buildUrl);
+    console.error(`
+\x1B[36mBuild result: ${result}\x1B[0m`);
+    notify("Jenkins Build", `${target.displayName}: ${result}`);
+    if (!result.startsWith("SUCCESS")) {
+      process.exitCode = 1;
+    }
+  });
+  jenkins.command("config").description("Show current Jenkins configuration").action(async () => {
+    const config = await ensureConfig();
+    if (!config)
+      return;
+    console.log(JSON.stringify(config, null, 2));
+  });
+  return jenkins;
+}
+
+// apps/ggd/src/commands/shell/completion.ts
+var import_commander6 = require("commander");
 function detectShell() {
   const shell = process.env["SHELL"] || "";
   if (shell.includes("zsh"))
@@ -152,7 +747,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_commander6.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 +763,13 @@ 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_commander7.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(createJenkinsCommand());
 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.4",
   "dependencies": {
     "commander": "12.1.0",
     "execa": "5.1.1"

package/postinstall.js

@@ -43,7 +43,7 @@ var fs = __toESM(require("fs"));
 var path = __toESM(require("path"));
 var os = __toESM(require("os"));
 
-// apps/ggd/src/commands/completion.ts
+// apps/ggd/src/commands/shell/completion.ts
 var import_commander = require("commander");
 function generateBashCompletion() {
   return `###-begin-ggd-completions-###

package/src/commands/git/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/git/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/commands/index.d.ts

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

package/src/commands/jenkins/jenkins-build.d.ts

@@ -0,0 +1,65 @@
+/**
+ * `ggd jenkins build` — trigger Jenkins builds via REST API.
+ *
+ * All build targets are loaded from user config (~/.ggd/jenkins.json),
+ * populated via `ggd jenkins setup --preset <file>`.
+ */
+import { JenkinsConfig } from './jenkins';
+export interface BuildTarget {
+    name: string;
+    displayName: string;
+    jobPathKey: string;
+    /** Custom job path override (for targets with unique paths) */
+    jobPathOverride?: string;
+    defaults: Record<string, string>;
+}
+/**
+ * Finds a build target by name from the given targets list.
+ */
+export declare function findTarget(name: string, targets: BuildTarget[]): BuildTarget | undefined;
+/**
+ * Lists all available build target names from the given targets list.
+ */
+export declare function listTargetNames(targets: BuildTarget[]): string[];
+/**
+ * Parses --KEY=value args into an overrides map.
+ */
+export declare function parseOverrides(args: string[]): Record<string, string>;
+/**
+ * Merges defaults with overrides to produce final params.
+ */
+export declare function mergeParams(defaults: Record<string, string>, overrides: Record<string, string>): Record<string, string>;
+/**
+ * Resolves the job path for a target.
+ */
+export declare function resolveJobPath(target: BuildTarget, config: JenkinsConfig): string;
+interface JenkinsHttpResponse {
+    statusCode: number;
+    headers: Record<string, string | string[] | undefined>;
+    body: string;
+}
+/**
+ * Makes an HTTP/HTTPS request to Jenkins.
+ */
+export declare function jenkinsRequest(url: string, method: string, user: string, token: string, headers?: Record<string, string>, body?: string): Promise<JenkinsHttpResponse>;
+/**
+ * Fetches the Jenkins CSRF crumb token.
+ */
+export declare function fetchCrumb(config: JenkinsConfig): Promise<string | null>;
+/**
+ * Triggers a Jenkins build. Returns the queue URL or null on failure.
+ */
+export declare function triggerBuild(config: JenkinsConfig, jobPath: string, params: Record<string, string>): Promise<string | null>;
+/**
+ * Polls the queue URL until the build starts. Returns the build URL.
+ */
+export declare function waitForBuild(config: JenkinsConfig, queueUrl: string): Promise<string | null>;
+/**
+ * Watches a build until it completes. Returns the final status.
+ */
+export declare function watchBuild(config: JenkinsConfig, buildUrl: string): Promise<string>;
+/**
+ * Sends a desktop notification. Best-effort — silently ignores failures.
+ */
+export declare function notify(title: string, message: string): void;
+export {};

package/src/commands/jenkins/jenkins-presets.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Jenkins preset file loader.
+ *
+ * Preset files are external JSON files that contain Jenkins configuration
+ * for a specific team/project. They can include environment-specific job paths
+ * and build targets.
+ */
+import { BuildTarget } from './jenkins-build';
+import { JenkinsJobPaths } from './jenkins';
+export interface JenkinsPreset {
+    url?: string;
+    environments?: Record<string, JenkinsJobPaths>;
+    targets: BuildTarget[];
+}
+/**
+ * Loads and validates a preset file from disk.
+ * Throws on missing file or invalid JSON structure.
+ */
+export declare function loadPresetFile(filePath: string): JenkinsPreset;

package/src/commands/jenkins/jenkins.d.ts

@@ -0,0 +1,54 @@
+/**
+ * `ggd jenkins` command — Jenkins CI integration.
+ *
+ * Config is stored at ~/.ggd/jenkins.json.
+ * Use `ggd jenkins setup --preset <file>` to load a team preset.
+ */
+import { Command } from 'commander';
+import { BuildTarget } from './jenkins-build';
+export interface JenkinsJobPaths {
+    [key: string]: string;
+}
+export interface JenkinsConfig {
+    url: string;
+    user: string;
+    token: string;
+    jobPaths: JenkinsJobPaths;
+    targets: BuildTarget[];
+}
+/**
+ * Returns the path to the ggd config directory (~/.ggd).
+ */
+export declare function getConfigDir(): string;
+/**
+ * Returns the path to the Jenkins config file.
+ */
+export declare function getConfigPath(): string;
+/**
+ * Reads the Jenkins config from disk. Returns null if not found.
+ */
+export declare function readConfig(): JenkinsConfig | null;
+/**
+ * Writes the Jenkins config to disk.
+ */
+export declare function writeConfig(config: JenkinsConfig): void;
+/**
+ * Prompts the user for input with a default value.
+ */
+export declare function prompt(question: string, defaultValue?: string): Promise<string>;
+/**
+ * Masks a token for display (shows first 4 and last 4 chars).
+ */
+export declare function maskToken(token: string): string;
+/**
+ * Runs the interactive setup flow.
+ */
+export declare function runSetup(presetPath?: string): Promise<JenkinsConfig>;
+/**
+ * Ensures Jenkins config exists. If not, runs interactive setup.
+ */
+export declare function ensureConfig(): Promise<JenkinsConfig | null>;
+/**
+ * Creates the `jenkins` command with subcommands.
+ */
+export declare function createJenkinsCommand(): Command;