gut-cli 0.1.3

package/dist/index.js

@@ -0,0 +1,1256 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command9 } from "commander";
+
+// src/commands/cleanup.ts
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { simpleGit } from "simple-git";
+var cleanupCommand = new Command("cleanup").description("Delete merged branches safely").option("-r, --remote", "Also delete remote branches").option("-f, --force", "Skip confirmation prompt").option("--dry-run", "Show branches that would be deleted without deleting").option("--base <branch>", "Base branch to compare against (default: main or master)").action(async (options) => {
+  const git = simpleGit();
+  const isRepo = await git.checkIsRepo();
+  if (!isRepo) {
+    console.error(chalk.red("Error: Not a git repository"));
+    process.exit(1);
+  }
+  const spinner = ora("Fetching branch information...").start();
+  try {
+    await git.fetch(["--prune"]);
+    const currentBranch = (await git.branch()).current;
+    const baseBranch = options.base || await detectBaseBranch(git);
+    spinner.text = `Using ${chalk.cyan(baseBranch)} as base branch`;
+    const mergedResult = await git.branch(["--merged", baseBranch]);
+    const mergedBranches = mergedResult.all.filter((branch) => {
+      const cleanName = branch.trim().replace(/^\* /, "");
+      return cleanName !== currentBranch && cleanName !== baseBranch && !cleanName.startsWith("remotes/") && cleanName !== "main" && cleanName !== "master" && cleanName !== "develop";
+    });
+    spinner.stop();
+    if (mergedBranches.length === 0) {
+      console.log(chalk.green("\u2713 No merged branches to clean up"));
+      return;
+    }
+    console.log(chalk.yellow(`
+Found ${mergedBranches.length} merged branch(es):
+`));
+    mergedBranches.forEach((branch) => {
+      console.log(`  ${chalk.red("\u2022")} ${branch}`);
+    });
+    if (options.dryRun) {
+      console.log(chalk.blue("\n(dry-run mode - no branches were deleted)"));
+      return;
+    }
+    if (!options.force) {
+      const readline = await import("readline");
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      const answer = await new Promise((resolve) => {
+        rl.question(chalk.yellow("\nDelete these branches? (y/N) "), resolve);
+      });
+      rl.close();
+      if (answer.toLowerCase() !== "y") {
+        console.log(chalk.gray("Cancelled"));
+        return;
+      }
+    }
+    const deleteSpinner = ora("Deleting branches...").start();
+    for (const branch of mergedBranches) {
+      try {
+        await git.deleteLocalBranch(branch, true);
+        deleteSpinner.text = `Deleted ${branch}`;
+        if (options.remote) {
+          try {
+            await git.push("origin", `:${branch}`);
+          } catch {
+          }
+        }
+      } catch (error) {
+        deleteSpinner.warn(`Failed to delete ${branch}`);
+      }
+    }
+    deleteSpinner.succeed(chalk.green(`Deleted ${mergedBranches.length} branch(es)`));
+  } catch (error) {
+    spinner.fail("Failed to cleanup branches");
+    console.error(chalk.red(error instanceof Error ? error.message : "Unknown error"));
+    process.exit(1);
+  }
+});
+async function detectBaseBranch(git) {
+  const branches = await git.branch();
+  if (branches.all.includes("main")) return "main";
+  if (branches.all.includes("master")) return "master";
+  return "main";
+}
+
+// src/commands/auth.ts
+import { Command as Command2 } from "commander";
+import chalk2 from "chalk";
+
+// src/lib/credentials.ts
+var SERVICE_NAME = "gut-cli";
+var PROVIDER_KEY_MAP = {
+  gemini: "gemini-api-key",
+  openai: "openai-api-key",
+  anthropic: "anthropic-api-key"
+};
+var ENV_VAR_MAP = {
+  gemini: "GUT_GEMINI_API_KEY",
+  openai: "GUT_OPENAI_API_KEY",
+  anthropic: "GUT_ANTHROPIC_API_KEY"
+};
+var FALLBACK_ENV_MAP = {
+  gemini: "GEMINI_API_KEY",
+  openai: "OPENAI_API_KEY",
+  anthropic: "ANTHROPIC_API_KEY"
+};
+async function getKeytar() {
+  try {
+    return await import("keytar");
+  } catch {
+    return null;
+  }
+}
+async function saveApiKey(provider, apiKey) {
+  const keytar = await getKeytar();
+  if (!keytar) {
+    throw new Error("Keychain not available. Set environment variable instead.");
+  }
+  await keytar.setPassword(SERVICE_NAME, PROVIDER_KEY_MAP[provider], apiKey);
+}
+async function getApiKey(provider) {
+  const envKey = process.env[ENV_VAR_MAP[provider]];
+  if (envKey) return envKey;
+  const fallbackKey = process.env[FALLBACK_ENV_MAP[provider]];
+  if (fallbackKey) return fallbackKey;
+  const keytar = await getKeytar();
+  if (!keytar) return null;
+  return keytar.getPassword(SERVICE_NAME, PROVIDER_KEY_MAP[provider]);
+}
+async function deleteApiKey(provider) {
+  const keytar = await getKeytar();
+  if (!keytar) {
+    throw new Error("Keychain not available.");
+  }
+  return keytar.deletePassword(SERVICE_NAME, PROVIDER_KEY_MAP[provider]);
+}
+async function listProviders() {
+  const providers = ["gemini", "openai", "anthropic"];
+  const results = await Promise.all(
+    providers.map(async (provider) => ({
+      provider,
+      hasKey: !!await getApiKey(provider)
+    }))
+  );
+  return results;
+}
+function getProviderDisplayName(provider) {
+  const names = {
+    gemini: "Google Gemini",
+    openai: "OpenAI",
+    anthropic: "Anthropic Claude"
+  };
+  return names[provider];
+}
+
+// src/commands/auth.ts
+var PROVIDERS = ["gemini", "openai", "anthropic"];
+async function readSecretInput(prompt) {
+  return new Promise((resolve) => {
+    process.stdout.write(chalk2.cyan(prompt));
+    let input = "";
+    const stdin = process.stdin;
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    const onData = (char) => {
+      const charCode = char.charCodeAt(0);
+      if (charCode === 13 || charCode === 10) {
+        stdin.setRawMode(false);
+        stdin.pause();
+        stdin.removeListener("data", onData);
+        console.log();
+        resolve(input);
+      } else if (charCode === 127 || charCode === 8) {
+        if (input.length > 0) {
+          input = input.slice(0, -1);
+          process.stdout.write("\b \b");
+        }
+      } else if (charCode === 3) {
+        stdin.setRawMode(false);
+        stdin.pause();
+        console.log();
+        process.exit(0);
+      } else if (charCode >= 32) {
+        input += char;
+        process.stdout.write("*");
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+var authCommand = new Command2("auth").description("Manage API key authentication");
+authCommand.command("login").description("Save an API key to the system keychain").requiredOption("-p, --provider <provider>", "AI provider (gemini, openai, anthropic)").option("-k, --key <key>", "API key (if not provided, will prompt)").action(async (options) => {
+  const provider = options.provider.toLowerCase();
+  if (!PROVIDERS.includes(provider)) {
+    console.error(chalk2.red(`Invalid provider: ${options.provider}`));
+    console.error(chalk2.gray(`Valid providers: ${PROVIDERS.join(", ")}`));
+    process.exit(1);
+  }
+  let apiKey = options.key;
+  if (!apiKey) {
+    const providerName = getProviderDisplayName(provider);
+    console.log(chalk2.bold(`
+\u{1F511} ${providerName} API Key Setup
+`));
+    console.log(chalk2.gray(`Your API key will be stored securely in the system keychain.`));
+    console.log();
+    apiKey = await readSecretInput(`Enter ${providerName} API key: `);
+  }
+  if (!apiKey || apiKey.trim() === "") {
+    console.error(chalk2.red("API key cannot be empty"));
+    process.exit(1);
+  }
+  try {
+    await saveApiKey(provider, apiKey.trim());
+    console.log(chalk2.green(`
+\u2713 API key for ${getProviderDisplayName(provider)} saved to system keychain`));
+  } catch (error) {
+    console.error(chalk2.red("Failed to save API key"));
+    console.error(chalk2.gray(error instanceof Error ? error.message : "Unknown error"));
+    process.exit(1);
+  }
+});
+authCommand.command("logout").description("Remove an API key from the system keychain").requiredOption("-p, --provider <provider>", "AI provider (gemini, openai, anthropic)").action(async (options) => {
+  const provider = options.provider.toLowerCase();
+  if (!PROVIDERS.includes(provider)) {
+    console.error(chalk2.red(`Invalid provider: ${options.provider}`));
+    process.exit(1);
+  }
+  try {
+    const deleted = await deleteApiKey(provider);
+    if (deleted) {
+      console.log(chalk2.green(`\u2713 API key for ${getProviderDisplayName(provider)} removed`));
+    } else {
+      console.log(chalk2.yellow(`No API key found for ${getProviderDisplayName(provider)}`));
+    }
+  } catch (error) {
+    console.error(chalk2.red("Failed to remove API key"));
+    process.exit(1);
+  }
+});
+authCommand.command("status").description("Show which providers have API keys configured").action(async () => {
+  try {
+    const providers = await listProviders();
+    console.log(chalk2.bold("\nAPI Key Status:\n"));
+    for (const { provider, hasKey } of providers) {
+      const status = hasKey ? chalk2.green("\u2713 configured") : chalk2.gray("\u25CB not set");
+      console.log(`  ${getProviderDisplayName(provider).padEnd(20)} ${status}`);
+    }
+    console.log(
+      chalk2.gray("\nKeys can also be set via environment variables:")
+    );
+    console.log(chalk2.gray("  GUT_GEMINI_API_KEY, GUT_OPENAI_API_KEY, GUT_ANTHROPIC_API_KEY\n"));
+  } catch (error) {
+    console.error(chalk2.red("Failed to check status"));
+    process.exit(1);
+  }
+});
+
+// src/commands/ai-commit.ts
+import { Command as Command3 } from "commander";
+import chalk3 from "chalk";
+import ora2 from "ora";
+import { simpleGit as simpleGit2 } from "simple-git";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+
+// src/lib/ai.ts
+import { generateText, generateObject } from "ai";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { z } from "zod";
+var DEFAULT_MODELS = {
+  gemini: "gemini-2.0-flash",
+  openai: "gpt-4o-mini",
+  anthropic: "claude-sonnet-4-20250514"
+};
+async function getModel(options) {
+  const apiKey = await getApiKey(options.provider);
+  if (!apiKey) {
+    throw new Error(
+      `No API key found for ${options.provider}. Run: gut auth login --provider ${options.provider}`
+    );
+  }
+  const modelName = options.model || DEFAULT_MODELS[options.provider];
+  switch (options.provider) {
+    case "gemini": {
+      const google = createGoogleGenerativeAI({ apiKey });
+      return google(modelName);
+    }
+    case "openai": {
+      const openai = createOpenAI({ apiKey });
+      return openai(modelName);
+    }
+    case "anthropic": {
+      const anthropic = createAnthropic({ apiKey });
+      return anthropic(modelName);
+    }
+  }
+}
+async function generateCommitMessage(diff, options, convention) {
+  const model = await getModel(options);
+  const conventionInstructions = convention ? `
+IMPORTANT: Follow this project's commit message convention:
+
+--- CONVENTION START ---
+${convention}
+--- CONVENTION END ---
+` : `
+Rules:
+- Use format: <type>(<scope>): <description>
+- Types: feat, fix, docs, style, refactor, perf, test, chore, build, ci
+- Scope is optional but helpful
+- Description should be lowercase, imperative mood, no period at end
+- Keep the first line under 72 characters
+- If changes are complex, add a blank line and bullet points for details`;
+  const prompt = `You are an expert at writing git commit messages.
+
+Analyze the following git diff and generate a concise, meaningful commit message.
+${conventionInstructions}
+
+Git diff:
+\`\`\`
+${diff.slice(0, 8e3)}
+\`\`\`
+
+Respond with ONLY the commit message, nothing else.`;
+  const result = await generateText({
+    model,
+    prompt,
+    maxTokens: 500
+  });
+  return result.text.trim();
+}
+async function generatePRDescription(context, options) {
+  const model = await getModel(options);
+  const templateInstructions = context.template ? `
+IMPORTANT: The repository has a PR template. You MUST fill in this template structure:
+
+--- PR TEMPLATE START ---
+${context.template}
+--- PR TEMPLATE END ---
+
+Fill in each section of the template based on the changes. Keep the template structure intact.
+Replace placeholder text and fill in the sections appropriately.` : `
+Rules for description:
+- Description should have:
+  - ## Summary section with 2-3 bullet points
+  - ## Changes section listing key modifications
+  - ## Test Plan section (suggest what to test)`;
+  const prompt = `You are an expert at writing pull request descriptions.
+
+Generate a clear and informative PR title and description based on the following information.
+
+Branch: ${context.currentBranch} -> ${context.baseBranch}
+
+Commits:
+${context.commits.map((c) => `- ${c}`).join("\n")}
+
+Diff summary (truncated):
+\`\`\`
+${context.diff.slice(0, 6e3)}
+\`\`\`
+${templateInstructions}
+
+Rules for title:
+- Title should be concise (under 72 chars), start with a verb
+
+Respond in JSON format:
+{
+  "title": "...",
+  "body": "..."
+}`;
+  const result = await generateText({
+    model,
+    prompt,
+    maxTokens: 2e3
+  });
+  try {
+    const cleaned = result.text.replace(/```json\n?|\n?```/g, "").trim();
+    return JSON.parse(cleaned);
+  } catch {
+    return {
+      title: context.currentBranch.replace(/[-_]/g, " "),
+      body: result.text
+    };
+  }
+}
+var CodeReviewSchema = z.object({
+  summary: z.string().describe("Brief overall assessment"),
+  issues: z.array(
+    z.object({
+      severity: z.enum(["critical", "warning", "suggestion"]),
+      file: z.string(),
+      line: z.number().optional(),
+      message: z.string(),
+      suggestion: z.string().optional()
+    })
+  ),
+  positives: z.array(z.string()).describe("Good practices observed")
+});
+var DiffSummarySchema = z.object({
+  summary: z.string().describe("Brief one-line summary of what changed"),
+  changes: z.array(
+    z.object({
+      file: z.string(),
+      description: z.string().describe("What changed in this file")
+    })
+  ),
+  impact: z.string().describe("What impact these changes have on the codebase"),
+  notes: z.array(z.string()).optional().describe("Any important notes or considerations")
+});
+async function generateDiffSummary(diff, options) {
+  const model = await getModel(options);
+  const result = await generateObject({
+    model,
+    schema: DiffSummarySchema,
+    prompt: `You are an expert at explaining code changes in a clear and concise way.
+
+Analyze the following git diff and provide a human-friendly summary.
+
+Focus on:
+- What was changed and why it might have been changed
+- The purpose and impact of the changes
+- Any notable patterns or refactoring
+
+Git diff:
+\`\`\`
+${diff.slice(0, 1e4)}
+\`\`\`
+
+Explain the changes in plain language that any developer can understand.`
+  });
+  return result.object;
+}
+async function generateCodeReview(diff, options) {
+  const model = await getModel(options);
+  const result = await generateObject({
+    model,
+    schema: CodeReviewSchema,
+    prompt: `You are an expert code reviewer. Analyze the following git diff and provide a structured review.
+
+Focus on:
+- Bugs and potential issues
+- Security vulnerabilities
+- Performance concerns
+- Code style and best practices
+- Suggestions for improvement
+
+Git diff:
+\`\`\`
+${diff.slice(0, 1e4)}
+\`\`\`
+
+Be constructive and specific. Include line numbers when possible.`
+  });
+  return result.object;
+}
+var ChangelogSchema = z.object({
+  version: z.string().optional().describe("Version string if detected"),
+  date: z.string().describe("Release date in YYYY-MM-DD format"),
+  sections: z.array(
+    z.object({
+      type: z.string().describe("Section type (Added, Changed, Fixed, Removed, etc.)"),
+      items: z.array(z.string()).describe("List of changes in this section")
+    })
+  ),
+  summary: z.string().optional().describe("Brief summary of this release")
+});
+async function generateChangelog(context, options) {
+  const model = await getModel(options);
+  const templateInstructions = context.template ? `
+IMPORTANT: Follow this project's changelog format:
+
+--- CHANGELOG TEMPLATE START ---
+${context.template.slice(0, 2e3)}
+--- CHANGELOG TEMPLATE END ---
+
+Match the style, sections, and formatting of the existing changelog.` : `
+Use Keep a Changelog format (https://keepachangelog.com/):
+- Group changes by: Added, Changed, Deprecated, Removed, Fixed, Security
+- Each item should be a concise description of the change
+- Use past tense`;
+  const commitList = context.commits.map((c) => `- ${c.hash.slice(0, 7)} ${c.message} (${c.author})`).join("\n");
+  const result = await generateObject({
+    model,
+    schema: ChangelogSchema,
+    prompt: `You are an expert at writing release notes and changelogs.
+
+Generate a changelog entry for changes from ${context.fromRef} to ${context.toRef}.
+
+Commits:
+${commitList}
+
+Diff summary (truncated):
+\`\`\`
+${context.diff.slice(0, 8e3)}
+\`\`\`
+${templateInstructions}
+
+Focus on:
+- User-facing changes and improvements
+- Bug fixes and their impact
+- Breaking changes (highlight these)
+- Group related changes together
+- Write for end users, not developers (unless it's a library)`
+  });
+  return result.object;
+}
+var ConflictResolutionSchema = z.object({
+  resolvedContent: z.string().describe("The resolved file content"),
+  explanation: z.string().describe("Brief explanation of how the conflict was resolved"),
+  strategy: z.enum(["ours", "theirs", "combined", "rewritten"]).describe("Resolution strategy used")
+});
+async function resolveConflict(conflictedContent, context, options, strategy) {
+  const model = await getModel(options);
+  const strategyInstructions = strategy ? `
+IMPORTANT: Follow this project's merge strategy:
+
+--- MERGE STRATEGY START ---
+${strategy}
+--- MERGE STRATEGY END ---
+` : `
+Rules:
+- Understand the intent of both changes
+- Combine changes when both are valid additions
+- Choose the more complete/correct version when they conflict
+- Preserve all necessary functionality`;
+  const result = await generateObject({
+    model,
+    schema: ConflictResolutionSchema,
+    prompt: `You are an expert at resolving git merge conflicts intelligently.
+
+Analyze the following conflicted file and provide a resolution.
+
+File: ${context.filename}
+Merging: ${context.theirsRef} into ${context.oursRef}
+
+Conflicted content:
+\`\`\`
+${conflictedContent}
+\`\`\`
+${strategyInstructions}
+
+Additional rules:
+- The resolved content should be valid, working code
+- Do NOT include conflict markers (<<<<<<, =======, >>>>>>)
+
+Provide the fully resolved file content.`
+  });
+  return result.object;
+}
+
+// src/commands/ai-commit.ts
+var CONVENTION_PATHS = [
+  ".gut/commit-convention.md",
+  ".github/commit-convention.md",
+  ".commit-convention.md",
+  "docs/commit-convention.md",
+  ".gitmessage"
+];
+function findCommitConvention(repoRoot) {
+  for (const conventionPath of CONVENTION_PATHS) {
+    const fullPath = join(repoRoot, conventionPath);
+    if (existsSync(fullPath)) {
+      return readFileSync(fullPath, "utf-8");
+    }
+  }
+  return null;
+}
+var aiCommitCommand = new Command3("ai-commit").alias("commit").description("Generate a commit message using AI").option("-p, --provider <provider>", "AI provider (gemini, openai, anthropic)", "gemini").option("-m, --model <model>", "Model to use (provider-specific)").option("-c, --commit", "Automatically commit with the generated message").option("-a, --all", "Force stage all changes (default: auto-stage if nothing staged)").action(async (options) => {
+  const git = simpleGit2();
+  const repoRoot = await git.revparse(["--show-toplevel"]).catch(() => process.cwd());
+  const isRepo = await git.checkIsRepo();
+  if (!isRepo) {
+    console.error(chalk3.red("Error: Not a git repository"));
+    process.exit(1);
+  }
+  const provider = options.provider.toLowerCase();
+  if (options.all) {
+    await git.add("-A");
+  }
+  let diff = await git.diff(["--cached"]);
+  if (!diff.trim()) {
+    const unstaged = await git.diff();
+    if (!unstaged.trim()) {
+      console.error(chalk3.yellow("No changes to commit."));
+      process.exit(1);
+    }
+    console.log(chalk3.gray("No staged changes, staging all changes..."));
+    await git.add("-A");
+    diff = await git.diff(["--cached"]);
+  }
+  const convention = findCommitConvention(repoRoot.trim());
+  if (convention) {
+    console.log(chalk3.gray("Using commit convention from project..."));
+  }
+  const spinner = ora2("Generating commit message...").start();
+  try {
+    const message = await generateCommitMessage(
+      diff,
+      { provider, model: options.model },
+      convention || void 0
+    );
+    spinner.stop();
+    console.log(chalk3.bold("\nGenerated commit message:\n"));
+    console.log(chalk3.green(`  ${message.split("\n")[0]}`));
+    if (message.includes("\n")) {
+      const details = message.split("\n").slice(1).join("\n");
+      console.log(chalk3.gray(details.split("\n").map((l) => `  ${l}`).join("\n")));
+    }
+    console.log();
+    if (options.commit) {
+      await git.commit(message);
+      console.log(chalk3.green("\u2713 Committed successfully"));
+    } else {
+      const readline = await import("readline");
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      const answer = await new Promise((resolve) => {
+        rl.question(chalk3.cyan("Commit with this message? (y/N/e to edit) "), resolve);
+      });
+      rl.close();
+      if (answer.toLowerCase() === "y") {
+        await git.commit(message);
+        console.log(chalk3.green("\u2713 Committed successfully"));
+      } else if (answer.toLowerCase() === "e") {
+        console.log(chalk3.gray("Opening editor..."));
+        const { execSync: execSync2 } = await import("child_process");
+        const editor = process.env.EDITOR || process.env.VISUAL || "vi";
+        const fs2 = await import("fs");
+        const os = await import("os");
+        const path2 = await import("path");
+        const tmpFile = path2.join(os.tmpdir(), "gut-commit-msg.txt");
+        fs2.writeFileSync(tmpFile, message);
+        execSync2(`${editor} "${tmpFile}"`, { stdio: "inherit" });
+        const editedMessage = fs2.readFileSync(tmpFile, "utf-8").trim();
+        fs2.unlinkSync(tmpFile);
+        if (editedMessage) {
+          await git.commit(editedMessage);
+          console.log(chalk3.green("\u2713 Committed successfully"));
+        } else {
+          console.log(chalk3.yellow("Commit cancelled (empty message)"));
+        }
+      } else {
+        console.log(chalk3.gray("Commit cancelled"));
+        console.log(chalk3.gray("\nTo commit manually:"));
+        console.log(chalk3.gray(`  git commit -m "${message.split("\n")[0]}"`));
+      }
+    }
+  } catch (error) {
+    spinner.fail("Failed to generate commit message");
+    console.error(chalk3.red(error instanceof Error ? error.message : "Unknown error"));
+    process.exit(1);
+  }
+});
+
+// src/commands/ai-pr.ts
+import { Command as Command4 } from "commander";
+import chalk4 from "chalk";
+import ora3 from "ora";
+import { simpleGit as simpleGit3 } from "simple-git";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
+var PR_TEMPLATE_PATHS = [
+  ".gut/pr-template.md",
+  ".github/pull_request_template.md",
+  ".github/PULL_REQUEST_TEMPLATE.md",
+  "pull_request_template.md",
+  "PULL_REQUEST_TEMPLATE.md",
+  "docs/pull_request_template.md"
+];
+function findPRTemplate(repoRoot) {
+  for (const templatePath of PR_TEMPLATE_PATHS) {
+    const fullPath = join2(repoRoot, templatePath);
+    if (existsSync2(fullPath)) {
+      return readFileSync2(fullPath, "utf-8");
+    }
+  }
+  return null;
+}
+var aiPrCommand = new Command4("ai-pr").alias("pr").description("Generate a pull request title and description using AI").option("-p, --provider <provider>", "AI provider (gemini, openai, anthropic)", "gemini").option("-m, --model <model>", "Model to use (provider-specific)").option("-b, --base <branch>", "Base branch to compare against (default: main or master)").option("--create", "Create the PR using gh CLI").option("--copy", "Copy the description to clipboard").action(async (options) => {
+  const git = simpleGit3();
+  const isRepo = await git.checkIsRepo();
+  if (!isRepo) {
+    console.error(chalk4.red("Error: Not a git repository"));
+    process.exit(1);
+  }
+  const provider = options.provider.toLowerCase();
+  const spinner = ora3("Analyzing branch...").start();
+  try {
+    const branchInfo = await git.branch();
+    const currentBranch = branchInfo.current;
+    let baseBranch = options.base;
+    if (!baseBranch) {
+      if (branchInfo.all.includes("main")) {
+        baseBranch = "main";
+      } else if (branchInfo.all.includes("master")) {
+        baseBranch = "master";
+      } else {
+        baseBranch = "main";
+      }
+    }
+    if (currentBranch === baseBranch) {
+      spinner.fail(`Already on ${baseBranch} branch`);
+      process.exit(1);
+    }
+    spinner.text = `Comparing ${currentBranch} to ${baseBranch}...`;
+    const log = await git.log({ from: baseBranch, to: currentBranch });
+    const commits = log.all.map((c) => c.message.split("\n")[0]);
+    if (commits.length === 0) {
+      spinner.fail("No commits found between branches");
+      process.exit(1);
+    }
+    const diff = await git.diff([`${baseBranch}...${currentBranch}`]);
+    const repoRoot = await git.revparse(["--show-toplevel"]);
+    const template = findPRTemplate(repoRoot.trim());
+    if (template) {
+      spinner.text = "Found PR template, generating description...";
+    } else {
+      spinner.text = "Generating PR description...";
+    }
+    const { title, body } = await generatePRDescription(
+      {
+        baseBranch,
+        currentBranch,
+        commits,
+        diff,
+        template: template || void 0
+      },
+      {
+        provider,
+        model: options.model
+      }
+    );
+    spinner.stop();
+    console.log(chalk4.bold("\n\u{1F4DD} Generated PR:\n"));
+    console.log(chalk4.cyan("Title:"), chalk4.white(title));
+    console.log(chalk4.cyan("\nDescription:"));
+    console.log(chalk4.gray("\u2500".repeat(50)));
+    console.log(body);
+    console.log(chalk4.gray("\u2500".repeat(50)));
+    if (options.copy) {
+      try {
+        const { execSync: execSync2 } = await import("child_process");
+        const fullText = `${title}
+
+${body}`;
+        execSync2("pbcopy", { input: fullText });
+        console.log(chalk4.green("\n\u2713 Copied to clipboard"));
+      } catch {
+        console.log(chalk4.yellow("\n\u26A0 Could not copy to clipboard"));
+      }
+    }
+    if (options.create) {
+      const readline = await import("readline");
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      const answer = await new Promise((resolve) => {
+        rl.question(chalk4.cyan("\nCreate PR with this description? (y/N) "), resolve);
+      });
+      rl.close();
+      if (answer.toLowerCase() === "y") {
+        const createSpinner = ora3("Creating PR...").start();
+        try {
+          const { execSync: execSync2 } = await import("child_process");
+          const escapedTitle = title.replace(/"/g, '\\"');
+          const escapedBody = body.replace(/"/g, '\\"');
+          execSync2(
+            `gh pr create --title "${escapedTitle}" --body "${escapedBody}" --base ${baseBranch}`,
+            { stdio: "pipe" }
+          );
+          createSpinner.succeed("PR created successfully!");
+        } catch (error) {
+          createSpinner.fail("Failed to create PR");
+          console.error(chalk4.gray("Make sure gh CLI is installed and authenticated"));
+        }
+      }
+    }
+    if (!options.copy && !options.create) {
+      console.log(chalk4.gray("\nOptions:"));
+      console.log(chalk4.gray("  --copy    Copy to clipboard"));
+      console.log(chalk4.gray("  --create  Create PR with gh CLI"));
+    }
+  } catch (error) {
+    spinner.fail("Failed to generate PR description");
+    console.error(chalk4.red(error instanceof Error ? error.message : "Unknown error"));
+    process.exit(1);
+  }
+});
+
+// src/commands/ai-review.ts
+import { Command as Command5 } from "commander";
+import chalk5 from "chalk";
+import ora4 from "ora";
+import { simpleGit as simpleGit4 } from "simple-git";
+import { execSync } from "child_process";
+async function getPRDiff(prNumber) {
+  try {
+    const diff = execSync(`gh pr diff ${prNumber}`, { encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 });
+    const prJsonStr = execSync(`gh pr view ${prNumber} --json number,title,author,url`, { encoding: "utf-8" });
+    const prJson = JSON.parse(prJsonStr);
+    return {
+      diff,
+      prInfo: {
+        number: prJson.number,
+        title: prJson.title,
+        author: prJson.author.login,
+        url: prJson.url
+      }
+    };
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("gh: command not found")) {
+      throw new Error("GitHub CLI (gh) is not installed. Install it from https://cli.github.com/");
+    }
+    throw error;
+  }
+}
+var aiReviewCommand = new Command5("ai-review").alias("review").description("Get an AI code review of your changes or a GitHub PR").argument("[pr-number]", "GitHub PR number to review").option("-p, --provider <provider>", "AI provider (gemini, openai, anthropic)", "gemini").option("-m, --model <model>", "Model to use (provider-specific)").option("-s, --staged", "Review only staged changes").option("-c, --commit <hash>", "Review a specific commit").option("--json", "Output as JSON").action(async (prNumber, options) => {
+  const git = simpleGit4();
+  const isRepo = await git.checkIsRepo();
+  if (!isRepo) {
+    console.error(chalk5.red("Error: Not a git repository"));
+    process.exit(1);
+  }
+  const provider = options.provider.toLowerCase();
+  const spinner = ora4("Getting diff...").start();
+  try {
+    let diff;
+    let prInfo = null;
+    if (prNumber) {
+      spinner.text = `Fetching PR #${prNumber}...`;
+      const result = await getPRDiff(prNumber);
+      diff = result.diff;
+      prInfo = result.prInfo;
+      spinner.text = `Reviewing PR #${prNumber}...`;
+    } else if (options.commit) {
+      diff = await git.diff([`${options.commit}^`, options.commit]);
+      spinner.text = `Reviewing commit ${options.commit.slice(0, 7)}...`;
+    } else if (options.staged) {
+      diff = await git.diff(["--cached"]);
+      spinner.text = "Reviewing staged changes...";
+    } else {
+      diff = await git.diff();
+      const stagedDiff = await git.diff(["--cached"]);
+      diff = stagedDiff + "\n" + diff;
+      spinner.text = "Reviewing uncommitted changes...";
+    }
+    if (!diff.trim()) {
+      spinner.info("No changes to review");
+      process.exit(0);
+    }
+    spinner.text = "AI is reviewing your code...";
+    const review = await generateCodeReview(diff, {
+      provider,
+      model: options.model
+    });
+    spinner.stop();
+    if (options.json) {
+      console.log(JSON.stringify({ prInfo, review }, null, 2));
+      return;
+    }
+    if (prInfo) {
+      console.log(chalk5.bold(`
+\u{1F517} PR #${prInfo.number}: ${prInfo.title}`));
+      console.log(chalk5.gray(`   by ${prInfo.author} - ${prInfo.url}`));
+    }
+    printReview(review);
+  } catch (error) {
+    spinner.fail("Failed to generate review");
+    console.error(chalk5.red(error instanceof Error ? error.message : "Unknown error"));
+    process.exit(1);
+  }
+});
+function printReview(review) {
+  console.log(chalk5.bold("\n\u{1F50D} AI Code Review\n"));
+  console.log(chalk5.cyan("Summary:"));
+  console.log(`  ${review.summary}
+`);
+  if (review.issues.length > 0) {
+    console.log(chalk5.cyan("Issues Found:"));
+    for (const issue of review.issues) {
+      const severityColors = {
+        critical: chalk5.red,
+        warning: chalk5.yellow,
+        suggestion: chalk5.blue
+      };
+      const severityIcons = {
+        critical: "\u{1F534}",
+        warning: "\u{1F7E1}",
+        suggestion: "\u{1F4A1}"
+      };
+      const color = severityColors[issue.severity];
+      const icon = severityIcons[issue.severity];
+      console.log(`
+  ${icon} ${color(issue.severity.toUpperCase())}`);
+      console.log(`     ${chalk5.gray("File:")} ${issue.file}${issue.line ? `:${issue.line}` : ""}`);
+      console.log(`     ${issue.message}`);
+      if (issue.suggestion) {
+        console.log(`     ${chalk5.green("\u2192")} ${issue.suggestion}`);
+      }
+    }
+  } else {
+    console.log(chalk5.green("  \u2713 No issues found!\n"));
+  }
+  if (review.positives.length > 0) {
+    console.log(chalk5.cyan("\nGood Practices:"));
+    for (const positive of review.positives) {
+      console.log(`  ${chalk5.green("\u2713")} ${positive}`);
+    }
+  }
+  const criticalCount = review.issues.filter((i) => i.severity === "critical").length;
+  const warningCount = review.issues.filter((i) => i.severity === "warning").length;
+  const suggestionCount = review.issues.filter((i) => i.severity === "suggestion").length;
+  console.log(chalk5.gray("\n\u2500".repeat(40)));
+  console.log(
+    `  ${chalk5.red(criticalCount)} critical  ${chalk5.yellow(warningCount)} warnings  ${chalk5.blue(suggestionCount)} suggestions`
+  );
+  console.log();
+}
+
+// src/commands/ai-diff.ts
+import { Command as Command6 } from "commander";
+import chalk6 from "chalk";
+import ora5 from "ora";
+import { simpleGit as simpleGit5 } from "simple-git";
+var aiDiffCommand = new Command6("ai-diff").alias("diff").description("Get an AI-powered explanation of your changes").option("-p, --provider <provider>", "AI provider (gemini, openai, anthropic)", "gemini").option("-m, --model <model>", "Model to use (provider-specific)").option("-s, --staged", "Explain only staged changes").option("-c, --commit <hash>", "Explain a specific commit").option("--json", "Output as JSON").action(async (options) => {
+  const git = simpleGit5();
+  const isRepo = await git.checkIsRepo();
+  if (!isRepo) {
+    console.error(chalk6.red("Error: Not a git repository"));
+    process.exit(1);
+  }
+  const provider = options.provider.toLowerCase();
+  const spinner = ora5("Getting diff...").start();
+  try {
+    let diff;
+    if (options.commit) {
+      diff = await git.diff([`${options.commit}^`, options.commit]);
+      spinner.text = `Analyzing commit ${options.commit.slice(0, 7)}...`;
+    } else if (options.staged) {
+      diff = await git.diff(["--cached"]);
+      spinner.text = "Analyzing staged changes...";
+    } else {
+      diff = await git.diff();
+      const stagedDiff = await git.diff(["--cached"]);
+      diff = stagedDiff + "\n" + diff;
+      spinner.text = "Analyzing uncommitted changes...";
+    }
+    if (!diff.trim()) {
+      spinner.info("No changes to analyze");
+      process.exit(0);
+    }
+    spinner.text = "AI is analyzing your changes...";
+    const summary = await generateDiffSummary(diff, {
+      provider,
+      model: options.model
+    });
+    spinner.stop();
+    if (options.json) {
+      console.log(JSON.stringify(summary, null, 2));
+      return;
+    }
+    printSummary(summary);
+  } catch (error) {
+    spinner.fail("Failed to analyze diff");
+    console.error(chalk6.red(error instanceof Error ? error.message : "Unknown error"));
+    process.exit(1);
+  }
+});
+function printSummary(summary) {
+  console.log(chalk6.bold("\n\u{1F4DD} Change Summary\n"));
+  console.log(chalk6.cyan("Overview:"));
+  console.log(`  ${summary.summary}
+`);
+  if (summary.changes.length > 0) {
+    console.log(chalk6.cyan("Changes:"));
+    for (const change of summary.changes) {
+      console.log(`  ${chalk6.yellow(change.file)}`);
+      console.log(`    ${chalk6.gray(change.description)}`);
+    }
+    console.log();
+  }
+  console.log(chalk6.cyan("Impact:"));
+  console.log(`  ${summary.impact}
+`);
+  if (summary.notes && summary.notes.length > 0) {
+    console.log(chalk6.cyan("Notes:"));
+    for (const note of summary.notes) {
+      console.log(`  ${chalk6.gray("\u2022")} ${note}`);
+    }
+    console.log();
+  }
+}
+
+// src/commands/ai-merge.ts
+import { Command as Command7 } from "commander";
+import chalk7 from "chalk";
+import ora6 from "ora";
+import { simpleGit as simpleGit6 } from "simple-git";
+import * as fs from "fs";
+import * as path from "path";
+var MERGE_STRATEGY_PATHS = [
+  ".gut/merge-strategy.md",
+  ".github/merge-strategy.md"
+];
+function findMergeStrategy(repoRoot) {
+  for (const strategyPath of MERGE_STRATEGY_PATHS) {
+    const fullPath = path.join(repoRoot, strategyPath);
+    if (fs.existsSync(fullPath)) {
+      return fs.readFileSync(fullPath, "utf-8");
+    }
+  }
+  return null;
+}
+var aiMergeCommand = new Command7("ai-merge").alias("merge").description("Merge a branch with AI-powered conflict resolution").argument("<branch>", "Branch to merge").option("-p, --provider <provider>", "AI provider (gemini, openai, anthropic)", "gemini").option("-m, --model <model>", "Model to use (provider-specific)").option("--no-commit", "Do not auto-commit after resolving").action(async (branch, options) => {
+  const git = simpleGit6();
+  const isRepo = await git.checkIsRepo();
+  if (!isRepo) {
+    console.error(chalk7.red("Error: Not a git repository"));
+    process.exit(1);
+  }
+  const provider = options.provider.toLowerCase();
+  const status = await git.status();
+  if (status.modified.length > 0 || status.staged.length > 0) {
+    console.error(chalk7.red("Error: Working directory has uncommitted changes"));
+    console.log(chalk7.gray("Please commit or stash your changes first"));
+    process.exit(1);
+  }
+  const branchInfo = await git.branch();
+  const currentBranch = branchInfo.current;
+  console.log(chalk7.bold(`
+Merging ${chalk7.cyan(branch)} into ${chalk7.cyan(currentBranch)}...
+`));
+  try {
+    await git.merge([branch]);
+    console.log(chalk7.green("\u2713 Merged successfully (no conflicts)"));
+    return;
+  } catch (error) {
+  }
+  const conflictStatus = await git.status();
+  const conflictedFiles = conflictStatus.conflicted;
+  if (conflictedFiles.length === 0) {
+    console.error(chalk7.red("Merge failed for unknown reason"));
+    await git.merge(["--abort"]);
+    process.exit(1);
+  }
+  console.log(chalk7.yellow(`\u26A0 ${conflictedFiles.length} conflict(s) detected
+`));
+  const spinner = ora6();
+  const rootDir = await git.revparse(["--show-toplevel"]);
+  const strategy = findMergeStrategy(rootDir.trim());
+  if (strategy) {
+    console.log(chalk7.gray("Using merge strategy from project...\n"));
+  }
+  for (const file of conflictedFiles) {
+    const filePath = path.join(rootDir.trim(), file);
+    const content = fs.readFileSync(filePath, "utf-8");
+    console.log(chalk7.bold(`
+\u{1F4C4} ${file}`));
+    const conflictMatch = content.match(/<<<<<<< HEAD[\s\S]*?>>>>>>>.+/g);
+    if (conflictMatch) {
+      console.log(chalk7.gray("\u2500".repeat(50)));
+      console.log(chalk7.gray(conflictMatch[0].slice(0, 500)));
+      if (conflictMatch[0].length > 500) console.log(chalk7.gray("..."));
+      console.log(chalk7.gray("\u2500".repeat(50)));
+    }
+    spinner.start("AI is analyzing conflict...");
+    try {
+      const resolution = await resolveConflict(content, {
+        filename: file,
+        oursRef: currentBranch,
+        theirsRef: branch
+      }, { provider, model: options.model }, strategy || void 0);
+      spinner.stop();
+      console.log(chalk7.cyan("\n\u{1F916} AI suggests:"));
+      console.log(chalk7.gray("\u2500".repeat(50)));
+      const preview = resolution.resolvedContent.slice(0, 800);
+      console.log(preview);
+      if (resolution.resolvedContent.length > 800) console.log(chalk7.gray("..."));
+      console.log(chalk7.gray("\u2500".repeat(50)));
+      console.log(chalk7.gray(`Strategy: ${resolution.strategy}`));
+      console.log(chalk7.gray(`Reason: ${resolution.explanation}`));
+      const readline = await import("readline");
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      const answer = await new Promise((resolve) => {
+        rl.question(chalk7.cyan("\nAccept this resolution? (y/n/s to skip) "), resolve);
+      });
+      rl.close();
+      if (answer.toLowerCase() === "y") {
+        fs.writeFileSync(filePath, resolution.resolvedContent);
+        await git.add(file);
+        console.log(chalk7.green(`\u2713 Resolved ${file}`));
+      } else if (answer.toLowerCase() === "s") {
+        console.log(chalk7.yellow(`\u23ED Skipped ${file}`));
+      } else {
+        console.log(chalk7.yellow(`\u2717 Rejected - resolve manually: ${file}`));
+      }
+    } catch (error) {
+      spinner.fail("AI resolution failed");
+      console.error(chalk7.red(error instanceof Error ? error.message : "Unknown error"));
+      console.log(chalk7.yellow(`Please resolve manually: ${file}`));
+    }
+  }
+  const finalStatus = await git.status();
+  if (finalStatus.conflicted.length > 0) {
+    console.log(chalk7.yellow(`
+\u26A0 ${finalStatus.conflicted.length} conflict(s) remaining`));
+    console.log(chalk7.gray("Resolve manually and run: git add <files> && git commit"));
+  } else if (options.commit !== false) {
+    await git.commit(`Merge branch '${branch}' into ${currentBranch}`);
+    console.log(chalk7.green("\n\u2713 All conflicts resolved and committed"));
+  } else {
+    console.log(chalk7.green("\n\u2713 All conflicts resolved"));
+    console.log(chalk7.gray("Run: git commit"));
+  }
+});
+
+// src/commands/changelog.ts
+import { Command as Command8 } from "commander";
+import chalk8 from "chalk";
+import ora7 from "ora";
+import { simpleGit as simpleGit7 } from "simple-git";
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import { join as join4 } from "path";
+var CHANGELOG_PATHS = [
+  ".gut/changelog-template.md",
+  ".gut/CHANGELOG.md",
+  "CHANGELOG.md",
+  "HISTORY.md",
+  "CHANGES.md",
+  "changelog.md",
+  "docs/CHANGELOG.md"
+];
+function findChangelog(repoRoot) {
+  for (const changelogPath of CHANGELOG_PATHS) {
+    const fullPath = join4(repoRoot, changelogPath);
+    if (existsSync4(fullPath)) {
+      return readFileSync4(fullPath, "utf-8");
+    }
+  }
+  return null;
+}
+function formatChangelog(changelog) {
+  const lines = [];
+  const header = changelog.version ? `## [${changelog.version}] - ${changelog.date}` : `## ${changelog.date}`;
+  lines.push(header);
+  lines.push("");
+  if (changelog.summary) {
+    lines.push(changelog.summary);
+    lines.push("");
+  }
+  for (const section of changelog.sections) {
+    if (section.items.length > 0) {
+      lines.push(`### ${section.type}`);
+      for (const item of section.items) {
+        lines.push(`- ${item}`);
+      }
+      lines.push("");
+    }
+  }
+  return lines.join("\n");
+}
+var changelogCommand = new Command8("changelog").description("Generate a changelog from commits between refs").argument("[from]", "Starting ref (tag, branch, commit)", "HEAD~10").argument("[to]", "Ending ref", "HEAD").option("-p, --provider <provider>", "AI provider (gemini, openai, anthropic)", "gemini").option("-m, --model <model>", "Model to use (provider-specific)").option("-t, --tag <tag>", "Generate changelog since this tag").option("--json", "Output as JSON").action(async (from, to, options) => {
+  const git = simpleGit7();
+  const isRepo = await git.checkIsRepo();
+  if (!isRepo) {
+    console.error(chalk8.red("Error: Not a git repository"));
+    process.exit(1);
+  }
+  const provider = options.provider.toLowerCase();
+  const spinner = ora7("Analyzing commits...").start();
+  try {
+    let fromRef = from;
+    let toRef = to;
+    if (options.tag) {
+      fromRef = options.tag;
+      toRef = "HEAD";
+    }
+    const log = await git.log({ from: fromRef, to: toRef });
+    if (log.all.length === 0) {
+      spinner.info("No commits found in range");
+      process.exit(0);
+    }
+    spinner.text = `Found ${log.all.length} commits, generating changelog...`;
+    const commits = log.all.map((c) => ({
+      hash: c.hash,
+      message: c.message,
+      author: c.author_name,
+      date: c.date
+    }));
+    const diff = await git.diff([`${fromRef}...${toRef}`]);
+    const repoRoot = await git.revparse(["--show-toplevel"]);
+    const existingChangelog = findChangelog(repoRoot.trim());
+    let template;
+    if (existingChangelog) {
+      const firstEntryMatch = existingChangelog.match(/## \[?[\d.]+\]?[\s\S]*?(?=## \[?[\d.]+\]?|$)/);
+      if (firstEntryMatch) {
+        template = firstEntryMatch[0].slice(0, 1500);
+      }
+      spinner.text = "Found existing changelog, matching style...";
+    }
+    const changelog = await generateChangelog(
+      {
+        commits,
+        diff,
+        fromRef,
+        toRef,
+        template
+      },
+      { provider, model: options.model }
+    );
+    spinner.stop();
+    if (options.json) {
+      console.log(JSON.stringify(changelog, null, 2));
+      return;
+    }
+    console.log(chalk8.bold("\n\u{1F4CB} Generated Changelog\n"));
+    console.log(chalk8.gray("\u2500".repeat(50)));
+    console.log(formatChangelog(changelog));
+    console.log(chalk8.gray("\u2500".repeat(50)));
+    console.log(chalk8.gray(`
+Range: ${fromRef}..${toRef} (${commits.length} commits)`));
+    if (existingChangelog) {
+      console.log(chalk8.gray("Style matched from existing CHANGELOG.md"));
+    }
+  } catch (error) {
+    spinner.fail("Failed to generate changelog");
+    console.error(chalk8.red(error instanceof Error ? error.message : "Unknown error"));
+    process.exit(1);
+  }
+});
+
+// src/index.ts
+var program = new Command9();
+program.name("gut").description("Git Utility Tool - AI-powered git commands").version("0.1.0");
+program.addCommand(cleanupCommand);
+program.addCommand(authCommand);
+program.addCommand(aiCommitCommand);
+program.addCommand(aiPrCommand);
+program.addCommand(aiReviewCommand);
+program.addCommand(aiDiffCommand);
+program.addCommand(aiMergeCommand);
+program.addCommand(changelogCommand);
+program.parse();
+//# sourceMappingURL=index.js.map