Prettier Ignore Skill

Purpose

Generate .prettierignore file to exclude build outputs, dependencies, and generated files from Prettier formatting.

🚨 MANDATORY FILE COUNT

Expected Output: 1 file

• •.prettierignore (standard format)

🔍 BEFORE GENERATING - CRITICAL RESEARCH REQUIRED

Perform these checks in order before generating the file:

1. •

   Prettier Version: Verify latest stable version and ignore file support

   • •Run: npm view prettier version
   • •Check documentation: Confirm .prettierignore format still supported
   • •If deprecated: Use alternative format (e.g., config-based ignore)
2. •

   Build Output Detection: Identify build directories from project config

   • •Check vite.config.ts or vite.config.js:
     • •Look for build.outDir property (default: dist)
     • •If custom output dir found → Use that directory name
   • •Check package.json scripts:
     • •Look for build output paths in scripts
   • •Default: Use dist/ if no custom output detected
3. •

   Test Coverage Detection: Check if test framework generates coverage reports

   • •Check for test framework (from jest-config or vitest-config skills):
     • •If jest.config.js exists → Check coverageDirectory (default: coverage/)
     • •If vitest.config.ts exists → Check test.coverage.reportsDirectory
   • •Check package.json test scripts:
     • •Look for --coverage flag or coverage directory references
   • •Default: Include coverage/ in ignore patterns
4. •

   Package Manager Detection: Identify which package manager is used

   • •Check for lock files:
     • •package-lock.json → npm
     • •yarn.lock → yarn
     • •pnpm-lock.yaml → pnpm
   • •Note: Lock files should NOT be in .prettierignore (formatting not applicable)
   • •Always exclude: node_modules/
5. •

   Minified/Bundled Files: Check for generated JavaScript patterns

   • •Standard patterns: *.min.js, *.bundle.js
   • •Check build config: Look for additional minified output patterns
   • •Always exclude: Prevents formatting of production bundles
6. •

   Verify Glob Pattern Support: Confirm pattern syntax compatibility

   • •Reference: https://prettier.io/docs/en/ignore.html
   • •Test patterns: Ensure glob syntax matches Prettier's expectations
   • •Common patterns: */, **/*.ext, negation with !
7. •

   Cross-Skill Coordination: Verify consistency with other ignore files

   • •Check .gitignore: Ensure .prettierignore doesn't format git-ignored generated files
   • •Check .eslintignore: Similar exclusion patterns should align
   • •Principle: Don't format files that are ignored by version control or linting
8. •

   Performance Optimization: Validate ignore patterns reduce unnecessary processing

   • •Large directories: node_modules/, dist/, build/ significantly impact performance
   • •Generated files: Coverage reports, minified bundles don't need formatting
   • •Benchmark: Prettier should skip excluded files entirely (zero processing time)

Execution Checklist

Execute in this order:

• • 1. Verify .prettierignore format is still supported by latest Prettier
• • 2. Detect build output directory from vite.config.ts (default: dist/)
• • 3. Detect test coverage directory from test config (default: coverage/)
• • 4. Identify package manager (npm/yarn/pnpm) for node_modules exclusion
• • 5. Verify glob patterns are valid Prettier ignore syntax
• • 6. Cross-check with .gitignore for consistency
• • 7. Generate .prettierignore with minimal essential exclusions
• • 8. Run validation script to confirm file exists and patterns are valid

Output

Primary Format: .prettierignore

# Build outputs
dist/
build/

# Dependencies
node_modules/

# Test coverage
coverage/

# Minified/bundled files
*.min.js
*.bundle.js

Template

See: examples.md in this directory for complete template and detailed examples.

🛑 BLOCKING VALIDATION - MUST RUN AFTER FILE GENERATION

Validation Script

Run this script after generating .prettierignore to verify correctness:

#!/bin/bash
# Prettier Ignore Validation Script

echo "🔍 Validating .prettierignore..."

# Check if file exists
if [ ! -f ".prettierignore" ]; then
  echo "❌ BLOCKING ERROR: .prettierignore file not found"
  exit 1
fi

# Check if file is not empty
if [ ! -s ".prettierignore" ]; then
  echo "❌ BLOCKING ERROR: .prettierignore is empty"
  exit 1
fi

# Check for required patterns
REQUIRED_PATTERNS=("dist/" "node_modules/" "coverage/")
for pattern in "${REQUIRED_PATTERNS[@]}"; do
  if ! grep -q "$pattern" .prettierignore; then
    echo "⚠️  WARNING: Missing recommended pattern: $pattern"
  fi
done

# Check glob pattern syntax (basic validation)
if grep -qE '^[^#].*\*\*.*\*\*' .prettierignore; then
  echo "⚠️  WARNING: Potential invalid glob pattern (multiple **)"
fi

echo "✅ .prettierignore validation passed"
exit 0

Usage: bash validate-prettierignore.sh

Manual Verification

After generation, manually verify:

1. •File exists: ls -la .prettierignore
2. •Content check: cat .prettierignore
3. •Pattern test: prettier --check "**/*" --ignore-path .prettierignore (should skip excluded paths)
4. •Performance test: Verify Prettier runs faster with ignore file (compare with/without)

Key Features

• •Minimal Exclusions: Only essential patterns (build, deps, coverage, minified)
• •Performance Optimized: Skips large directories that don't need formatting
• •Build-Aware: Automatically detects custom build output directories
• •Coverage-Aware: Excludes test coverage reports based on test framework config
• •Glob Patterns: Uses standard ignore syntax compatible with Prettier
• •Cross-Tool Consistency: Aligns with .gitignore and .eslintignore

Pattern Philosophy

• •Build outputs: Never format generated production code
• •Dependencies: Skip third-party code in node_modules
• •Coverage reports: Exclude auto-generated test reports
• •Minified files: Don't format compressed/bundled JavaScript
• •Performance: Only ignore what's necessary for speed improvement

Configuration Strategy

• •Minimal approach: Keep ignore list short and focused
• •No source code: Never exclude src/ or application code
• •No configs: Format all config files (package.json, tsconfig.json, etc.)
• •No lock files: These don't apply to Prettier (not formatted)
• •Glob efficiency: Use directory patterns (dir/) over file globs when possible

Integration Considerations

• •Git alignment: Ensure git-ignored build outputs are also Prettier-ignored
• •CI/CD: Verify ignore patterns work in automated formatting checks
• •Pre-commit hooks: Lint-staged should respect .prettierignore patterns
• •Editor plugins: VSCode Prettier extension respects this file

Maintenance Considerations

• •Prettier updates: Check release notes for ignore file format changes
• •Build config changes: Update ignore patterns if output directory changes
• •New generated files: Add patterns for new auto-generated content
• •Performance monitoring: Verify ignore patterns still provide speed benefits