Advanced CLI Features

Advanced Feature Overview

The InitRepo CLI goes beyond basic code analysis to provide enterprise-grade automation, team collaboration features, and comprehensive integration capabilities. This guide covers advanced usage patterns for power users, teams, and enterprise environments.

CI/CD Integration

Automated quality gates and reporting in build pipelines

Team Workflows

Standardized analysis and collaborative development practices

API Integration

Programmatic access and custom automation solutions

Enterprise Features

Large-scale analysis, compliance, and security features

CI/CD Integration

GitHub Actions Integration

Complete GitHub Actions workflow for automated quality checks:

# .github/workflows/code-quality.yml
name: InitRepo Code Quality Analysis
on: [push, pull_request]

jobs:
  quality-check:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '18'

      - name: Install InitRepo CLI
        run: npm install -g initrepo-cli

      - name: Structure Validation
        run: |
          initrepo-cli validate-structure --format=json > validation.json
          echo "Structure validation completed"

      - name: Complexity Analysis
        run: |
          initrepo-cli analyze-complexity --threshold=15 --format=json > complexity.json
          echo "Complexity analysis completed"

      - name: Import Analysis
        run: |
          initrepo-cli analyze-imports --format=json > imports.json
          echo "Import analysis completed"

      - name: Quality Gate
        run: |
          score=$(jq '.data.score' validation.json)
          high_complexity=$(jq '.data.summary.highPriority' complexity.json)
          unused_imports=$(jq '.data.summary.unusedImports' imports.json)
          
          echo "📊 Quality Metrics:"
          echo "Structure Score: $score/100"
          echo "High Complexity Issues: $high_complexity"
          echo "Unused Imports: $unused_imports"
          
          if [ "$score" -lt 80 ]; then
            echo "❌ Structure score too low: $score/100"
            exit 1
          fi
          
          if [ "$high_complexity" -gt 5 ]; then
            echo "❌ Too many high complexity issues: $high_complexity"
            exit 1
          fi
          
          echo "✅ Quality gate passed!"

      - name: Upload Reports
        uses: actions/upload-artifact@v3
        with:
          name: quality-reports
          path: |
            validation.json
            complexity.json
            imports.json

GitLab CI Integration

# .gitlab-ci.yml
stages:
  - quality

initrepo_analysis:
  stage: quality
  image: node:18
  before_script:
    - npm install -g initrepo-cli
  script:
    - echo "🔍 Running InitRepo analysis..."
    - initrepo-cli validate-structure --format=json > validation.json
    - initrepo-cli analyze-complexity --format=json > complexity.json
    - initrepo-cli analyze-imports --format=json > imports.json
    
    # Quality gates
    - |
      score=$(jq '.data.score' validation.json)
      if [ "$score" -lt 70 ]; then
        echo "Structure score too low: $score/100"
        exit 1
      fi
      echo "✅ Quality checks passed!"
  artifacts:
    paths:
      - validation.json
      - complexity.json
      - imports.json
    expire_in: 1 week
  only:
    - merge_requests

Jenkins Pipeline Integration

// Jenkinsfile
pipeline {
    agent any

    stages {
        stage('Setup') {
            steps {
                sh 'npm install -g initrepo-cli'
            }
        }

        stage('Code Quality Analysis') {
            steps {
                sh '''
                    echo "🔍 Running InitRepo analysis..."
                    initrepo-cli validate-structure --format=json > validation.json
                    initrepo-cli analyze-complexity --format=json > complexity.json
                    initrepo-cli analyze-imports --format=json > imports.json
                '''
                archiveArtifacts artifacts: '*.json', fingerprint: true
            }
        }

        stage('Quality Gate') {
            steps {
                script {
                    def validation = readJSON file: 'validation.json'
                    def complexity = readJSON file: 'complexity.json'
                    def imports = readJSON file: 'imports.json'

                    echo "📊 Quality Metrics:"
                    echo "Structure Score: ${validation.data.score}/100"
                    echo "High Complexity: ${complexity.data.summary.highPriority}"
                    echo "Unused Imports: ${imports.data.summary.unusedImports}"

                    if (validation.data.score < 75) {
                        error("Structure score too low: ${validation.data.score}/100")
                    }

                    if (complexity.data.summary.highPriority > 10) {
                        error("Too many high complexity issues: ${complexity.data.summary.highPriority}")
                    }

                    echo "✅ Quality gate passed!"
                }
            }
        }
    }

    post {
        always {
            publishHTML([
                allowMissing: false,
                alwaysLinkToLastBuild: true,
                keepAll: true,
                reportDir: '.',
                reportFiles: '*.json',
                reportName: 'InitRepo Analysis Report'
            ])
        }
    }
}

Automation & Scripting

Shell Script Integration

Create powerful automation scripts for consistent quality checks:

#!/bin/bash
# comprehensive-analysis.sh - Complete project analysis workflow

set -e  # Exit on any error

PROJECT_NAME="${1:-$(basename $(pwd))}"
OUTPUT_DIR="${2:-./initrepo-reports}"
TIMESTAMP=$(date +"%Y%m%d_%H%M%S")

echo "🚀 Starting comprehensive analysis for $PROJECT_NAME..."

# Create output directory
mkdir -p "$OUTPUT_DIR"

# Run all analyses
echo "📊 Running structure validation..."
initrepo-cli validate-structure --format=json > "$OUTPUT_DIR/validation_$TIMESTAMP.json"

echo "🔍 Running complexity analysis..."
initrepo-cli analyze-complexity --threshold=12 --format=json > "$OUTPUT_DIR/complexity_$TIMESTAMP.json"

echo "📋 Running import analysis..."
initrepo-cli analyze-imports --format=json > "$OUTPUT_DIR/imports_$TIMESTAMP.json"

echo "📦 Running dependency analysis..."
initrepo-cli deps --format=json > "$OUTPUT_DIR/dependencies_$TIMESTAMP.json"

echo "🎯 Running refactoring analysis..."
initrepo-cli suggest-refactor --format=json > "$OUTPUT_DIR/refactor_$TIMESTAMP.json"

# Generate comprehensive report
echo "📝 Generating comprehensive report..."
cat > "$OUTPUT_DIR/summary_$TIMESTAMP.md" << EOF
# Comprehensive Analysis Report - $PROJECT_NAME

**Generated:** $(date)
**Analysis ID:** $TIMESTAMP

## Summary

### Structure Validation
- **Score:** $(jq '.data.score' "$OUTPUT_DIR/validation_$TIMESTAMP.json")/100
- **Issues:** $(jq '.data.issues | length' "$OUTPUT_DIR/validation_$TIMESTAMP.json")

### Code Complexity
- **Total Functions:** $(jq '.data.summary.totalFunctions' "$OUTPUT_DIR/complexity_$TIMESTAMP.json")
- **High Priority:** $(jq '.data.summary.highPriority' "$OUTPUT_DIR/complexity_$TIMESTAMP.json")
- **Average Complexity:** $(jq '.data.summary.averageComplexity' "$OUTPUT_DIR/complexity_$TIMESTAMP.json")

### Import Health
- **Total Imports:** $(jq '.data.summary.totalImports' "$OUTPUT_DIR/imports_$TIMESTAMP.json")
- **Unused Imports:** $(jq '.data.summary.unusedImports' "$OUTPUT_DIR/imports_$TIMESTAMP.json")
- **Circular Dependencies:** $(jq '.data.summary.circularDependencies' "$OUTPUT_DIR/imports_$TIMESTAMP.json")

### Dependencies
- **Runtime:** $(jq '.data.runtime | length' "$OUTPUT_DIR/dependencies_$TIMESTAMP.json")
- **Development:** $(jq '.data.development | length' "$OUTPUT_DIR/dependencies_$TIMESTAMP.json")

### Refactoring Suggestions
- **Total Suggestions:** $(jq '.data.suggestions | length' "$OUTPUT_DIR/refactor_$TIMESTAMP.json")

## Recommendations

$(jq -r '.data.recommendations[]' "$OUTPUT_DIR/refactor_$TIMESTAMP.json" 2>/dev/null || echo "No specific recommendations available")

EOF

echo "✅ Analysis complete! Reports available in: $OUTPUT_DIR"
echo "📋 Summary: $OUTPUT_DIR/summary_$TIMESTAMP.md"

Node.js API Integration

Create programmatic interfaces for custom tooling:

// initrepo-api.js - Programmatic InitRepo interface
const { exec } = require('child_process');
const util = require('util');
const execAsync = util.promisify(exec);

class InitRepoAPI {
    constructor(projectPath = process.cwd()) {
        this.projectPath = projectPath;
    }

    async analyzeProject(options = {}) {
        const commands = {
            structure: 'initrepo-cli validate-structure --format=json',
            complexity: `initrepo-cli analyze-complexity --threshold=${options.threshold || 10} --format=json`,
            imports: 'initrepo-cli analyze-imports --format=json',
            dependencies: 'initrepo-cli deps --format=json'
        };

        const results = {};
        
        for (const [key, command] of Object.entries(commands)) {
            try {
                console.log(`🔍 Running ${key} analysis...`);
                const { stdout } = await execAsync(command, { cwd: this.projectPath });
                results[key] = JSON.parse(stdout);
            } catch (error) {
                console.error(`❌ Error in ${key} analysis:`, error.message);
                results[key] = { error: error.message };
            }
        }

        return {
            timestamp: new Date().toISOString(),
            projectPath: this.projectPath,
            results
        };
    }

    async safeRefactor(oldName, newName, options = {}) {
        const dryRun = options.preview ? '--dry-run' : '';
        const backup = options.backup ? '--backup' : '';
        
        try {
            const { stdout } = await execAsync(
                `initrepo-cli safe-rename "${oldName}" "${newName}" ${dryRun} ${backup} --format=json`,
                { cwd: this.projectPath }
            );
            return JSON.parse(stdout);
        } catch (error) {
            throw new Error(`Refactoring failed: ${error.message}`);
        }
    }

    async generateReport(outputPath = './initrepo-report.json') {
        const analysis = await this.analyzeProject();
        
        // Add quality score calculation
        const structureScore = analysis.results.structure?.data?.score || 0;
        const complexityIssues = analysis.results.complexity?.data?.summary?.highPriority || 0;
        const unusedImports = analysis.results.imports?.data?.summary?.unusedImports || 0;
        
        const report = {
            ...analysis,
            qualityMetrics: {
                structureScore,
                complexityIssues,
                unusedImports,
                overallGrade: this.calculateGrade(structureScore, complexityIssues, unusedImports)
            }
        };

        const fs = require('fs').promises;
        await fs.writeFile(outputPath, JSON.stringify(report, null, 2));
        
        return report;
    }

    calculateGrade(structureScore, complexityIssues, unusedImports) {
        let score = structureScore;
        score -= (complexityIssues * 5); // -5 points per high complexity issue
        score -= (unusedImports * 1); // -1 point per unused import
        
        if (score >= 90) return 'A';
        if (score >= 80) return 'B';
        if (score >= 70) return 'C';
        if (score >= 60) return 'D';
        return 'F';
    }
}

// Usage example
async function main() {
    const api = new InitRepoAPI('/path/to/project');
    
    try {
        console.log('🚀 Starting comprehensive analysis...');
        const report = await api.generateReport('./project-analysis.json');
        
        console.log('📊 Analysis Results:');
        console.log(`Structure Score: ${report.qualityMetrics.structureScore}/100`);
        console.log(`Complexity Issues: ${report.qualityMetrics.complexityIssues}`);
        console.log(`Unused Imports: ${report.qualityMetrics.unusedImports}`);
        console.log(`Overall Grade: ${report.qualityMetrics.overallGrade}`);
        
    } catch (error) {
        console.error('❌ Analysis failed:', error.message);
        process.exit(1);
    }
}

// Export for use in other modules
module.exports = InitRepoAPI;

// Run if called directly
if (require.main === module) {
    main();
}

Team Collaboration Features

Standardized Team Workflows

#!/bin/bash
# team-setup.sh - Set up standardized team configuration

TEAM_CONFIG_DIR="./team-initrepo-config"

echo "🏗️ Setting up team InitRepo configuration..."

# Create team configuration directory
mkdir -p "$TEAM_CONFIG_DIR"

# Team .initrepoignore template
cat > "$TEAM_CONFIG_DIR/.initrepoignore" << 'EOF'
# Team standard exclusions
node_modules/
.git/
dist/
build/
coverage/
.cache/
*.log
.env*
.DS_Store
Thumbs.db

# IDE files
.vscode/
.idea/
*.swp
*.swo

# Temporary files
*.tmp
*.temp
.tmp/
EOF

# Team coding standards configuration
cat > "$TEAM_CONFIG_DIR/coding-standards.json" << 'EOF'
{
  "complexityThreshold": 10,
  "maxFileSize": 500,
  "requireReadme": true,
  "requireTests": true,
  "namingConvention": "camelCase",
  "maxFunctionLength": 50,
  "maxClassLength": 300
}
EOF

# Team analysis script
cat > "$TEAM_CONFIG_DIR/team-analysis.sh" << 'EOF'
#!/bin/bash
# team-analysis.sh - Standardized team analysis

PROJECT_NAME="${1:-$(basename $(pwd))}"
echo "🔍 Running standardized team analysis for $PROJECT_NAME..."

# Copy team configuration
cp team-initrepo-config/.initrepoignore ./ 2>/dev/null || true

# Run standardized analysis
initrepo-cli validate-structure --format=json > "team-validation.json"
initrepo-cli analyze-complexity --threshold=10 --format=json > "team-complexity.json"
initrepo-cli analyze-imports --format=json > "team-imports.json"

# Generate team report
echo "📋 Generating team report..."
cat > "team-report.md" << 'REPORT'
# Team Analysis Report

## Quality Metrics
- Structure Score: $(jq '.data.score' team-validation.json)/100
- High Complexity Issues: $(jq '.data.summary.highPriority' team-complexity.json)
- Unused Imports: $(jq '.data.summary.unusedImports' team-imports.json)

## Team Standards Compliance
$(jq -r '.data.compliance | to_entries[] | "- \(.key): \(.value)"' team-validation.json 2>/dev/null || echo "- Standards check: In progress")

## Recommendations
$(jq -r '.data.recommendations[]?' team-complexity.json 2>/dev/null || echo "See detailed JSON files for specific recommendations")
REPORT

echo "✅ Team analysis complete!"
echo "📄 Report: team-report.md"
EOF

chmod +x "$TEAM_CONFIG_DIR/team-analysis.sh"

echo "✅ Team configuration setup complete!"
echo "📁 Configuration available in: $TEAM_CONFIG_DIR"
echo "🚀 Run: $TEAM_CONFIG_DIR/team-analysis.sh"

Pre-commit Hooks

Integrate InitRepo with Git hooks for automatic quality checks:

#!/bin/bash
# .git/hooks/pre-commit - InitRepo quality gate

echo "🔍 Running InitRepo quality checks..."

# Run lightweight analysis
initrepo-cli validate-structure --format=json > /tmp/pre-commit-structure.json
initrepo-cli analyze-imports --format=json > /tmp/pre-commit-imports.json

# Check structure score
score=$(jq '.data.score' /tmp/pre-commit-structure.json)
unused_imports=$(jq '.data.summary.unusedImports' /tmp/pre-commit-imports.json)

echo "📊 Pre-commit Results:"
echo "Structure Score: $score/100"
echo "Unused Imports: $unused_imports"

if [ "$score" -lt 70 ]; then
    echo "❌ Structure score too low: $score/100"
    echo "Please improve project structure before committing."
    exit 1
fi

if [ "$unused_imports" -gt 10 ]; then
    echo "⚠️ Many unused imports: $unused_imports"
    echo "Consider cleaning up imports: initrepo-cli manage-imports --remove-unused"
    # Don't block commit for unused imports, just warn
fi

echo "✅ Pre-commit quality checks passed!"

Enterprise Features

Large-Scale Analysis

For enterprise environments with multiple repositories:

#!/bin/bash
# enterprise-analysis.sh - Multi-repository analysis

REPOS_DIR="${1:-./repositories}"
OUTPUT_DIR="${2:-./enterprise-analysis}"
PARALLEL_JOBS="${3:-4}"

echo "🏢 Starting enterprise-wide analysis..."
echo "Repositories: $REPOS_DIR"
echo "Output: $OUTPUT_DIR" 
echo "Parallel jobs: $PARALLEL_JOBS"

mkdir -p "$OUTPUT_DIR"

# Function to analyze a single repository
analyze_repo() {
    local repo_path="$1"
    local repo_name=$(basename "$repo_path")
    
    echo "🔍 Analyzing $repo_name..."
    
    cd "$repo_path"
    
    # Run comprehensive analysis
    initrepo-cli validate-structure --format=json > "$OUTPUT_DIR/${repo_name}-structure.json"
    initrepo-cli analyze-complexity --format=json > "$OUTPUT_DIR/${repo_name}-complexity.json"
    initrepo-cli analyze-imports --format=json > "$OUTPUT_DIR/${repo_name}-imports.json"
    initrepo-cli deps --format=json > "$OUTPUT_DIR/${repo_name}-deps.json"
    
    echo "✅ Completed analysis for $repo_name"
}

# Export function for parallel execution
export -f analyze_repo
export OUTPUT_DIR

# Find all repositories and run analysis in parallel
find "$REPOS_DIR" -type d -name ".git" | while read git_dir; do
    echo "${git_dir%/.git}"
done | xargs -I {} -P "$PARALLEL_JOBS" bash -c 'analyze_repo "{}"'

# Generate enterprise summary report
echo "📊 Generating enterprise summary..."

python3 << 'EOF'
import json
import os
import glob
from datetime import datetime

output_dir = os.environ['OUTPUT_DIR']
repos = set()

# Collect all repository names
for file in glob.glob(f"{output_dir}/*-structure.json"):
    repo = os.path.basename(file).replace('-structure.json', '')
    repos.add(repo)

summary = {
    'timestamp': datetime.now().isoformat(),
    'total_repositories': len(repos),
    'repositories': {}
}

for repo in repos:
    try:
        with open(f"{output_dir}/{repo}-structure.json") as f:
            structure = json.load(f)
        with open(f"{output_dir}/{repo}-complexity.json") as f:
            complexity = json.load(f)
        with open(f"{output_dir}/{repo}-imports.json") as f:
            imports = json.load(f)
            
        summary['repositories'][repo] = {
            'structure_score': structure.get('data', {}).get('score', 0),
            'complexity_issues': complexity.get('data', {}).get('summary', {}).get('highPriority', 0),
            'unused_imports': imports.get('data', {}).get('summary', {}).get('unusedImports', 0)
        }
    except Exception as e:
        print(f"Error processing {repo}: {e}")

with open(f"{output_dir}/enterprise-summary.json", 'w') as f:
    json.dump(summary, f, indent=2)

print("📋 Enterprise summary saved to enterprise-summary.json")
EOF

echo "🎉 Enterprise analysis complete!"
echo "📊 Summary: $OUTPUT_DIR/enterprise-summary.json"

Compliance and Security

#!/bin/bash
# compliance-check.sh - Security and compliance validation

echo "🔒 Running compliance and security checks..."

# Security-focused analysis
initrepo-cli analyze-imports --check-security --format=json > security-analysis.json

# Compliance validation (future feature)
# initrepo-cli validate-compliance --standard=sox --format=json > compliance.json

# Custom security patterns check
security_patterns=(
    "password.*=.*[\"'].*[\"']"
    "api_key.*=.*[\"'].*[\"']"
    "secret.*=.*[\"'].*[\"']"
    "token.*=.*[\"'].*[\"']"
)

echo "🔍 Checking for security patterns..."
for pattern in "${security_patterns[@]}"; do
    if grep -r -E "$pattern" . --exclude-dir=node_modules --exclude-dir=.git; then
        echo "⚠️ Potential security issue found: $pattern"
    fi
done

echo "✅ Security and compliance check complete"

Team Collaboration Features

Standardized Team Workflows

Create consistent analysis workflows across your development team:

#!/bin/bash
# team-setup.sh - Set up standardized team configuration

TEAM_CONFIG_DIR="./team-initrepo-config"

echo "🏗️ Setting up team InitRepo configuration..."

# Create team configuration directory
mkdir -p "$TEAM_CONFIG_DIR"

# Team .initrepoignore template
cat > "$TEAM_CONFIG_DIR/.initrepoignore" << 'EOF'
# Team standard exclusions
node_modules/
.git/
dist/
build/
*.log
.env*
coverage/
.DS_Store
Thumbs.db

# IDE files
.vscode/
.idea/
*.swp
*.swo

# Temporary files
*.tmp
*.temp
.tmp/
EOF

# Team coding standards configuration
cat > "$TEAM_CONFIG_DIR/coding-standards.json" << 'EOF'
{
  "complexityThreshold": 10,
  "maxFileSize": 500,
  "requireReadme": true,
  "requireTests": true,
  "namingConvention": "camelCase",
  "maxFunctionLength": 50,
  "maxClassLength": 300
}
EOF

# Team analysis script
cat > "$TEAM_CONFIG_DIR/team-analysis.sh" << 'EOF'
#!/bin/bash
# team-analysis.sh - Standardized team analysis

PROJECT_NAME="${1:-$(basename $(pwd))}"
echo "🔍 Running standardized team analysis for $PROJECT_NAME..."

# Copy team configuration
cp team-initrepo-config/.initrepoignore ./ 2>/dev/null || true

# Run standardized analysis
initrepo-cli validate-structure --format=json > "team-validation.json"
initrepo-cli analyze-complexity --threshold=10 --format=json > "team-complexity.json"
initrepo-cli analyze-imports --format=json > "team-imports.json"

# Generate team report
echo "📋 Generating team report..."
cat > "team-report.md" << 'REPORT'
# Team Analysis Report

## Quality Metrics
- Structure Score: $(jq '.data.score' team-validation.json)/100
- High Complexity Issues: $(jq '.data.summary.highPriority' team-complexity.json)
- Unused Imports: $(jq '.data.summary.unusedImports' team-imports.json)

## Team Standards Compliance
$(jq -r '.data.compliance | to_entries[] | "- \(.key): \(.value)"' team-validation.json 2>/dev/null || echo "- Standards check: In progress")

## Recommendations
$(jq -r '.data.recommendations[]?' team-complexity.json 2>/dev/null || echo "See detailed JSON files for specific recommendations")
REPORT

echo "✅ Team analysis complete!"
echo "📄 Report: team-report.md"
EOF

chmod +x "$TEAM_CONFIG_DIR/team-analysis.sh"

echo "✅ Team configuration setup complete!"
echo "📁 Configuration available in: $TEAM_CONFIG_DIR"
echo "🚀 Run: $TEAM_CONFIG_DIR/team-analysis.sh"

Pre-commit Hooks

Integrate InitRepo with Git hooks for automatic quality checks:

#!/bin/bash
# .git/hooks/pre-commit - InitRepo quality gate

echo "🔍 Running InitRepo quality checks..."

# Run lightweight analysis
initrepo-cli validate-structure --format=json > /tmp/pre-commit-structure.json
initrepo-cli analyze-imports --format=json > /tmp/pre-commit-imports.json

# Check structure score
structure_score=$(jq '.data.score' /tmp/pre-commit-structure.json)
unused_imports=$(jq '.data.summary.unusedImports' /tmp/pre-commit-imports.json)

echo "📊 Pre-commit Results:"
echo "Structure Score: $structure_score/100"
echo "Unused Imports: $unused_imports"

if [ "$structure_score" -lt 70 ]; then
    echo "❌ Structure score too low: $structure_score/100"
    echo "Please improve project structure before committing."
    exit 1
fi

if [ "$unused_imports" -gt 10 ]; then
    echo "⚠️ Many unused imports: $unused_imports"
    echo "Consider cleaning up imports: initrepo-cli manage-imports --remove-unused"
    # Don't block commit for unused imports, just warn
fi

echo "✅ Pre-commit quality checks passed!"

Collaborative Templates

Create standardized project templates for your team:

// team-templates/react-component.js
module.exports = (variables) => `
/**
 * ${variables.componentName} Component
 *
 * @description ${variables.description || 'A reusable React component'}
 * @author Team Name
 * @version 1.0.0
 * @since ${new Date().toISOString().split('T')[0]}
 */

import React, { useState, useEffect } from 'react';
import PropTypes from 'prop-types';
import './${variables.componentName}.css';

// Team coding standards
const ${variables.componentName} = ({
  id,
  className,
  children,
  onChange,
  disabled = false,
  ...props
}) => {
  const [isLoading, setIsLoading] = useState(false);
  const [error, setError] = useState(null);

  useEffect(() => {
    // Component initialization
    return () => {
      // Cleanup
    };
  }, []);

  const handleAction = async () => {
    try {
      setIsLoading(true);
      setError(null);

      // Component logic here

      if (onChange) {
        onChange();
      }
    } catch (err) {
      setError(err.message);
    } finally {
      setIsLoading(false);
    }
  };

  return (
    <div
      id={id}
      className={\`\${className || ''} ${variables.componentName.toLowerCase()}-container\`}
      {...props}
    >
      {error && (
        <div className="error-message" role="alert">
          {error}
        </div>
      )}

      <div className="component-content">
        {children}
      </div>

      <button
        type="button"
        onClick={handleAction}
        disabled={disabled || isLoading}
        className="action-button"
      >
        {isLoading ? 'Loading...' : 'Action'}
      </button>
    </div>
  );
};

${variables.componentName}.propTypes = {
  id: PropTypes.string,
  className: PropTypes.string,
  children: PropTypes.node,
  onChange: PropTypes.func,
  disabled: PropTypes.bool
};

${variables.componentName}.defaultProps = {
  disabled: false
};

export default ${variables.componentName};
`;

Enterprise Features

Large-Scale Analysis

For enterprise environments with multiple repositories:

#!/bin/bash
# enterprise-analysis.sh - Multi-repository analysis

REPOS_DIR="${1:-./repositories}"
OUTPUT_DIR="${2:-./enterprise-analysis}"
PARALLEL_JOBS="${3:-4}"

echo "🏢 Starting enterprise-wide analysis..."
echo "Repositories: $REPOS_DIR"
echo "Output: $OUTPUT_DIR"
echo "Parallel jobs: $PARALLEL_JOBS"

mkdir -p "$OUTPUT_DIR"

# Function to analyze a single repository
analyze_repo() {
    local repo_path="$1"
    local repo_name=$(basename "$repo_path")

    echo "🔍 Analyzing $repo_name..."

    cd "$repo_path"

    # Run comprehensive analysis
    initrepo-cli validate-structure --format=json > "$OUTPUT_DIR/${repo_name}-structure.json"
    initrepo-cli analyze-complexity --format=json > "$OUTPUT_DIR/${repo_name}-complexity.json"
    initrepo-cli analyze-imports --format=json > "$OUTPUT_DIR/${repo_name}-imports.json"
    initrepo-cli deps --format=json > "$OUTPUT_DIR/${repo_name}-deps.json"

    echo "✅ Completed analysis for $repo_name"
}

# Export function for parallel execution
export -f analyze_repo
export OUTPUT_DIR

# Find all repositories and run analysis in parallel
find "$REPOS_DIR" -type d -name ".git" | while read git_dir; do
    echo "${git_dir%/.git}"
done | xargs -I {} -P "$PARALLEL_JOBS" bash -c 'analyze_repo "{}"'

# Generate enterprise summary report
echo "📊 Generating enterprise summary..."

python3 << 'EOF'
import json
import os
import glob
from datetime import datetime

output_dir = os.environ['OUTPUT_DIR']
repos = set()

# Collect all repository names
for file in glob.glob(f"{output_dir}/*-structure.json"):
    repo = os.path.basename(file).replace('-structure.json', '')
    repos.add(repo)

summary = {
    'timestamp': datetime.now().isoformat(),
    'total_repositories': len(repos),
    'repositories': {}
}

for repo in repos:
    try:
        with open(f"{output_dir}/{repo}-structure.json") as f:
            structure = json.load(f)
        with open(f"{output_dir}/{repo}-complexity.json") as f:
            complexity = json.load(f)
        with open(f"{output_dir}/{repo}-imports.json") as f:
            imports = json.load(f)

        summary['repositories'][repo] = {
            'structure_score': structure.get('data', {}).get('score', 0),
            'complexity_issues': complexity.get('data', {}).get('summary', {}).get('highPriority', 0),
            'unused_imports': imports.get('data', {}).get('summary', {}).get('unusedImports', 0)
        }
    except Exception as e:
        print(f"Error processing {repo}: {e}")

with open(f"{output_dir}/enterprise-summary.json", 'w') as f:
    json.dump(summary, f, indent=2)

print("📋 Enterprise summary saved to enterprise-summary.json")
EOF

echo "🎉 Enterprise analysis complete!"
echo "📊 Summary: $OUTPUT_DIR/enterprise-summary.json"

Audit Logging

Enable comprehensive audit logging for enterprise compliance:

# Enable audit logging
export INITREPO_AUDIT_ENABLED=true
export INITREPO_AUDIT_FILE=/var/log/initrepo/audit.log

# View audit logs
tail -f /var/log/initrepo/audit.log

# Analyze audit data
jq '.timestamp + " " + .command + " " + .user' /var/log/initrepo/audit.log

Performance Optimization

Large Project Optimization

# Optimize for large projects
export NODE_OPTIONS="--max-old-space-size=4096"

# Use chunked processing
initrepo-cli analyze-complexity --chunk-size=100

# Process specific patterns only
initrepo-cli analyze --include "src/**/*.js" --exclude "**/*.test.js"

# Use streaming for large outputs
initrepo-cli generate-structure --stream-output

Caching Configuration

# Enable analysis caching
export INITREPO_CACHE_ENABLED=true
export INITREPO_CACHE_DIR=~/.initrepo/cache
export INITREPO_CACHE_TTL=3600  # 1 hour

# Clear cache when needed
rm -rf ~/.initrepo/cache

Next Steps

MCP Server Integration

Connect your CLI workflows with AI assistants through the MCP server

Integration Guides

Set up integrations with popular AI IDEs and development tools

Complete Platform Overview

See how CLI advanced features fit into the complete InitRepo ecosystem

Getting Started

Plans & Pricing

Security & Compliance

MCP Server

CLI Tool

Advanced CLI Features

Advanced Feature Overview

CI/CD Integration

Team Workflows

API Integration

Enterprise Features

CI/CD Integration

GitHub Actions Integration

GitLab CI Integration

Jenkins Pipeline Integration

Automation & Scripting

Shell Script Integration

Node.js API Integration

Team Collaboration Features

Standardized Team Workflows

Pre-commit Hooks

Enterprise Features

Large-Scale Analysis

Compliance and Security

Team Collaboration Features

Standardized Team Workflows

Pre-commit Hooks

Collaborative Templates

Enterprise Features

Large-Scale Analysis

Audit Logging

Performance Optimization

Large Project Optimization

Caching Configuration

Next Steps

MCP Server Integration

Integration Guides

Complete Platform Overview

​Advanced Feature Overview

CI/CD Integration

Team Workflows

API Integration

Enterprise Features

​CI/CD Integration

​GitHub Actions Integration

​GitLab CI Integration

​Jenkins Pipeline Integration

​Automation & Scripting

​Shell Script Integration

​Node.js API Integration

​Team Collaboration Features

​Standardized Team Workflows

​Pre-commit Hooks

​Enterprise Features

​Large-Scale Analysis

​Compliance and Security

​Team Collaboration Features

​Standardized Team Workflows

​Pre-commit Hooks

​Collaborative Templates

​Enterprise Features

​Large-Scale Analysis

​Audit Logging

​Performance Optimization

​Large Project Optimization

​Caching Configuration

​Next Steps

MCP Server Integration

Integration Guides

Complete Platform Overview

Advanced Feature Overview

CI/CD Integration

GitHub Actions Integration

GitLab CI Integration

Jenkins Pipeline Integration

Automation & Scripting

Shell Script Integration

Node.js API Integration

Team Collaboration Features

Standardized Team Workflows

Pre-commit Hooks

Enterprise Features

Large-Scale Analysis

Compliance and Security

Team Collaboration Features

Standardized Team Workflows

Pre-commit Hooks

Collaborative Templates

Enterprise Features

Large-Scale Analysis

Audit Logging

Performance Optimization

Large Project Optimization

Caching Configuration

Next Steps