Laravel Devtoolbox

https://github.com/grazulex/laravel-devtoolbox
Admin
A Swiss-army artisan CLI for Laravel to scan, inspect, debug, and explore every aspect of your...
Tokens:48,569
Snippets:352
Trust Score:9.4
License:MIT
Update:1 year ago
Show doc for...
Tokens:
Raw
### List and Get Help for Devtoolbox Commands

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Getting-Started

Demonstrates how to list all available Laravel Devtoolbox commands prefixed with 'dev:' and how to get help for a specific command, such as 'dev:scan'.

```bash
# List all Laravel Devtoolbox commands
php artisan list dev:

# Get help for any specific command
php artisan dev:scan --help
```

--------------------------------

### Initiating a Comprehensive Application Scan

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Getting-Started

Start your exploration of the Laravel DevToolbox with `dev:scan --all` to obtain a complete overview of your application's structure and potential issues. This command serves as a foundational step for understanding your project's health.

```bash
dev:scan --all
```

--------------------------------

### Laravel Devtoolbox Configuration Example

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Installation

Example of the default configuration file for Laravel Devtoolbox. It includes settings for default output format, performance options like memory and time limits, and scanner-specific configurations for models and routes.

```php
<?php

return [
    /*
    |--------------------------------------------------------------------------
    | Default Output Format
    |--------------------------------------------------------------------------
    |
    | The default format for command output when none is specified.
    | Supported: "array", "json", "count", "mermaid"
    |
    */
    'default_format' => 'array',

    /*
    |--------------------------------------------------------------------------
    | Performance Settings
    |--------------------------------------------------------------------------
    |
    | Configure performance-related settings for analysis commands.
    |
    */
    'performance' => [
        'memory_limit' => '512M',
        'time_limit' => 300,
    ],

    /*
    |--------------------------------------------------------------------------
    | Scanner Options
    |--------------------------------------------------------------------------
    |
    | Configuration for specific scanner types.
    |
    */
    'scanners' => [
        'models' => [
            'include_relationships' => true,
            'analyze_usage' => true,
        ],
        'routes' => [
            'check_controllers' => true,
            'analyze_middleware' => true,
        ],
    ],
];
```

--------------------------------

### Performance Analysis with Devtoolbox

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Getting-Started

Demonstrates commands for performance analysis, including monitoring SQL queries for tracing and identifying N+1 problems, and analyzing service provider execution times.

```bash
# Monitor SQL queries
php artisan dev:sql:trace --route=dashboard
php artisan dev:sql:duplicates --route=users.index

# Analyze service providers
php artisan dev:providers:timeline --slow-threshold=100
```

--------------------------------

### Install Dev Dependencies in CI/CD

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Installation

Shows how to install development dependencies and run Laravel Devtoolbox commands within a CI/CD pipeline. This example scans all models and outputs the result in JSON format to a file.

```bash
# In your CI/CD script
composer install --dev
php artisan dev:scan --all --format=json --output=analysis.json
```

--------------------------------

### Route Inspection with Devtoolbox

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Getting-Started

Shows how to inspect and analyze application routes, including listing all routes, finding unused routes, and performing reverse lookups by controller.

```bash
# List all routes
php artisan dev:routes

# Find unused routes
php artisan dev:routes:unused

# Find routes by controller (reverse lookup)
php artisan dev:routes:where UserController
```

--------------------------------

### Model Analysis with Devtoolbox

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Getting-Started

Illustrates commands for analyzing Eloquent models, including listing all models, finding where a model is used, and generating relationship graphs in Mermaid format.

```bash
# List all models
php artisan dev:models

# Find where a specific model is used
php artisan dev:model:where-used App\Models\User

# Generate a relationship graph
php artisan dev:model:graph --format=mermaid --output=models.mmd
```

--------------------------------

### GitLab CI: Setup Environment and Install Dependencies

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Export-Automation

This snippet outlines the initial setup for a GitLab CI job, including system package updates, Composer installation, DevToolbox installation, environment configuration, and database migrations. It ensures a consistent environment for subsequent analysis steps.

```yaml
stages:
  - prepare
  - analyze
  - quality-gates
  - report

variables:
  MYSQL_ROOT_PASSWORD: password
  MYSQL_DATABASE: testing
  MYSQL_USER: laravel
  MYSQL_PASSWORD: laravel

services:
  - mysql:8.0

cache:
  paths:
    - vendor/
    - node_modules/

.setup_template:
  &setup
  before_script:
    - apt-get update -qq && apt-get install -y -qq git unzip jq
    - curl -sS https://getcomposer.org/installer | php
    - php composer.phar install --no-dev --optimize-autoloader
    - php composer.phar require --dev grazulex/laravel-devtoolbox
    - cp .env.example .env
    - php artisan key:generate
    - php artisan config:cache
    - php artisan migrate --force

prepare:
  stage: prepare
  image: php:8.3
  <<: *setup
  script:
    - echo "Environment prepared"
  artifacts:
    paths:
      - vendor/
    expire_in: 1 hour
```

--------------------------------

### Security Checks with Devtoolbox

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Getting-Started

Highlights commands for security checks, such as finding unprotected routes and auditing environment configuration differences.

```bash
# Find unprotected routes
php artisan dev:security:unprotected-routes --critical-only

# Environment configuration audit
php artisan dev:env:diff --against=.env.example
```

--------------------------------

### Database Analysis with Devtoolbox

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Getting-Started

Demonstrates commands for analyzing database usage and queries, such as checking column usage, tracing SQL queries for a specific route, and identifying N+1 problems.

```bash
# Analyze database column usage
php artisan dev:db:column-usage --unused-only

# Trace SQL queries for a specific route
php artisan dev:sql:trace --route=dashboard

# Analyze SQL queries for N+1 problems
php artisan dev:sql:duplicates --route=users.index --threshold=3
```

--------------------------------

### Help Option for DevToolbox Commands

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Getting-Started

Access detailed information about available options and arguments for any DevToolbox command by appending the `--help` flag. This is crucial for understanding command capabilities and proper usage.

```bash
dev:scan --help
```

--------------------------------

### Code Review Preparation with Devtoolbox

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Getting-Started

Shows how to use Laravel Devtoolbox commands to generate documentation and analysis reports for code reviews, including model and route details, and relationship graphs.

```bash
# Generate documentation
php artisan dev:models --format=json --output=docs/models.json
php artisan dev:routes --format=json --output=docs/routes.json
php artisan dev:model:graph --format=mermaid --output=docs/relationships.mmd
```

--------------------------------

### Verify Laravel Devtoolbox Installation

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Installation

Commands to verify the installation of Laravel Devtoolbox. It lists available 'dev:' commands and shows about information.

```bash
php artisan list dev:
```

```bash
php artisan dev:about+
```

--------------------------------

### Application Health Checks with Devtoolbox

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Getting-Started

Provides examples for performing basic and enhanced health checks on a Laravel application using the 'dev:scan' and 'dev:about+' commands, including performance and security aspects.

```bash
# Basic health check
php artisan dev:scan --all

# Enhanced application overview
php artisan dev:about+ --extended --performance --security
```

--------------------------------

### Combining Output Formats for Automation and Development

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Getting-Started

Leverage multiple output formats simultaneously for different workflows. Use `--format=json` for machine-readable output suitable for automation scripts and `--format=array` for human-readable output during development.

```bash
dev:scan --format=json --format=array
```

--------------------------------

### Real-time Log Monitoring with Devtoolbox

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Getting-Started

Illustrates how to monitor application logs in real-time using the 'dev:log:tail' command, with options to follow logs and filter by level or pattern.

```bash
# Monitor logs in real-time
php artisan dev:log:tail --follow --level=error

# Watch for specific patterns
php artisan dev:log:tail --follow --pattern="SQL"
```

--------------------------------

### General Scanning and Exporting Results

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Getting-Started

Explains the general scanning capabilities of the 'dev:scan' command for various application types and demonstrates how to export results in different formats like JSON and Mermaid.

```bash
# Scan all available types
php artisan dev:scan --all

# Scan a specific type
php artisan dev:scan models
php artisan dev:scan routes  
php artisan dev:scan services

# List available scanner types
php artisan dev:scan

# Export to JSON
php artisan dev:models --format=json --output=models.json

# Generate Mermaid diagram
php artisan dev:model:graph --format=mermaid --output=relationships.mmd

# Save comprehensive scan
php artisan dev:scan --all --format=json --output=app-analysis.json
```

--------------------------------

### Analyze Container Bindings with Details

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/examples/README

Provides a detailed analysis of container bindings, showing resolved bindings and their parameters. Useful for in-depth understanding of dependency injection setup.

```bash
php artisan dev:container:bindings --show-resolved --show-parameters
```

--------------------------------

### Daily Development Workflows with Devtoolbox

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Getting-Started

Outlines common daily development tasks using Laravel Devtoolbox, including performing morning health checks and reviewing potential issues like unused routes.

```bash
# Morning health check
php artisan dev:scan --all --format=count

# Review potential issues
php artisan dev:routes:unused
php artisan dev:security:unprotected-routes
```

--------------------------------

### Globally Install Laravel Devtoolbox

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Installation

Installs the Laravel Devtoolbox package globally using Composer, allowing it to be used across multiple projects. Ensure your global Composer bin directory is in your system's PATH.

```bash
composer global require grazulex/laravel-devtoolbox
```

--------------------------------

### Saving DevToolbox Command Results to a File

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Getting-Started

Redirect the output of DevToolbox commands to a file for later review or analysis using the `--output` option. This is beneficial for tracking changes or debugging issues over time.

```bash
dev:scan --all --output=scan_results.txt
```

--------------------------------

### CI/CD GitHub Actions Integration

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Examples

Example GitHub Actions workflow for integrating Laravel Devtoolbox quality checks into a CI/CD pipeline. It sets up PHP, installs dependencies, runs various Devtoolbox analysis commands, and performs quality gates based on the results.

```yaml
# .github/workflows/devtoolbox-quality.yml
name: Laravel Devtoolbox Quality Checks

on: [push, pull_request]

jobs:
  devtoolbox-analysis:
    runs-on: ubuntu-latest
    
    steps:
    - uses: actions/checkout@v3
    
    - name: Setup PHP
      uses: shivammathur/setup-php@v2
      with:
        php-version: 8.3
        
    - name: Install dependencies
      run: |
        composer install --no-dev --optimize-autoloader
        composer require --dev grazulex/laravel-devtoolbox
        
    - name: Run Laravel Devtoolbox Analysis
      run: |
        # Enhanced application check (NEW!)
        php artisan dev:about+ --extended --performance --security --format=json > analysis/about.json
        
        # Basic quality checks
        php artisan dev:scan --all --format=json > analysis/scan.json
        
        # Route analysis
        UNUSED_ROUTES=$(php artisan dev:routes:unused --format=count | jq '.count')
        echo "Unused routes: $UNUSED_ROUTES"
        
        # Security checks
        UNPROTECTED_ROUTES=$(php artisan dev:security:unprotected-routes --format=count | jq '.count')
        echo "Unprotected routes: $UNPROTECTED_ROUTES"
        
        # Performance checks (NEW!)
        SLOW_PROVIDERS=$(php artisan dev:providers:timeline --slow-threshold=200 --format=count | jq '.slow_count // 0')
        echo "Slow providers: $SLOW_PROVIDERS"
        
        # Quality gates
        if [ $UNUSED_ROUTES -gt 10 ]; then exit 1; fi
        if [ $UNPROTECTED_ROUTES -gt 5 ]; then exit 1; fi
        if [ $SLOW_PROVIDERS -gt 3 ]; then exit 1; fi
        
    - name: Upload Analysis Results
      uses: actions/upload-artifact@v3
      with:
        name: devtoolbox-analysis
        path: analysis/
```

--------------------------------

### Test Laravel Devtoolbox Commands

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Installation

Demonstrates testing various functionalities of Laravel Devtoolbox, including basic scanning, using different output formats (JSON, count), and exporting scan results to a file.

```bash
php artisan dev:scan models
```

```bash
php artisan dev:models --format=json
```

```bash
php artisan dev:models --format=count
```

```bash
php artisan dev:models --format=json --output=test-models.json
```

--------------------------------

### Install Laravel Devtoolbox with Composer

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Installation

Installs the Laravel Devtoolbox package as a development dependency using Composer. This is the recommended method for most projects.

```bash
composer require --dev grazulex/laravel-devtoolbox
```

--------------------------------

### Generate Service and Container Overview

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/examples/README

Provides an overview of services and container bindings within the application. Outputs can be formatted as JSON and saved to files.

```bash
php artisan dev:services --format=json --output=onboarding/services.json
```

```bash
php artisan dev:container:bindings --show-resolved --format=json --output=onboarding/container.json
```

--------------------------------

### DevToolbox Configuration File Example (Bash)

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Export-Automation

A sample configuration file (`.devtoolbox-monitor.conf`) for setting up notification channels, quality and performance thresholds, and monitoring parameters.

```bash
# ~/.devtoolbox-monitor.conf

# Notification settings
SLACK_WEBHOOK="https://hooks.slack.com/services/YOUR/SLACK/WEBHOOK"
ALERT_EMAIL="admin@yourcompany.com"

# Quality thresholds
UNUSED_ROUTES_THRESHOLD=5
UNPROTECTED_ROUTES_THRESHOLD=3
SLOW_PROVIDERS_THRESHOLD=2
N_PLUS_ONE_THRESHOLD=0

# Performance thresholds
MEMORY_THRESHOLD=256
EXECUTION_TIME_THRESHOLD=20

# Monitoring settings
REPORT_RETENTION_DAYS=30
ENABLE_SLACK_NOTIFICATIONS=true
ENABLE_EMAIL_NOTIFICATIONS=true

# Critical routes to monitor for N+1 issues
CRITICAL_ROUTES=("dashboard" "users.index" "api.orders" "reports.daily" "admin.dashboard")
```

--------------------------------

### Code Review Preparation Script

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/examples/README

A bash script to prepare for code reviews by generating documentation for model relationships, routes, and service bindings in various formats.

```bash
#!/bin/bash
echo "📝 Generating code review documentation..."

# Model relationships
echo "🔗 Generating model relationships diagram..."
php artisan dev:model:graph --format=mermaid --output=docs/models.mmd

# Route analysis
echo "🛣️ Generating route analysis..."
php artisan dev:routes --format=json --output=docs/routes.json

# Service bindings
echo "⚙️ Generating service bindings analysis..."
php artisan dev:services --format=json --output=docs/services.json
```

--------------------------------

### Generate Application Overview for Onboarding

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/examples/README

A bash script to generate a comprehensive application overview, likely for onboarding new team members. It utilizes the `dev:about+` Artisan command with extended and performance flags.

```bash
# Generate comprehensive application overview for new developers

echo "📋 Generating enhanced application overview for onboarding..."


```

--------------------------------

### Get Performance Summary (Memory Usage)

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Examples

Retrieves and displays the current memory usage percentage of the application. It fetches this data in JSON format and extracts the relevant metric using jq.

```bash
MEMORY_USAGE=$(php artisan dev:performance:memory --format=json | jq -r '.data.memory.usage_percentage // "N/A"')
echo "   Memory Usage: ${MEMORY_USAGE}%"
```

--------------------------------

### Publish Laravel Devtoolbox Configuration

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Installation

Publishes the configuration file for Laravel Devtoolbox, typically named 'devtoolbox.php' in the 'config' directory. This allows for customization of the package's settings.

```bash
php artisan vendor:publish --tag=devtoolbox-config
```

--------------------------------

### Generate Application Documentation (Bash Script)

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Examples

A bash script to initiate the generation of comprehensive application documentation, creating necessary directories for architecture and analysis documentation.

```bash
#!/bin/bash
# generate-docs.sh - Generate comprehensive application documentation

echo "📚 Generating Laravel Devtoolbox Documentation"

mkdir -p docs/architecture
mkdir -p docs/analysis
```

--------------------------------

### Generate Provider Performance Timeline

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/examples/README

Creates a timeline of provider performance, including deferred providers and dependencies. The output is in JSON format and saved to a file.

```bash
php artisan dev:providers:timeline --include-deferred --show-dependencies --format=json --output=onboarding/providers.json
```

--------------------------------

### Service Container and Provider Analysis

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Examples

Analyze service container bindings, check service provider performance, and group bindings by type.

```bash
# Analyze container bindings
php artisan dev:container:bindings --show-resolved --show-parameters

# Check service provider performance
php artisan dev:providers:timeline --slow-threshold=50

# Group bindings by type
php artisan dev:container:bindings --group-by=singleton --format=json
```

--------------------------------

### Update Laravel Devtoolbox Version

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Installation

Updates the Laravel Devtoolbox package to its latest available version using Composer.

```bash
composer update grazulex/laravel-devtoolbox
```

--------------------------------

### Generate Core Architecture Documentation

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Examples

Generates documentation for models, routes, and provides an enhanced application overview and service analysis. It outputs results in JSON and Mermaid formats.

```bash
php artisan dev:models --format=json --output=docs/architecture/models.json
php artisan dev:model:graph --format=mermaid --output=docs/architecture/models.mmd
php artisan dev:routes --format=json --output=docs/architecture/routes.json
php artisan dev:about+ --extended --performance --security --format=json --output=docs/architecture/overview.json
php artisan dev:container:bindings --show-resolved --show-parameters --format=json --output=docs/architecture/container.json
php artisan dev:providers:timeline --include-deferred --show-dependencies --format=json --output=docs/architecture/providers.json
```

--------------------------------

### Scan Application Structure

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/examples/README

Scans the entire application to document its structure. The results are output in JSON format to a specified file.

```bash
php artisan dev:scan --all --format=json --output=onboarding/app-structure.json
```

--------------------------------

### Document Routes with Controller Mapping

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/examples/README

Generates documentation for application routes, including their corresponding controller mappings. The output is in JSON format and saved to a file.

```bash
php artisan dev:routes --format=json --output=onboarding/routes.json
```

--------------------------------

### Generate Enhanced Application Overview

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/examples/README

Generates a comprehensive overview of the application, including performance and security information. The output can be formatted as JSON and saved to a specified file.

```bash
php artisan dev:about+ --extended --performance --security --format=json --output=onboarding/overview.json
```

--------------------------------

### Analyze Service Provider Performance with Dependencies

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/examples/README

Examines the performance timeline of service providers, including their dependencies, and highlights slow providers. Helps optimize application loading times.

```bash
php artisan dev:providers:timeline --slow-threshold=50 --show-dependencies
```

--------------------------------

### Real-time Log Monitoring

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Examples

Monitor application logs in real-time, watch for specific patterns, and monitor custom log files.

```bash
# Monitor logs in real-time
php artisan dev:log:tail --follow --level=error

# Watch for specific patterns
php artisan dev:log:tail --follow --pattern="database"

# Monitor custom log file
php artisan dev:log:tail --file=custom.log --lines=100 --follow
```

--------------------------------

### JSON Data Processing with jq Examples

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/examples/README

A collection of bash commands using `jq` to process JSON output from various Laravel DevToolbox commands. These examples demonstrate filtering, grouping, and transforming data for analysis.

```bash
# Find models with many relationships
php artisan dev:models --format=json | jq '.data[] | select(.relationships | length > 5) | .class'
```

```bash
# Count routes by middleware
php artisan dev:routes --format=json | jq '.data | group_by(.middleware[]) | map({middleware: .[0].middleware[0], count: length})'
```

```bash
# Find slow SQL queries
php artisan dev:sql:trace --route=dashboard --format=json | jq '.data.queries[] | select(.time > 100)'
```

```bash
# Analyze container bindings by type (NEW!)
php artisan dev:container:bindings --format=json | jq '.data | group_by(.type) | map({type: .[0].type, count: length})'
```

```bash
# Find slow service providers (NEW!)
php artisan dev:providers:timeline --format=json | jq '.data[] | select(.boot_time > 100) | {name: .name, time: .boot_time}'
```

```bash
# Find N+1 problems (NEW!)
php artisan dev:sql:duplicates --route=users.index --format=json | jq '.duplicates[] | {query: .query, count: .count}'
```

```bash
# Find controllers with most routes (NEW!)
php artisan dev:routes --format=json | jq '.data | group_by(.controller) | map({controller: .[0].controller, route_count: length}) | sort_by(.route_count) | reverse'
```

```bash
# Analyze middleware usage patterns (NEW!)
php artisan dev:middlewares:where-used auth --format=json | jq '.usage | {routes: (.routes | length), groups: (.groups | length)}'
```

--------------------------------

### Performance Monitoring Script (v1.5)

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Examples

A bash script to monitor application performance using v1.5 commands, focusing on memory analysis and slow query detection.

```bash
#!/bin/bash
# performance-monitor.sh - Monitor application performance with v1.5 commands

echo "⚡ Laravel Devtoolbox Performance Monitor v1.5"

# Memory analysis
echo "🧠 Memory Analysis:"
php artisan dev:performance:memory --detailed

# Slow query detection
echo "📊 Slow Query Analysis:"
php artisan dev:performance:slow-queries --threshold=500 --duplicates --limit=10

```

--------------------------------

### Code Review Documentation Preparation Script

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Examples

A bash script to generate documentation for code review, including models, routes, relationships, application structure, container bindings, provider performance, and security checks.

```bash
#!/bin/bash
# prepare-review.sh - Generate documentation for code review

DATE=$(date +%Y%m%d)
mkdir -p review/$DATE

echo "📋 Preparing code review documentation..."

# Application structure
php artisan dev:models --format=json --output=review/$DATE/models.json
php artisan dev:routes --format=json --output=review/$DATE/routes.json
php artisan dev:model:graph --format=mermaid --output=review/$DATE/relationships.mmd

# Enhanced analysis (NEW!)
php artisan dev:about+ --extended --performance --security --format=json --output=review/$DATE/about.json
php artisan dev:container:bindings --show-resolved --format=json --output=review/$DATE/container.json

# Performance analysis
php artisan dev:providers:timeline --format=json --output=review/$DATE/providers.json

# Security check
php artisan dev:security:unprotected-routes --format=json --output=review/$DATE/security.json

echo "📁 Review documentation saved to review/$DATE/"
```

--------------------------------

### Security Audit and Configuration Diff

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Examples

Perform security checks by finding unprotected routes and comparing environment configurations.

```bash
# Find unprotected routes
php artisan dev:security:unprotected-routes --critical-only

# Compare environment configurations
php artisan dev:env:diff --against=.env.example

# Comprehensive security check
php artisan dev:security:unprotected-routes --format=json --output=security-report.json
```

--------------------------------

### Model Analysis and Visualization

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Examples

Analyze Eloquent models, find their usage, and generate visual relationship diagrams or export data for documentation.

```bash
# List all models
php artisan dev:models

# Find where User model is used
php artisan dev:model:where-used App\Models\User

# Generate visual relationship diagram
php artisan dev:model:graph --format=mermaid --output=models.mmd

# Export model data for documentation
php artisan dev:models --format=json --output=docs/models.json
```

--------------------------------

### Compare Current Performance Against Baseline with DevToolbox

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Examples

Compares current performance metrics (provider boot times and route duplicate queries) against a baseline directory. It uses `jq` to parse JSON and identifies performance regressions.

```bash
if [ -d "$BASELINE_DIR" ] && [ "$(ls -A $BASELINE_DIR)" ]; then
    echo "📊 Comparing with baseline..."
    
    CURRENT_SLOW=$(jq '.data | map(select(.boot_time > 100)) | length' "$CURRENT_DIR/providers.json")
    BASELINE_SLOW=$(jq '.data | map(select(.boot_time > 100)) | length' "$BASELINE_DIR/providers.json" 2>/dev/null || echo 0)
    
    if [ $CURRENT_SLOW -gt $BASELINE_SLOW ]; then
        echo "⚠️ Performance regression detected: Slow providers increased from $BASELINE_SLOW to $CURRENT_SLOW"
    fi
    
    for route in "${ROUTES[@]}"; do
        if [ -f "$BASELINE_DIR/$route-performance.json" ]; then
            CURRENT_DUPLICATES=$(jq '.data.duplicate_queries // 0' "$CURRENT_DIR/$route-performance.json" 2>/dev/null || echo 0)
            BASELINE_DUPLICATES=$(jq '.data.duplicate_queries // 0' "$BASELINE_DIR/$route-performance.json" 2>/dev/null || echo 0)
            
            if [ $CURRENT_DUPLICATES -gt $BASELINE_DUPLICATES ]; then
                echo "⚠️ Performance regression in $route: Duplicate queries increased from $BASELINE_DUPLICATES to $CURRENT_DUPLICATES"
            fi
        fi
    done
else
    echo "📁 Creating baseline performance metrics..."
    cp -r "$CURRENT_DIR/"* "$BASELINE_DIR/"
fi
```

--------------------------------

### Create Visual Diagrams with Bash

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Examples

This script generates visual documentation diagrams for model relationships using Mermaid format and integrates them into a README file. It utilizes Artisan commands to create the diagrams.

```bash
#!/bin/bash
# create-diagrams.sh - Generate visual documentation

echo "📊 Creating Visual Documentation"

mkdir -p diagrams

# Model relationships
php artisan dev:model:graph --format=mermaid --direction=TB --output=diagrams/models-vertical.mmd
php artisan dev:model:graph --format=mermaid --direction=LR --output=diagrams/models-horizontal.mmd

# Create README with diagrams
cat > diagrams/README.md << 'EOF'
# Application Architecture Diagrams

## Model Relationships (Vertical)
```mermaid
$(cat diagrams/models-vertical.mmd)
```

## Model Relationships (Horizontal)
```mermaid
$(cat diagrams/models-horizontal.mmd)
```
EOF

echo "📁 Diagrams created in diagrams/ directory"
```

--------------------------------

### CI/CD Documentation Generation Script

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/examples/README

A bash script for automatically generating documentation artifacts within a CI/CD pipeline, including application overviews, scans, model graphs, and container analyses.

```bash
#!/bin/bash
# Auto-generate documentation
DATE=$(date +%Y%m%d)
mkdir -p docs/generated/$DATE

# Enhanced application overview (NEW!)
echo "Generating enhanced application overview..."
php artisan dev:about+ --extended --performance --format=json --output=docs/generated/$DATE/about.json

# Full application scan
echo "Generating full application scan..."
php artisan dev:scan --all --format=json --output=docs/generated/$DATE/full-scan.json

# Model relationships
echo "Generating model relationships diagram..."
php artisan dev:model:graph --format=mermaid --output=docs/generated/$DATE/models.mmd

# Container analysis (NEW!)
echo "Generating container analysis..."
php artisan dev:container:bindings --show-resolved --format=json --output=docs/generated/$DATE/bindings.json
```

--------------------------------

### Route Inspection and Cleanup

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Examples

Inspect, list, and find unused routes for cleanup, with options to search by controller and show method details.

```bash
# List all routes
php artisan dev:routes

# Find unused routes for cleanup
php artisan dev:routes:unused

# Find routes by controller (NEW!)
php artisan dev:routes:where UserController

# Reverse lookup with details
php artisan dev:routes:where UserController --show-methods --include-parameters
```

--------------------------------

### Map Controller Routes

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Examples

Maps routes for specified controllers and outputs the results in JSON format. Errors during the process are ignored.

```bash
CONTROLLERS=("UserController" "ApiController" "AdminController" "ReportController")
mkdir -p docs/controllers
for controller in "${CONTROLLERS[@]}"; do
    php artisan dev:routes:where "$controller" --show-methods --include-parameters --format=json --output="docs/controllers/$controller.json" 2>/dev/null || true
done
```

--------------------------------

### Automating Documentation Generation (Bash)

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/examples/output-samples/README

Provides examples of automating documentation generation using Laravel Artisan commands, specifically for creating Mermaid diagrams of models and exporting model summaries to JSON.

```bash
# Auto-update architecture docs
php artisan dev:model:graph --format=mermaid --output=docs/models.mmd
php artisan dev:models --format=json | jq '.data[]' > docs/models-summary.json
```

--------------------------------

### Trace SQL Queries for Route

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/examples/README

Traces SQL queries executed for a specific route and HTTP method. Useful for detailed performance analysis of API endpoints or specific actions.

```bash
php artisan dev:sql:trace --route=api.users --method=GET
```

--------------------------------

### Get Help for Dev Commands

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Commands-Reference

Provides general help for all commands prefixed with 'dev:' or specific help for individual commands. This is crucial for understanding the available options and usage patterns.

```bash
# General help
php artisan list dev:

# Specific command help
php artisan dev:scan --help
php artisan dev:model:where-used --help
```

--------------------------------

### Database Query Optimization

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Examples

Analyze database column usage, trace SQL queries for specific routes, detect N+1 problems, and monitor for performance issues.

```bash
# Find unused database columns
php artisan dev:db:column-usage --unused-only

# Trace SQL queries for specific route
php artisan dev:sql:trace --route=dashboard

# Analyze N+1 problems (NEW!)
php artisan dev:sql:duplicates --route=users.index --threshold=1 --auto-explain

# Monitor for performance issues
php artisan dev:sql:duplicates --route=api.orders --threshold=2
```

--------------------------------

### Basic Health Check & Scan

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Examples

Perform an enhanced application overview and comprehensive scans of all components for quick metrics and health status.

```bash
# Enhanced application overview (NEW!)
php artisan dev:about+ --extended --performance

# Comprehensive scan of all components
php artisan dev:scan --all

# Get quick metrics
php artisan dev:scan --all --format=count
```

--------------------------------

### CI/CD Integration with DevToolbox

Source: https://github.com/grazulex/laravel-devtoolbox/blob/main/README.md

Illustrates how to integrate DevToolbox commands into CI/CD pipelines for automated quality gates. This example checks for a threshold of unused routes before proceeding.

```bash
# Quality gates in CI
UNUSED_ROUTES=$(php artisan dev:routes:unused --format=count | jq '.count')
if [ $UNUSED_ROUTES -gt 10 ]; then
  echo "Too many unused routes: $UNUSED_ROUTES"
  exit 1
fi
```

--------------------------------

### Trace Critical Routes in Bash

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/examples/README

This script iterates through a predefined list of critical routes and traces their SQL queries, outputting the analysis to JSON files. It requires the `dev:sql:trace` Artisan command.

```bash
CRITICAL_ROUTES=("home" "dashboard" "api.status")
for route in "${CRITICAL_ROUTES[@]}"; do
    echo "⚡ Tracing $route..."
    php artisan dev:sql:trace --route=$route --output="analysis/sql-$route.json"
done

echo "✅ Route analysis complete"
```

--------------------------------

### Get Application Overview with Laravel Devtoolbox

Source: https://github.com/grazulex/laravel-devtoolbox/blob/main/README.md

Retrieves an enhanced application overview, including extended information and performance metrics, using the `dev:about+` artisan command.

```bash
php artisan dev:about+ --extended --performance
```

--------------------------------

### Post-merge Hook for Documentation Update

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/examples/README

A bash script for a `.git/hooks/post-merge` file that automatically updates generated documentation after a merge. It generates overviews, model diagrams, route documentation, container bindings, and provider performance data.

```bash
# .git/hooks/post-merge - Enhanced documentation update

echo "📊 Updating documentation after merge..."

# Enhanced application overview (NEW!)
php artisan dev:about+ --extended --performance --format=json --output=docs/about.json

# Update model diagrams
php artisan dev:model:graph --format=mermaid --output=docs/models.mmd

# Update route documentation
php artisan dev:routes --format=json --output=docs/routes.json

# Container bindings documentation (NEW!)
php artisan dev:container:bindings --show-resolved --format=json --output=docs/container.json

# Provider performance baseline (NEW!)
php artisan dev:providers:timeline --include-deferred --format=json --output=docs/providers.json

git add docs/
git commit -m "docs: update auto-generated documentation with enhanced data" || true
```

--------------------------------

### Generate Refactoring Plan

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/examples/README

Creates a markdown file containing a refactoring plan for legacy code. It incorporates data from previously generated JSON analysis files (like unused routes and SQL issues) and suggests phases for migration and optimization.

```bash
echo "📋 Generating refactoring recommendations..."
cat > legacy/refactoring-plan.md << 'EOF'
# Legacy Code Refactoring Plan

**Generated:** $(date)

## Cleanup Opportunities

### Unused Routes
$(jq -r '.data | length' legacy/unused-routes.json 2>/dev/null || echo "0") unused routes found - candidates for removal

### Performance Issues
- Service providers with >50ms boot time (check provider-performance.json)
- N+1 problems in legacy routes (check sql/ directory)
- Complex container bindings (check container-analysis.json)

## Migration Strategy

### Phase 1: Quick Wins
1. Remove unused routes
2. Fix N+1 problems with eager loading
3. Optimize slow service providers

### Phase 2: Architecture Improvements
1. Refactor tightly coupled models
2. Modernize legacy controllers
3. Update deprecated middleware

### Phase 3: Performance Optimization
1. Review container bindings
2. Implement caching strategies
3. Database query optimization

## Next Steps
1. Review generated JSON files for detailed analysis
2. Prioritize changes based on impact and effort
3. Create feature branches for each refactoring phase

EOF

echo "✅ Enhanced legacy analysis complete"
echo "📁 Analysis results saved in legacy/ directory"
echo "📋 Review legacy/refactoring-plan.md for recommendations"
```

--------------------------------

### Check Laravel Devtoolbox Version

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Installation

Checks the currently installed version of the Laravel Devtoolbox package using Composer.

```bash
composer show grazulex/laravel-devtoolbox
```

--------------------------------

### Monitor Logs with Pattern Matching

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/examples/README

Tails application logs in real-time, filtering entries that match a specific pattern, such as 'slow', 'error', or 'exception'. Useful for targeted log monitoring.

```bash
php artisan dev:log:tail --follow --pattern="slow|error|exception"
```

--------------------------------

### Generate Analysis Reports

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Examples

Generates various analysis reports including a full system scan, database column usage, and unprotected routes, all in JSON format.

```bash
php artisan dev:scan --all --format=json --output=docs/analysis/full-scan.json
php artisan dev:db:column-usage --format=json --output=docs/analysis/database.json
php artisan dev:security:unprotected-routes --format=json --output=docs/analysis/security.json

echo "📁 Documentation generated in docs/ directory"
```

--------------------------------

### Pre-commit Hook for Enhanced Checks

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/examples/README

A bash script for a `.git/hooks/pre-commit` file that performs several checks before allowing a commit. It verifies unused routes, potential N+1 problems in critical routes, and service provider boot times.

```bash
# .git/hooks/pre-commit - Enhanced checks

echo "🔍 Running enhanced pre-commit checks..."

# Check for unused routes
UNUSED=$(php artisan dev:routes:unused --format=count | jq '.count')
if [ $UNUSED -gt 20 ]; then
    echo "❌ Too many unused routes: $UNUSED"
    echo "Please clean up unused routes before committing"
    exit 1
fi

# Check for N+1 problems in critical routes (NEW!)
CRITICAL_ROUTES=("dashboard" "users.index")
for route in "${CRITICAL_ROUTES[@]}"; do
    echo "🔍 Checking N+1 problems in $route..."
    if ! php artisan dev:sql:duplicates --route=$route --threshold=1 >/dev/null 2>&1; then
        echo "⚠️ Potential N+1 problems in $route - review before committing"
    fi
done

# Check service provider performance (NEW!)
SLOW_PROVIDERS=$(php artisan dev:providers:timeline --slow-threshold=200 --format=count | jq '.slow_count // 0')
if [ $SLOW_PROVIDERS -gt 5 ]; then
    echo "❌ Too many slow service providers: $SLOW_PROVIDERS"
    echo "Please optimize provider boot times before committing"
    exit 1
fi

echo "✅ Enhanced pre-commit checks passed"
```

--------------------------------

### Analyze SQL Performance for Route

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/examples/README

Analyzes SQL performance for a specific route, including automatic EXPLAIN statements for slow queries. Aids in identifying and resolving database performance bottlenecks.

```bash
php artisan dev:sql:duplicates --route=dashboard --auto-explain
```

--------------------------------

### Analyze Queue Configuration and Status (Bash)

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Commands-Reference

Analyze the overall queue configuration and current status. This command provides a general overview of your Laravel queue setup.

```bash
php artisan dev:queue:analysis
```

--------------------------------

### SQL Performance Tracking Script

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/examples/README

A bash script to track SQL performance, likely by executing commands that analyze query efficiency or identify duplicate queries.

```bash
#!/bin/bash
# Track SQL performance

# Example: Analyze SQL N+1 problems for a specific route
php artisan dev:sql:duplicates --route=posts.index --threshold=2

# Example: Trace SQL queries for a specific route
php artisan dev:sql:trace --route=api.comments --method=POST
```

--------------------------------

### Enhanced Laravel Application Analysis

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/examples/README

This script provides an enhanced analysis of a Laravel application, covering an overview, container and service analysis, route analysis with reverse lookups, and finding routes for common controllers. Outputs are saved in JSON format.

```bash
#!/bin/bash
# Comprehensive application analysis with new features

echo "🔍 Enhanced Laravel Application Analysis..."

# Enhanced overview
php artisan dev:about+ --extended --performance --security --format=json --output=analysis/overview.json

# Container and service analysis
php artisan dev:container:bindings --show-resolved --show-parameters --format=json --output=analysis/container.json
php artisan dev:providers:timeline --include-deferred --show-dependencies --format=json --output=analysis/providers.json

# Route analysis with reverse lookups
php artisan dev:routes --format=json --output=analysis/all-routes.json
php artisan dev:routes:unused --format=json --output=analysis/unused-routes.json

# Find routes for common controllers
CONTROLLERS=("UserController" "AuthController" "ApiController")
for controller in "${CONTROLLERS[@]}"; do
    echo "📊 Finding routes for $controller..."
    php artisan dev:routes:where "$controller" --format=json --output="analysis/$controller-routes.json"
done

echo "✅ Enhanced analysis complete"
```

--------------------------------

### CI/CD Quality Gates Script

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/examples/README

A bash script for CI/CD pipelines to enforce quality gates by checking for unused routes, N+1 SQL problems, and slow service providers. Exits with an error code if checks fail.

```bash
#!/bin/bash
# Check for code quality issues

UNUSED_ROUTES=$(php artisan dev:routes:unused --format=count | jq '.count')
if [ $UNUSED_ROUTES -gt 10 ]; then
    echo "❌ Too many unused routes: $UNUSED_ROUTES"
    exit 1
fi

# Check for N+1 problems (NEW!)
php artisan dev:sql:duplicates --route=api.users --threshold=1
if [ $? -ne 0 ]; then
    echo "❌ N+1 problems detected in critical routes"
    exit 1
fi

# Check provider performance (NEW!)
SLOW_PROVIDERS=$(php artisan dev:providers:timeline --slow-threshold=100 --format=count | jq '.slow_count // 0')
if [ $SLOW_PROVIDERS -gt 3 ]; then
    echo "❌ Too many slow service providers: $SLOW_PROVIDERS"
    exit 1
fi

echo "✅ Quality checks passed"
```

--------------------------------

### Analyze SQL N+1 Problems

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/examples/README

Identifies potential N+1 query problems by analyzing SQL query patterns for a specific route. Includes a threshold for detecting issues.

```bash
php artisan dev:sql:duplicates --route=users.index --threshold=2
```

--------------------------------

### Capture Application Performance Metrics with DevToolbox

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Examples

Captures current performance metrics for application providers and routes, saving them to JSON files. It uses `dev:providers:timeline` and `dev:about+` commands.

```bash
php artisan dev:providers:timeline --format=json > "$CURRENT_DIR/providers.json"
php artisan dev:about+ --performance --format=json > "$CURRENT_DIR/about.json"
```

--------------------------------

### Real-time Application Performance Monitoring

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/examples/README

This script monitors application performance in real-time by checking service provider performance, analyzing container bindings, and tailing logs for performance-related issues. It leverages specific DevToolbox commands for each task.

```bash
#!/bin/bash
# Monitor application performance in real-time

# Service provider performance
echo "📊 Checking service provider performance..."
php artisan dev:providers:timeline --slow-threshold=50

# Container binding analysis
echo "🔍 Analyzing container bindings..."
php artisan dev:container:bindings --show-resolved

# Log monitoring for performance issues
echo "📋 Monitoring logs for performance issues..."
php artisan dev:log:tail --follow --pattern="slow|timeout|memory" --level=warning
```

--------------------------------

### Analyze Critical Route Performance with DevToolbox

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/Examples

Iterates through a predefined list of critical routes, analyzing SQL query duplicates for each and saving the results to JSON files. It handles potential errors by redirecting stderr and continuing.

```bash
ROUTES=("dashboard" "users.index" "api.orders")
for route in "${ROUTES[@]}"; do
    php artisan dev:sql:duplicates --route=$route --format=json > "$CURRENT_DIR/$route-performance.json" 2>/dev/null || true
done
```

--------------------------------

### Analyze Legacy Code for Refactoring

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/examples/README

Assesses legacy code to identify areas for refactoring. This includes generating an enhanced application overview, finding unused routes, analyzing provider performance, and examining container bindings.

```bash
#!/bin/bash
# Analyze legacy code for refactoring with enhanced tools

echo "🔧 Analyzing legacy code with enhanced tools..."
mkdir -p legacy

# Enhanced application overview to understand current state (NEW!)
php artisan dev:about+ --extended --performance --format=json --output=legacy/current-state.json

# Find unused routes (potential cleanup candidates)
php artisan dev:routes:unused --format=json --output=legacy/unused-routes.json

# Analyze service provider performance for legacy providers (NEW!)
php artisan dev:providers:timeline --slow-threshold=50 --show-dependencies --format=json --output=legacy/provider-performance.json

# Container binding analysis to understand dependencies (NEW!)
php artisan dev:container:bindings --show-resolved --show-parameters --format=json --output=legacy/container-analysis.json
```

--------------------------------

### Daily Development Checks Script

Source: https://github.com/grazulex/laravel-devtoolbox/wiki/examples/README

A bash script that performs several daily development checks, including counting unused routes, getting a model overview, and comparing environment files.

```bash
#!/bin/bash
echo "🔍 Running daily development checks..."

# Check for unused routes
echo "📍 Checking for unused routes..."
php artisan dev:routes:unused --format=count

# Quick model overview
echo "📊 Model overview..."
php artisan dev:models --format=count

# Environment consistency
echo "⚙️ Environment check..."
php artisan dev:env:diff --against=.env.example
```

--------------------------------

### Install Dependencies with Composer

Source: https://github.com/grazulex/laravel-devtoolbox/blob/main/CONTRIBUTING.md

Installs project dependencies using Composer, a dependency manager for PHP. This is a crucial step before making changes or running tests.

```bash
composer install
```
Tokens:
Raw