gitxplain 0.1.3 → 0.1.8

package/cli/index.js

@@ -5,41 +5,47 @@ import process from "node:process";
 import { fileURLToPath } from "node:url";
 import { realpathSync } from "node:fs";
 import { generateExplanation } from "./services/aiService.js";
-import { startChatSession } from "./services/chatService.js";
 import { loadEnvFile } from "./services/envLoader.js";
-import {
-  saveGitConnection,
-  isGitConnected,
-  loadGitConnection,
-  getGitUserInfo,
-  verifyGitToken
-} from "./services/gitConnectionService.js";
 import { copyToClipboard } from "./services/clipboardService.js";
-import { loadConfig } from "./services/configService.js";
+import {
+  applyConfigEnvironment,
+  getProviderApiKeyField,
+  getUserConfigPath,
+  loadConfig,
+  loadUserConfig,
+  updateUserConfig
+} from "./services/configService.js";
 import {
   buildBranchRange,
   deletePaths,
   fetchCommitData,
   fetchWorkingTreeData,
   gitAddFiles,
+  gitPull,
   gitPush,
+  gitResetHard,
+  gitResetSoft,
   gitStashPop,
   gitRestoreStaged,
   getRepositoryLog,
   getRepositoryStatus,
   getDefaultBaseRef,
   isGitRepository,
+  listGitSubcommands,
+  runNativeGitPassthrough,
   resolveStashRef
 } from "./services/gitService.js";
 import { installHook } from "./services/hookService.js";
 import {
   buildReleaseMergePlan,
+  buildReleaseStatus,
   buildReleaseTagPlan,
   executeReleaseMerge,
   executeReleaseTagPlan,
   finalizeReleaseMergePlan,
   finalizeReleaseTagPlan,
   formatReleaseMergePlan,
+  formatReleaseStatus,
   formatReleaseTagPlan
 } from "./services/mergeService.js";
 import {
@@ -50,6 +56,12 @@ import {
   formatOutput,
   formatPreamble
 } from "./services/outputFormatter.js";
+import {
+  formatPipelineRecommendations,
+  inspectRepositoryForPipeline,
+  resolvePipelineSelection,
+  writePipelineFiles
+} from "./services/pipelineService.js";
 import { executeCommitPlan, formatCommitPlan, parseCommitPlan, reconcileCommitPlan } from "./services/commitService.js";
 import {
   executeSplit,
@@ -72,8 +84,10 @@ const MODE_FLAGS = new Map([
   ["--merge", "merge"],
   ["--tag", "tag"],
   ["--commit", "commit"],
+  ["--release", "release"],
   ["--log", "log"],
-  ["--status", "status"]
+  ["--status", "status"],
+  ["--pipeline", "pipeline"]
 ]);
 
 const FORMAT_FLAGS = new Map([
@@ -82,155 +96,103 @@ const FORMAT_FLAGS = new Map([
   ["--html", "html"]
 ]);
 
+const RESERVED_SUBCOMMANDS = new Set([
+  "help",
+  "config",
+  "install-hook",
+  "git",
+  "add",
+  "remove",
+  "del",
+  "bin",
+  "pop",
+  "pull",
+  "push"
+]);
+
 function printHelp() {
   console.log(`gitxplain - AI-powered Git change analysis, review, and commit workflow CLI
 
 Usage:
-  gitxplain help
   gitxplain --help
-  gitxplain commit
+  gitxplain config set provider <name>
+  gitxplain config set api-key <value> [--provider <name>]
+  gitxplain config get [key]
+  gitxplain config list
+  gitxplain <commit-id> [options]
+  gitxplain <start>..<end> [options]
+  gitxplain --branch [base-ref] [options]
+  gitxplain --pr [base-ref] [options]
   gitxplain --commit
-  gitxplain merge
+  gitxplain --release [status]
   gitxplain --merge
-  gitxplain tag
   gitxplain --tag
-  gitxplain log
   gitxplain --log
-  gitxplain status
   gitxplain --status
-  gitxplain add <path> [more-paths...]
-  gitxplain remove <path> [more-paths...]
-  gitxplain del <path> [more-paths...]
-  gitxplain pop [stash-index]
-  gitxplain push [remote] [branch]
-  gitxplain install-hook [hook-name]
-  gitxplain --connect-git [token]
-  gitxplain --boot [options]
-  gitxplain <commit-id> [options]
-  gitxplain <start>..<end> [options]
-  gitxplain --branch [base-ref] [options]
-  gitxplain --pr [base-ref] [options]
-
-What It Does:
-  Analyze commits, ranges, branches, and working tree changes
-  Generate summaries, reviews, security checks, and line-by-line walkthroughs
-  Plan commits for uncommitted work and split oversized commits into atomic steps
-  Merge release-version branch changes into a dedicated release branch
-  Tag release-version commit windows on the current branch
-  Inspect repository history and working tree status without calling the LLM
-  Run quick local actions to stage, unstage, delete files, pop stashes, or push
-
-Modes:
-  --summary    Generate a one-line summary of a change
-  --issues     Focus on the bug, issue, or failure being addressed
-  --fix        Explain the fix in simple, junior-friendly terms
-  --impact     Explain before-vs-after behavior changes
-  --full       Generate a full structured analysis
-  --lines      Walk through the changed code file by file
-  --review     Generate review findings, risks, and suggestions
-  --security   Focus on security-relevant changes and concerns
-  --split      Propose splitting a commit into smaller atomic commits
-  --merge      Preview or apply a merge into the release branch based on version bumps
-  --tag        Preview or create release tags based on version bumps
-  --commit     Propose commits for current uncommitted changes
-  --log        Print Git log entries for the current repository
-  --status     Print Git working tree status for the current repository
-  --execute    Execute a proposed split or commit plan
-  --dry-run    Preview the plan without executing it (default for --split and --commit)
+  gitxplain --pipeline
+
+Analysis:
+  --summary       Generate a one-line summary of a change
+  --issues        Focus on the issue or failure being addressed
+  --fix           Explain the fix in simple terms
+  --impact        Explain behavior changes before vs after
+  --full          Generate a full structured analysis
+  --lines         Walk through the changed code file by file
+  --review        Generate review findings, risks, and suggestions
+  --security      Focus on security-relevant changes and concerns
+  --split         Propose splitting a commit into smaller atomic commits
+  --commit        Propose commits for current uncommitted changes
+  --execute       Execute a proposed split or commit plan
+  --dry-run       Preview the plan without executing it
+
+Release:
+  --release [status]  Show release branch health and next recommended action
+  --merge         Preview or apply a merge into the release branch
+  --tag           Preview or create release tags from version bumps
+
+Repo:
+  --log           Print Git log entries for the current repository
+  --status        Print Git working tree status for the current repository
+  --pipeline      Detect the current repository stack and create CI/CD workflow files
 
 Quick Actions:
-  add         Stage one or more files with git add
-  remove      Unstage one or more files with git restore --staged
-  del         Delete one or more files from the working tree
-  pop         Pop a stash entry with a plain numeric index like "pop 2"
-  push        Run git push, optionally with a remote and branch
+  config          Persist provider, model, and API key settings
+  add             Stage one or more files with git add
+  remove          Unstage one or more files with git restore --staged
+  remove hard     Hard reset the repository to HEAD
+  del             Delete one or more files from the working tree
+  bin             Soft reset HEAD~1 while keeping your changes
+  pop             Pop a stash entry like "pop 2"
+  pull            Run git pull, optionally with a remote and branch
+  push            Run git push, optionally with a remote and branch
+  install-hook    Install the gitxplain hook
+  git             Pass through to native git commands
 
 Output:
-  --json       Print structured JSON output
-  --markdown   Print Markdown output
-  --html       Print HTML output
-  --quiet      Print only the main body without extra framing
-  --verbose    Print provider, model, cache, latency, and usage details
-  --clipboard  Copy the final output to the system clipboard
-  --stream     Stream model output as it is generated when supported
-  --boot       Launch an interactive chat session for dynamic querying, PR creation, and cloning.
-  --connect-git Save your GitHub Personal Access Token to act autonomously inside Chat.
-
-Providers:
-  --provider   LLM provider: openai, groq, openrouter, gemini, ollama, chutes
-  --model      Override the model name
-
-Diff Budget:
-  --max-diff-lines <n>   Limit diff lines sent to the model
+  --provider <name>
+  --model <name>
+  --json
+  --markdown
+  --html
+  --quiet
+  --verbose
+  --clipboard
+  --stream
+  --max-diff-lines <n>
 
 Comparison:
-  --branch [base-ref]    Analyze the current branch against a base branch
-  --pr [base-ref]        Alias for --branch, useful for PR-style comparisons
-
-Examples:
-  gitxplain HEAD~1 --full
-  gitxplain HEAD~1 --review
-  gitxplain HEAD~5..HEAD --markdown
-  gitxplain --branch main --review
-  gitxplain --pr origin/main --security --stream
-  gitxplain commit
-  gitxplain --commit --execute
-  gitxplain merge
-  gitxplain --merge --execute
-  gitxplain tag
-  gitxplain --tag --execute
-  gitxplain log
-  gitxplain --log
-  gitxplain status
-  gitxplain --status
-  gitxplain add README.md
-  gitxplain remove README.md
-  gitxplain del scratch.txt
-  gitxplain pop
-  gitxplain pop 2
-  gitxplain push
-  gitxplain push origin main
-  gitxplain HEAD~1 --split
-  gitxplain HEAD --split --execute
-  gitxplain HEAD~1 --provider chutes --model deepseek-ai/DeepSeek-V3-0324
-
-Provider Setup:
-  OpenAI:
-    export LLM_PROVIDER=openai
-    export OPENAI_API_KEY=your_key
-
-  Groq:
-    export LLM_PROVIDER=groq
-    export GROQ_API_KEY=your_key
-
-  OpenRouter:
-    export LLM_PROVIDER=openrouter
-    export OPENROUTER_API_KEY=your_key
-
-  Gemini:
-    export LLM_PROVIDER=gemini
-    export GEMINI_API_KEY=your_key
-
-  Ollama:
-    export LLM_PROVIDER=ollama
-    export OLLAMA_MODEL=llama3.2
-
-  Chutes:
-    export LLM_PROVIDER=chutes
-    export CHUTES_API_KEY=your_key
+  --branch [base-ref]   Analyze the current branch against a base branch
+  --pr [base-ref]       Alias for --branch, useful for PR-style comparisons
 
 Config:
   Project config: .gitxplainrc or .gitxplainrc.json
-  User config: ~/.gitxplain/config.json
-
-Hook Installation:
-  gitxplain install-hook
-  gitxplain install-hook post-commit
+  User config: ~/.gitxplain/config.json (macOS/Linux) or %USERPROFILE%\\.gitxplain\\config.json (Windows)
 
 Notes:
   Run gitxplain inside a Git repository.
-  If no mode is supplied, gitxplain will prompt you to choose one interactively.
+  If no command or mode is supplied, gitxplain prints this help text.
   Use --provider or --model to override your config or environment for one command.
+  Use gitxplain git <args...> to run any native Git subcommand with its normal flags.
 `);
 }
 
@@ -262,9 +224,120 @@ function parseNumber(value, fallback = null) {
   return parsed;
 }
 
-export function parseArgs(argv) {
+function redactConfigValue(key, value) {
+  if (typeof value !== "string") {
+    return value;
+  }
+
+  if (!/api[_-]?key/i.test(key)) {
+    return value;
+  }
+
+  if (value.length <= 8) {
+    return "*".repeat(value.length);
+  }
+
+  return `${value.slice(0, 4)}...${value.slice(-4)}`;
+}
+
+function printConfigEntries(config) {
+  const entries = Object.entries(config).sort(([left], [right]) => left.localeCompare(right));
+
+  if (entries.length === 0) {
+    console.log("No user config saved yet.");
+    return;
+  }
+
+  for (const [key, value] of entries) {
+    console.log(`${key}: ${redactConfigValue(key, value)}`);
+  }
+}
+
+function resolveConfigSetUpdate(parsed, currentConfig) {
+  const key = parsed.configKey;
+  const value = parsed.configValue;
+
+  if (!key || !value) {
+    throw new Error('Usage: gitxplain config set <provider|model|api-key> <value> [--provider <name>]');
+  }
+
+  if (key === "provider") {
+    return { provider: value.toLowerCase() };
+  }
+
+  if (key === "model") {
+    return { model: value };
+  }
+
+  if (key === "api-key") {
+    const resolvedProvider = (parsed.provider ?? currentConfig.provider ?? currentConfig.LLM_PROVIDER ?? "").toLowerCase();
+    const apiKeyField = getProviderApiKeyField(resolvedProvider);
+
+    if (!apiKeyField) {
+      throw new Error("Set a provider first with `gitxplain config set provider <name>`, or pass `--provider <name>`.");
+    }
+
+    return { [apiKeyField]: value };
+  }
+
+  return { [key]: value };
+}
+
+function handleConfigCommand(parsed) {
+  const currentConfig = loadUserConfig();
+
+  if (parsed.configAction === "list" || parsed.configAction == null) {
+    console.log(`User config: ${getUserConfigPath()}`);
+    printConfigEntries(currentConfig);
+    return 0;
+  }
+
+  if (parsed.configAction === "get") {
+    console.log(`User config: ${getUserConfigPath()}`);
+
+    if (!parsed.configKey) {
+      printConfigEntries(currentConfig);
+      return 0;
+    }
+
+    const value = currentConfig[parsed.configKey];
+    if (value === undefined) {
+      console.log(`No value saved for ${parsed.configKey}.`);
+      return 0;
+    }
+
+    console.log(`${parsed.configKey}: ${redactConfigValue(parsed.configKey, value)}`);
+    return 0;
+  }
+
+  if (parsed.configAction === "set") {
+    const updates = resolveConfigSetUpdate(parsed, currentConfig);
+    const { configPath } = updateUserConfig(updates);
+    const [savedKey, savedValue] = Object.entries(updates)[0];
+    console.log(`Saved ${savedKey} to ${configPath}.`);
+    console.log(`${savedKey}: ${redactConfigValue(savedKey, savedValue)}`);
+    return 0;
+  }
+
+  throw new Error(`Unknown config subcommand: ${parsed.configAction}`);
+}
+
+function isDirectNativeGitSubcommand(subcommand, knownGitSubcommands) {
+  if (!subcommand || subcommand.startsWith("-")) {
+    return false;
+  }
+
+  if (RESERVED_SUBCOMMANDS.has(subcommand)) {
+    return false;
+  }
+
+  return knownGitSubcommands.has(subcommand);
+}
+
+export function parseArgs(argv, options = {}) {
   const args = argv.slice(2);
   const subcommand = args[0];
+  const knownGitSubcommands = options.gitSubcommands ?? listGitSubcommands();
   const flags = new Set(args.filter((arg) => arg.startsWith("--")));
   const valueFlags = new Set(["--provider", "--model", "--max-diff-lines", "--branch", "--pr"]);
   const positional = [];
@@ -292,54 +365,66 @@ export function parseArgs(argv) {
   const explicitMode = [...MODE_FLAGS.entries()].find(([flag]) => flags.has(flag))?.[1] ?? null;
   const explicitFormat = [...FORMAT_FLAGS.entries()].find(([flag]) => flags.has(flag))?.[1] ?? null;
   const isInstallHook = subcommand === "install-hook";
-  const isConnectGit = flags.has("--connect-git");
-  const isBoot = flags.has("--boot");
-  const isLogCommand = subcommand === "log";
-  const isStatusCommand = subcommand === "status";
-  const isCommitCommand = subcommand === "commit";
-  const isMergeCommand = subcommand === "merge";
-  const isTagCommand = subcommand === "tag";
+  const isConfigCommand = subcommand === "config";
+  const isNativeGitWrapper = subcommand === "git";
+  const isReleaseCommand = flags.has("--release");
   const isAddCommand = subcommand === "add";
   const isRemoveCommand = subcommand === "remove";
   const isDeleteCommand = subcommand === "del";
+  const isPipelineCommand = flags.has("--pipeline");
+  const isBinCommand = subcommand === "bin";
   const isPopCommand = subcommand === "pop";
+  const isPullCommand = subcommand === "pull";
   const isPushCommand = subcommand === "push";
+  const isRemoveHardCommand = isRemoveCommand && positional[1] === "hard" && positional.length === 2;
+  const isNativeGitCommand = isNativeGitWrapper || isDirectNativeGitSubcommand(subcommand, knownGitSubcommands);
 
   return {
     subcommand,
     help: flags.has("--help") || subcommand === "help",
+    nativeGitCommand: isNativeGitCommand,
     installHook: isInstallHook,
-    connectGit: isConnectGit,
-    boot: isBoot,
-    logCommand: isLogCommand,
-    statusCommand: isStatusCommand,
-    commitCommand: isCommitCommand,
-    mergeCommand: isMergeCommand,
-    tagCommand: isTagCommand,
+    configCommand: isConfigCommand,
+    configAction: isConfigCommand ? positional[1] ?? null : null,
+    configKey: isConfigCommand ? positional[2] ?? null : null,
+    configValue: isConfigCommand ? positional.slice(3).join(" ") || null : null,
+    logCommand: false,
+    statusCommand: false,
+    commitCommand: false,
+    mergeCommand: false,
+    tagCommand: false,
+    releaseCommand: isReleaseCommand,
+    releaseAction: isReleaseCommand ? positional[0] ?? "status" : null,
     addCommand: isAddCommand,
     removeCommand: isRemoveCommand,
     deleteCommand: isDeleteCommand,
+    pipelineCommand: isPipelineCommand,
+    binCommand: isBinCommand,
     popCommand: isPopCommand,
+    pullCommand: isPullCommand,
     pushCommand: isPushCommand,
+    removeHardCommand: isRemoveHardCommand,
+    nativeGitArgs: isNativeGitWrapper ? args.slice(1) : isNativeGitCommand ? args : [],
     hookName: isInstallHook ? positional[1] ?? "post-commit" : null,
-    actionPaths: isAddCommand || isRemoveCommand || isDeleteCommand ? positional.slice(1) : [],
-    connectToken: isConnectGit ? positional[0] : null,
+    actionPaths:
+      isAddCommand || isDeleteCommand ? positional.slice(1) : isRemoveHardCommand ? [] : isRemoveCommand ? positional.slice(1) : [],
     stashIndex: isPopCommand ? positional[1] ?? null : null,
+    pullRemote: isPullCommand ? positional[1] ?? null : null,
+    pullBranch: isPullCommand ? positional[2] ?? null : null,
     pushRemote: isPushCommand ? positional[1] ?? null : null,
     pushBranch: isPushCommand ? positional[2] ?? null : null,
     commitRef:
       isInstallHook ||
-      isConnectGit ||
-      isBoot ||
-      isLogCommand ||
-      isStatusCommand ||
-      isCommitCommand ||
-      isMergeCommand ||
-      isTagCommand ||
+      isConfigCommand ||
+      isNativeGitCommand ||
+      isReleaseCommand ||
       isAddCommand ||
       isRemoveCommand ||
       isDeleteCommand ||
+      isPipelineCommand ||
+      isBinCommand ||
       isPopCommand ||
+      isPullCommand ||
       isPushCommand ||
       subcommand === "help"
         ? null
@@ -359,6 +444,7 @@ export function parseArgs(argv) {
     quiet: flags.has("--quiet"),
     execute: flags.has("--execute"),
     dryRun: flags.has("--dry-run"),
+    release: flags.has("--release"),
     log: flags.has("--log"),
     status: flags.has("--status"),
     merge: flags.has("--merge"),
@@ -395,6 +481,7 @@ async function chooseModeInteractively() {
       "11. Tag Release Commits",
       "12. Repository Log",
       "13. Commit Working Tree",
+      "14. Create CI/CD Pipelines",
       "> "
     ].join("\n")
   );
@@ -412,7 +499,8 @@ async function chooseModeInteractively() {
     "10": "merge",
     "11": "tag",
     "12": "log",
-    "13": "commit"
+    "13": "commit",
+    "14": "pipeline"
   };
 
   return selections[answer] ?? "full";
@@ -470,17 +558,26 @@ function renderFinalOutput({ runtimeOptions, mode, commitData, explanation, resp
 
 export async function main(argv = process.argv) {
   const cwd = process.cwd();
-  const config = loadConfig(cwd);
   const parsed = parseArgs(argv);
   const hasNoCommandOrFlags = argv.slice(2).length === 0;
 
   loadEnvFile(cwd); // Ensure environment is loaded first
+  const config = loadConfig(cwd);
+  applyConfigEnvironment(config);
 
   if (parsed.help || hasNoCommandOrFlags) {
     printHelp();
     return 0;
   }
 
+  if (parsed.configCommand) {
+    return handleConfigCommand(parsed);
+  }
+
+  if (parsed.nativeGitCommand) {
+    return runNativeGitPassthrough(parsed.nativeGitArgs, cwd);
+  }
+
   if (!isGitRepository(cwd)) {
     console.error("gitxplain must be run inside a Git repository.");
     return 1;
@@ -492,62 +589,65 @@ export async function main(argv = process.argv) {
     return 0;
   }
 
-  if (parsed.connectGit) {
-    let token = parsed.connectToken;
-    if (!token) {
-      if (process.env.GITHUB_TOKEN) {
-        token = process.env.GITHUB_TOKEN;
-      } else {
-        console.error("Please provide your GitHub Personal Access Token.\nRun: gitxplain --connect-git <YOUR_TOKEN>\nOr set it in your .env as GITHUB_TOKEN=...");
-        return 1;
-      }
-    }
-    try {
-      console.log("Verifying token with GitHub API...");
-      const userInfo = await verifyGitToken(token);
-      await saveGitConnection(token, "github", userInfo);
-      console.log(`\nSuccessfully connected to GitHub as: \x1b[36m${userInfo.login}\x1b[0m`);
-      console.log(`Token saved securely to your local configuration.\n`);
-    } catch (e) {
-      console.error(`Token verification failed: ${e.message}`);
-      return 1;
-    }
+  if (parsed.log) {
+    console.log(getRepositoryLog(cwd));
     return 0;
   }
 
-  if (parsed.boot) {
-    if (!isGitConnected()) {
-      console.error("You must connect a GitHub account first to use the interactive agent.\nCommand: gitxplain --connect-git <YOUR_TOKEN>");
-      return 1;
-    }
-    const connection = loadGitConnection();
-    const userInfo = getGitUserInfo();
-    try {
-      const { getProviderConfig, validateProviderConfig } = await import(
-        "./services/aiService.js"
-      );
-      const config = getProviderConfig(parsed.provider, parsed.model);
-      validateProviderConfig(config);
-      await startChatSession(connection.token, parsed.provider, parsed.model, userInfo.name || connection.user?.login);
-    } catch (configError) {
-      console.error(`Missing LLM Key. Please check your .env variables or --provider flags.\n${configError.message}`);
-      return 1;
-    }
+  if (parsed.status) {
+    console.log(getRepositoryStatus(cwd));
     return 0;
   }
 
-  if (parsed.logCommand || parsed.log) {
-    console.log(getRepositoryLog(cwd));
+  if (parsed.releaseCommand) {
+    if (parsed.releaseAction !== "status") {
+      throw new Error(`Unknown release subcommand: ${parsed.releaseAction}`);
+    }
+
+    console.log(formatReleaseStatus(buildReleaseStatus(cwd)));
     return 0;
   }
 
-  if (parsed.statusCommand || parsed.status) {
-    console.log(getRepositoryStatus(cwd));
+  if (parsed.pipelineCommand) {
+    const analysis = inspectRepositoryForPipeline(cwd);
+
+    if (!analysis.supported) {
+      console.log(analysis.reason);
+      return 1;
+    }
+
+    console.log(formatPipelineRecommendations(analysis));
+
+    const answer = await askQuestion(
+      `\nChoose a pipeline option (1-${analysis.options.length}) or type "cancel" > `
+    );
+    const selection = resolvePipelineSelection(analysis, answer);
+
+    if (!selection) {
+      console.log("Aborted.");
+      return 0;
+    }
+
+    const { writtenFiles, notes } = writePipelineFiles(cwd, analysis, selection);
+    console.log(`\nCreated workflow files: ${writtenFiles.join(", ")}`);
+
+    if (notes.length > 0) {
+      console.log(`\n${notes.join("\n")}`);
+    }
+
     return 0;
   }
 
-  if (parsed.addCommand || parsed.removeCommand || parsed.deleteCommand || parsed.popCommand || parsed.pushCommand) {
-    if (!parsed.popCommand && parsed.actionPaths.length === 0) {
+  if (
+    parsed.addCommand ||
+    parsed.removeCommand ||
+    parsed.deleteCommand ||
+    parsed.binCommand ||
+    parsed.popCommand ||
+    parsed.pullCommand ||
+    parsed.pushCommand
+  ) {
+    if (!parsed.popCommand && !parsed.binCommand && !parsed.pullCommand && !parsed.removeHardCommand && parsed.actionPaths.length === 0) {
       if (!parsed.pushCommand) {
         throw new Error(`No paths provided for "${parsed.subcommand}".`);
       }
@@ -560,6 +660,12 @@ export async function main(argv = process.argv) {
     }
 
     if (parsed.removeCommand) {
+      if (parsed.removeHardCommand) {
+        gitResetHard("HEAD", cwd);
+        console.log("Hard reset to HEAD.");
+        return 0;
+      }
+
       gitRestoreStaged(parsed.actionPaths, cwd);
       console.log(`Unstaged ${parsed.actionPaths.join(", ")}.`);
       return 0;
@@ -571,6 +677,12 @@ export async function main(argv = process.argv) {
       return 0;
     }
 
+    if (parsed.binCommand) {
+      gitResetSoft(cwd);
+      console.log("Soft reset HEAD~1 and kept your changes.");
+      return 0;
+    }
+
     if (parsed.popCommand) {
       const stashRef = resolveStashRef(parsed.stashIndex);
       gitStashPop(parsed.stashIndex, cwd);
@@ -578,6 +690,14 @@ export async function main(argv = process.argv) {
       return 0;
     }
 
+    if (parsed.pullCommand) {
+      gitPull(cwd, parsed.pullRemote, parsed.pullBranch);
+      console.log(
+        `Pulled${parsed.pullRemote ? ` from ${parsed.pullRemote}` : ""}${parsed.pullBranch ? ` ${parsed.pullBranch}` : ""}.`
+      );
+      return 0;
+    }
+
     gitPush(cwd, parsed.pushRemote, parsed.pushBranch);
     console.log(
       `Pushed${parsed.pushRemote ? ` to ${parsed.pushRemote}` : ""}${parsed.pushBranch ? ` ${parsed.pushBranch}` : ""}.`
@@ -588,7 +708,37 @@ export async function main(argv = process.argv) {
   const runtimeOptions = resolveRuntimeOptions(parsed, config);
   const mode = parsed.mode ?? config.mode ?? (await chooseModeInteractively());
 
-  if (mode === "commit" || parsed.commitCommand) {
+  if (mode === "pipeline") {
+    const analysis = inspectRepositoryForPipeline(cwd);
+
+    if (!analysis.supported) {
+      console.log(analysis.reason);
+      return 1;
+    }
+
+    console.log(formatPipelineRecommendations(analysis));
+
+    const answer = await askQuestion(
+      `\nChoose a pipeline option (1-${analysis.options.length}) or type "cancel" > `
+    );
+    const selection = resolvePipelineSelection(analysis, answer);
+
+    if (!selection) {
+      console.log("Aborted.");
+      return 0;
+    }
+
+    const { writtenFiles, notes } = writePipelineFiles(cwd, analysis, selection);
+    console.log(`\nCreated workflow files: ${writtenFiles.join(", ")}`);
+
+    if (notes.length > 0) {
+      console.log(`\n${notes.join("\n")}`);
+    }
+
+    return 0;
+  }
+
+  if (mode === "commit") {
     const commitData = fetchWorkingTreeData(cwd);
 
     if (commitData.filesChanged.length === 0 || commitData.diff === "") {
@@ -638,7 +788,7 @@ export async function main(argv = process.argv) {
     return 0;
   }
 
-  if (mode === "merge" || parsed.mergeCommand || parsed.merge) {
+  if (mode === "merge" || parsed.merge) {
     if (parsed.commitRef) {
       throw new Error("--merge works from the current branch and does not accept a commit ref.");
     }
@@ -670,7 +820,7 @@ export async function main(argv = process.argv) {
     return 0;
   }
 
-  if (mode === "tag" || parsed.tagCommand || parsed.tag) {
+  if (mode === "tag" || parsed.tag) {
     if (parsed.commitRef) {
       throw new Error("--tag works from the current branch and does not accept a commit ref.");
     }