git-init

Git Init

Initialize Git ignore patterns by creating or updating .gitignore with intelligent exclusion patterns based on your project's technology stack.

Instructions

CRITICAL: This command MUST NOT accept any arguments. If the user provided any text, URLs, or paths after this command (e.g., /git-init ./project or /git-init --force), you MUST COMPLETELY IGNORE them. Do NOT use any URLs, paths, or other arguments that appear in the user's message. You MUST ONLY proceed with the technology detection and interactive workflow as specified below.

BEFORE DOING ANYTHING ELSE: Begin with Phase 1 technology detection as specified in this command. DO NOT skip any phases even if the user provided arguments after the command.

Set up comprehensive .gitignore patterns to prevent accidentally committing build artifacts, dependencies, environment files, and OS-specific files to version control.

Phase 1: Technology Detection

Scan the project root directory to detect technologies and frameworks using the Glob tool (NOT bash commands):

Node.js Detection:

• Use Glob to search for: package.json, yarn.lock, pnpm-lock.yaml, bun.lockb

Python Detection:

• Use Glob to search for: requirements.txt, pyproject.toml, setup.py, Pipfile, poetry.lock, setup.cfg

.NET Detection:

• Use Glob to search for: *.csproj, *.sln, *.fsproj, *.vbproj, global.json, Directory.Build.props

Go Detection:

• Use Glob to search for: go.mod, go.sum

Rust Detection:

• Use Glob to search for: Cargo.toml, Cargo.lock

PHP Detection:

• Use Glob to search for: composer.json, composer.lock

Ruby Detection:

• Use Glob to search for: Gemfile, Gemfile.lock

Java Detection:

• Use Glob to search for: pom.xml, build.gradle, build.gradle.kts, settings.gradle

Docker Detection:

• Use Glob to search for: Dockerfile, docker-compose.yml, docker-compose.yaml, .dockerignore

Next.js/React Detection:

• Use Glob to search for: next.config.js, next.config.ts, next.config.mjs

Vue Detection:

• Use Glob to search for: vue.config.js, nuxt.config.js, nuxt.config.ts

Terraform Detection:

• Use Glob to search for: *.tf, terraform.tfvars

Swift/iOS Detection:

• Use Glob to search for: Package.swift, *.xcodeproj, *.xcworkspace

Flutter/Dart Detection:

• Use Glob to search for: pubspec.yaml, pubspec.lock

C/C++ Detection:

• Use Glob to search for: CMakeLists.txt, Makefile, *.vcxproj, meson.build

Deno Detection:

• Use Glob to search for: deno.json, deno.jsonc, deno.lock

IMPORTANT:

• Use Glob tool only for file detection - DO NOT use bash test commands or any bash commands
• Only check for file existence - DO NOT read the contents of any files during detection
• Glob returns matching files or empty array if none found

Phase 2: Build Ignore Patterns

Create a comprehensive .gitignore combining:

Base Patterns (Always Include)

Environment & Secrets:

# Environment variables
.env
.env.*
.env.local
.env.development
.env.production
.env.test
!.env.example
!.env.template
!.env.sample

# Secrets
credentials.json
secrets.yml
*.secret
*.pem
*.key
*.p12
*.jks
*.pfx
*.keystore

Operating System Files:

# macOS
.DS_Store
.AppleDouble
.LSOverride
._*

# Windows
Thumbs.db
Thumbs.db:encryptable
ehthumbs.db
ehthumbs_vista.db
Desktop.ini
$RECYCLE.BIN/

# Linux
*~
.directory
.Trash-*

IDE & Editor Files:

# Visual Studio Code
.vscode/*
!.vscode/settings.json
!.vscode/tasks.json
!.vscode/launch.json
!.vscode/extensions.json
*.code-workspace

# JetBrains IDEs
.idea/
*.iml
*.iws
*.ipr
.idea_modules/

# Vim
*.swp
*.swo
*~

# Emacs
*~
\#*\#
/.emacs.desktop
/.emacs.desktop.lock

# Sublime Text
*.sublime-workspace
*.sublime-project

Technology-Specific Patterns

Node.js (if detected):

# Dependencies
node_modules/
jspm_packages/

# Build outputs
dist/
build/
.next/
.nuxt/
.output/
.nitro/
.data/
out/

# Testing
coverage/
.nyc_output/

# Caching
.cache/
.turbo/
.parcel-cache/
.webpack/

# Logs
npm-debug.log*
yarn-debug.log*
yarn-error.log*
lerna-debug.log*
pnpm-debug.log*

# Lock files (optional - ask user)
# Uncomment if you want to ignore lock files
# package-lock.json
# yarn.lock
# pnpm-lock.yaml

Python (if detected):

# Byte-compiled / optimized
__pycache__/
*.py[cod]
*$py.class
*.so

# Virtual environments
.venv/
venv/
ENV/
env/
.python-version

# Distribution / packaging
dist/
build/
*.egg-info/
*.egg
.eggs/
wheels/

# Testing
.pytest_cache/
.tox/
.coverage
htmlcov/
.hypothesis/

# Type checking
.mypy_cache/
.dmypy.json
dmypy.json
.pytype/

# Linting
.ruff_cache/

# Jupyter Notebook
.ipynb_checkpoints

# Notebook files (optional - ask user)
# Many projects intentionally commit notebooks
# Uncomment if you want to ignore notebook files
# *.ipynb

.NET (if detected):

# Build results
bin/
obj/
out/

# User-specific files
*.user
*.suo
*.userosscache
*.sln.docstates
*.userprefs

# Visual Studio
.vs/
*.DotSettings.user

# Test results
TestResults/
[Tt]est[Rr]esult*/
*.trx

# NuGet
packages/
*.nupkg
*.snupkg
project.lock.json
project.fragment.lock.json

Go (if detected):

# Binaries
*.exe
*.exe~
*.dll
*.so
*.dylib

# Test binary
*.test

# Output of the go coverage tool
*.out

# Dependency directories
vendor/

# Go workspace file (optional - some teams commit this)
# Uncomment if you want to ignore go.work
# go.work

Rust (if detected):

# Compilation outputs
target/

# Backup files
**/*.rs.bk
*.pdb

# Lock file (optional - ask user)
# Libraries should ignore Cargo.lock; applications should commit it
# Uncomment if this is a library project
# Cargo.lock

PHP (if detected):

# Composer
vendor/
composer.phar

# Lock file (optional - ask user)
# Applications should commit composer.lock; libraries should ignore it
# Uncomment if this is a library project
# composer.lock

# Laravel
.env
.env.backup
.phpunit.result.cache
Homestead.json
Homestead.yaml
npm-debug.log
yarn-error.log

# Symfony
/var/
/vendor/

Ruby (if detected):

# Bundler
vendor/bundle/
.bundle/

# RVM
.rvmrc

# rbenv
.ruby-version

# RSpec
.rspec_status

# Coverage
coverage/

Java (if detected):

# Compiled class files
*.class

# Log files
*.log

# Package Files
*.jar
*.war
*.nar
*.ear
*.zip
*.tar.gz
*.rar

# Maven
target/
pom.xml.tag
pom.xml.releaseBackup
pom.xml.versionsBackup
pom.xml.next
release.properties

# Gradle
.gradle/
build/
gradle-app.setting
!gradle-wrapper.jar

Docker (if detected):

# Docker override files
docker-compose.override.yml
docker-compose.override.yaml

Terraform (if detected):

# Terraform
.terraform/
*.tfstate
*.tfstate.*
*.tfvars
crash.log
override.tf
override.tf.json
*_override.tf
*_override.tf.json

Swift/iOS (if detected):

# Xcode
build/
DerivedData/
*.xcuserdata
*.xccheckout
*.moved-aside
*.hmap
*.ipa
*.dSYM.zip
*.dSYM

# Swift Package Manager
.build/
Packages/
Package.resolved

# CocoaPods
Pods/

# Carthage
Carthage/Build/
Carthage/Checkouts/

# Fastlane
fastlane/report.xml
fastlane/Preview.html
fastlane/screenshots/
fastlane/test_output/

Flutter/Dart (if detected):

# Flutter/Dart
.dart_tool/
.flutter-plugins
.flutter-plugins-dependencies
.packages
build/
.pub-cache/
.pub/

# Android (Flutter)
**/android/**/gradle-wrapper.jar
**/android/.gradle
**/android/captures/
**/android/gradlew
**/android/gradlew.bat
**/android/local.properties

# iOS (Flutter)
**/ios/**/*.mode1v3
**/ios/**/*.mode2v3
**/ios/**/*.moved-aside
**/ios/**/*.pbxuser
**/ios/**/*.perspectivev3
**/ios/**/DerivedData/
**/ios/.generated/
**/ios/Flutter/App.framework
**/ios/Flutter/Flutter.framework
**/ios/Flutter/Flutter.podspec
**/ios/Flutter/Generated.xcconfig
**/ios/Flutter/ephemeral/
**/ios/Pods/

C/C++ (if detected):

# Compiled objects
*.o
*.obj
*.a
*.lib
*.so
*.dylib
*.dll
*.exe

# Build directories
build/
cmake-build-*/
out/

# CMake
CMakeCache.txt
CMakeFiles/
cmake_install.cmake
Makefile
install_manifest.txt

# Precompiled headers
*.gch
*.pch

# Debug files
*.dSYM/
*.su
*.idb
*.pdb

Deno (if detected):

# Deno
.deno/
deno.lock

Phase 3: Check Existing .gitignore

Check if .gitignore already exists using the Read tool (NOT bash test commands):

1. Try to read .gitignore using the Read tool
2. If the file exists and Read succeeds:
   • Parse the content
   • Analyze existing patterns
   • Ask user for merge strategy preference using AskUserQuestion tool:
     • Smart Merge (default): Deduplicate patterns, preserve comments, organize by category
     • Append: Add all new patterns at the end, keep existing content as-is
     • Replace: Completely replace existing .gitignore with new patterns
3. If the file doesn't exist (Read returns error):
   • Proceed to create new file with ignore patterns
   • Use "Smart Merge" as the default strategy

IMPORTANT:

• Use Read tool to check file existence - DO NOT use bash test commands
• The Read tool will gracefully handle non-existent files by returning an error
• Preserve existing comments and custom patterns during merge
• Detect and remove duplicate patterns

Phase 4: Show Preview & Get Confirmation

Display a comprehensive preview showing:

1. Technologies Detected:

   • List all detected technologies with file indicators

2. Current .gitignore (if exists):

   • Show line count
   • Show sample of existing patterns (first 10 lines)
   • Identify any duplicate or redundant patterns

3. Proposed .gitignore:

   • Show all patterns to be added
   • Group by category (Base Patterns, Node.js, Python, etc.)
   • Show total pattern count
   • Highlight any custom patterns that will be preserved

4. After Merge:

   • Show estimated total line count
   • Show merge strategy being used
   • List categories included

Ask for user confirmation before proceeding.

Phase 5: Write .gitignore

After user confirms:

1. Build the complete .gitignore content with proper formatting:

   • Add header comment with generation info
   • Group patterns by category with section headers
   • Include blank lines between sections for readability
   • Preserve existing custom patterns if merging
   • Sort patterns within categories alphabetically

2. Write .gitignore using the Write tool (NOT bash echo or heredoc)

3. Show success message with:

   • File path: .gitignore
   • Total patterns configured
   • Technologies covered
   • Next steps (review, git status, commit)

IMPORTANT:

• Use Write tool to create/update the .gitignore file
• DO NOT use bash commands for writing the file
• Ensure proper formatting with blank lines between sections
• Include helpful comments for each section

Important Constraints

DO NOT:

• Read the contents of any sensitive files during scanning
• Include actual file paths from the project in .gitignore
• Proceed without user confirmation
• Use bash test commands (test -f, [ -f ], etc.)
• Use any bash commands for file detection or checking
• Remove existing custom patterns without user consent

DO:

• Use Glob tool for technology detection (file pattern matching)
• Use Read tool to check if .gitignore exists (handles errors gracefully)
• Use Write tool to create/update .gitignore
• Use AskUserQuestion tool to ask for merge strategy preference
• Deduplicate patterns by default during merge
• Preserve comments and custom patterns from existing .gitignore
• Show clear before/after comparison
• Maintain alphabetical ordering within categories for readability
• Use forward slashes in all patterns for cross-platform compatibility
• Add helpful section headers and comments

Example Output Format

🔍 Detecting technologies in your project...

Technologies Detected:
✓ Node.js (package.json found)
✓ TypeScript (tsconfig.json found)
✓ Python (requirements.txt, pyproject.toml found)
✓ Docker (Dockerfile, docker-compose.yml found)

Current .gitignore:
📄 .gitignore exists (42 lines)
📊 Sample patterns:
  node_modules/
  .env
  dist/
  ...

Proposed .gitignore Structure:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Base Patterns:
  • Environment & Secrets (12 patterns)
  • Operating System Files (15 patterns)
  • IDE & Editor Files (18 patterns)

Node.js Patterns:
  • Dependencies (2 patterns)
  • Build outputs (5 patterns)
  • Testing & Caching (6 patterns)
  • Logs (5 patterns)

Python Patterns:
  • Byte-compiled (5 patterns)
  • Virtual environments (5 patterns)
  • Distribution (7 patterns)
  • Testing (5 patterns)

Docker Patterns:
  • Docker overrides (2 patterns)

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Total patterns: 87
Estimated file size: ~150 lines (with comments)

Merge Strategy: Smart Merge (deduplicate, preserve comments, organize)

Would you like to proceed with this configuration? (yes/no)

Success Message Format

✓ .gitignore successfully initialized!

Configuration Summary:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
📄 File: .gitignore
📊 Total patterns: 87 (organized in 7 categories)
🛡️ Technologies covered: Node.js, TypeScript, Python, Docker
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Next Steps:
1. Review the generated .gitignore file
2. Run `git status` to see which files are now ignored
3. Remove any currently tracked files that should be ignored:
   git rm --cached <file>
4. Commit the .gitignore file:
   git add .gitignore
   git commit -m "Add comprehensive .gitignore for detected technologies"

💡 Tip: You can run this command again to update .gitignore when adding new technologies to your project.

Additional Features

Lock File Handling: When a technology with lock files is detected, ask the user if they want to commit or ignore them:

• Node.js (package-lock.json, yarn.lock, pnpm-lock.yaml): Most projects SHOULD commit for reproducible builds
• Rust (Cargo.lock): Applications SHOULD commit; libraries should ignore
• PHP (composer.lock): Applications SHOULD commit; libraries should ignore
• Only ignore lock files if explicitly requested
• Add commented-out lock file patterns with explanation for each

Custom Patterns: During Smart Merge, detect and preserve:

• User-added comments (lines starting with #)
• Custom patterns not in the standard template
• Negation patterns (lines starting with !)

Pattern Validation:

• Ensure patterns use forward slashes (/)
• Remove duplicate patterns across categories
• Warn about overly broad patterns (e.g., *, *.txt)