Data

Tools

Indexes

Applications

Experiments

Awesome

An open API service indexing awesome lists of open source software.

https://github.com/wronai/devix

Automated development and code repair system with enhanced analysis capabilities
https://github.com/wronai/devix

automated-development code-analysis code-repair continuous-integration markdown monitoring python quality-assurance testing wronai

Last synced: about 1 hour ago
JSON representation

Automated development and code repair system with enhanced analysis capabilities

Awesome Lists containing this project

README 

          
# 🔍 Devix - Modular Code Analysis Platform



**Devix** is a comprehensive, modular code analysis platform that provides deep insights into your codebase through multiple specialized analyzers. Built with Python, it offers powerful CLI tools, rich reporting, and intelligent project structure analysis.



## ✨ Key Features



- 🔍 **Multi-Analyzer Architecture**: 5 specialized analyzers (ProjectScanner, Security, Quality, Test, Performance)

- 📊 **Rich Reporting**: Enhanced markdown and text reports with project tree visualization

- 🚫 **Smart Filtering**: `.devixignore` support with visual indicators for ignored files

- ⚡ **Parallel Execution**: Concurrent analyzer execution for optimal performance

- 🎯 **CLI Subcommands**: Clean command-line interface with `analyze`, `config`, and `info` commands

- 📈 **Comprehensive Metrics**: File statistics, coverage analysis, and cross-analyzer insights

- 🌳 **Project Structure Visualization**: ASCII tree with file sizes and ignore markers

- 🔧 **Modular Design**: Extensible architecture for adding custom analyzers



## 🛠️ Installation



### Quick Start



```bash

# Clone or navigate to the Devix directory

cd devix



# Install dependencies

pip install -e .



# Run analysis on your project

devix analyze /path/to/your/project

```



### Installation Methods



#### Method 1: Package Installation

```bash

cd devix

pip install -e .  # Install in development mode

devix analyze .    # Analyze current directory

```



#### Method 2: Direct Execution

```bash

cd devix

PYTHONPATH=src python -m devix analyze /path/to/project

```



#### Method 3: Using Makefile

```bash

cd devix

make run          # Analyze parent directory

make test         # Run tests

make lint         # Run linting

```



## 🎮 Usage



### CLI Commands



#### Main Analysis Command

```bash

# Analyze current directory with verbose output

devix analyze . --verbose



# Analyze specific project path

devix analyze /path/to/project



# Select specific analyzers

devix analyze . --analyzers project_scanner,security,quality



# Enable parallel execution (default)

devix analyze . --parallel



# Set custom output directory

devix analyze . --output-dir ./reports

```



#### Configuration Management

```bash

# Create default configuration

devix config create



# Validate existing configuration

devix config validate



# Show configuration location

devix config validate --config /path/to/config.yaml

```



#### Information Commands

```bash

# Show version and system info

devix info



# List available analyzers

devix info --analyzers



# Validate system setup

devix info --validate

```



### Makefile Commands



```bash

# Development workflow

make dev          # Full development workflow

make run          # Analyze parent directory

make test         # Run tests with coverage

make lint         # Run code quality checks

make format       # Format code with black/isort



# Publishing and deployment

make build        # Build package

make publish      # Publish to PyPI

make version      # Show version info



# Docker operations

make docker-build # Build Docker image

make docker-run   # Run in Docker container

```



## ⚙️ Configuration



### Configuration File (`config.yaml`)



```yaml

# Analyzer settings

analyzers:

  enabled: ["project_scanner", "security", "quality", "test", "performance"]

  parallel_execution: true

  max_workers: 4



# Reporting configuration

reporting:

  formats: ["markdown", "text"]

  output_directory: "."

  include_tree_visualization: true

  include_file_statistics: true



# File filtering

filtering:

  use_gitignore: true

  custom_ignore_patterns:

    - "*.log"

    - "node_modules/"

    - ".pytest_cache/"

```



### .devixignore File



Create a `.devixignore` file to exclude files/directories from analysis:



```

# Dependencies

node_modules/

__pycache__/

.venv/



# Build artifacts

dist/

build/

*.egg-info/



# IDE and system files

.vscode/

.idea/

.DS_Store



# Logs and temporary files

logs/

*.log

.coverage

```



## 🔍 Analyzers



### Project Scanner

- **Purpose**: Analyzes project structure, file statistics, and generates tree visualization

- **Features**: 

  - Full and filtered project trees

  - File type breakdown and statistics

  - Code fragment extraction

  - Visual ignore markers (🚫) for excluded files



### Security Analyzer

- **Purpose**: Identifies security vulnerabilities and risks

- **Tools**: Bandit, Safety (when available)

- **Features**:

  - Static security analysis

  - Dependency vulnerability scanning

  - Hardcoded credentials detection



### Quality Analyzer

- **Purpose**: Evaluates code quality and style

- **Tools**: Pylint, Flake8, Black, isort, mypy (when available)

- **Features**:

  - Code complexity analysis

  - Style guide compliance

  - Type checking validation



### Test Analyzer

- **Purpose**: Analyzes test coverage and quality

- **Tools**: pytest, coverage.py (when available)

- **Features**:

  - Test discovery and execution

  - Coverage measurement

  - Test quality assessment



### Performance Analyzer

- **Purpose**: Identifies performance bottlenecks

- **Features**:

  - Runtime profiling

  - Resource usage analysis

  - Performance pattern detection



## 📊 Report Features



### Enhanced Reporting

- **Multiple Formats**: Markdown and text reports with rich formatting

- **Project Statistics**: Real file counts (analyzed vs skipped)

- **Tree Visualization**: ASCII project structure with file sizes

- **Visual Indicators**: 🚫 markers for ignored files and directories

- **Cross-Analyzer Insights**: Correlations between different analysis results



### Report Contents

- **Executive Summary**: Health scores and quick metrics

- **Detailed Analysis**: Per-analyzer results with issues and recommendations

- **File Statistics**: Comprehensive breakdown by file type and location

- **Project Structure**: Complete tree view with ignore patterns applied

- **Actionable Recommendations**: Priority-sorted improvement suggestions



## 🚨 Troubleshooting



### Common Issues



**No files found for analysis**

- Check your `.devixignore` patterns

- Ensure project path is correct

- Verify file permissions



**Missing analyzer tools**

- Install optional dependencies: `pip install bandit safety pylint`

- Check tool availability: `devix info --validate`



**Slow performance**

- Use parallel execution: `--parallel` (default)

- Reduce analyzer scope: `--analyzers project_scanner,quality`

- Filter large directories in `.devixignore`



**Import errors**

- Ensure proper installation: `pip install -e .`

- Check PYTHONPATH: `export PYTHONPATH=src:$PYTHONPATH`

- Verify Python version compatibility (3.8+)



## 📝 Example Workflows



### Basic Analysis

```bash

# Quick analysis of current directory

devix analyze . --verbose



# Check reports

ls devix_report_*.md devix_report_*.txt

```



### CI/CD Integration

```bash

# In your CI pipeline

devix analyze . --output-dir ./reports



# Check exit code for quality gates

if [ $? -eq 0 ]; then

  echo "Analysis passed!"

else

  echo "Analysis found issues"

  exit 1

fi

```



### Custom Configuration

```bash

# Create and customize config

devix config create

# Edit config.yaml as needed



# Run with custom config

devix analyze . --config ./my-config.yaml

```



## 🏗️ Architecture



### High-Level Architecture



This diagram illustrates the main components of the Devix platform and their interactions:



```mermaid

graph TD

    subgraph User Interface

        CLI[CLI]

    end



    subgraph Core System

        Orchestrator(DevixOrchestrator)

        ConfigManager[ConfigManager]

    end



    subgraph Analyzers

        ProjectScanner[ProjectScanner]

        SecurityAnalyzer[SecurityAnalyzer]

        QualityAnalyzer[QualityAnalyzer]

        TestAnalyzer[TestAnalyzer]

        PerformanceAnalyzer[PerformanceAnalyzer]

    end



    subgraph Reporting

        ReportGenerator[EnhancedReportGenerator]

        MarkdownFormatter[MarkdownFormatter]

        TextFormatter[TextFormatter]

    end



    CLI --> Orchestrator

    Orchestrator --> ConfigManager

    Orchestrator --> ProjectScanner

    Orchestrator --> SecurityAnalyzer

    Orchestrator --> QualityAnalyzer

    Orchestrator --> TestAnalyzer

    Orchestrator --> PerformanceAnalyzer

    Orchestrator --> ReportGenerator

    ReportGenerator --> MarkdownFormatter

    ReportGenerator --> TextFormatter

```



### Workflow Sequence Diagram



This diagram shows the sequence of operations during a typical analysis run:



```mermaid

sequenceDiagram

    participant User

    participant CLI

    participant DevixOrchestrator

    participant Analyzers

    participant ReportGenerator



    User->>CLI: devix analyze .

    CLI->>DevixOrchestrator: run_analysis()

    DevixOrchestrator->>Analyzers: analyze() in parallel

    Analyzers-->>DevixOrchestrator: Analysis results

    DevixOrchestrator->>ReportGenerator: generate_reports()

    ReportGenerator-->>DevixOrchestrator: Report files

    DevixOrchestrator-->>CLI: Display summary

    CLI-->>User: Output summary and report paths

```



### Module Structure



```

devix/

├── src/devix/

│   ├── analysis/          # Analysis modules

│   │   ├── project_scanner.py

│   │   ├── security_analyzer.py

│   │   ├── quality_analyzer.py

│   │   ├── test_analyzer.py

│   │   └── performance_analyzer.py

│   ├── reporting/         # Report generation

│   │   ├── enhanced_generator.py

│   │   ├── markdown_formatter.py

│   │   └── text_formatter.py

│   ├── cli/              # Command-line interface

│   ├── config/           # Configuration management

│   └── core/             # Core orchestration

├── tests/                # Test suite

└── docs/                 # Documentation

```



### Extension Points

- **Custom Analyzers**: Inherit from `BaseAnalyzer`

- **Custom Formatters**: Inherit from `BaseFormatter`

- **Custom Configuration**: Extend `ConfigManager`



## 🤝 Contributing



### Development Setup

```bash

# Clone and setup

git clone 

cd devix

pip install -e ".[dev]"



# Run tests

make test



# Run linting

make lint



# Format code

make format

```



### Adding New Analyzers

1. Create new analyzer in `src/devix/analysis/`

2. Inherit from `BaseAnalyzer`

3. Implement `analyze()` method

4. Register in `DevixOrchestrator`

5. Add tests and documentation



## 📄 License



This project is licensed under the MIT License - see the LICENSE file for details.



---



*Generated by **Devix** - Modular Code Analysis Platform*