gut-cli 0.1.13 → 0.1.15

package/.gut/gitignore.md

@@ -0,0 +1,42 @@
+You are an expert at creating .gitignore files.
+
+Analyze the following project structure and configuration files to generate an appropriate .gitignore file.
+
+## Project Structure
+
+```
+{{files}}
+```
+
+{{#configFiles}}
+## Detected Config Files
+
+{{configFiles}}
+{{/configFiles}}
+
+{{#existingGitignore}}
+## Existing .gitignore
+
+```
+{{existingGitignore}}
+```
+{{/existingGitignore}}
+
+## Rules
+
+- Detect the language/framework being used (Node.js, Python, Go, Rust, Java, Ruby, PHP, .NET, etc.)
+- Include common ignore patterns for the detected stack
+- Include OS-specific files (.DS_Store, Thumbs.db, etc.)
+- Include IDE/editor files (.vscode/, .idea/, *.swp, etc.)
+- Include environment files (.env, .env.local, etc.)
+- Include build outputs and dependencies based on detected stack
+- Include log files and temporary files
+- Do NOT ignore files that should be tracked (source code, configs, etc.)
+- Keep the file organized with comments for each section
+{{#existingGitignore}}
+- Preserve any project-specific patterns from the existing .gitignore
+{{/existingGitignore}}
+
+## Output
+
+Respond with ONLY the .gitignore content, nothing else. Include section comments for clarity.

package/README.md

@@ -35,6 +35,7 @@ npm install -g gut-cli
 | `gut config` | Manage configuration (language, etc.) |
 | `gut lang` | Set or show output language |
 | `gut init` | Initialize .gut/ templates in your project |
+| `gut gitignore` | Generate .gitignore from codebase |
 
 ### `gut commit`
 
@@ -389,6 +390,32 @@ gut init --provider openai
 
 Templates are automatically translated to your configured language (set via `gut lang`).
 
+### `gut gitignore`
+
+Generate a .gitignore file by analyzing your project structure.
+
+```bash
+# Generate .gitignore (prompts before overwriting)
+gut gitignore
+
+# Auto-overwrite without confirmation
+gut gitignore --yes
+
+# Print to stdout instead of file
+gut gitignore --stdout
+
+# Use specific provider
+gut gitignore --provider openai
+```
+
+**How it works:**
+- Scans your project structure (files and directories)
+- Detects config files (package.json, Cargo.toml, go.mod, pyproject.toml, etc.)
+- Identifies the language/framework stack
+- Generates appropriate ignore patterns
+
+**Template Support**: Create `.gut/gitignore.md` to customize the generation prompt.
+
 ### `gut cleanup`
 
 Delete merged branches safely.
@@ -457,6 +484,7 @@ gut looks for template files in your repository's `.gut/` folder. Each template
 | `.gut/changelog.md` | Changelog format |
 | `.gut/stash.md` | Stash name prompt |
 | `.gut/summary.md` | Work summary format |
+| `.gut/gitignore.md` | Gitignore generation prompt |
 | `.github/pull_request_template.md` | GitHub PR template (prioritized over `.gut/pr.md`) |
 
 ## Development

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command18 } from "commander";
+import { Command as Command19 } from "commander";
 
 // src/commands/cleanup.ts
 import { Command } from "commander";
@@ -114,6 +114,9 @@ async function getKeytar() {
   }
 }
 async function saveApiKey(provider, apiKey) {
+  if (provider === "ollama") {
+    throw new Error("Ollama does not require an API key");
+  }
   const keytar = await getKeytar();
   if (!keytar) {
     throw new Error("Keychain not available. Set environment variable instead.");
@@ -121,6 +124,9 @@ async function saveApiKey(provider, apiKey) {
   await keytar.setPassword(SERVICE_NAME, PROVIDER_KEY_MAP[provider], apiKey);
 }
 async function getApiKey(provider) {
+  if (provider === "ollama") {
+    return null;
+  }
   const envKey = process.env[ENV_VAR_MAP[provider]];
   if (envKey) return envKey;
   const fallbackKey = process.env[FALLBACK_ENV_MAP[provider]];
@@ -130,6 +136,9 @@ async function getApiKey(provider) {
   return keytar.getPassword(SERVICE_NAME, PROVIDER_KEY_MAP[provider]);
 }
 async function deleteApiKey(provider) {
+  if (provider === "ollama") {
+    throw new Error("Ollama does not use an API key");
+  }
   const keytar = await getKeytar();
   if (!keytar) {
     throw new Error("Keychain not available.");
@@ -137,20 +146,22 @@ async function deleteApiKey(provider) {
   return keytar.deletePassword(SERVICE_NAME, PROVIDER_KEY_MAP[provider]);
 }
 async function listProviders() {
-  const providers = ["gemini", "openai", "anthropic"];
+  const apiKeyProviders = ["gemini", "openai", "anthropic"];
   const results = await Promise.all(
-    providers.map(async (provider) => ({
+    apiKeyProviders.map(async (provider) => ({
       provider,
       hasKey: !!await getApiKey(provider)
     }))
   );
+  results.push({ provider: "ollama", hasKey: true });
   return results;
 }
 function getProviderDisplayName(provider) {
   const names = {
     gemini: "Google Gemini",
     openai: "OpenAI",
-    anthropic: "Anthropic Claude"
+    anthropic: "Anthropic Claude",
+    ollama: "Ollama (Local)"
   };
   return names[provider];
 }
@@ -270,6 +281,7 @@ import { generateText, generateObject } from "ai";
 import { createGoogleGenerativeAI } from "@ai-sdk/google";
 import { createOpenAI } from "@ai-sdk/openai";
 import { createAnthropic } from "@ai-sdk/anthropic";
+import { createOllama } from "ollama-ai-provider";
 import { z } from "zod";
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 import { join as join2, dirname } from "path";
@@ -410,29 +422,45 @@ function applyTemplate(userTemplate, templateName, variables) {
 var DEFAULT_MODELS = {
   gemini: "gemini-2.0-flash",
   openai: "gpt-4o-mini",
-  anthropic: "claude-sonnet-4-20250514"
+  anthropic: "claude-sonnet-4-20250514",
+  ollama: "llama3.2"
 };
 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];
+  async function resolveApiKey() {
+    if (options.apiKey) return options.apiKey;
+    return getApiKey(options.provider);
+  }
+  if (options.provider !== "ollama") {
+    const apiKey = await resolveApiKey();
+    if (!apiKey) {
+      throw new Error(
+        `No API key found for ${options.provider}. Run: gut auth login --provider ${options.provider}`
+      );
+    }
+  }
   switch (options.provider) {
     case "gemini": {
+      const apiKey = await resolveApiKey();
       const google = createGoogleGenerativeAI({ apiKey });
       return google(modelName);
     }
     case "openai": {
+      const apiKey = await resolveApiKey();
       const openai = createOpenAI({ apiKey });
       return openai(modelName);
     }
     case "anthropic": {
+      const apiKey = await resolveApiKey();
       const anthropic = createAnthropic({ apiKey });
       return anthropic(modelName);
     }
+    case "ollama": {
+      const ollama = createOllama({
+        baseURL: options.ollamaBaseUrl || "http://localhost:11434/api"
+      });
+      return ollama(modelName);
+    }
   }
 }
 async function generateCommitMessage(diff, options, template) {
@@ -614,11 +642,12 @@ async function searchCommits(query, commits, options, maxResults = 5, template)
     schema: CommitSearchSchema,
     prompt
   });
-  const enrichedMatches = result.object.matches.map((match) => {
+  const enrichedMatches = result.object.matches.map((match, index) => {
     const commit = commits.find((c) => c.hash.startsWith(match.hash));
     if (!commit) {
       return null;
     }
+    const relevance = index === 0 ? "high" : index < 3 ? "medium" : "low";
     return {
       hash: commit.hash,
       message: commit.message,
@@ -626,15 +655,9 @@ async function searchCommits(query, commits, options, maxResults = 5, template)
       email: commit.email,
       date: commit.date,
       reason: match.reason,
-      relevance: "high"
-      // First results are most relevant
+      relevance
     };
   }).filter((m) => m !== null);
-  enrichedMatches.forEach((match, index) => {
-    if (index === 0) match.relevance = "high";
-    else if (index < 3) match.relevance = "medium";
-    else match.relevance = "low";
-  });
   return {
     matches: enrichedMatches,
     summary: result.object.summary
@@ -735,6 +758,20 @@ async function resolveConflict(conflictedContent, context, options, template) {
   });
   return result.object;
 }
+async function generateGitignore(context, options, template) {
+  const model = await getModel(options);
+  const prompt = applyTemplate(template, "gitignore", {
+    files: context.files,
+    configFiles: context.configFiles,
+    existingGitignore: context.existingGitignore
+  });
+  const result = await generateText({
+    model,
+    prompt,
+    maxTokens: 2e3
+  });
+  return result.text.trim();
+}
 
 // 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) => {
@@ -2477,8 +2514,181 @@ var initCommand = new Command17("init").description("Initialize .gut/ templates
   console.log(chalk18.gray("\nYou can now customize these templates for your project."));
 });
 
+// src/commands/gitignore.ts
+import { Command as Command18 } from "commander";
+import chalk19 from "chalk";
+import ora15 from "ora";
+import { simpleGit as simpleGit15 } from "simple-git";
+import { readdirSync as readdirSync2, readFileSync as readFileSync7, existsSync as existsSync6, writeFileSync as writeFileSync4 } from "fs";
+import { join as join6 } from "path";
+var CONFIG_FILES = [
+  // JavaScript/TypeScript
+  "package.json",
+  "tsconfig.json",
+  "vite.config.ts",
+  "vite.config.js",
+  "next.config.js",
+  "next.config.mjs",
+  "nuxt.config.ts",
+  "astro.config.mjs",
+  // Python
+  "pyproject.toml",
+  "setup.py",
+  "requirements.txt",
+  "Pipfile",
+  "poetry.lock",
+  // Go
+  "go.mod",
+  "go.sum",
+  // Rust
+  "Cargo.toml",
+  "Cargo.lock",
+  // Java/Kotlin
+  "pom.xml",
+  "build.gradle",
+  "build.gradle.kts",
+  // Ruby
+  "Gemfile",
+  "Gemfile.lock",
+  // PHP
+  "composer.json",
+  "composer.lock",
+  // .NET
+  "*.csproj",
+  "*.fsproj",
+  "*.sln",
+  // Elixir
+  "mix.exs",
+  // Dart/Flutter
+  "pubspec.yaml",
+  // Swift
+  "Package.swift"
+];
+function getFiles(dir, maxDepth = 3, currentDepth = 0) {
+  if (currentDepth >= maxDepth) return [];
+  const files = [];
+  try {
+    const entries = readdirSync2(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "vendor" || entry.name === "target" || entry.name === "__pycache__" || entry.name === "venv" || entry.name === ".venv") {
+        continue;
+      }
+      const fullPath = join6(dir, entry.name);
+      if (entry.isDirectory()) {
+        files.push(entry.name + "/");
+        const subFiles = getFiles(fullPath, maxDepth, currentDepth + 1);
+        files.push(...subFiles.map((f) => entry.name + "/" + f));
+      } else {
+        files.push(entry.name);
+      }
+    }
+  } catch {
+  }
+  return files;
+}
+function findConfigFiles(repoRoot) {
+  const found = /* @__PURE__ */ new Map();
+  for (const configFile of CONFIG_FILES) {
+    if (configFile.includes("*")) {
+      const ext = configFile.replace("*", "");
+      try {
+        const entries = readdirSync2(repoRoot);
+        for (const entry of entries) {
+          if (entry.endsWith(ext)) {
+            const content = readFileSync7(join6(repoRoot, entry), "utf-8");
+            found.set(entry, content.slice(0, 2e3));
+          }
+        }
+      } catch {
+      }
+    } else {
+      const filePath = join6(repoRoot, configFile);
+      if (existsSync6(filePath)) {
+        try {
+          const content = readFileSync7(filePath, "utf-8");
+          found.set(configFile, content.slice(0, 2e3));
+        } catch {
+        }
+      }
+    }
+  }
+  return found;
+}
+var gitignoreCommand = new Command18("gitignore").description("Generate .gitignore from current codebase").option("-p, --provider <provider>", "AI provider (gemini, openai, anthropic)", "gemini").option("-m, --model <model>", "Model to use (provider-specific)").option("-o, --output <file>", "Output file (default: .gitignore)", ".gitignore").option("--stdout", "Print to stdout instead of file").option("-y, --yes", "Overwrite existing .gitignore without confirmation").action(async (options) => {
+  const git = simpleGit15();
+  const repoRoot = await git.revparse(["--show-toplevel"]).catch(() => process.cwd());
+  const root = repoRoot.trim();
+  const provider = options.provider.toLowerCase();
+  const template = findTemplate(root, "gitignore");
+  if (template) {
+    console.log(chalk19.gray("Using template from project..."));
+  }
+  const spinner = ora15("Analyzing project structure...").start();
+  const files = getFiles(root);
+  const configFiles = findConfigFiles(root);
+  const gitignorePath = join6(root, options.output);
+  let existingGitignore;
+  if (existsSync6(gitignorePath)) {
+    existingGitignore = readFileSync7(gitignorePath, "utf-8");
+  }
+  let configFilesStr = "";
+  if (configFiles.size > 0) {
+    const entries = [];
+    for (const [name, content] of configFiles) {
+      entries.push(`### ${name}
+\`\`\`
+${content}
+\`\`\``);
+    }
+    configFilesStr = entries.join("\n\n");
+  }
+  spinner.text = "Generating .gitignore...";
+  try {
+    const gitignoreContent = await generateGitignore(
+      {
+        files: files.slice(0, 200).join("\n"),
+        configFiles: configFilesStr,
+        existingGitignore
+      },
+      { provider, model: options.model },
+      template || void 0
+    );
+    spinner.stop();
+    if (options.stdout) {
+      console.log(gitignoreContent);
+      return;
+    }
+    console.log(chalk19.bold("\nGenerated .gitignore:\n"));
+    console.log(chalk19.gray("\u2500".repeat(50)));
+    console.log(gitignoreContent);
+    console.log(chalk19.gray("\u2500".repeat(50)));
+    console.log();
+    if (existsSync6(gitignorePath) && !options.yes) {
+      const readline = await import("readline");
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      const answer = await new Promise((resolve) => {
+        rl.question(chalk19.cyan(`${options.output} already exists. Overwrite? (y/N) `), resolve);
+      });
+      rl.close();
+      if (answer.toLowerCase() !== "y") {
+        console.log(chalk19.gray("Aborted."));
+        return;
+      }
+    }
+    writeFileSync4(gitignorePath, gitignoreContent);
+    console.log(chalk19.green(`\u2713 Wrote ${options.output}`));
+  } catch (error) {
+    spinner.fail("Failed to generate .gitignore");
+    console.error(chalk19.red(error instanceof Error ? error.message : "Unknown error"));
+    process.exit(1);
+  }
+});
+
 // src/index.ts
-var program = new Command18();
+var program = new Command19();
 program.name("gut").description("Git Utility Tool - AI-powered git commands").version("0.1.0");
 program.addCommand(cleanupCommand);
 program.addCommand(authCommand);
@@ -2497,5 +2707,6 @@ program.addCommand(summaryCommand);
 program.addCommand(configCommand);
 program.addCommand(langCommand);
 program.addCommand(initCommand);
+program.addCommand(gitignoreCommand);
 program.parse();
 //# sourceMappingURL=index.js.map