Make Dogfood

Use the makefile-dogfooder script to analyze, test, and enhance Makefiles across the claude-night-market project with thorough safety checks and auto-generation capabilities.

When To Use

Use this command when you need to:

• Analyzing Makefile completeness
• Testing existing make targets
• Generating missing targets
• Preparing plugins for release
• Auditing Makefile coverage across plugins
• Creating Makefiles for plugins without them

When NOT To Use

Avoid this command if:

• Writing initial Makefiles from scratch (use --generate-makefiles instead)
• Debugging specific build failures
• Creating custom build systems

Parameters

• --mode: Operation mode (default: analyze)
• analyze: Only analyze and report gaps (SAFE - no changes)
• generate: Show generated targets without writing files
• apply: Write targets to Makefiles (use with --dry-run first)

• --plugin: Restrict to specific plugin (e.g., --plugin sanctum)
• Recommended: Test on one plugin before applying to all

• --dry-run: Preview changes without writing files (HIGHLY RECOMMENDED)
• Always use this before applying changes for real
• Shows what will be generated/modified

• --generate-makefiles: Generate Makefiles for plugins that don't have them
• Follows attune:makefile-generation pattern
• Auto-detects language (Python/Rust/TypeScript)
• Creates standard targets for detected language

• --preflight-check: Run validation checks before processing
• Validates directories exist
• Checks write permissions
• Detects git repository for rollback

• --verbose: Show detailed progress and error messages

• --output: Output format (text|json, default: text)

Workflow

1. Discovery Phase

Scan all Makefiles and build an inventory of existing targets:

• Find all Makefile and .mk files
• Extract target definitions and metadata
• Build dependency graphs
• Identify plugin type (leaf vs aggregator)

2. Analysis Phase

Evaluate Makefiles against best practices:

• Check for essential targets (help, clean, test, lint)
• Identify missing convenience targets (demo, quick-run)
• Detect anti-patterns and inconsistencies
• Score each Makefile on completeness (0-100)

3. Testing Phase

Safely validate existing targets:

• Run make -n for dry-run validation
• Test help targets and documentation coverage
• Verify target dependencies exist
• Check for common runtime issues

4. Generation Phase

Create missing targets based on analysis:

• Generate LIVE demo targets that run actual CLI tools/scripts
• Add dogfood targets that run plugin tools on the plugin itself
• Create quick-run targets for common workflows
• Ensure demos show REAL output, not static echoes
• Maintain consistency with existing patterns

Generation Checklist:

• Does demo-* target run an actual script/tool?
• Does output show real, dynamic data?
• Would a user learn something by running this?
• Is the plugin "eating its own dogfood"?

Examples

# SAFE WORKFLOW (Recommended)

# 1. Analyze all plugins to see what's missing
python3 plugins/abstract/scripts/makefile_dogfooder.py --mode analyze

# 2. Generate for a single plugin (see what would be created)
python3 plugins/abstract/scripts/makefile_dogfooder.py --plugin sanctum --mode generate

# 3. Dry-run to preview changes
python3 plugins/abstract/scripts/makefile_dogfooder.py --plugin sanctum --mode apply --dry-run

# 4. Apply for real
python3 plugins/abstract/scripts/makefile_dogfooder.py --plugin sanctum --mode apply

# 5. Generate Makefiles for plugins missing them
python3 plugins/abstract/scripts/makefile_dogfooder.py --generate-makefiles --mode analyze

# 6. Bulk workflow with safety
…

Safety Features

The script includes thorough safety checks:

1. Preflight Validation (automatic in apply mode)

• Directory existence checks
• Write permission verification
• Git repository detection

1. Working Directory Validation

• Automatic normalization
• Prevents "file not found" errors

1. Confirmation Prompt

• Prompts before applying without --dry-run
• Prevents accidental changes

1. Duplicate Detection

• Checks for existing targets
• Prevents conflicts and warnings

What This Command Does

1. Creates detailed inventory of all Makefile targets across the project
2. Identifies gaps in user-facing functionality using pattern matching
3. Tests safely without modifying files or running risky operations
4. Generates missing targets with contextually appropriate templates