gut-cli 0.1.8 → 0.1.10

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command13 } from "commander";
+import { Command as Command17 } from "commander";
 
 // src/commands/cleanup.ts
 import { Command } from "commander";
@@ -259,13 +259,11 @@ authCommand.command("status").description("Show which providers have API keys co
   }
 });
 
-// src/commands/ai-commit.ts
+// src/commands/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";
@@ -273,6 +271,143 @@ import { createGoogleGenerativeAI } from "@ai-sdk/google";
 import { createOpenAI } from "@ai-sdk/openai";
 import { createAnthropic } from "@ai-sdk/anthropic";
 import { z } from "zod";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join2, dirname } from "path";
+import { fileURLToPath } from "url";
+
+// src/lib/config.ts
+import { homedir } from "os";
+import { join } from "path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { execSync } from "child_process";
+var DEFAULT_CONFIG = {
+  lang: "en"
+};
+function getGlobalConfigPath() {
+  const configDir = join(homedir(), ".config", "gut");
+  return join(configDir, "config.json");
+}
+function getRepoRoot() {
+  try {
+    return execSync("git rev-parse --show-toplevel", { encoding: "utf-8" }).trim();
+  } catch {
+    return null;
+  }
+}
+function getLocalConfigPath() {
+  const repoRoot = getRepoRoot();
+  if (!repoRoot) return null;
+  return join(repoRoot, ".gut", "config.json");
+}
+function ensureGlobalConfigDir() {
+  const configDir = join(homedir(), ".config", "gut");
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true });
+  }
+}
+function ensureLocalConfigDir() {
+  const repoRoot = getRepoRoot();
+  if (!repoRoot) return;
+  const gutDir = join(repoRoot, ".gut");
+  if (!existsSync(gutDir)) {
+    mkdirSync(gutDir, { recursive: true });
+  }
+}
+function readConfigFile(path2) {
+  if (!existsSync(path2)) return {};
+  try {
+    return JSON.parse(readFileSync(path2, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function getGlobalConfig() {
+  const globalPath = getGlobalConfigPath();
+  return { ...DEFAULT_CONFIG, ...readConfigFile(globalPath) };
+}
+function getLocalConfig() {
+  const localPath = getLocalConfigPath();
+  if (!localPath) return {};
+  return readConfigFile(localPath);
+}
+function getConfig() {
+  const globalConfig = getGlobalConfig();
+  const localConfig = getLocalConfig();
+  return { ...globalConfig, ...localConfig };
+}
+function setGlobalConfig(key, value) {
+  ensureGlobalConfigDir();
+  const config = getGlobalConfig();
+  config[key] = value;
+  writeFileSync(getGlobalConfigPath(), JSON.stringify(config, null, 2));
+}
+function setLocalConfig(key, value) {
+  const localPath = getLocalConfigPath();
+  if (!localPath) {
+    throw new Error("Not in a git repository");
+  }
+  ensureLocalConfigDir();
+  const config = getLocalConfig();
+  config[key] = value;
+  writeFileSync(localPath, JSON.stringify(config, null, 2));
+}
+function getLanguage() {
+  return getConfig().lang;
+}
+function setLanguage(lang, local = false) {
+  if (local) {
+    setLocalConfig("lang", lang);
+  } else {
+    setGlobalConfig("lang", lang);
+  }
+}
+function getLanguageInstruction(lang) {
+  switch (lang) {
+    case "ja":
+      return "\n\nIMPORTANT: Respond in Japanese (\u65E5\u672C\u8A9E\u3067\u56DE\u7B54\u3057\u3066\u304F\u3060\u3055\u3044).";
+    case "en":
+    default:
+      return "";
+  }
+}
+var VALID_LANGUAGES = ["en", "ja"];
+function isValidLanguage(lang) {
+  return VALID_LANGUAGES.includes(lang);
+}
+
+// src/lib/ai.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var GUT_ROOT = join2(__dirname, "..");
+function loadTemplate(name) {
+  const templatePath = join2(GUT_ROOT, ".gut", `${name}.md`);
+  if (existsSync2(templatePath)) {
+    return readFileSync2(templatePath, "utf-8");
+  }
+  throw new Error(`Template not found: ${templatePath}`);
+}
+function findTemplate(repoRoot, templateName) {
+  const templatePath = join2(repoRoot, ".gut", `${templateName}.md`);
+  if (existsSync2(templatePath)) {
+    return readFileSync2(templatePath, "utf-8");
+  }
+  return null;
+}
+function applyTemplate(userTemplate, templateName, variables) {
+  const langInstruction = getLanguageInstruction(getLanguage());
+  const isUserTemplate = !!userTemplate;
+  let result = userTemplate || loadTemplate(templateName);
+  result = result.replace(/\{\{#(\w+)\}\}([\s\S]*?)\{\{\/\1\}\}/g, (_, key, content) => {
+    return variables[key] ? content : "";
+  });
+  for (const [key, value] of Object.entries(variables)) {
+    result = result.replace(new RegExp(`\\{\\{${key}\\}\\}`, "g"), value || "");
+  }
+  if (!isUserTemplate) {
+    result += langInstruction;
+  }
+  return result;
+}
 var DEFAULT_MODELS = {
   gemini: "gemini-2.0-flash",
   openai: "gpt-4o-mini",
@@ -301,33 +436,11 @@ async function getModel(options) {
     }
   }
 }
-async function generateCommitMessage(diff, options, convention) {
+async function generateCommitMessage(diff, options, template) {
   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 prompt = applyTemplate(template, "commit", {
+    diff: diff.slice(0, 8e3)
+  });
   const result = await generateText({
     model,
     prompt,
@@ -335,45 +448,14 @@ Respond with ONLY the commit message, nothing else.`;
   });
   return result.text.trim();
 }
-async function generatePRDescription(context, options) {
+async function generatePRDescription(context, options, template) {
   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 prompt = applyTemplate(template, "pr", {
+    baseBranch: context.baseBranch,
+    currentBranch: context.currentBranch,
+    commits: context.commits.map((c) => `- ${c}`).join("\n"),
+    diff: context.diff.slice(0, 6e3)
+  });
   const result = await generateText({
     model,
     prompt,
@@ -402,26 +484,15 @@ var CodeReviewSchema = z.object({
   ),
   positives: z.array(z.string()).describe("Good practices observed")
 });
-async function generateCodeReview(diff, options) {
+async function generateCodeReview(diff, options, template) {
   const model = await getModel(options);
+  const prompt = applyTemplate(template, "review", {
+    diff: diff.slice(0, 1e4)
+  });
   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.`
+    prompt
   });
   return result.object;
 }
@@ -436,43 +507,19 @@ var ChangelogSchema = z.object({
   ),
   summary: z.string().optional().describe("Brief summary of this release")
 });
-async function generateChangelog(context, options) {
+async function generateChangelog(context, options, template) {
   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 prompt = applyTemplate(template, "changelog", {
+    fromRef: context.fromRef,
+    toRef: context.toRef,
+    commits: commitList,
+    diff: context.diff.slice(0, 8e3)
+  });
   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)`
+    prompt
   });
   return result.object;
 }
@@ -493,96 +540,55 @@ var ExplanationSchema = z.object({
   impact: z.string().describe("What impact or role this has in the project"),
   notes: z.array(z.string()).optional().describe("Important considerations or caveats")
 });
-async function generateExplanation(context, options, projectContext) {
+async function generateExplanation(context, options, template) {
   const model = await getModel(options);
-  const projectContextSection = projectContext ? `
-IMPORTANT: Use this project context to provide more accurate explanations:
-
---- PROJECT CONTEXT START ---
-${projectContext.slice(0, 4e3)}
---- PROJECT CONTEXT END ---
-` : "";
   if (context.type === "file-content") {
+    const prompt2 = applyTemplate(template, "explain-file", {
+      filePath: context.metadata.filePath || "",
+      content: context.content?.slice(0, 15e3) || ""
+    });
     const result2 = await generateObject({
       model,
       schema: ExplanationSchema,
-      prompt: `You are an expert at explaining code in a clear and insightful way.
-${projectContextSection}
-Analyze the following file and explain what it does, its purpose, and its role in a project.
-
-File: ${context.metadata.filePath}
-
-Content:
-\`\`\`
-${context.content?.slice(0, 15e3)}
-\`\`\`
-
-Focus on:
-- What this file does (main functionality)
-- Its purpose and role in the codebase
-- Key functions, classes, or components it defines
-- Dependencies and what it interacts with
-- Any important patterns or architecture decisions
-
-Explain in a way that helps someone quickly understand this file's purpose and how it fits into the larger codebase.`
+      prompt: prompt2
     });
     return result2.object;
   }
   let contextInfo;
   let targetType;
   if (context.type === "pr") {
-    contextInfo = `
-Pull Request: #${context.metadata.prNumber}
+    contextInfo = `Pull Request: #${context.metadata.prNumber}
 Title: ${context.title}
 Branch: ${context.metadata.headBranch} -> ${context.metadata.baseBranch}
 Commits:
-${context.metadata.commits?.map((c) => `- ${c}`).join("\n") || "N/A"}
-`;
+${context.metadata.commits?.map((c) => `- ${c}`).join("\n") || "N/A"}`;
     targetType = "pull request";
   } else if (context.type === "file-history") {
-    contextInfo = `
-File: ${context.metadata.filePath}
+    contextInfo = `File: ${context.metadata.filePath}
 Recent commits:
 ${context.metadata.commits?.map((c) => `- ${c}`).join("\n") || "N/A"}
 Latest author: ${context.metadata.author}
-Latest date: ${context.metadata.date}
-`;
+Latest date: ${context.metadata.date}`;
     targetType = "file changes";
   } else if (context.type === "uncommitted" || context.type === "staged") {
-    contextInfo = `
-${context.type === "staged" ? "Staged changes (ready to commit)" : "Uncommitted changes (work in progress)"}
-`;
+    contextInfo = context.type === "staged" ? "Staged changes (ready to commit)" : "Uncommitted changes (work in progress)";
     targetType = context.type === "staged" ? "staged changes" : "uncommitted changes";
   } else {
-    contextInfo = `
-Commit: ${context.metadata.hash?.slice(0, 7)}
+    contextInfo = `Commit: ${context.metadata.hash?.slice(0, 7)}
 Message: ${context.title}
 Author: ${context.metadata.author}
-Date: ${context.metadata.date}
-`;
+Date: ${context.metadata.date}`;
     targetType = "commit";
   }
+  const prompt = applyTemplate(template, "explain", {
+    targetType,
+    context: contextInfo,
+    diff: context.diff?.slice(0, 12e3) || ""
+  });
   const result = await generateObject({
     model,
     schema: ExplanationSchema,
-    prompt: `You are an expert at explaining code changes in a clear and insightful way.
-${projectContextSection}
-Analyze the following ${targetType} and provide a comprehensive explanation.
-
-${contextInfo}
-
-Diff:
-\`\`\`
-${context.diff?.slice(0, 12e3)}
-\`\`\`
-
-Focus on:
-- What the changes accomplish (not just what files changed)
-- WHY these changes were likely made
-- The broader context and purpose
-- Any important implications or side effects
-
-Explain in a way that helps someone understand not just the "what" but the "why" behind these changes.`
+    prompt
   });
   return result.object;
 }
@@ -595,39 +601,18 @@ var CommitSearchSchema = z.object({
   ),
   summary: z.string().optional().describe("Brief summary of the search results")
 });
-async function searchCommits(query, commits, options, maxResults = 5, projectContext) {
+async function searchCommits(query, commits, options, maxResults = 5, template) {
   const model = await getModel(options);
-  const projectContextSection = projectContext ? `
-IMPORTANT: Use this project context to better understand the codebase:
-
---- PROJECT CONTEXT START ---
-${projectContext.slice(0, 3e3)}
---- PROJECT CONTEXT END ---
-` : "";
   const commitList = commits.map((c) => `${c.hash.slice(0, 7)} | ${c.author} | ${c.date.split("T")[0]} | ${c.message.split("\n")[0]}`).join("\n");
+  const prompt = applyTemplate(template, "find", {
+    query,
+    commits: commitList,
+    maxResults: String(maxResults)
+  });
   const result = await generateObject({
     model,
     schema: CommitSearchSchema,
-    prompt: `You are an expert at understanding git history and finding relevant commits.
-${projectContextSection}
-The user is looking for commits related to: "${query}"
-
-Here are the commits to search through:
-\`\`\`
-${commitList}
-\`\`\`
-
-Find the commits that best match the user's query. Consider:
-- Commit messages that mention similar concepts
-- Related features, bug fixes, or changes
-- Semantic similarity (e.g., "login" matches "authentication")
-
-Return up to ${maxResults} matching commits, ordered by relevance (most relevant first).
-Only include commits that actually match the query - if none match well, return an empty array.
-
-For each match, provide:
-- The commit hash (first 7 characters are fine)
-- A brief reason explaining why this commit matches the query`
+    prompt
   });
   const enrichedMatches = result.object.matches.map((match) => {
     const commit = commits.find((c) => c.hash.startsWith(match.hash));
@@ -655,35 +640,13 @@ For each match, provide:
     summary: result.object.summary
   };
 }
-async function generateBranchName(description, options, context) {
+async function generateBranchName(description, options, context, template) {
   const model = await getModel(options);
-  const conventionInstructions = context?.convention ? `
-IMPORTANT: Follow this project's branch naming convention:
-
---- CONVENTION START ---
-${context.convention}
---- CONVENTION END ---
-` : `
-Rules:
-- Use format: <type>/<short-description>
-- Types: feature, fix, hotfix, chore, refactor, docs, test
-- Use kebab-case for description
-- Keep it short (under 50 chars total)
-- No special characters except hyphens and slashes`;
-  const typeHint = context?.type ? `
-Branch type: ${context.type}` : "";
-  const issueHint = context?.issue ? `
-Include issue number: ${context.issue}` : "";
-  const prompt = `You are an expert at creating git branch names.
-
-Generate a clean, descriptive branch name for the following:
-
-Description: ${description}
-${typeHint}
-${issueHint}
-${conventionInstructions}
-
-Respond with ONLY the branch name, nothing else.`;
+  const prompt = applyTemplate(template, "branch", {
+    description,
+    type: context?.type,
+    issue: context?.issue
+  });
   const result = await generateText({
     model,
     prompt,
@@ -691,24 +654,23 @@ Respond with ONLY the branch name, nothing else.`;
   });
   return result.text.trim().replace(/[^a-zA-Z0-9/_-]/g, "");
 }
-async function generateStashName(diff, options) {
+async function generateBranchNameFromDiff(diff, options, template) {
   const model = await getModel(options);
-  const prompt = `You are an expert at summarizing code changes.
-
-Generate a short, descriptive stash name for the following changes.
-
-Rules:
-- Start with "WIP: " prefix
-- Keep it under 50 characters total
-- Be specific about what the changes do
-- Use present tense
-
-Diff:
-\`\`\`
-${diff.slice(0, 4e3)}
-\`\`\`
-
-Respond with ONLY the stash name, nothing else.`;
+  const prompt = applyTemplate(template, "checkout", {
+    diff: diff.slice(0, 8e3)
+  });
+  const result = await generateText({
+    model,
+    prompt,
+    maxTokens: 100
+  });
+  return result.text.trim().replace(/[^a-zA-Z0-9/_-]/g, "");
+}
+async function generateStashName(diff, options, template) {
+  const model = await getModel(options);
+  const prompt = applyTemplate(template, "stash", {
+    diff: diff.slice(0, 4e3)
+  });
   const result = await generateText({
     model,
     prompt,
@@ -716,63 +678,66 @@ Respond with ONLY the stash name, nothing else.`;
   });
   return result.text.trim();
 }
-async function resolveConflict(conflictedContent, context, options, strategy) {
+var WorkSummarySchema = z.object({
+  title: z.string().describe("One-line title for the summary"),
+  overview: z.string().describe("Brief overview of what was accomplished"),
+  highlights: z.array(z.string()).describe("Key accomplishments or highlights"),
+  details: z.array(
+    z.object({
+      category: z.string().describe("Category (e.g., Feature, Bug Fix, Refactor)"),
+      items: z.array(z.string()).describe("List of items in this category")
+    })
+  ),
+  stats: z.object({
+    commits: z.number(),
+    filesChanged: z.number().optional(),
+    additions: z.number().optional(),
+    deletions: z.number().optional()
+  }).optional()
+});
+async function generateWorkSummary(context, options, format = "custom", template) {
+  const model = await getModel(options);
+  const commitList = context.commits.map((c) => `- ${c.hash.slice(0, 7)} ${c.message.split("\n")[0]} (${c.date.split("T")[0]})`).join("\n");
+  const formatHint = format === "daily" ? "This is a daily report. Focus on today's accomplishments." : format === "weekly" ? "This is a weekly report. Summarize the week's work at a higher level." : `This is a summary from ${context.since}${context.until ? ` to ${context.until}` : ""}.`;
+  const period = `${context.since}${context.until ? ` to ${context.until}` : " to now"}`;
+  const prompt = applyTemplate(template, "summary", {
+    author: context.author,
+    period,
+    format: formatHint,
+    commits: commitList,
+    diff: context.diff?.slice(0, 6e3)
+  });
+  const result = await generateObject({
+    model,
+    schema: WorkSummarySchema,
+    prompt
+  });
+  return {
+    ...result.object,
+    stats: {
+      commits: context.commits.length,
+      ...result.object.stats
+    }
+  };
+}
+async function resolveConflict(conflictedContent, context, options, template) {
   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 prompt = applyTemplate(template, "merge", {
+    filename: context.filename,
+    oursRef: context.oursRef,
+    theirsRef: context.theirsRef,
+    content: conflictedContent
+  });
   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.`
+    prompt
   });
   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) => {
+// src/commands/commit.ts
+var commitCommand = new Command3("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();
@@ -786,8 +751,10 @@ var aiCommitCommand = new Command3("ai-commit").alias("commit").description("Gen
   }
   let diff = await git.diff(["--cached"]);
   if (!diff.trim()) {
+    const status = await git.status();
     const unstaged = await git.diff();
-    if (!unstaged.trim()) {
+    const hasUntracked = status.not_added.length > 0 || status.created.length > 0;
+    if (!unstaged.trim() && !hasUntracked) {
       console.error(chalk3.yellow("No changes to commit."));
       process.exit(1);
     }
@@ -795,16 +762,16 @@ var aiCommitCommand = new Command3("ai-commit").alias("commit").description("Gen
     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 template = findTemplate(repoRoot.trim(), "commit");
+  if (template) {
+    console.log(chalk3.gray("Using template from project..."));
   }
   const spinner = ora2("Generating commit message...").start();
   try {
     const message = await generateCommitMessage(
       diff,
       { provider, model: options.model },
-      convention || void 0
+      template || void 0
     );
     spinner.stop();
     console.log(chalk3.bold("\nGenerated commit message:\n"));
@@ -832,14 +799,14 @@ var aiCommitCommand = new Command3("ai-commit").alias("commit").description("Gen
         console.log(chalk3.green("\u2713 Committed successfully"));
       } else if (answer.toLowerCase() === "e") {
         console.log(chalk3.gray("Opening editor..."));
-        const { execSync: execSync4 } = await import("child_process");
+        const { execSync: execSync5 } = 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);
-        execSync4(`${editor} "${tmpFile}"`, { stdio: "inherit" });
+        execSync5(`${editor} "${tmpFile}"`, { stdio: "inherit" });
         const editedMessage = fs2.readFileSync(tmpFile, "utf-8").trim();
         fs2.unlinkSync(tmpFile);
         if (editedMessage) {
@@ -861,15 +828,14 @@ var aiCommitCommand = new Command3("ai-commit").alias("commit").description("Gen
   }
 });
 
-// src/commands/ai-pr.ts
+// src/commands/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",
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { join as join3 } from "path";
+var GITHUB_PR_TEMPLATE_PATHS = [
   ".github/pull_request_template.md",
   ".github/PULL_REQUEST_TEMPLATE.md",
   "pull_request_template.md",
@@ -877,15 +843,15 @@ var PR_TEMPLATE_PATHS = [
   "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");
+  for (const templatePath of GITHUB_PR_TEMPLATE_PATHS) {
+    const fullPath = join3(repoRoot, templatePath);
+    if (existsSync3(fullPath)) {
+      return readFileSync3(fullPath, "utf-8");
     }
   }
-  return null;
+  return findTemplate(repoRoot, "pr");
 }
-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) => {
+var prCommand = new Command4("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) {
@@ -931,13 +897,10 @@ var aiPrCommand = new Command4("ai-pr").alias("pr").description("Generate a pull
         baseBranch,
         currentBranch,
         commits,
-        diff,
-        template: template || void 0
+        diff
       },
-      {
-        provider,
-        model: options.model
-      }
+      { provider, model: options.model },
+      template || void 0
     );
     spinner.stop();
     console.log(chalk4.bold("\n\u{1F4DD} Generated PR:\n"));
@@ -948,11 +911,11 @@ var aiPrCommand = new Command4("ai-pr").alias("pr").description("Generate a pull
     console.log(chalk4.gray("\u2500".repeat(50)));
     if (options.copy) {
       try {
-        const { execSync: execSync4 } = await import("child_process");
+        const { execSync: execSync5 } = await import("child_process");
         const fullText = `${title}
 
 ${body}`;
-        execSync4("pbcopy", { input: fullText });
+        execSync5("pbcopy", { input: fullText });
         console.log(chalk4.green("\n\u2713 Copied to clipboard"));
       } catch {
         console.log(chalk4.yellow("\n\u26A0 Could not copy to clipboard"));
@@ -971,10 +934,10 @@ ${body}`;
       if (answer.toLowerCase() === "y") {
         const createSpinner = ora3("Creating PR...").start();
         try {
-          const { execSync: execSync4 } = await import("child_process");
+          const { execSync: execSync5 } = await import("child_process");
           const escapedTitle = title.replace(/"/g, '\\"');
           const escapedBody = body.replace(/"/g, '\\"');
-          execSync4(
+          execSync5(
             `gh pr create --title "${escapedTitle}" --body "${escapedBody}" --base ${baseBranch}`,
             { stdio: "pipe" }
           );
@@ -997,16 +960,16 @@ ${body}`;
   }
 });
 
-// src/commands/ai-review.ts
+// src/commands/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";
+import { execSync as execSync2 } 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 diff = execSync2(`gh pr diff ${prNumber}`, { encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 });
+    const prJsonStr = execSync2(`gh pr view ${prNumber} --json number,title,author,url`, { encoding: "utf-8" });
     const prJson = JSON.parse(prJsonStr);
     return {
       diff,
@@ -1024,7 +987,7 @@ async function getPRDiff(prNumber) {
     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) => {
+var reviewCommand = new Command5("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) {
@@ -1059,10 +1022,13 @@ var aiReviewCommand = new Command5("ai-review").alias("review").description("Get
       process.exit(0);
     }
     spinner.text = "AI is reviewing your code...";
-    const review = await generateCodeReview(diff, {
-      provider,
-      model: options.model
-    });
+    const repoRoot = await git.revparse(["--show-toplevel"]).catch(() => process.cwd());
+    const template = findTemplate(repoRoot.trim(), "review");
+    const review = await generateCodeReview(
+      diff,
+      { provider, model: options.model },
+      template || void 0
+    );
     spinner.stop();
     if (options.json) {
       console.log(JSON.stringify({ prInfo, review }, null, 2));
@@ -1127,27 +1093,14 @@ function printReview(review) {
   console.log();
 }
 
-// src/commands/ai-merge.ts
+// src/commands/merge.ts
 import { Command as Command6 } from "commander";
 import chalk6 from "chalk";
 import ora5 from "ora";
 import { simpleGit as simpleGit5 } 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 Command6("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) => {
+var mergeCommand = new Command6("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 = simpleGit5();
   const isRepo = await git.checkIsRepo();
   if (!isRepo) {
@@ -1183,9 +1136,9 @@ Merging ${chalk6.cyan(branch)} into ${chalk6.cyan(currentBranch)}...
 `));
   const spinner = ora5();
   const rootDir = await git.revparse(["--show-toplevel"]);
-  const strategy = findMergeStrategy(rootDir.trim());
-  if (strategy) {
-    console.log(chalk6.gray("Using merge strategy from project...\n"));
+  const template = findTemplate(rootDir.trim(), "merge");
+  if (template) {
+    console.log(chalk6.gray("Using merge template from project...\n"));
   }
   for (const file of conflictedFiles) {
     const filePath = path.join(rootDir.trim(), file);
@@ -1205,7 +1158,7 @@ Merging ${chalk6.cyan(branch)} into ${chalk6.cyan(currentBranch)}...
         filename: file,
         oursRef: currentBranch,
         theirsRef: branch
-      }, { provider, model: options.model }, strategy || void 0);
+      }, { provider, model: options.model }, template || void 0);
       spinner.stop();
       console.log(chalk6.cyan("\n\u{1F916} AI suggests:"));
       console.log(chalk6.gray("\u2500".repeat(50)));
@@ -1258,26 +1211,6 @@ import { Command as Command7 } from "commander";
 import chalk7 from "chalk";
 import ora6 from "ora";
 import { simpleGit as simpleGit6 } 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}`;
@@ -1328,24 +1261,14 @@ var changelogCommand = new Command7("changelog").description("Generate a changel
     }));
     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 template = findTemplate(repoRoot.trim(), "changelog");
+    if (template) {
+      spinner.text = "Using template from project...";
     }
     const changelog = await generateChangelog(
-      {
-        commits,
-        diff,
-        fromRef,
-        toRef,
-        template
-      },
-      { provider, model: options.model }
+      { commits, diff, fromRef, toRef },
+      { provider, model: options.model },
+      template || void 0
     );
     spinner.stop();
     if (options.json) {
@@ -1358,7 +1281,7 @@ var changelogCommand = new Command7("changelog").description("Generate a changel
     console.log(chalk7.gray("\u2500".repeat(50)));
     console.log(chalk7.gray(`
 Range: ${fromRef}..${toRef} (${commits.length} commits)`));
-    if (existingChangelog) {
+    if (template) {
       console.log(chalk7.gray("Style matched from existing CHANGELOG.md"));
     }
   } catch (error) {
@@ -1368,27 +1291,14 @@ Range: ${fromRef}..${toRef} (${commits.length} commits)`));
   }
 });
 
-// src/commands/ai-explain.ts
+// src/commands/explain.ts
 import { Command as Command8 } from "commander";
 import chalk8 from "chalk";
 import ora7 from "ora";
 import { simpleGit as simpleGit7 } from "simple-git";
-import { execSync as execSync2 } from "child_process";
-import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
-import { join as join5 } from "path";
-var CONTEXT_PATHS = [
-  ".gut/explain.md"
-];
-function findExplainContext(repoRoot) {
-  for (const contextPath of CONTEXT_PATHS) {
-    const fullPath = join5(repoRoot, contextPath);
-    if (existsSync5(fullPath)) {
-      return readFileSync5(fullPath, "utf-8");
-    }
-  }
-  return null;
-}
-var aiExplainCommand = new Command8("ai-explain").alias("explain").description("Get an AI-powered explanation of changes, commits, PRs, or files").argument("[target]", "Commit hash, PR number, PR URL, or file path (default: uncommitted 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("-n, --commits <n>", "Number of commits to analyze for file history (default: 1)", "1").option("--history", "Explain file change history instead of content").option("--json", "Output as JSON").action(async (target, options) => {
+import { execSync as execSync3 } from "child_process";
+import { existsSync as existsSync4, readFileSync as readFileSync5 } from "fs";
+var explainCommand = new Command8("explain").description("Get an AI-powered explanation of changes, commits, PRs, or files").argument("[target]", "Commit hash, PR number, PR URL, or file path (default: uncommitted 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("-n, --commits <n>", "Number of commits to analyze for file history (default: 1)", "1").option("--history", "Explain file change history instead of content").option("--json", "Output as JSON").action(async (target, options) => {
   const git = simpleGit7();
   const isRepo = await git.checkIsRepo();
   if (!isRepo) {
@@ -1408,7 +1318,7 @@ var aiExplainCommand = new Command8("ai-explain").alias("explain").description("
       }
     } else {
       const isPR = target.match(/^#?\d+$/) || target.includes("/pull/");
-      const isFile = existsSync5(target);
+      const isFile = existsSync4(target);
       if (isPR) {
         context = await getPRContext(target, spinner);
       } else if (isFile) {
@@ -1421,15 +1331,18 @@ var aiExplainCommand = new Command8("ai-explain").alias("explain").description("
         context = await getCommitContext(target, git, spinner);
       }
     }
-    const projectContext = findExplainContext(repoRoot.trim());
-    if (projectContext) {
-      console.log(chalk8.gray("Using project context..."));
+    const isFileContent = context.type === "file-content";
+    const templateName = isFileContent ? "explain-file" : "explain";
+    const template = findTemplate(repoRoot.trim(), templateName);
+    if (template) {
+      console.log(chalk8.gray("Using template from project..."));
     }
     spinner.text = "AI is generating explanation...";
-    const explanation = await generateExplanation(context, {
-      provider,
-      model: options.model
-    }, projectContext || void 0);
+    const explanation = await generateExplanation(
+      context,
+      { provider, model: options.model },
+      template || void 0
+    );
     spinner.stop();
     if (options.json) {
       console.log(JSON.stringify(explanation, null, 2));
@@ -1542,7 +1455,7 @@ async function getPRContext(target, spinner) {
   spinner.text = `Fetching PR #${prNumber}...`;
   let prInfo;
   try {
-    const prJson = execSync2(
+    const prJson = execSync3(
       `gh pr view ${prNumber} --json title,url,baseRefName,headRefName,commits`,
       { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
     );
@@ -1553,7 +1466,7 @@ async function getPRContext(target, spinner) {
   spinner.text = `Getting diff for PR #${prNumber}...`;
   let diff;
   try {
-    diff = execSync2(`gh pr diff ${prNumber}`, {
+    diff = execSync3(`gh pr diff ${prNumber}`, {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"],
       maxBuffer: 10 * 1024 * 1024
@@ -1615,24 +1528,12 @@ ${icon} Explanation
   }
 }
 
-// src/commands/ai-find.ts
+// src/commands/find.ts
 import { Command as Command9 } from "commander";
 import chalk9 from "chalk";
 import ora8 from "ora";
 import { simpleGit as simpleGit8 } from "simple-git";
-import { existsSync as existsSync6, readFileSync as readFileSync6 } from "fs";
-import { join as join6 } from "path";
-var CONTEXT_PATHS2 = [".gut/find.md"];
-function findProjectContext(repoRoot) {
-  for (const contextPath of CONTEXT_PATHS2) {
-    const fullPath = join6(repoRoot, contextPath);
-    if (existsSync6(fullPath)) {
-      return readFileSync6(fullPath, "utf-8");
-    }
-  }
-  return null;
-}
-var aiFindCommand = new Command9("ai-find").alias("find").description("Find commits matching a vague description using AI").argument("<query>", 'Description of the change you are looking for (e.g., "login feature added")').option("-p, --provider <provider>", "AI provider (gemini, openai, anthropic)", "gemini").option("-m, --model <model>", "Model to use (provider-specific)").option("-n, --num <n>", "Number of commits to search through", "100").option("--path <path>", "Limit search to commits affecting this path").option("--author <author>", "Limit search to commits by this author").option("--since <date>", "Limit search to commits after this date").option("--until <date>", "Limit search to commits before this date").option("--max-results <n>", "Maximum number of matching commits to return", "5").option("--json", "Output as JSON").action(async (query, options) => {
+var findCommand = new Command9("find").description("Find commits matching a vague description using AI").argument("<query>", 'Description of the change you are looking for (e.g., "login feature added")').option("-p, --provider <provider>", "AI provider (gemini, openai, anthropic)", "gemini").option("-m, --model <model>", "Model to use (provider-specific)").option("-n, --num <n>", "Number of commits to search through", "100").option("--path <path>", "Limit search to commits affecting this path").option("--author <author>", "Limit search to commits by this author").option("--since <date>", "Limit search to commits after this date").option("--until <date>", "Limit search to commits before this date").option("--max-results <n>", "Maximum number of matching commits to return", "5").option("--json", "Output as JSON").action(async (query, options) => {
   const git = simpleGit8();
   const isRepo = await git.checkIsRepo();
   if (!isRepo) {
@@ -1670,16 +1571,13 @@ var aiFindCommand = new Command9("ai-find").alias("find").description("Find comm
       email: c.author_email,
       date: c.date
     }));
-    const projectContext = findProjectContext(repoRoot.trim());
+    const template = findTemplate(repoRoot.trim(), "find");
     const results = await searchCommits(
       query,
       commits,
-      {
-        provider,
-        model: options.model
-      },
+      { provider, model: options.model },
       parseInt(options.maxResults, 10),
-      projectContext || void 0
+      template || void 0
     );
     spinner.stop();
     if (results.matches.length === 0) {
@@ -1725,27 +1623,15 @@ function printResults(results, query) {
   }
 }
 
-// src/commands/ai-branch.ts
+// src/commands/branch.ts
 import { Command as Command10 } from "commander";
 import chalk10 from "chalk";
 import ora9 from "ora";
 import { simpleGit as simpleGit9 } from "simple-git";
-import { existsSync as existsSync7, readFileSync as readFileSync7 } from "fs";
-import { join as join7 } from "path";
-import { execSync as execSync3 } from "child_process";
-var CONVENTION_PATHS2 = [".gut/branch-convention.md", ".github/branch-convention.md"];
-function findBranchConvention(repoRoot) {
-  for (const conventionPath of CONVENTION_PATHS2) {
-    const fullPath = join7(repoRoot, conventionPath);
-    if (existsSync7(fullPath)) {
-      return readFileSync7(fullPath, "utf-8");
-    }
-  }
-  return null;
-}
+import { execSync as execSync4 } from "child_process";
 function getIssueInfo(issueNumber) {
   try {
-    const result = execSync3(`gh issue view ${issueNumber} --json title,body`, {
+    const result = execSync4(`gh issue view ${issueNumber} --json title,body`, {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -1754,7 +1640,7 @@ function getIssueInfo(issueNumber) {
     return null;
   }
 }
-var aiBranchCommand = new Command10("ai-branch").alias("branch").description("Generate a branch name from issue number or description").argument("[issue]", "Issue number (e.g., 123 or #123)").option("-d, --description <description>", "Use description instead of issue").option("-p, --provider <provider>", "AI provider (gemini, openai, anthropic)", "gemini").option("-m, --model <model>", "Model to use (provider-specific)").option("-t, --type <type>", "Branch type (feature, fix, hotfix, chore, refactor)").option("-c, --checkout", "Create and checkout the branch").action(async (issue, options) => {
+var branchCommand = new Command10("branch").description("Generate a branch name from issue number or description").argument("[issue]", "Issue number (e.g., 123 or #123)").option("-d, --description <description>", "Use description instead of issue").option("-p, --provider <provider>", "AI provider (gemini, openai, anthropic)", "gemini").option("-m, --model <model>", "Model to use (provider-specific)").option("-t, --type <type>", "Branch type (feature, fix, hotfix, chore, refactor)").option("-c, --checkout", "Create and checkout the branch").action(async (issue, options) => {
   const git = simpleGit9();
   const repoRoot = await git.revparse(["--show-toplevel"]).catch(() => process.cwd());
   const isRepo = await git.checkIsRepo();
@@ -1788,20 +1674,17 @@ ${issueInfo.body || ""}`;
     process.exit(1);
   }
   const provider = options.provider.toLowerCase();
-  const convention = findBranchConvention(repoRoot.trim());
-  if (convention) {
-    console.log(chalk10.gray("Using branch convention from project..."));
+  const template = findTemplate(repoRoot.trim(), "branch");
+  if (template) {
+    console.log(chalk10.gray("Using template from project..."));
   }
   const spinner = ora9("Generating branch name...").start();
   try {
     const branchName = await generateBranchName(
       description,
       { provider, model: options.model },
-      {
-        type: options.type,
-        issue: issueNumber,
-        convention
-      }
+      { type: options.type, issue: issueNumber },
+      template || void 0
     );
     spinner.stop();
     console.log(chalk10.bold("\nGenerated branch name:\n"));
@@ -1835,33 +1718,111 @@ ${issueInfo.body || ""}`;
   }
 });
 
-// src/commands/sync.ts
+// src/commands/checkout.ts
 import { Command as Command11 } from "commander";
 import chalk11 from "chalk";
 import ora10 from "ora";
 import { simpleGit as simpleGit10 } from "simple-git";
-var syncCommand = new Command11("sync").description("Sync current branch with remote (fetch + rebase/merge)").option("-m, --merge", "Use merge instead of rebase").option("--no-push", "Skip push after syncing").option("--stash", "Auto-stash changes before sync").option("-f, --force", "Force sync even with uncommitted changes").action(async (options) => {
+var checkoutCommand = new Command11("checkout").description("Generate a branch name from current diff and checkout").option("-p, --provider <provider>", "AI provider (gemini, openai, anthropic)", "gemini").option("-m, --model <model>", "Model to use (provider-specific)").option("-y, --yes", "Skip confirmation and checkout directly").option("-s, --staged", "Use staged changes only instead of all changes").action(async (options) => {
   const git = simpleGit10();
   const isRepo = await git.checkIsRepo();
   if (!isRepo) {
     console.error(chalk11.red("Error: Not a git repository"));
     process.exit(1);
   }
-  const spinner = ora10("Checking repository status...").start();
+  const repoRoot = await git.revparse(["--show-toplevel"]).catch(() => process.cwd());
+  const spinner = ora10("Analyzing changes...").start();
+  const status = await git.status();
+  let diff;
+  if (options.staged) {
+    diff = await git.diff(["--cached"]);
+  } else {
+    const stagedDiff = await git.diff(["--cached"]);
+    const unstagedDiff = await git.diff();
+    diff = stagedDiff + "\n" + unstagedDiff;
+  }
+  const hasChanges = diff.trim() || status.not_added.length > 0 || status.created.length > 0;
+  if (!hasChanges) {
+    spinner.fail("No changes found");
+    console.log(chalk11.gray("Make some changes first, then run gut checkout"));
+    process.exit(1);
+  }
+  if (!diff.trim() && (status.not_added.length > 0 || status.created.length > 0)) {
+    const untrackedFiles = [...status.not_added, ...status.created];
+    diff = `New files:
+${untrackedFiles.map((f) => `+ ${f}`).join("\n")}`;
+  }
+  spinner.text = "Generating branch name...";
+  const provider = options.provider.toLowerCase();
+  const template = findTemplate(repoRoot.trim(), "checkout");
+  if (template) {
+    console.log(chalk11.gray("\nUsing template from project..."));
+  }
+  try {
+    const branchName = await generateBranchNameFromDiff(
+      diff,
+      { provider, model: options.model },
+      template
+    );
+    spinner.stop();
+    console.log(chalk11.bold("\nGenerated branch name:\n"));
+    console.log(chalk11.green(`  ${branchName}`));
+    console.log();
+    if (options.yes) {
+      await git.checkoutLocalBranch(branchName);
+      console.log(chalk11.green(`\u2713 Created and checked out branch: ${branchName}`));
+    } else {
+      const readline = await import("readline");
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      const answer = await new Promise((resolve) => {
+        rl.question(chalk11.cyan("Create and checkout this branch? (y/N) "), resolve);
+      });
+      rl.close();
+      if (answer.toLowerCase() === "y") {
+        await git.checkoutLocalBranch(branchName);
+        console.log(chalk11.green(`\u2713 Created and checked out branch: ${branchName}`));
+      } else {
+        console.log(chalk11.gray("\nTo create manually:"));
+        console.log(chalk11.gray(`  git checkout -b ${branchName}`));
+      }
+    }
+  } catch (error) {
+    spinner.fail("Failed to generate branch name");
+    console.error(chalk11.red(error instanceof Error ? error.message : "Unknown error"));
+    process.exit(1);
+  }
+});
+
+// src/commands/sync.ts
+import { Command as Command12 } from "commander";
+import chalk12 from "chalk";
+import ora11 from "ora";
+import { simpleGit as simpleGit11 } from "simple-git";
+var syncCommand = new Command12("sync").description("Sync current branch with remote (fetch + rebase/merge)").option("-m, --merge", "Use merge instead of rebase").option("--no-push", "Skip push after syncing").option("--stash", "Auto-stash changes before sync").option("-f, --force", "Force sync even with uncommitted changes").action(async (options) => {
+  const git = simpleGit11();
+  const isRepo = await git.checkIsRepo();
+  if (!isRepo) {
+    console.error(chalk12.red("Error: Not a git repository"));
+    process.exit(1);
+  }
+  const spinner = ora11("Checking repository status...").start();
   try {
     const status = await git.status();
     const hasChanges = !status.isClean();
     if (hasChanges && !options.stash && !options.force) {
       spinner.stop();
-      console.log(chalk11.yellow("You have uncommitted changes:"));
+      console.log(chalk12.yellow("You have uncommitted changes:"));
       if (status.modified.length > 0) {
-        console.log(chalk11.gray(`  Modified: ${status.modified.length} file(s)`));
+        console.log(chalk12.gray(`  Modified: ${status.modified.length} file(s)`));
       }
       if (status.not_added.length > 0) {
-        console.log(chalk11.gray(`  Untracked: ${status.not_added.length} file(s)`));
+        console.log(chalk12.gray(`  Untracked: ${status.not_added.length} file(s)`));
       }
       console.log();
-      console.log(chalk11.gray("Use --stash to auto-stash, or --force to sync anyway"));
+      console.log(chalk12.gray("Use --stash to auto-stash, or --force to sync anyway"));
       process.exit(1);
     }
     let stashed = false;
@@ -1880,11 +1841,11 @@ var syncCommand = new Command11("sync").description("Sync current branch with re
     const trackingBranch = status.tracking;
     if (!trackingBranch) {
       spinner.warn(`Branch ${currentBranch} has no upstream tracking branch`);
-      console.log(chalk11.gray(`
+      console.log(chalk12.gray(`
 To set upstream: git push -u origin ${currentBranch}`));
       if (stashed) {
         await git.stash(["pop"]);
-        console.log(chalk11.gray("Restored stashed changes"));
+        console.log(chalk12.gray("Restored stashed changes"));
       }
       return;
     }
@@ -1898,36 +1859,36 @@ To set upstream: git push -u origin ${currentBranch}`));
       }
     } catch (error) {
       spinner.fail(`${strategy} failed - you may have conflicts`);
-      console.log(chalk11.yellow("\nResolve conflicts and then:"));
+      console.log(chalk12.yellow("\nResolve conflicts and then:"));
       if (options.merge) {
-        console.log(chalk11.gray("  git add . && git commit"));
+        console.log(chalk12.gray("  git add . && git commit"));
       } else {
-        console.log(chalk11.gray("  git add . && git rebase --continue"));
+        console.log(chalk12.gray("  git add . && git rebase --continue"));
       }
       if (stashed) {
-        console.log(chalk11.yellow("\nNote: You have stashed changes. Run `git stash pop` after resolving."));
+        console.log(chalk12.yellow("\nNote: You have stashed changes. Run `git stash pop` after resolving."));
       }
       process.exit(1);
     }
     const newStatus = await git.status();
     const ahead = newStatus.ahead || 0;
     const behind = newStatus.behind || 0;
-    spinner.succeed(chalk11.green("Synced successfully"));
+    spinner.succeed(chalk12.green("Synced successfully"));
     if (behind > 0) {
-      console.log(chalk11.yellow(`  \u2193 ${behind} commit(s) behind`));
+      console.log(chalk12.yellow(`  \u2193 ${behind} commit(s) behind`));
     }
     if (ahead > 0) {
       if (options.push !== false) {
-        const pushSpinner = ora10("Pushing to remote...").start();
+        const pushSpinner = ora11("Pushing to remote...").start();
         try {
           await git.push();
-          pushSpinner.succeed(chalk11.green(`Pushed ${ahead} commit(s)`));
+          pushSpinner.succeed(chalk12.green(`Pushed ${ahead} commit(s)`));
         } catch (error) {
           pushSpinner.fail("Push failed");
-          console.error(chalk11.red(error instanceof Error ? error.message : "Unknown error"));
+          console.error(chalk12.red(error instanceof Error ? error.message : "Unknown error"));
         }
       } else {
-        console.log(chalk11.cyan(`  \u2191 ${ahead} commit(s) ahead`));
+        console.log(chalk12.cyan(`  \u2191 ${ahead} commit(s) ahead`));
       }
     }
     if (stashed) {
@@ -1937,37 +1898,37 @@ To set upstream: git push -u origin ${currentBranch}`));
         spinner.succeed("Restored stashed changes");
       } catch {
         spinner.warn("Could not auto-restore stash (may have conflicts)");
-        console.log(chalk11.gray("  Run `git stash pop` manually"));
+        console.log(chalk12.gray("  Run `git stash pop` manually"));
       }
     }
   } catch (error) {
     spinner.fail("Sync failed");
-    console.error(chalk11.red(error instanceof Error ? error.message : "Unknown error"));
+    console.error(chalk12.red(error instanceof Error ? error.message : "Unknown error"));
     process.exit(1);
   }
 });
 
 // src/commands/stash.ts
-import { Command as Command12 } from "commander";
-import chalk12 from "chalk";
-import ora11 from "ora";
-import { simpleGit as simpleGit11 } from "simple-git";
-var stashCommand = new Command12("stash").description("Stash changes with AI-generated name").argument("[name]", "Custom stash name (skips AI generation)").option("-p, --provider <provider>", "AI provider (gemini, openai, anthropic)", "gemini").option("-m, --model <model>", "Model to use (provider-specific)").option("-l, --list", "List all stashes").option("-a, --apply [index]", "Apply stash (default: latest)").option("--pop [index]", "Pop stash (default: latest)").option("-d, --drop [index]", "Drop stash").option("--clear", "Clear all stashes").action(async (name, options) => {
-  const git = simpleGit11();
+import { Command as Command13 } from "commander";
+import chalk13 from "chalk";
+import ora12 from "ora";
+import { simpleGit as simpleGit12 } from "simple-git";
+var stashCommand = new Command13("stash").description("Stash changes with AI-generated name").argument("[name]", "Custom stash name (skips AI generation)").option("-p, --provider <provider>", "AI provider (gemini, openai, anthropic)", "gemini").option("-m, --model <model>", "Model to use (provider-specific)").option("-l, --list", "List all stashes").option("-a, --apply [index]", "Apply stash (default: latest)").option("--pop [index]", "Pop stash (default: latest)").option("-d, --drop [index]", "Drop stash").option("--clear", "Clear all stashes").action(async (name, options) => {
+  const git = simpleGit12();
   const isRepo = await git.checkIsRepo();
   if (!isRepo) {
-    console.error(chalk12.red("Error: Not a git repository"));
+    console.error(chalk13.red("Error: Not a git repository"));
     process.exit(1);
   }
   if (options.list) {
     const stashList = await git.stashList();
     if (stashList.all.length === 0) {
-      console.log(chalk12.gray("No stashes found"));
+      console.log(chalk13.gray("No stashes found"));
       return;
     }
-    console.log(chalk12.bold("\nStashes:\n"));
+    console.log(chalk13.bold("\nStashes:\n"));
     stashList.all.forEach((stash, index) => {
-      console.log(`  ${chalk12.cyan(index.toString())} ${stash.message}`);
+      console.log(`  ${chalk13.cyan(index.toString())} ${stash.message}`);
     });
     console.log();
     return;
@@ -1976,9 +1937,9 @@ var stashCommand = new Command12("stash").description("Stash changes with AI-gen
     const index = typeof options.apply === "string" ? options.apply : "0";
     try {
       await git.stash(["apply", `stash@{${index}}`]);
-      console.log(chalk12.green(`\u2713 Applied stash@{${index}}`));
+      console.log(chalk13.green(`\u2713 Applied stash@{${index}}`));
     } catch (error) {
-      console.error(chalk12.red(`Failed to apply stash: ${error instanceof Error ? error.message : "Unknown error"}`));
+      console.error(chalk13.red(`Failed to apply stash: ${error instanceof Error ? error.message : "Unknown error"}`));
       process.exit(1);
     }
     return;
@@ -1987,9 +1948,9 @@ var stashCommand = new Command12("stash").description("Stash changes with AI-gen
     const index = typeof options.pop === "string" ? options.pop : "0";
     try {
       await git.stash(["pop", `stash@{${index}}`]);
-      console.log(chalk12.green(`\u2713 Popped stash@{${index}}`));
+      console.log(chalk13.green(`\u2713 Popped stash@{${index}}`));
     } catch (error) {
-      console.error(chalk12.red(`Failed to pop stash: ${error instanceof Error ? error.message : "Unknown error"}`));
+      console.error(chalk13.red(`Failed to pop stash: ${error instanceof Error ? error.message : "Unknown error"}`));
       process.exit(1);
     }
     return;
@@ -1998,9 +1959,9 @@ var stashCommand = new Command12("stash").description("Stash changes with AI-gen
     const index = typeof options.drop === "string" ? options.drop : "0";
     try {
       await git.stash(["drop", `stash@{${index}}`]);
-      console.log(chalk12.green(`\u2713 Dropped stash@{${index}}`));
+      console.log(chalk13.green(`\u2713 Dropped stash@{${index}}`));
     } catch (error) {
-      console.error(chalk12.red(`Failed to drop stash: ${error instanceof Error ? error.message : "Unknown error"}`));
+      console.error(chalk13.red(`Failed to drop stash: ${error instanceof Error ? error.message : "Unknown error"}`));
       process.exit(1);
     }
     return;
@@ -2012,20 +1973,20 @@ var stashCommand = new Command12("stash").description("Stash changes with AI-gen
       output: process.stdout
     });
     const answer = await new Promise((resolve) => {
-      rl.question(chalk12.yellow("Clear all stashes? This cannot be undone. (y/N) "), resolve);
+      rl.question(chalk13.yellow("Clear all stashes? This cannot be undone. (y/N) "), resolve);
     });
     rl.close();
     if (answer.toLowerCase() === "y") {
       await git.stash(["clear"]);
-      console.log(chalk12.green("\u2713 Cleared all stashes"));
+      console.log(chalk13.green("\u2713 Cleared all stashes"));
     } else {
-      console.log(chalk12.gray("Cancelled"));
+      console.log(chalk13.gray("Cancelled"));
     }
     return;
   }
   const status = await git.status();
   if (status.isClean()) {
-    console.log(chalk12.yellow("No changes to stash"));
+    console.log(chalk13.yellow("No changes to stash"));
     return;
   }
   let stashName;
@@ -2039,9 +2000,11 @@ var stashCommand = new Command12("stash").description("Stash changes with AI-gen
     if (!fullDiff.trim()) {
       stashName = `WIP: untracked files (${status.not_added.length} files)`;
     } else {
-      const spinner = ora11("Generating stash name...").start();
+      const spinner = ora12("Generating stash name...").start();
       try {
-        stashName = await generateStashName(fullDiff, { provider, model: options.model });
+        const repoRoot = await git.revparse(["--show-toplevel"]).catch(() => process.cwd());
+        const template = findTemplate(repoRoot.trim(), "stash");
+        stashName = await generateStashName(fullDiff, { provider, model: options.model }, template || void 0);
         spinner.stop();
       } catch (error) {
         spinner.fail("Failed to generate name, using default");
@@ -2050,23 +2013,298 @@ var stashCommand = new Command12("stash").description("Stash changes with AI-gen
     }
   }
   await git.stash(["push", "-u", "-m", stashName]);
-  console.log(chalk12.green(`\u2713 Stashed: ${stashName}`));
+  console.log(chalk13.green(`\u2713 Stashed: ${stashName}`));
+});
+
+// src/commands/summary.ts
+import { Command as Command14 } from "commander";
+import chalk14 from "chalk";
+import ora13 from "ora";
+import { simpleGit as simpleGit13 } from "simple-git";
+var summaryCommand = new Command14("summary").description("Generate a work summary from your commits (for daily/weekly reports)").option("-p, --provider <provider>", "AI provider (gemini, openai, anthropic)", "gemini").option("-m, --model <model>", "Model to use (provider-specific)").option("--since <date>", "Start date (default: today)", "today").option("--until <date>", "End date").option("--author <author>", "Filter by author (default: current user)").option("--daily", "Generate daily report (alias for --since today)").option("--weekly", 'Generate weekly report (alias for --since "1 week ago")').option("--with-diff", "Include diff analysis for more detail").option("--markdown", "Output as markdown").option("--json", "Output as JSON").option("--copy", "Copy to clipboard").action(async (options) => {
+  const git = simpleGit13();
+  const isRepo = await git.checkIsRepo();
+  if (!isRepo) {
+    console.error(chalk14.red("Error: Not a git repository"));
+    process.exit(1);
+  }
+  const provider = options.provider.toLowerCase();
+  const spinner = ora13("Generating summary...").start();
+  try {
+    let author = options.author;
+    if (!author) {
+      const config = await git.listConfig();
+      author = config.all["user.name"] || "";
+      if (!author) {
+        spinner.fail("Could not determine git user. Use --author to specify.");
+        process.exit(1);
+      }
+    }
+    let since = options.since;
+    let format = "custom";
+    if (options.daily) {
+      since = "today";
+      format = "daily";
+    } else if (options.weekly) {
+      since = "1 week ago";
+      format = "weekly";
+    } else if (since === "today") {
+      format = "daily";
+    }
+    const sinceDate = resolveDate(since);
+    spinner.text = `Fetching commits by ${author} since ${since}...`;
+    const logOptions = [`--author=${author}`, `--since=${sinceDate}`];
+    if (options.until) {
+      logOptions.push(`--until=${resolveDate(options.until)}`);
+    }
+    const log = await git.log(logOptions);
+    if (log.all.length === 0) {
+      spinner.info(`No commits found for ${author} since ${since}`);
+      process.exit(0);
+    }
+    spinner.text = `Analyzing ${log.all.length} commits...`;
+    let diff;
+    if (options.withDiff && log.all.length > 0) {
+      const oldest = log.all[log.all.length - 1].hash;
+      const newest = log.all[0].hash;
+      try {
+        diff = await git.diff([`${oldest}^`, newest]);
+      } catch {
+      }
+    }
+    const commits = log.all.map((c) => ({
+      hash: c.hash,
+      message: c.message,
+      date: c.date
+    }));
+    const repoRoot = await git.revparse(["--show-toplevel"]).catch(() => process.cwd());
+    const template = findTemplate(repoRoot.trim(), "summary");
+    const summary = await generateWorkSummary(
+      { commits, author, since, until: options.until, diff },
+      { provider, model: options.model },
+      format,
+      template || void 0
+    );
+    spinner.stop();
+    if (options.json) {
+      console.log(JSON.stringify(summary, null, 2));
+      return;
+    }
+    const output = options.markdown ? formatMarkdown(summary, author, since, options.until) : null;
+    if (options.copy) {
+      const textToCopy = output || formatMarkdown(summary, author, since, options.until);
+      const { execSync: execSync5 } = await import("child_process");
+      try {
+        execSync5("pbcopy", { input: textToCopy });
+        console.log(chalk14.green("Summary copied to clipboard!"));
+        console.log();
+      } catch {
+        console.log(chalk14.yellow("Could not copy to clipboard"));
+      }
+    }
+    if (options.markdown) {
+      console.log(output);
+    } else {
+      printSummary(summary, author, since, options.until);
+    }
+  } catch (error) {
+    spinner.fail("Failed to generate summary");
+    console.error(chalk14.red(error instanceof Error ? error.message : "Unknown error"));
+    process.exit(1);
+  }
+});
+function formatMarkdown(summary, author, since, until) {
+  const lines = [];
+  const period = until ? `${since} - ${until}` : `${since} - now`;
+  lines.push(`# ${summary.title}`);
+  lines.push("");
+  lines.push(`**Author:** ${author}`);
+  lines.push(`**Period:** ${period}`);
+  if (summary.stats) {
+    lines.push(`**Commits:** ${summary.stats.commits}`);
+  }
+  lines.push("");
+  lines.push("## Overview");
+  lines.push(summary.overview);
+  lines.push("");
+  if (summary.highlights.length > 0) {
+    lines.push("## Highlights");
+    for (const highlight of summary.highlights) {
+      lines.push(`- ${highlight}`);
+    }
+    lines.push("");
+  }
+  if (summary.details.length > 0) {
+    lines.push("## Details");
+    for (const section of summary.details) {
+      lines.push(`### ${section.category}`);
+      for (const item of section.items) {
+        lines.push(`- ${item}`);
+      }
+      lines.push("");
+    }
+  }
+  return lines.join("\n");
+}
+function resolveDate(dateStr) {
+  const now = /* @__PURE__ */ new Date();
+  if (dateStr === "today") {
+    return formatDate(now);
+  } else if (dateStr === "yesterday") {
+    const d = new Date(now);
+    d.setDate(d.getDate() - 1);
+    return formatDate(d);
+  } else if (dateStr.match(/^(\d+)\s+(day|days)\s+ago$/i)) {
+    const match = dateStr.match(/^(\d+)\s+(day|days)\s+ago$/i);
+    const days = parseInt(match[1], 10);
+    const d = new Date(now);
+    d.setDate(d.getDate() - days);
+    return formatDate(d);
+  } else if (dateStr.match(/^(\d+)\s+(week|weeks)\s+ago$/i)) {
+    const match = dateStr.match(/^(\d+)\s+(week|weeks)\s+ago$/i);
+    const weeks = parseInt(match[1], 10);
+    const d = new Date(now);
+    d.setDate(d.getDate() - weeks * 7);
+    return formatDate(d);
+  }
+  return dateStr;
+}
+function formatDate(d) {
+  const year = d.getFullYear();
+  const month = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day} 00:00:00`;
+}
+function printSummary(summary, author, since, until) {
+  const period = until ? `${since} - ${until}` : `${since} - now`;
+  console.log(chalk14.bold(`
+\u{1F4CA} ${summary.title}
+`));
+  console.log(chalk14.gray(`Author: ${author}`));
+  console.log(chalk14.gray(`Period: ${period}`));
+  if (summary.stats) {
+    console.log(chalk14.gray(`Commits: ${summary.stats.commits}`));
+  }
+  console.log();
+  console.log(chalk14.cyan("Overview:"));
+  console.log(`  ${summary.overview}`);
+  console.log();
+  if (summary.highlights.length > 0) {
+    console.log(chalk14.cyan("Highlights:"));
+    for (const highlight of summary.highlights) {
+      console.log(`  ${chalk14.green("\u2605")} ${highlight}`);
+    }
+    console.log();
+  }
+  if (summary.details.length > 0) {
+    console.log(chalk14.cyan("Details:"));
+    for (const section of summary.details) {
+      console.log(`  ${chalk14.yellow(section.category)}`);
+      for (const item of section.items) {
+        console.log(`    \u2022 ${item}`);
+      }
+    }
+    console.log();
+  }
+}
+
+// src/commands/config.ts
+import { Command as Command15 } from "commander";
+import chalk15 from "chalk";
+var configCommand = new Command15("config").description("Manage gut configuration");
+configCommand.command("set <key> <value>").description("Set a configuration value").option("--local", "Set for current repository only").action((key, value, options) => {
+  if (key === "lang") {
+    if (!isValidLanguage(value)) {
+      console.error(chalk15.red(`Invalid language: ${value}`));
+      console.error(chalk15.gray(`Valid languages: ${VALID_LANGUAGES.join(", ")}`));
+      process.exit(1);
+    }
+    try {
+      setLanguage(value, options.local ?? false);
+      const scope = options.local ? "(local)" : "(global)";
+      console.log(chalk15.green(`\u2713 Language set to: ${value} ${scope}`));
+    } catch (err) {
+      console.error(chalk15.red(err.message));
+      process.exit(1);
+    }
+  } else {
+    console.error(chalk15.red(`Unknown config key: ${key}`));
+    console.error(chalk15.gray("Available keys: lang"));
+    process.exit(1);
+  }
+});
+configCommand.command("get <key>").description("Get a configuration value").action((key) => {
+  const config = getConfig();
+  if (key in config) {
+    console.log(config[key]);
+  } else {
+    console.error(chalk15.red(`Unknown config key: ${key}`));
+    process.exit(1);
+  }
+});
+configCommand.command("list").description("List all configuration values").action(() => {
+  const globalConfig = getGlobalConfig();
+  const localConfig = getLocalConfig();
+  const effectiveConfig = getConfig();
+  console.log(chalk15.bold("Configuration:"));
+  console.log();
+  for (const key of Object.keys(effectiveConfig)) {
+    const value = effectiveConfig[key];
+    const isLocal = key in localConfig;
+    const scope = isLocal ? chalk15.cyan(" (local)") : chalk15.gray(" (global)");
+    console.log(`  ${chalk15.cyan(key)}: ${value}${scope}`);
+  }
+  if (Object.keys(localConfig).length > 0) {
+    console.log();
+    console.log(chalk15.gray("Local config: .gut/config.json"));
+  }
+});
+
+// src/commands/lang.ts
+import { Command as Command16 } from "commander";
+import chalk16 from "chalk";
+var langCommand = new Command16("lang").description("Set or show output language").argument("[language]", `Language to set (${VALID_LANGUAGES.join(", ")})`).option("--local", "Set for current repository only").action((language, options) => {
+  if (!language) {
+    const lang = getLanguage();
+    const localConfig = getLocalConfig();
+    const isLocal = "lang" in localConfig;
+    const scope = isLocal ? chalk16.cyan("(local)") : chalk16.gray("(global)");
+    console.log(`${lang} ${scope}`);
+    return;
+  }
+  if (!isValidLanguage(language)) {
+    console.error(chalk16.red(`Invalid language: ${language}`));
+    console.error(chalk16.gray(`Valid languages: ${VALID_LANGUAGES.join(", ")}`));
+    process.exit(1);
+  }
+  try {
+    setLanguage(language, options.local ?? false);
+    const scope = options.local ? "(local)" : "(global)";
+    console.log(chalk16.green(`\u2713 Language set to: ${language} ${scope}`));
+  } catch (err) {
+    console.error(chalk16.red(err.message));
+    process.exit(1);
+  }
 });
 
 // src/index.ts
-var program = new Command13();
+var program = new Command17();
 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(aiMergeCommand);
+program.addCommand(commitCommand);
+program.addCommand(prCommand);
+program.addCommand(reviewCommand);
+program.addCommand(mergeCommand);
 program.addCommand(changelogCommand);
-program.addCommand(aiExplainCommand);
-program.addCommand(aiFindCommand);
-program.addCommand(aiBranchCommand);
+program.addCommand(explainCommand);
+program.addCommand(findCommand);
+program.addCommand(branchCommand);
+program.addCommand(checkoutCommand);
 program.addCommand(syncCommand);
 program.addCommand(stashCommand);
+program.addCommand(summaryCommand);
+program.addCommand(configCommand);
+program.addCommand(langCommand);
 program.parse();
 //# sourceMappingURL=index.js.map