gut-cli 0.1.13 → 0.1.14

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";
@@ -735,6 +735,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 +2491,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 +2684,6 @@ program.addCommand(summaryCommand);
 program.addCommand(configCommand);
 program.addCommand(langCommand);
 program.addCommand(initCommand);
+program.addCommand(gitignoreCommand);
 program.parse();
 //# sourceMappingURL=index.js.map