From f2a969906a73eab62bd7c22cf4496a14ad4bf254 Mon Sep 17 00:00:00 2001 From: omsherikar Date: Sun, 15 Feb 2026 16:51:14 +0530 Subject: [PATCH] Add Mintlify documentation with Maple theme - Set up Mintlify docs with Maple theme and emerald color scheme - Added comprehensive documentation pages for all features - Configured Space Grotesk font for modern typography - Added 8-step workflow guide (login -> init -> repo -> analyze -> suggest -> refactor -> report -> rollback) - Created API reference, CLI reference, guides, and advanced topics - Added social media links (GitHub, X, LinkedIn, Discord) - Migrated content from existing documentation to MDX format --- docs/.nojekyll | 0 docs/_config.yml | 42 - docs/advanced/ci-cd.mdx | 259 ++ docs/advanced/monitoring.mdx | 208 ++ docs/advanced/performance.mdx | 178 + docs/api-reference/overview.mdx | 271 ++ docs/api-reference/refactron-class.mdx | 345 ++ docs/cli/commands.mdx | 543 ++++ docs/docs.json | 92 + docs/essentials/authentication.mdx | 159 + docs/essentials/configuration.mdx | 187 ++ docs/essentials/installation.mdx | 121 + docs/guides/ai-features.mdx | 364 +++ docs/guides/code-analysis.mdx | 305 ++ docs/guides/pattern-learning.mdx | 364 +++ docs/guides/refactoring.mdx | 337 ++ docs/images/cli_dashboard.png | Bin 584636 -> 0 bytes docs/index.html | 1134 ------- docs/introduction.mdx | 94 + docs/{images => logo}/Refactron-logo-TM.png | Bin .../Refactron_CLI.png} | Bin docs/logo/image.png | Bin 0 -> 380532 bytes docs/logo/logo.png | Bin 0 -> 39180 bytes docs/logo/logo.svg | 11 + docs/quickstart.mdx | 217 ++ docs/resources/changelog.mdx | 168 + docs/resources/faq.mdx | 231 ++ documentation/docs/ARCHITECTURE.md | 364 +++ documentation/docs/CHANGELOG.md | 365 +++ documentation/docs/CLI_REFERENCE.md | 455 +++ documentation/docs/CODE_OF_CONDUCT.md | 133 + .../docs}/ERROR_HANDLING.md | 0 .../docs}/FALSE_POSITIVE_REDUCTION.md | 0 documentation/docs/LLM_RAG_INTEGRATION.md | 111 + {docs => documentation/docs}/MONITORING.md | 0 .../docs}/PATTERN_LEARNING.md | 1 + .../docs}/PERFORMANCE_OPTIMIZATION.md | 4 +- .../docs}/QUICK_REFERENCE.md | 32 + {docs => documentation/docs}/README.md | 0 documentation/docs/SECURITY.md | 131 + {docs => documentation/docs}/TUTORIAL.md | 27 +- documentation/docs/api/analyzers.md | 488 +++ documentation/docs/api/autofix.md | 802 +++++ documentation/docs/api/cicd.md | 470 +++ documentation/docs/api/core.md | 2881 +++++++++++++++++ documentation/docs/api/llm.md | 290 ++ documentation/docs/api/patterns.md | 914 ++++++ documentation/docs/api/rag.md | 351 ++ documentation/docs/api/refactorers.md | 278 ++ .../docs/images/Refactron-logo-TM.png | Bin 0 -> 45976 bytes .../Screenshot 2026-01-29 at 17.45.00.png | Bin 0 -> 578533 bytes documentation/docs/images/logo.png | Bin 0 -> 39180 bytes .../docs}/v1.0.13_RELEASE_GUIDE.md | 0 .../docs/v1.0.15_DETAILED_CHANGELOG.md | 76 + documentation/docs/v1.0.15_RELEASE_NOTES.md | 47 + 55 files changed, 12671 insertions(+), 1179 deletions(-) delete mode 100644 docs/.nojekyll delete mode 100644 docs/_config.yml create mode 100644 docs/advanced/ci-cd.mdx create mode 100644 docs/advanced/monitoring.mdx create mode 100644 docs/advanced/performance.mdx create mode 100644 docs/api-reference/overview.mdx create mode 100644 docs/api-reference/refactron-class.mdx create mode 100644 docs/cli/commands.mdx create mode 100644 docs/docs.json create mode 100644 docs/essentials/authentication.mdx create mode 100644 docs/essentials/configuration.mdx create mode 100644 docs/essentials/installation.mdx create mode 100644 docs/guides/ai-features.mdx create mode 100644 docs/guides/code-analysis.mdx create mode 100644 docs/guides/pattern-learning.mdx create mode 100644 docs/guides/refactoring.mdx delete mode 100644 docs/images/cli_dashboard.png delete mode 100644 docs/index.html create mode 100644 docs/introduction.mdx rename docs/{images => logo}/Refactron-logo-TM.png (100%) rename docs/{images/Screenshot 2026-01-29 at 17.45.00.png => logo/Refactron_CLI.png} (100%) create mode 100644 docs/logo/image.png create mode 100644 docs/logo/logo.png create mode 100644 docs/logo/logo.svg create mode 100644 docs/quickstart.mdx create mode 100644 docs/resources/changelog.mdx create mode 100644 docs/resources/faq.mdx create mode 100644 documentation/docs/ARCHITECTURE.md create mode 100644 documentation/docs/CHANGELOG.md create mode 100644 documentation/docs/CLI_REFERENCE.md create mode 100644 documentation/docs/CODE_OF_CONDUCT.md rename {docs => documentation/docs}/ERROR_HANDLING.md (100%) rename {docs => documentation/docs}/FALSE_POSITIVE_REDUCTION.md (100%) create mode 100644 documentation/docs/LLM_RAG_INTEGRATION.md rename {docs => documentation/docs}/MONITORING.md (100%) rename {docs => documentation/docs}/PATTERN_LEARNING.md (99%) rename {docs => documentation/docs}/PERFORMANCE_OPTIMIZATION.md (99%) rename {docs => documentation/docs}/QUICK_REFERENCE.md (83%) rename {docs => documentation/docs}/README.md (100%) create mode 100644 documentation/docs/SECURITY.md rename {docs => documentation/docs}/TUTORIAL.md (92%) create mode 100644 documentation/docs/api/analyzers.md create mode 100644 documentation/docs/api/autofix.md create mode 100644 documentation/docs/api/cicd.md create mode 100644 documentation/docs/api/core.md create mode 100644 documentation/docs/api/llm.md create mode 100644 documentation/docs/api/patterns.md create mode 100644 documentation/docs/api/rag.md create mode 100644 documentation/docs/api/refactorers.md create mode 100644 documentation/docs/images/Refactron-logo-TM.png create mode 100644 documentation/docs/images/Screenshot 2026-01-29 at 17.45.00.png create mode 100644 documentation/docs/images/logo.png rename {docs => documentation/docs}/v1.0.13_RELEASE_GUIDE.md (100%) create mode 100644 documentation/docs/v1.0.15_DETAILED_CHANGELOG.md create mode 100644 documentation/docs/v1.0.15_RELEASE_NOTES.md diff --git a/docs/.nojekyll b/docs/.nojekyll deleted file mode 100644 index e69de29..0000000 diff --git a/docs/_config.yml b/docs/_config.yml deleted file mode 100644 index b415412..0000000 --- a/docs/_config.yml +++ /dev/null @@ -1,42 +0,0 @@ -# GitHub Pages Configuration for Refactron - -# Site settings -title: Refactron -description: The Intelligent Code Refactoring Transformer for Python -author: Om Sherikar -email: omsherikar@example.com - -# Build settings -theme: null -markdown: kramdown - -# Exclude from processing -exclude: - - README.md - - Gemfile - - Gemfile.lock - - node_modules - - vendor - -# Include files -include: - - _headers - -# Base URL (leave empty for GitHub Pages) -baseurl: "" -url: "https://refactron-ai.github.io" - -# GitHub metadata -github: - repository_url: "https://github.com/Refactron-ai/Refactron_lib" - repository_name: "Refactron_lib" - -# Social -social: - - name: GitHub - url: "https://github.com/Refactron-ai/Refactron_lib" - - name: PyPI - url: "https://pypi.org/project/refactron/" - -# Analytics (optional - add your tracking ID) -# google_analytics: UA-XXXXXXXXX-X diff --git a/docs/advanced/ci-cd.mdx b/docs/advanced/ci-cd.mdx new file mode 100644 index 0000000..ccb4f46 --- /dev/null +++ b/docs/advanced/ci-cd.mdx @@ -0,0 +1,259 @@ +--- +title: CI/CD Integration +description: 'Integrate Refactron into your CI/CD pipeline' +--- + +## Overview + +Refactron can be integrated into your CI/CD pipeline to automatically analyze code quality on every commit, pull request, or deployment. + +## Generate CI/CD Templates + +Refactron can generate ready-to-use CI/CD configuration files: + +```bash +# GitHub Actions +refactron ci github + +# GitLab CI +refactron ci gitlab + +# Pre-commit hooks +refactron ci pre-commit + +# Generate all +refactron ci all +``` + +## GitHub Actions + +### Basic Workflow + +```yaml .github/workflows/refactron.yml +name: Refactron Analysis + +on: [push, pull_request] + +jobs: + analyze: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + + - name: Set up Python + uses: actions/setup-python@v2 + with: + python-version: '3.9' + + - name: Install Refactron + run: pip install refactron + + - name: Analyze Code + run: refactron analyze . --log-format json +``` + +### Fail on Critical Issues + +```yaml +- name: Analyze Code + run: | + refactron analyze . --log-format json || exit_code=$? + if [ $exit_code -eq 1 ]; then + echo "Critical issues found!" + exit 1 + fi +``` + +## GitLab CI + +### Basic Configuration + +```yaml .gitlab-ci.yml +refactron: + image: python:3.9 + before_script: + - pip install refactron + script: + - refactron analyze . --log-format json + only: + - merge_requests + - main +``` + +### With Artifacts + +```yaml +refactron: + image: python:3.9 + before_script: + - pip install refactron + script: + - refactron report . --format html -o report.html + artifacts: + paths: + - report.html + expire_in: 1 week +``` + +## Pre-commit Hooks + +### Installation + +```bash +# Generate pre-commit config +refactron ci pre-commit + +# Install pre-commit +pip install pre-commit +pre-commit install +``` + +### Configuration + +```.pre-commit-config.yaml +repos: + - repo: local + hooks: + - id: refactron + name: Refactron Analysis + entry: refactron analyze + language: system + pass_filenames: false + always_run: true +``` + +## Best Practices + + + + Enable JSON logging for easier parsing in CI/CD: + ```bash + refactron analyze . --log-format json + ``` + + + + Fail builds based on severity: + ```yaml + # .refactron.yaml + fail_on_critical: true + fail_on_errors: false + max_critical_issues: 0 + max_error_issues: 10 + ``` + + + + Speed up CI runs by caching pip packages: + ```yaml + # GitHub Actions + - uses: actions/cache@v2 + with: + path: ~/.cache/pip + key: ${{ runner.os }}-pip-refactron + ``` + + + + Create HTML reports and save as artifacts: + ```bash + refactron report . --format html -o report.html + ``` + + + +## Environment-Specific Configuration + +### Development + +```yaml .refactron.yaml +log_level: DEBUG +fail_on_critical: false +fail_on_errors: false +``` + +### CI/CD + +```yaml .refactron.yaml +log_level: INFO +log_format: json +fail_on_critical: true +fail_on_errors: false +max_critical_issues: 0 +``` + +### Production + +```yaml .refactron.yaml +log_level: WARNING +log_format: json +fail_on_critical: true +fail_on_errors: true +max_critical_issues: 0 +max_error_issues: 5 +``` + +## Advanced Patterns + +### Incremental Analysis + +Only analyze changed files in CI: + +```yaml +- name: Get Changed Files + id: changed + run: | + if [ "${{ github.event_name }}" == "pull_request" ]; then + FILES=$(git diff --name-only ${{ github.event.pull_request.base.sha }} ${{ github.sha }} | grep '\.py$' || true) + else + FILES=$(git diff --name-only HEAD~1..HEAD | grep '\.py$' || true) + fi + echo "files=$FILES" >> $GITHUB_OUTPUT + +- name: Analyze Changed Files + if: steps.changed.outputs.files != '' + run: | + for file in ${{ steps.changed.outputs.files }}; do + refactron analyze "$file" + done +``` + +### Parallel Analysis + +Run analysis in parallel for faster CI: + +```yaml .refactron.yaml +enable_parallel_processing: true +max_parallel_workers: 4 +``` + +## Exit Codes + +Refactron uses standard exit codes: + +| Code | Meaning | +|------|---------| +| 0 | Success, no issues | +| 1 | Issues found | +| 2 | Error during execution | + +Use these to control CI behavior: + +```bash +refactron analyze . || exit_code=$? +if [ $exit_code -gt 1 ]; then + echo "Refactron error!" + exit $exit_code +fi +``` + +## Next Steps + + + + Configure Refactron for CI/CD + + + Monitor Refactron in production + + diff --git a/docs/advanced/monitoring.mdx b/docs/advanced/monitoring.mdx new file mode 100644 index 0000000..9a0441d --- /dev/null +++ b/docs/advanced/monitoring.mdx @@ -0,0 +1,208 @@ +--- +title: Monitoring +description: 'Production monitoring and telemetry' +--- + +## Overview + +Refactron includes comprehensive logging and monitoring capabilities for production environments: + +- **Structured Logging** - JSON-formatted logs for CI/CD +- **Metrics Collection** - Track analysis time and success rates +- **Prometheus Integration** - Expose metrics via HTTP endpoint +- **Opt-in Telemetry** - Anonymous usage analytics + +## Structured Logging + +### Configuration + +```yaml .refactron.yaml +log_level: INFO # DEBUG, INFO, WARNING, ERROR, CRITICAL +log_format: json # json or text +enable_console_logging: true +enable_file_logging: true +``` + +### JSON Log Output + +```json +{ + "timestamp": "2026-02-15T10:30:42Z", + "level": "INFO", + "logger": "refactron.core.refactron", + "message": "Analysis completed successfully", + "duration_ms": 123.45 +} +``` + +### CLI Usage + +```bash +# JSON logging for CI/CD +refactron analyze mycode.py --log-format json + +# Set log level +refactron analyze mycode.py --log-level DEBUG +``` + +## Metrics Collection + +Track detailed metrics about Refactron operations. + +### View Metrics + +```bash +# Text format +refactron metrics + +# JSON format +refactron metrics --format json +``` + +### Example Output + +``` +📈 Refactron Metrics + +Analysis Metrics: + Files analyzed: 45 + Issues found: 123 + Total time: 5234ms + Success rate: 95.6% + +Analyzer Hit Counts: + complexity: 23 + security: 15 + type_hints: 45 +``` + +### Python API + +```python +stats = refactron.get_performance_stats() +print(f"Files analyzed: {stats['files_analyzed']}") +print(f"Issues found: {stats['issues_found']}") +``` + +## Prometheus Integration + +Expose metrics via HTTP endpoint for Prometheus scraping. + +### Start Metrics Server + +```bash +# Default port 9090 +refactron serve-metrics + +# Custom port +refactron serve-metrics --port 8080 +``` + +### Available Metrics + +**Counters:** +- `refactron_files_analyzed_total` +- `refactron_issues_found_total` +- `refactron_analyzer_hits_total{analyzer="name"}` + +**Gauges:** +- `refactron_analysis_duration_ms` +- `refactron_analysis_success_rate` + +### Prometheus Configuration + +Add to your `prometheus.yml`: + +```yaml +scrape_configs: + - job_name: 'refactron' + static_configs: + - targets: ['localhost:9090'] +``` + +## Telemetry + + + Telemetry is **opt-in only** and disabled by default. It collects anonymous usage statistics to help improve Refactron. + + +### What is Collected + +**Collected:** +- Number of files analyzed +- Analysis execution time +- Python version and OS platform + +**NOT Collected:** +- Your code or file names +- Personal information +- Error messages or stack traces + +### Manage Telemetry + +```bash +# Check status +refactron telemetry --status + +# Enable telemetry +refactron telemetry --enable + +# Disable telemetry +refactron telemetry --disable +``` + +## Environment-Specific Configurations + +### Development + +```yaml +log_level: DEBUG +log_format: text +enable_metrics: true +enable_prometheus: false +``` + +### CI/CD + +```yaml +log_level: INFO +log_format: json +enable_metrics: true +enable_prometheus: false +``` + +### Production + +```yaml +log_level: WARNING +log_format: json +enable_metrics: true +enable_prometheus: true +prometheus_port: 9090 +``` + +## Best Practices + + + + JSON format integrates easily with log aggregation systems + + + + Track performance and identify bottlenecks + + + + Visualize Refactron metrics over time + + + + Respect user privacy with opt-in telemetry + + + +## Next Steps + + + Learn how to integrate Refactron into your CI/CD pipeline + diff --git a/docs/advanced/performance.mdx b/docs/advanced/performance.mdx new file mode 100644 index 0000000..9734477 --- /dev/null +++ b/docs/advanced/performance.mdx @@ -0,0 +1,178 @@ +--- +title: Performance Optimization +description: 'Optimize Refactron for large codebases' +--- + +## Overview + +Refactron includes several performance optimization features designed to handle large codebases efficiently: + +- **AST Caching** - Avoid re-parsing unchanged files +- **Incremental Analysis** - Only analyze changed files +- **Parallel Processing** - Analyze multiple files concurrently + +## Quick Start + +Enable all optimizations in `.refactron.yaml`: + +```yaml .refactron.yaml +# Performance optimizations +enable_ast_cache: true +max_ast_cache_size_mb: 100 + +enable_incremental_analysis: true + +enable_parallel_processing: true +max_parallel_workers: 4 +``` + +## AST Caching + +Cache parsed Abstract Syntax Trees to avoid re-parsing. + + + + - 5-10x faster on repeated analysis + - Reduces CPU usage + - Especially effective for large files + + + + ```python + from refactron import Refactron + from refactron.core.config import RefactronConfig + + config = RefactronConfig( + enable_ast_cache=True, + max_ast_cache_size_mb=100 + ) + refactron = Refactron(config) + ``` + + + + ```python + stats = refactron.get_performance_stats() + print(f"Hit rate: {stats['ast_cache']['hit_rate']}%") + print(f"Cache size: {stats['ast_cache']['cache_size_mb']} MB") + ``` + + + +## Incremental Analysis + +Only analyze files that changed since the last run. + +**Benefits:** +- Up to 90% reduction in analysis time +- Ideal for CI/CD pipelines +- Perfect for iterative development + +**Example:** +```python +from refactron import Refactron + +refactron = Refactron() + +# First run - analyzes all files +result1 = refactron.analyze("project/") +print(f"Analyzed {result1.summary['files_analyzed']} files") + +# Second run (no changes) - skips unchanged files +result2 = refactron.analyze("project/") +print(f"Analyzed {result2.summary['files_analyzed']} files") # Much less! +``` + +## Parallel Processing + +Analyze multiple files concurrently using multiprocessing. + +**Configuration:** +```yaml .refactron.yaml +enable_parallel_processing: true +max_parallel_workers: 4 # Number of parallel workers +``` + +**When to Use:** +- ✅ Large codebases (1000+ files) +- ✅ Multi-core systems +- ❌ Small codebases (<10 files) + +## Best Practices by Project Size + +### Small Projects (<1000 files) + +```yaml +enable_ast_cache: true +enable_incremental_analysis: true +enable_parallel_processing: false # Overhead not worth it +``` + +### Medium Projects (1000-10000 files) + +```yaml +enable_ast_cache: true +enable_incremental_analysis: true +enable_parallel_processing: true +max_parallel_workers: 4 +``` + +### Large Projects (10000+ files) + +```yaml +enable_ast_cache: true +max_ast_cache_size_mb: 200 # Larger cache +enable_incremental_analysis: true +enable_parallel_processing: true +max_parallel_workers: 8 # More workers +``` + +## Performance Statistics + +Get detailed performance stats: + +```python +stats = refactron.get_performance_stats() + +# AST Cache +print(f"Cache hits: {stats['ast_cache']['hits']}") +print(f"Hit rate: {stats['ast_cache']['hit_rate']}%") + +# Parallel Processing +print(f"Workers: {stats['parallel']['max_workers']}") + +# Clear caches when needed +refactron.clear_caches() +``` + +## Troubleshooting + + + + Check if optimizations are enabled: + ```python + stats = refactron.get_performance_stats() + print(f"Cache enabled: {stats['ast_cache']['enabled']}") + print(f"Hit rate: {stats['ast_cache']['hit_rate']}%") + ``` + + + + - Reduce cache size: `max_ast_cache_size_mb: 50` + - Lower parallel workers: `max_parallel_workers: 2` + - Clear caches periodically: `refactron.clear_caches()` + + + + Disable for small codebases: + ```yaml + enable_parallel_processing: false + ``` + + + +## Next Steps + + + Learn how to monitor Refactron in production + diff --git a/docs/api-reference/overview.mdx b/docs/api-reference/overview.mdx new file mode 100644 index 0000000..7adc298 --- /dev/null +++ b/docs/api-reference/overview.mdx @@ -0,0 +1,271 @@ +--- +title: API Overview +description: 'Python API reference for Refactron' +--- + +## Introduction + +Refactron provides a comprehensive Python API for programmatic code analysis and refactoring. This is ideal for integrating Refactron into your own tools, scripts, or CI/CD pipelines. + +## Quick Start + +```python +from refactron import Refactron + +# Initialize Refactron +refactron = Refactron() + +# Analyze code +analysis = refactron.analyze("myproject/") +print(f"Found {analysis.summary['total_issues']} issues") + +# Refactor code +result = refactron.refactor("myfile.py", preview=True) +result.show_diff() +``` + +## Core Classes + + + + Main entry point for all operations + + + Configuration management + + + Analysis results and metrics + + + Refactoring results and diffs + + + +## Installation for Python API + +```bash +pip install refactron +``` + +## Basic Patterns + +### Analysis + +```python +from refactron import Refactron + +refactron = Refactron() + +# Analyze file or directory +analysis = refactron.analyze("path/to/code") + +# Access summary +print(f"Files: {analysis.summary['files_analyzed']}") +print(f"Issues: {analysis.summary['total_issues']}") + +# Iterate through issues +for issue in analysis.issues: + print(f"{issue.level.value}: {issue.message} at {issue.file_path}:{issue.line_number}") +``` + +### Filtering Issues + +```python +# Filter by severity +critical_issues = [i for i in analysis.issues if i.level.value == "CRITICAL"] +errors = [i for i in analysis.issues if i.level.value == "ERROR"] + +# Filter by category +security_issues = [i for i in analysis.issues if i.category == "SECURITY"] +complexity_issues = [i for i in analysis.issues if i.category == "COMPLEXITY"] +``` + +### Refactoring + +```python +from refactron import Refactron + +refactron = Refactron() + +# Preview refactoring +result = refactron.refactor("myfile.py", preview=True) + +# Show diff for each operation +for op in result.operations: + print(f"Operation: {op.operation_type}") + print(f"Risk: {op.risk_score}") + print(f"Diff:\n{op.diff}") + +# Apply specific refactorings +result = refactron.refactor( + "myfile.py", + preview=False, + operation_types=["extract_constant", "add_docstring"] +) + +if result.success: + print(f"Backup: {result.backup_path}") +``` + +### Configuration + +```python +from refactron import Refactron +from refactron.core.config import RefactronConfig + +# Custom configuration +config = RefactronConfig( + max_function_complexity=15, + max_function_length=100, + enabled_analyzers=["security", "complexity"], + enabled_refactorers=["extract_constant"], + enable_pattern_learning=True +) + +refactron = Refactron(config) +``` + +### Feedback and Pattern Learning + +```python +from refactron import Refactron + +refactron = Refactron() +result = refactron.refactor("myfile.py", preview=True) + +# Record feedback +for op in result.operations: + refactron.record_feedback( + operation_id=op.operation_id, + action="accepted", # or "rejected", "ignored" + reason="Improved code quality", + operation=op + ) +``` + +## Configuration Options + + + Maximum cyclomatic complexity for functions + + + + Maximum lines per function + + + + Maximum parameters per function + + + + Maximum nesting depth for control structures + + + + List of analyzers to enable: `security`, `complexity`, `code_smell`, `type_hint`, `dead_code`, `dependency` + + + + List of refactorers to enable: `extract_constant`, `add_docstring`, `simplify_conditionals`, `reduce_parameters` + + + + Enable pattern learning system + + +## Models and Data Structures + +### Issue + +```python +class Issue: + file_path: str # Path to file with issue + line_number: int # Line number + message: str # Issue description + level: IssueLevel # CRITICAL, ERROR, WARNING, INFO + category: str # SECURITY, COMPLEXITY, etc. + suggestion: Optional[str] # Fix suggestion +``` + +### RefactoringOperation + +```python +class RefactoringOperation: + operation_id: str # Unique identifier + operation_type: str # Type of refactoring + file_path: str # Target file + line_number: int # Target line + risk_score: float # 0.0 to 1.0 + diff: str # Unified diff + description: str # Human-readable description +``` + +### AnalysisResult + +```python +class AnalysisResult: + summary: dict # Summary statistics + issues: List[Issue] # All detected issues + metrics: FileMetrics # Code metrics + errors: List[str] # Any errors encountered +``` + +## Error Handling + +```python +from refactron import Refactron +from refactron.core.exceptions import RefactronError, AnalysisError + +refactron = Refactron() + +try: + analysis = refactron.analyze("myproject/") +except AnalysisError as e: + print(f"Analysis failed: {e}") +except RefactronError as e: + print(f"Refactron error: {e}") +``` + +## Advanced Usage + +### Custom Analyzers + +```python +from refactron.analyzers.base_analyzer import BaseAnalyzer + +class MyCustomAnalyzer(BaseAnalyzer): + def analyze_file(self, file_path, ast_tree): + # Custom analysis logic + issues = [] + # ... analyze and create issues + return issues + +# Use with Refactron +refactron = Refactron() +refactron.analyzers.append(MyCustomAnalyzer()) +``` + +### Performance Optimization + +```python +from refactron import Refactron + +refactron = Refactron() + +# Get performance stats +stats = refactron.get_performance_stats() +print(f"AST cache hits: {stats['ast_cache']['hits']}") + +# Clear caches +refactron.clear_caches() +``` + +## Next Steps + + + Detailed API documentation for the Refactron class + diff --git a/docs/api-reference/refactron-class.mdx b/docs/api-reference/refactron-class.mdx new file mode 100644 index 0000000..40c9f7d --- /dev/null +++ b/docs/api-reference/refactron-class.mdx @@ -0,0 +1,345 @@ +--- +title: Refactron Class +description: 'Main API class reference' +--- + +## Overview + +The `Refactron` class is the main entry point for all code analysis and refactoring operations. + +## Constructor + +```python +from refactron import Refactron +from refactron.core.config import RefactronConfig + +# Default configuration +refactron = Refactron() + +# Custom configuration +config = RefactronConfig( + max_function_complexity=15, + enabled_analyzers=["security", "complexity"] +) +refactron = Refactron(config) +``` + + + Configuration object. If None, uses default configuration. + + +## Methods + +### analyze() + +Analyze a file or directory for issues. + +```python +def analyze(target: Union[str, Path]) -> AnalysisResult +``` + + + Path to file or directory to analyze + + +**Returns:** `AnalysisResult` containing detected issues and metrics + +**Example:** +```python +refactron = Refactron() +result = refactron.analyze("myproject/") + +print(f"Files analyzed: {result.summary['files_analyzed']}") +print(f"Total issues: {result.summary['total_issues']}") + +for issue in result.issues: + print(f"{issue.level.value}: {issue.message}") +``` + +--- + +### refactor() + +Refactor a file or directory with intelligent transformations. + +```python +def refactor( + target: Union[str, Path], + preview: bool = True, + operation_types: Optional[List[str]] = None +) -> RefactorResult +``` + + + Path to file or directory to refactor + + + + If True, show changes without applying them + + + + Specific refactoring types to apply. None = all types. + + Available types: + - `extract_constant` + - `add_docstring` + - `simplify_conditionals` + - `reduce_parameters` + + +**Returns:** `RefactorResult` containing operations and status + +**Example:** +```python +# Preview all refactorings +result = refactron.refactor("myfile.py", preview=True) +result.show_diff() + +# Apply specific refactorings +result = refactron.refactor( + "myfile.py", + preview=False, + operation_types=["extract_constant", "add_docstring"] +) + +if result.success: + print(f"Applied {len(result.operations)} refactorings") + print(f"Backup: {result.backup_path}") +``` + +--- + +### record_feedback() + +Record developer feedback on a refactoring suggestion. + +```python +def record_feedback( + operation_id: str, + action: str, + reason: Optional[str] = None, + operation: Optional[RefactoringOperation] = None +) -> None +``` + + + Unique identifier for the refactoring operation + + + + Feedback action: `"accepted"`, `"rejected"`, or `"ignored"` + + + + Optional reason for the feedback + + + + The refactoring operation object (for pattern learning) + + +**Example:** +```python +result = refactron.refactor("myfile.py", preview=True) + +for op in result.operations: + refactron.record_feedback( + operation_id=op.operation_id, + action="accepted", + reason="Improved readability", + operation=op + ) +``` + +--- + +### get_python_files() + +Get all Python files in a directory, respecting exclude patterns. + +```python +def get_python_files(directory: Path) -> List[Path] +``` + + + Directory to search for Python files + + +**Returns:** List of Python file paths + +**Example:** +```python +from pathlib import Path + +refactron = Refactron() +files = refactron.get_python_files(Path("myproject")) + +print(f"Found {len(files)} Python files") +for file in files: + print(file) +``` + +--- + +### get_performance_stats() + +Get performance statistics from optimization components. + +```python +def get_performance_stats() -> Dict[str, Any] +``` + +**Returns:** Dictionary containing performance statistics + +**Example:** +```python +stats = refactron.get_performance_stats() + +print(f"AST cache hits: {stats['ast_cache']['hits']}") +print(f"AST cache misses: {stats['ast_cache']['misses']}") +print(f"Parallel jobs: {stats['parallel']['max_workers']}") +``` + +--- + +### clear_caches() + +Clear all performance-related caches. + +```python +def clear_caches() -> None +``` + +**Example:** +```python +# Clear caches after major code changes +refactron.clear_caches() +``` + +--- + +### detect_project_root () + +Detect project root by looking for common markers. + +```python +def detect_project_root(file_path: Path) -> Path +``` + + + File path to start searching from + + +**Returns:** Path to project root + +**Example:** +```python +from pathlib import Path + +refactron = Refactron() +root = refactron.detect_project_root(Path("src/module/file.py")) +print(f"Project root: {root}") +``` + +## Properties + +### config + +Access current configuration. + +```python +config = refactron.config +print(f"Max complexity: {config.max_function_complexity}") +``` + +### analyzers + +List of enabled analyzers. + +```python +analyzers = refactron.analyzers +print(f"Enabled analyzers: {[a.__class__.__name__ for a in analyzers]}") +``` + +### refactorers + +List of enabled refactorers. + +```python +refactorers = refactron.refactorers +print(f"Enabled refactorers: {[r.__class__.__name__ for r in refactorers]}") +``` + +## Complete Example + +```python +from refactron import Refactron +from refactron.core.config import RefactronConfig +from pathlib import Path + +# Configure Refactron +config = RefactronConfig( + max_function_complexity=15, + max_function_length=100, + enabled_analyzers=["security", "complexity", "code_smell"], + enabled_refactorers=["extract_constant", "add_docstring"], + enable_pattern_learning=True +) + +# Initialize +refactron = Refactron(config) + +# Analyze project +print("Analyzing project...") +analysis = refactron.analyze("myproject/") + +# Print summary +print(f"\nAnalysis Summary:") +print(f" Files analyzed: {analysis.summary['files_analyzed']}") +print(f" Total issues: {analysis.summary['total_issues']}") + +# Print critical issues +critical = [i for i in analysis.issues if i.level.value == "CRITICAL"] +if critical: + print(f"\nCritical Issues ({len(critical)}):") + for issue in critical: + print(f" {issue.file_path}:{issue.line_number} - {issue.message}") + +# Refactor with preview +print("\nGenerating refactoring suggestions...") +result = refactron.refactor("myproject/", preview=True) + +# Review and apply specific operations +for op in result.operations: + print(f"\nOperation: {op.operation_type}") + print(f" File: {op.file_path}:{op.line_number}") + print(f" Risk: {op.risk_score}") + print(f" Description: {op.description}") + + # Record feedback + refactron.record_feedback( + operation_id=op.operation_id, + action="accepted", + reason="Approved after review", + operation=op + ) + +# Get performance stats +stats = refactron.get_performance_stats() +print(f"\nPerformance:") +print(f" AST cache hit rate: {stats['ast_cache']['hit_rate']:.1%}") + +print("\nRefactoring complete!") +``` + +## Next Steps + + + + Learn about analysis features + + + Master refactoring workflows + + diff --git a/docs/cli/commands.mdx b/docs/cli/commands.mdx new file mode 100644 index 0000000..a43efb7 --- /dev/null +++ b/docs/cli/commands.mdx @@ -0,0 +1,543 @@ +--- +title: CLI Commands +description: 'Complete command-line interface reference' +--- + +## Overview + +Refactron provides a comprehensive CLI for code analysis, refactoring, AI features, and more. + +## Core Commands + +### analyze + +Analyze code for issues. + +```bash +refactron analyze [options] +``` + +**Options:** +- `--detailed` - Show detailed analysis output +- `--summary` - Show summary only +- `--config FILE` - Use custom config file + +**Examples:** +```bash +# Analyze single file +refactron analyze myfile.py + +# Analyze directory with details +refactron analyze myproject/ --detailed +``` + +--- + +### refactor + +Preview or apply refactoring suggestions. + +```bash +refactron refactor [options] +``` + +**Options:** +- `--preview` - Preview changes without applying +- `--type TYPE` - Filter by operation type (can use multiple) +- `--risk-level LEVEL` - Filter by risk: safe, low, moderate, high +- `--ai` - Enable AI-powered refactoring +- `--feedback` - Enable interactive feedback + +**Examples:** +```bash +# Preview all refactorings +refactron refactor myfile.py --preview + +# Apply specific types only +refactron refactor myfile.py --type extract_constant --type add_docstring + +# AI-powered refactoring +refactron refactor myfile.py --ai --preview +``` + +--- + +### autofix + +Apply automated fixes. + +```bash +refactron autofix [options] +``` + +**Options:** +- `--preview` - Preview auto-fixes +- `--apply` - Apply auto-fixes +- `--no-backup` - Don't create backups + +**Examples:** +```bash +# Preview auto-fixes +refactron autofix myfile.py --preview + +# Apply safe fixes +refactron autofix myfile.py --apply +``` + +--- + +### report + +Generate analysis reports. + +```bash +refactron report [options] +``` + +**Options:** +- `--format FORMAT` - Output format: json, html, text +- `-o FILE` - Output file path + +**Examples:** +```bash +# JSON report +refactron report myproject/ --format json -o report.json + +# HTML report +refactron report my project/ --format html -o report.html +``` + +--- + +## AI Commands + +### suggest + +Get AI-powered suggestions for specific lines. + +```bash +refactron suggest [options] +``` + +**Options:** +- `--line N` - Target specific line number +- `--apply` - Apply suggestion immediately + +**Examples:** +```bash +# Get suggestion for line 42 +refactron suggest myfile.py --line 42 + +# Apply AI suggestion +refactron suggest myfile.py --line 42 --apply +``` + +--- + +### document + +Generate AI-powered documentation. + +```bash +refactron document [options] +``` + +**Options:** +- `--apply` - Apply generated docstrings + +**Examples:** +```bash +# Preview documentation +refactron document myfile.py + +# Apply documentation +refactron document myfile.py --apply +``` + +--- + +### rag + +Manage RAG (Retrieval-Augmented Generation) index. + +```bash +refactron rag [options] +``` + +**Commands:** +- `index` - Index codebase for RAG +- `search` - Search indexed code +- `status` - Show index status + +**Options:** +- `--summarize` - Generate AI summaries when indexing +- `--rerank` - Use AI reranking for search +- `--update` - Incremental index update +- `--force` - Force full re-index + +**Examples:** +```bash +# Index codebase +refactron rag index + +# Index with AI summaries +refactron rag index --summarize + +# Search code +refactron rag search "authentication logic" + +# Search with reranking +refactron rag search "database queries" --rerank + +# Check status +refactron rag status +``` + +--- + +## Pattern Learning Commands + +### feedback + +Record feedback on refactoring operations. + +```bash +refactron feedback --action [options] +``` + +**Options:** +- `--action ACTION` - accepted, rejected, or ignored +- `--reason TEXT` - Reason for feedback + +**Examples:** +```bash +# Accept a suggestion +refactron feedback op-123 --action accepted + +# Reject with reason +refactron feedback op-456 --action rejected --reason "Breaks API contract" +``` + +--- + +### patterns + +Manage pattern learning system. + +```bash +refactron patterns +``` + +**Commands:** +- `analyze` - Analyze project patterns +- `recommend` - Get tuning recommendations +- `tune` - Apply pattern tuning +- `profile` - View current pattern profile + +**Options:** +- `--auto` - Auto-apply recommendations (for tune command) + +**Examples:** +```bash +# Analyze patterns +refactron patterns analyze + +# Get recommendations +refactron patterns recommend + +# Auto-tune +refactron patterns tune --auto + +# View profile +refactron patterns profile +``` + +--- + +## Authentication & Repository + +### auth + +Manage authentication. + +```bash +refactron auth +``` + +**Commands:** +- `status` - Check authentication status +- `logout` - Log out from account + +**Examples:** +```bash +# Check auth status +refactron auth status + +# Logout +refactron auth logout +``` + +--- + +### repo + +Manage repository connections. + +```bash +refactron repo [options] +``` + +**Commands:** +- `list` - List connected repositories +- `connect` - Connect a repository +- `disconnect` - Disconnect a repository + +**Options:** +- `--path PATH` - Repository path (for connect) +- `--delete-files` - Delete local files (for disconnect) + +**Examples:** +```bash +# List repos +refactron repo list + +# Connect repo +refactron repo connect my-repo --path /path/to/repo + +# Disconnect repo +refactron repo disconnect my-repo +``` + +--- + +## Backup & Rollback + +### rollback + +Rollback refactoring changes. + +```bash +refactron rollback [options] +``` + +**Options:** +- `--list` - List available rollback sessions +- `--session ID` - Rollback specific session + +**Examples:** +```bash +# List sessions +refactron rollback --list + +# Rollback session +refactron rollback --session abc123 +``` + +--- + +## CI/CD Integration + +### ci + +Generate CI/CD configuration. + +```bash +refactron ci +``` + +**Platforms:** +- `github` - GitHub Actions workflow +- `gitlab` - GitLab CI configuration +- `pre-commit` - Pre-commit hooks + +**Examples:** +```bash +# Generate GitHub Actions +refactron ci github + +# Generate GitLab CI +refactron ci gitlab + +# Generate pre-commit hooks +refactron ci pre-commit +``` + +--- + +## Observability + +### metrics + +View usage metrics. + +```bash +refactron metrics [options] +``` + +**Options:** +- `--format FORMAT` - Output format: json, text + +**Examples:** +```bash +# View metrics +refactron metrics + +# JSON format +refactron metrics --format json +``` + +--- + +### serve-metrics + +Start Prometheus metrics server. + +```bash +refactron serve-metrics [options] +``` + +**Options:** +- `--port N` - Server port (default: 8000) + +**Examples:** +```bash +# Start metrics server +refactron serve-metrics + +# Custom port +refactron serve-metrics --port 9090 +``` + +--- + +### telemetry + +Manage telemetry settings. + +```bash +refactron telemetry +``` + +**Commands:** +- `enable` - Enable telemetry +- `disable` - Disable telemetry +- `status` - Show telemetry status + +**Examples:** +```bash +# Check status +refactron telemetry status + +# Disable telemetry +refactron telemetry disable +``` + +--- + +## Configuration + +### init + +Initialize Refactron configuration. + +```bash +refactron init +``` + +Creates `.refactron.yaml` in current directory with default settings. + +--- + +## Global Options + +Available for all commands: + +- `--help` - Show help message +- `--version` - Show version +- `--config FILE` - Use custom config file +- `--log-level LEVEL` - Set log level (DEBUG, INFO, WARNING, ERROR) + +**Examples:** +```bash +# Show version +refactron --version + +# Custom config +refactron analyze myfile.py --config custom-config.yaml + +# Debug logging +refactron analyze myfile.py --log-level DEBUG +``` + +--- + +## Environment Variables + +```bash +# Disable color output +export REFACTRON_NO_COLOR=1 + +# Set log level +export REFACTRON_LOG_LEVEL=DEBUG + +# Custom config path +export REFACTRON_CONFIG=/path/to/.refactron.yaml + +# API keys +export GROQ_API_KEY=your-key +export REFACTRON_API_KEY=your-key +``` + +--- + +## Exit Codes + +| Code | Meaning | +|------|---------| +| 0 | Success, no issues found | +| 1 | Issues found | +| 2 | Error during execution | + +--- + +## Quick Reference + +```bash +# Analysis workflow +refactron analyze myproject/ +refactron report myproject/ --format json -o report.json + +# Refactoring workflow +refactron refactor myfile.py --preview +ref actron refactor myfile.py --type extract_constant +refactron rollback --list + +# AI workflow +refactron rag index +refactron refactor myfile.py --ai --preview +refactron suggest myfile.py --line 42 + +# Pattern learning +refactron feedback op-123 --action accepted +refactron patterns analyze +refactron patterns tune --auto +``` + +## Next Steps + + + + Python API documentation + + + Configure Refactron settings + + diff --git a/docs/docs.json b/docs/docs.json new file mode 100644 index 0000000..22642d2 --- /dev/null +++ b/docs/docs.json @@ -0,0 +1,92 @@ +{ + "$schema": "https://mintlify.com/docs.json", + "theme": "maple", + "name": "Refactron", + "description": "Intelligent Python code refactoring with AI-powered suggestions and pattern learning", + "colors": { + "primary": "#10B981", + "light": "#ECFDF5", + "dark": "#065F46" + }, + "fonts": { + "family": "Space Grotesk" + }, + "navigation": { + "groups": [ + { + "group": "Getting Started", + "pages": [ + "introduction", + "quickstart" + ] + }, + { + "group": "Essentials", + "pages": [ + "essentials/installation", + "essentials/configuration", + "essentials/authentication" + ] + }, + { + "group": "Guides", + "pages": [ + "guides/code-analysis", + "guides/refactoring", + "guides/ai-features", + "guides/pattern-learning" + ] + }, + { + "group": "CLI Reference", + "pages": [ + "cli/commands" + ] + }, + { + "group": "API Reference", + "pages": [ + "api-reference/overview", + "api-reference/refactron-class" + ] + }, + { + "group": "Advanced", + "pages": [ + "advanced/performance", + "advanced/monitoring", + "advanced/ci-cd" + ] + }, + { + "group": "Resources", + "pages": [ + "resources/changelog", + "resources/faq" + ] + } + ] + }, + "logo": { + "light": "/logo/logo.png", + "dark": "/logo/logo.png", + "href": "https://www.refactron.dev" + }, + "footer": { + "socials": { + "github": "https://github.com/Refactron-ai/Refactron_lib", + "x": "https://x.com/refactron", + "linkedin": "https://www.linkedin.com/company/refactron", + "discord": "https://discord.gg/HY8WawSH" + } + }, + "favicon": "logo/logo.svg", + "contextual": { + "options": [ + "copy", + "view", + "chatgpt", + "claude" + ] + } +} \ No newline at end of file diff --git a/docs/essentials/authentication.mdx b/docs/essentials/authentication.mdx new file mode 100644 index 0000000..ddb6cd9 --- /dev/null +++ b/docs/essentials/authentication.mdx @@ -0,0 +1,159 @@ +--- +title: Authentication +description: 'Authenticate with Refactron cloud services' +--- + +## Overview + +Some Refactron features require authentication with cloud services: + +- Repository management +- Cloud-based AI features +- Collaborative pattern learning +- Usage analytics + +## Login + +Authenticate using the CLI: + +```bash +refactron login +``` + +This will open your browser to complete the authentication flow. + + + Local analysis and refactoring features work without authentication + + +## Check Authentication Status + +Verify your authentication status: + +```bash +refactron auth status +``` + +Expected output: + +``` +✓ Authenticated as user@example.com + Organization: my-org + Plan: Pro +``` + +## Logout + +To log out from your account: + +```bash +refactron auth logout +``` + +## API Keys + +For CI/CD environments, use API keys instead of interactive login: + +### Generate API Key + +1. Log in via the CLI: `refactron login` +2. Visit your dashboard +3. Navigate to **Settings** → **API Keys** +4. Click **Generate New Key** + +### Use API Key + +Set the API key as an environment variable: + +```bash +export REFACTRON_API_KEY=your_api_key_here +``` + + + Keep your API keys secret! Never commit them to version control. + + +## Authenticated Features + +Features that require authentication: + + + + ```bash + refactron repo list + refactron repo connect my-repo + ``` + + + + Enhanced AI-powered refactoring with cloud LLM models + + + + ```bash + refactron metrics + ``` + + + + Share learned patterns across your team + + + +## Offline Mode + +Refactron works offline for core features: + +- Local code analysis +- Refactoring suggestions +- Auto-fix operations +- Report generation + +Cloud features gracefully degrade when offline. + +## Troubleshooting + + + + If the browser doesn't open automatically: + 1. Copy the URL from the terminal + 2. Paste it into your browser manually + 3. Complete the authentication + + + + If you see "Token expired" errors: + ```bash + refactron auth logout + refactron login + ``` + + + + Verify the API key is set correctly: + ```bash + echo $REFACTRON_API_KEY + ``` + Ensure it's exported in your shell profile. + + + +## Security + + + Refactron follows security best practices: + - Tokens are stored securely in your system keychain + - API keys are never logged or displayed + - All communication uses HTTPS + - Authentication tokens expire after 30 days + + +## Next Steps + + + Start analyzing your code with Refactron + diff --git a/docs/essentials/configuration.mdx b/docs/essentials/configuration.mdx new file mode 100644 index 0000000..335614a --- /dev/null +++ b/docs/essentials/configuration.mdx @@ -0,0 +1,187 @@ +--- +title: Configuration +description: 'Configure Refactron for your project' +--- + +## Configuration File + +Refactron uses a `.refactron.yaml` file to configure analyzers, refactorers, and thresholds. + +### Initialize Configuration + +Generate a default configuration file: + +```bash +refactron init +``` + +This creates `.refactron.yaml` in your project root. + +## Configuration Options + +### Basic Configuration + +```yaml .refactron.yaml +# Analyzers to run +enabled_analyzers: + - complexity + - code_smell + - security + - type_hint + - dead_code + - dependency + +# Refactorers to use +enabled_refactorers: + - extract_constant + - add_docstring + - simplify_conditionals + - reduce_parameters + +# Thresholds +max_function_complexity: 10 +max_function_length: 50 +max_parameters: 5 +max_nesting_depth: 3 +``` + +### Pattern Learning + +Enable pattern learning to improve suggestions over time: + +```yaml .refactron.yaml +# Pattern Learning (optional) +enable_pattern_learning: true +pattern_learning_enabled: true +pattern_ranking_enabled: true +pattern_storage_dir: null # null = auto-detect +``` + + + Learn more about pattern learning in the [Pattern Learning Guide](/guides/pattern-learning) + + +## Available Analyzers + + + + Detects security vulnerabilities like SQL injection, code injection, hardcoded secrets, and SSRF + + + + Identifies magic numbers, long functions, excessive parameters, and deep nesting + + + + Measures cyclomatic complexity, maintainability index, and nested loops + + + + Checks for missing or incomplete type annotations + + + + Finds unused functions and unreachable code + + + + Analyzes circular imports and wildcard imports + + + +## Available Refactorers + + + + Extract magic numbers into named constants + + + + Add missing docstrings to functions and classes + + + + Simplify complex conditional statements + + + + Reduce function parameter count using dataclasses or dictionaries + + + +## Threshold Configuration + +Adjust thresholds to match your project's standards: + +```yaml .refactron.yaml +# Complexity thresholds +max_function_complexity: 15 # Default: 10 +max_function_length: 100 # Default: 50 +max_parameters: 7 # Default: 5 +max_nesting_depth: 4 # Default: 3 + +# Code quality thresholds +min_maintainability_index: 60 # Default: 65 +max_cognitive_complexity: 20 # Default: 15 +``` + +## Exclude Patterns + +Exclude files or directories from analysis: + +```yaml .refactron.yaml +exclude_patterns: + - "*/tests/*" + - "*/migrations/*" + - "*/venv/*" + - "*.pyc" + - "__pycache__" +``` + +## Environment Variables + +Configure Refactron using environment variables: + +```bash +# Disable color output +export REFACTRON_NO_COLOR=1 + +# Set log level (DEBUG, INFO, WARNING, ERROR) +export REFACTRON_LOG_LEVEL=DEBUG + +# Custom config path +export REFACTRON_CONFIG=/path/to/.refactron.yaml +``` + +## Per-File Ignores + +Ignore specific issues in code using comments: + +```python +def my_function(): # refactron: ignore + # This entire function will be ignored + pass + +def another_function(): + x = 42 # refactron: ignore magic-number + # Only magic-number check will be ignored for this line +``` + +## Next Steps + + + + Set up authentication for cloud features + + + Learn about analysis capabilities + + diff --git a/docs/essentials/installation.mdx b/docs/essentials/installation.mdx new file mode 100644 index 0000000..0ec2f0e --- /dev/null +++ b/docs/essentials/installation.mdx @@ -0,0 +1,121 @@ +--- +title: Installation +description: 'How to install and set up Refactron' +--- + +## Requirements + + + **Python Version**: 3.8 or higher + **Supported Platforms**: macOS, Linux, Windows + + +## Install via pip + +The recommended way to install Refactron is using pip: + +```bash +pip install refactron +``` + +### Development Version + +To install the latest development version from GitHub: + +```bash +pip install git+https://github.com/Refactron-ai/Refactron_lib.git +``` + +## Verify Installation + +Check that Refactron is installed correctly: + +```bash +refactron --version +``` + +You should see output like: + +``` +refactron, version 1.0.15 +``` + +## Optional: Install Development Dependencies + +If you plan to contribute to Refactron: + +```bash +# Clone the repository +git clone https://github.com/Refactron-ai/Refactron_lib.git +cd Refactron_lib + +# Run the development setup script +bash setup_dev.sh +``` + +This will: +- Create a virtual environment +- Install all dependencies (including dev tools) +- Set up pre-commit hooks +- Run initial tests + +## Dependencies + +Refactron automatically installs these dependencies: + + + + - **libcst** - Code parsing and transformation + - **click** - CLI framework + - **rich** - Terminal formatting + - **radon** - Complexity metrics + - **astroid** - AST analysis + + + + - **chromadb** - Vector database for RAG + - **tree-sitter** - Code parsing + - **sentence-transformers** - Embeddings + - **groq** - LLM integration + - **pydantic** - Data validation + + + +## Troubleshooting + + + + If you get a permission error, try: + ```bash + pip install --user refactron + ``` + + + + Ensure you're using Python 3.8+: + ```bash + python --version + ``` + If needed, use a specific Python version: + ```bash + python3.10 -m pip install refactron + ``` + + + + On macOS, you may need to install certificates: + ```bash + /Applications/Python\ 3.x/Install\ Certificates.command + ``` + + + +## Next Steps + + + Configure Refactron for your project + diff --git a/docs/guides/ai-features.mdx b/docs/guides/ai-features.mdx new file mode 100644 index 0000000..16466e6 --- /dev/null +++ b/docs/guides/ai-features.mdx @@ -0,0 +1,364 @@ +--- +title: AI Features +description: 'LLM and RAG-powered intelligent refactoring' +--- + +## Overview + +Refactron v1.0.15+ integrates Large Language Models (LLMs) with Retrieval-Augmented Generation (RAG) to provide context-aware, intelligent code refactoring and documentation generation. + +## Core Components + + + + Coordinates between analyzer, retriever, and LLM backends + + + Vector database (ChromaDB) for code indexing and retrieval + + + Support for Groq, local models, and custom providers + + + Validates LLM-generated code for syntax and safety + + + +## Setup + +### Prerequisites + +AI features require additional dependencies (already included with Refactron): + +- ChromaDB for vector storage +- Sentence Transformers for embeddings +- Groq API access (or alternative LLM provider) + +### Configuration + +Set your LLM API key: + +```bash +export GROQ_API_KEY='your-api-key-here' +``` + +Configure LLM settings in `.refactron.yaml`: + +```yaml .refactron.yaml +llm: + provider: groq + model: llama3-70b-8192 + temperature: 0.1 + max_tokens: 4096 + +rag: + enabled: true + storage_dir: .refactron/rag_index + embedding_model: all-MiniLM-L6-v2 +``` + +## RAG Indexing + +### Index Your Codebase + +Before using AI features, index your project: + +```bash +# Basic indexing +refactron rag index + +# Index with AI-generated summaries +refactron rag index --summarize +``` + +This creates vector embeddings of your code for context retrieval. + +### Check Index Status + +```bash +refactron rag status +``` + +Output: +``` +✓ RAG Index Status + Indexed files: 142 + Total chunks: 856 + Last updated: 2024-02-15 10:30:42 + Storage: .refactron/rag_index +``` + +### Search Codebase + +Semantic search across your codebase: + +```bash +# Basic search +refactron rag search "authentication logic" + +# With AI reranking +refactron rag search "database connection" --rerank +``` + +## AI-Powered Refactoring + +### Enable AI Suggestions + +Use the `--ai` flag to enable LLM-powered refactoring: + +```bash +# Preview AI refactoring suggestions +refactron refactor myfile.py --ai --preview + +# Apply AI suggestions +refactron refactor myfile.py --ai --apply +``` + +### How It Works + + + + Refactron analyzes your code for issues + + + + RAG system retrieves relevant code chunks from your project + + + + LLM generates refactoring suggestions with project context + + + + Safety gate validates syntax and checks for issues + + + + Suggestions presented with explanations and risk scores + + + +### Example + +```python +# Original code with issues +def process_users(users): + result = [] + for user in users: + if user.age > 18: + if user.status == 'active': + if user.verified: + result.append(user) + return result +``` + +AI-powered refactoring suggests: + +```python +# AI-suggested refactoring +def process_users(users): + """Process and filter users based on eligibility criteria. + + Args: + users: List of user objects to process + + Returns: + List of eligible users (adult, active, verified) + """ + return [ + user for user in users + if user.age > 18 and user.status == 'active' and user.verified + ] +``` + +## AI Documentation Generation + +### Generate Docstrings + +Automatically create docstrings using AI: + +```bash +# Preview docstring generation +refactron document myfile.py + +# Apply docstrings +refactron document myfile.py --apply +``` + +### Line-Specific Suggestions + +Get AI suggestions for specific lines: + +```bash +# Suggest improvements for line 42 +refactron suggest myfile.py --line 42 + +# Apply suggestion instantly +refactron suggest myfile.py --line 42 --apply +``` + +## Available LLM Providers + + + + Fast, cloud-based LLM provider with free tier + + **Models:** + - `llama3-70b-8192` - Best quality + - `llama3-8b-8192` - Faster, good quality + - `mixtral-8x7b-32768` - Long context window + + **Setup:** + ```bash + export GROQ_API_KEY='your-key' + ``` + + + + Bring your own LLM provider + + Configure in `.refactron.yaml`: + ```yaml + llm: + provider: custom + endpoint: https://your-llm-api.com/v1 + api_key: your-key + ``` + + + +## RAG Workflow + +### How RAG Enhances Refactoring + +1. **Parsing**: Code files split into semantic chunks (classes, methods) +2. **Embedding**: Chunks converted to vector representations +3. **Indexing**: Vectors stored in ChromaDB with metadata +4. **Retrieval**: Relevant chunks retrieved when analyzing issues +5. **Context**: LLM receives project-specific context for better suggestions + +### Update Index + +Re-index after significant code changes: + +```bash +# Update index incrementally +refactron rag index --update + +# Full re-index +refactron rag index --force +``` + +## Feedback and Learning + +Provide feedback on AI suggestions to improve quality: + +```bash +# Record acceptance +refactron feedback --action accepted + +# Record rejection with reason +refactron feedback --action rejected --reason "Breaks API contract" +``` + + + AI suggestions integrate with [Pattern Learning](/guides/pattern-learning) to improve over time + + +## Configuration Options + + + LLM provider (groq, custom) + + + + Model identifier for the provider + + + + Temperature for generation (0.0 - 1.0, lower = more deterministic) + + + + Maximum tokens in LLM response + + + + Enable RAG system + + + + Directory for RAG index storage + + + + Sentence transformer model for embeddings + + +## Best Practices + + + + Re-run `refactron rag index` after significant code changes for accurate context + + + + Models like Llama 3 70B provide better refactoring logic than smaller models + + + + Use `--preview` to review AI-generated code before applying + + + + Record feedback to improve AI suggestions over time + + + + Run your test suite after applying AI refactorings + + + +## Troubleshooting + + + + Ensure `GROQ_API_KEY` is set: + ```bash + echo $GROQ_API_KEY + ``` + Export it in your shell profile for persistence + + + + Create index first: + ```bash + refactron rag index + ``` + + + + - Use smaller models (llama3-8b-8192) + - Reduce `max_tokens` + - Limit context retrieval chunks + + + +## Next Steps + + + + Learn how feedback improves suggestions + + + Explore all AI-related commands + + diff --git a/docs/guides/code-analysis.mdx b/docs/guides/code-analysis.mdx new file mode 100644 index 0000000..9a8de3a --- /dev/null +++ b/docs/guides/code-analysis.mdx @@ -0,0 +1,305 @@ +--- +title: Code Analysis +description: 'Comprehensive code analysis features in Refactron' +--- + +## Overview + +Refactron provides comprehensive static analysis to identify security vulnerabilities, code quality issues, complexity problems, and performance bottlenecks in your Python code. + +## Running Analysis + +### Basic Analysis + +```bash +# Analyze a single file +refactron analyze myfile.py + +# Analyze entire directory +refactron analyze myproject/ + +# Show detailed output +refactron analyze myproject/ --detailed +``` + +### Python API + +```python +from refactron import Refactron + +refactron = Refactron() +analysis = refactron.analyze("myproject/") + +# Print summary +print(f"Files analyzed: {analysis.summary['files_analyzed']}") +print(f"Total issues: {analysis.summary['total_issues']}") + +# Access issues by severity +for issue in analysis.issues: + if issue.level.value == "CRITICAL": + print(f"{issue.message} at line {issue.line_number}") +``` + +## Analysis Categories + + + + Detects critical security vulnerabilities: + - **SQL Injection**: Unsafe database queries + - **Code Injection**: Use of `eval()` and `exec()` + - **Hardcoded Secrets**: API keys, passwords in code + - **SSRF Vulnerabilities**: Unsafe URL handling + + ```python + # ❌ Security issue detected + query = f"SELECT * FROM users WHERE id = {user_id}" # SQL injection + eval(user_input) # Code injection + API_KEY = "hardcoded-secret-123" # Hardcoded secret + ``` + + + + Identifies code smells and maintainability issues: + - **Magic Numbers**: Unexplained numeric constants + - **Long Functions**: Functions exceeding length threshold + - **Excessive Parameters**: Too many function parameters + - **Deep Nesting**: Complex nested control structures + + ```python + # ❌ Code quality issues + def process(a, b, c, d, e, f, g): # Too many parameters + if condition1: + if condition2: + if condition3: + if condition4: # Deep nesting + return 42 # Magic number + ``` + + + + Measures code complexity: + - **Cyclomatic Complexity**: Control flow complexity + - **Cognitive Complexity**: Human readability complexity + - **Maintainability Index**: Overall maintainability score + - **Nested Loops**: Performance-impacting nested iterations + + ```python + # ❌ High complexity + def complex_function(data): + for item in data: + for sub in item: + if sub.type == 'A': + for val in sub.values: + # Nested loops = high complexity + process(val) + ``` + + + + Checks type annotation coverage: + - Missing function type hints + - Incomplete parameter annotations + - Missing return type annotations + + ```python + # ❌ Missing type hints + def calculate(x, y): # No type hints + return x + y + + # ✅ Properly typed + def calculate(x: int, y: int) -> int: + return x + y + ``` + + + + Finds unused and unreachable code: + - Unused variables + - Unused functions + - Unreachable code blocks + + ```python + # ❌ Dead code + def process(): + result = expensive_calculation() # Unused variable + return None + + def unused_function(): # Never called + pass + + def example(): + return True + print("Never executed") # Unreachable + ``` + + + + Analyzes import patterns: + - Circular imports + - Wildcard imports + - Deprecated modules + + ```python + # ❌ Dependency issues + from module_a import * # Wildcard import + import deprecated_lib # Deprecated + ``` + + + +## Severity Levels + +Issues are categorized by severity: + + + + Security vulnerabilities requiring immediate attention + + + Significant problems affecting functionality + + + Code quality issues to address + + + Suggestions for improvement + + + +## Filtering Results + +### By Severity + +```python +from refactron import Refactron + +refactron = Refactron() +analysis = refactron.analyze("myproject/") + +# Filter by severity +critical = [i for i in analysis.issues if i.level.value == "CRITICAL"] +errors = [i for i in analysis.issues if i.level.value == "ERROR"] +warnings = [i for i in analysis.issues if i.level.value == "WARNING"] +``` + +### By Category + +```python +security_issues = [i for i in analysis.issues if i.category == "SECURITY"] +complexity_issues = [i for i in analysis.issues if i.category == "COMPLEXITY"] +``` + +## Generating Reports + +### JSON Report + +```bash +refactron report myproject/ --format json -o report.json +``` + +### HTML Report + +```bash +refactron report myproject/ --format html -o report.html +``` + +### Custom Report Format + +```python +from refactron import Refactron + +refactron = Refactron() +analysis = refactron.analyze("myproject/") + +# Create custom report +report = { + "summary": analysis.summary, + "critical_issues": [ + { + "file": issue.file_path, + "line": issue.line_number, + "message": issue.message + } + for issue in analysis.issues + if issue.level.value == "CRITICAL" + ] +} +``` + +## Configuration + +Customize analysis behavior in `.refactron.yaml`: + +```yaml .refactron.yaml +# Enable specific analyzers +enabled_analyzers: + - security + - complexity + - code_smell + - type_hint + - dead_code + - dependency + +# Set thresholds +max_function_complexity: 10 +max_function_length: 50 +max_parameters: 5 +max_nesting_depth: 3 + +# Exclude patterns +exclude_patterns: + - "*/tests/*" + - "*/venv/*" +``` + +## Ignoring Issues + +### Inline Ignores + +```python +def my_function(): # refactron: ignore + # Entire function ignored + pass + +x = 42 # refactron: ignore magic-number +# Only magic-number check ignored +``` + +### Configuration-Based Excludes + +```yaml .refactron.yaml +exclude_patterns: + - "*/migrations/*" + - "*/legacy/*" +``` + +## Performance Tips + + + For large codebases, analyze specific modules separately to get faster results + + +```bash +# Analyze specific modules +refactron analyze src/module1/ +refactron analyze src/module2/ +``` + +## Next Steps + + + + Learn how to fix issues automatically + + + Explore all CLI commands + + diff --git a/docs/guides/pattern-learning.mdx b/docs/guides/pattern-learning.mdx new file mode 100644 index 0000000..3022ede --- /dev/null +++ b/docs/guides/pattern-learning.mdx @@ -0,0 +1,364 @@ +--- +title: Pattern Learning +description: 'Adaptive learning system that improves over time' +--- + +## Overview + +Refactron's Pattern Learning System learns from your refactoring decisions, building a knowledge base that improves the quality and relevance of future recommendations. **The more you use Refactron, the smarter it gets!** + +## How It Works + + + + When Refactron suggests a refactoring, it creates a unique "fingerprint" of the code pattern + + + + You provide feedback: **accepted**, **rejected**, or **ignored** + + + + Refactron tracks: + - Acceptance rates for each pattern + - Pattern frequency and recency + - Code metrics improvements + - Project-specific preferences + + + + Future suggestions ranked based on historical acceptance rates and patterns + + + +## Key Features + + + + Learns from every refactoring decision you make + + + Ranks suggestions by historical acceptance patterns + + + Adapts to your project's unique coding style + + + Patterns persist across sessions + + + +## Configuration + +### Enable Pattern Learning + +Pattern learning is **enabled by default**. Configure in `.refactron.yaml`: + +```yaml .refactron.yaml +# Pattern learning settings +enable_pattern_learning: true # Master switch +pattern_learning_enabled: true # Learn from feedback +pattern_ranking_enabled: true # Rank by patterns +pattern_storage_dir: null # null = auto-detect +``` + +### Python API + +```python +from refactron import Refactron +from refactron.core.config import RefactronConfig + +# Enable all pattern learning features +config = RefactronConfig( + enable_pattern_learning=True, + pattern_learning_enabled=True, + pattern_ranking_enabled=True +) +refactron = Refactron(config) + +# Disable pattern learning +config = RefactronConfig(enable_pattern_learning=False) +refactron = Refactron(config) +``` + +## Providing Feedback + +### Interactive Feedback + +```bash +# Refactor with feedback prompts +refactron refactor myfile.py --preview --feedback +``` + +During preview, you'll be prompted to accept/reject each suggestion. + +### Automatic Feedback + +Feedback is automatically recorded when you apply refactorings: + +```bash +# Accepted suggestions are automatically recorded +refactron refactor myfile.py --apply +``` + +### Manual Feedback + +Provide explicit feedback for specific operations: + +```bash +# Accept a suggestion +refactron feedback --action accepted + +# Reject with reason +refactron feedback --action rejected --reason "Breaks API" + +# Mark as ignored +refactron feedback --action ignored +``` + +### Python API Feedback + +```python +from refactron import Refactron + +refactron = Refactron() +result = refactron.refactor("myfile.py", preview=True) + +# Record feedback for first operation +if result.operations: + op = result.operations[0] + refactron.record_feedback( + operation_id=op.operation_id, + action="accepted", + reason="Improved readability", + operation=op + ) +``` + +## Pattern Analysis + +### View Pattern Statistics + +```bash +# Analyze project patterns +refactron patterns analyze +``` + +Output shows: +- Most accepted patterns +- Patterns with low acceptance +- Recommendations for tuning + +### Get Tuning Recommendations + +```bash +# Get automated recommendations +refactron patterns recommend +``` + +### Apply Tuning + +```bash +# Auto-apply recommended tuning +refactron patterns tune --auto + +# View current pattern profile +refactron patterns profile +``` + +## Ranking in Action + +When pattern learning is enabled, suggestions show ranking scores: + +```bash +refactron refactor myfile.py --preview +``` + +Output: +``` +📊 Refactoring Suggestions (ranked by learned patterns) + +Operation 1: Extract Constant + File: myfile.py:42 + Ranking Score: 0.85 ⭐ # High acceptance history + Risk: Low (0.2) + Description: Extract magic number 42 to constant + +Operation 2: Simplify Conditional + File: myfile.py:67 + Ranking Score: 0.35 # Lower acceptance history + Risk: Moderate (0.4) + Description: Simplify nested if statements +``` + +## Storage Location + +Pattern data is stored in JSON files: + +**Default Locations:** +- Project root: `.refactron/patterns/` +- User home: `~/.refactron/patterns/` (fallback) + +**Storage Files:** +- `patterns.json` - Learned patterns +- `feedback.json` - Feedback records +- `project_profiles.json` - Project configs +- `pattern_metrics.json` - Pattern metrics + +**Custom Location:** +```yaml .refactron.yaml +pattern_storage_dir: /custom/path/patterns +``` + +## Configuration Options + + + Master switch for all pattern learning features + + + + Enable learning from feedback (requires `enable_pattern_learning`) + + + + Enable ranking based on learned patterns (requires `enable_pattern_learning`) + + + + Custom storage directory (null = auto-detect project root or home directory) + + +## Best Practices + + + + The more feedback you provide, the better the system learns: + - **Accept** good refactorings + - **Reject** inappropriate suggestions + - **Ignore** if unsure + + + + For large projects, use automated tuning: + ```bash + refactron patterns analyze + refactron patterns tune --auto + ``` + + + + Periodically check pattern performance: + ```bash + refactron patterns analyze + ``` + + + + In CI/CD environments, use consistent storage: + ```yaml + pattern_storage_dir: /ci/patterns + ``` + + + +## Advanced Usage + +### Custom Pattern Weights + +```python +from refactron.patterns.storage import PatternStorage +from pathlib import Path + +storage = PatternStorage() +profile = storage.get_project_profile(project_path=Path("/project")) + +# Set custom weight for a pattern +profile.set_pattern_weight("pattern-id-123", 0.9) + +# Save profile +storage.save_project_profile(profile) +``` + +### Batch Learning + +```python +from refactron.patterns.learner import PatternLearner + +learner = PatternLearner(storage=storage, fingerprinter=fingerprinter) + +# Load pending feedback +feedback_list = storage.load_feedback() + +# Process in batch +learner.batch_learn(feedback_list) +``` + +### Pattern Cleanup + +```python +from refactron.patterns.learning_service import LearningService + +service = LearningService(storage=storage) + +# Remove patterns older than 90 days +service.cleanup_old_patterns(days=90) +``` + +## Integration with AI + +Pattern learning integrates with [AI Features](/guides/ai-features): + +- AI suggestions use learned patterns for better context +- Feedback on AI refactorings improves future AI suggestions +- RAG system considers pattern preferences + +## Troubleshooting + + + + **Solutions:** + 1. Check `pattern_learning_enabled` is `true` + 2. Verify storage directory is writable + 3. Check logs: `refactron refactor --log-level DEBUG` + + + + **Solutions:** + 1. Check `pattern_ranking_enabled` is `true` + 2. Ensure patterns have been learned (provide feedback first) + 3. Verify sufficient pattern history exists + + + + **Solutions:** + 1. Check directory permissions + 2. Use custom `pattern_storage_dir` if needed + 3. Verify disk space available + + + +## Performance + +- **Memory**: In-memory caching with invalidation on updates +- **Storage**: ~100-200 KB for typical project (100-1000 patterns) +- **Learning Speed**: <100ms per feedback record +- **Ranking Speed**: ~10ms per operation + +## Next Steps + + + + Combine pattern learning with AI + + + Performance optimization techniques + + diff --git a/docs/guides/refactoring.mdx b/docs/guides/refactoring.mdx new file mode 100644 index 0000000..ac55e22 --- /dev/null +++ b/docs/guides/refactoring.mdx @@ -0,0 +1,337 @@ +--- +title: Refactoring +description: 'Automated refactoring and code transformation' +--- + +## Overview + +Refactron provides intelligent refactoring suggestions with safety previews, risk scoring, and automated fixes. All refactorings include backup and rollback capabilities. + +## Basic Refactoring + +### Preview Changes + +Always preview refactoring suggestions before applying: + +```bash +refactron refactor myfile.py --preview +``` + +### Apply Refactoring + +Apply all suggested refactorings: + +```bash +refactron refactor myfile.py +``` + + + Refactoring modifies your code. Always preview changes first and ensure you have backups or version control. + + +## Available Refactorers + + + + Replaces magic numbers with named constants + + ```python + # Before + def calculate_tax(amount): + return amount * 0.18 + + # After + TAX_RATE = 0.18 + + def calculate_tax(amount): + return amount * TAX_RATE + ``` + + + + Adds missing docstrings to functions and classes + + ```python + # Before + def calculate_total(items): + return sum(item.price for item in items) + + # After + def calculate_total(items): + """Calculate total price for list of items. + + Args: + items: List of items with price attribute + + Returns: + Total sum of item prices + """ + return sum(item.price for item in items) + ``` + + + + Refactors complex conditional expressions + + ```python + # Before + if not (x < 10 or x > 20): + process() + + # After + if 10 <= x <= 20: + process() + ``` + + + + Reduces function parameters using dataclasses or dicts + + ```python + # Before + def create_user(name, email, age, city, country): + pass + + # After + from dataclasses import dataclass + + @dataclass + class UserData: + name: str + email: str + age: int + city: str + country: str + + def create_user(user: UserData): + pass + ``` + + + +## Risk Levels + +Refactoring suggestions include risk scores: + + + + Formatting, imports only + + + Documentation, constants + + + Logic changes + + + Complex transformations + + + +## Filter by Risk Level + +```bash +# Only apply safe refactorings +refactron refactor myfile.py --risk-level safe + +# Apply safe and low-risk refactorings +refactron refactor myfile.py --risk-level low +``` + +## Specific Refactorings + +Apply only specific types of refactoring: + +```bash +# Only extract constants +refactron refactor myfile.py --type extract_constant + +# Multiple types +refactron refactor myfile.py --type extract_constant --type add_docstring +``` + +## Python API + +```python +from refactron import Refactron + +refactron = Refactron() + +# Preview refactoring +result = refactron.refactor("myfile.py", preview=True) +result.show_diff() + +# Apply specific refactorings +result = refactron.refactor( + "myfile.py", + preview=False, + operation_types=["extract_constant", "add_docstring"] +) + +if result.success: + print(f"Applied {len(result.operations)} refactorings") + print(f"Backup: {result.backup_path}") +``` + +## Auto-Fix + +The `autofix` command applies safe, automated fixes: + +```bash +# Preview auto-fixes +refactron autofix myfile.py --preview + +# Apply auto-fixes +refactron autofix myfile.py --apply +``` + +Auto-fix includes 14 automated fixers for common issues. + +## Backup and Rollback + +Every refactoring creates automatic backups: + +### List Rollback Sessions + +```bash +refactron rollback --list +``` + +### Rollback Specific Session + +```bash +refactron rollback --session +``` + +### Python API Rollback + +```python +from refactron.autofix.file_ops import FileOperations + +file_ops = FileOperations() + +# Rollback one file +file_ops.rollback_file("myfile.py") + +# Rollback all changes +file_ops.rollback_all() +``` + +## Refactoring Workflow + + + + First, analyze your code to identify issues + ```bash + refactron analyze myproject/ + ``` + + + + Preview refactoring suggestions + ```bash + refactron refactor myproject/ --preview + ``` + + + + Review the diff output and risk scores + + + + Apply refactorings you want to keep + ```bash + refactron refactor myproject/ --type extract_constant + ``` + + + + Run your tests to ensure nothing broke + + + + Rollback if something went wrong + ```bash + refactron rollback --session + ``` + + + +## Configuration + +Configure refactoring behavior in `.refactron.yaml`: + +```yaml .refactron.yaml +# Enable specific refactorers +enabled_refactorers: + - extract_constant + - add_docstring + - simplify_conditionals + - reduce_parameters + +# Risk tolerance +max_risk_score: 0.5 # Don't apply refactorings with risk > 0.5 + +# Backup settings +create_backups: true +backup_dir: .refactron/backups +``` + +## Pattern Learning Integration + +Refactron learns from your refactoring decisions: + +```bash +# Refactor with pattern learning +refactron refactor myfile.py --feedback + +# Provide explicit feedback +refactron feedback --action accepted +``` + + + Learn more about pattern learning in the [Pattern Learning Guide](/guides/pattern-learning) + + +## Best Practices + + + + Use `--preview` to see changes before applying them + + + + Commit your code before refactoring for easy rollback + + + + Run your test suite after applying refactorings + + + + Begin with safe refactorings, then gradually increase risk tolerance + + + + Refactor small portions at a time rather than entire codebase + + + +## Next Steps + + + + Explore AI-powered refactoring + + + Learn how Refactron improves over time + + diff --git a/docs/images/cli_dashboard.png b/docs/images/cli_dashboard.png deleted file mode 100644 index d7c83ad5593a6367ba060064953ae4fdce52e2a4..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 584636 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�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%0A`T{|}NTi0!H*J0yPIVglc_cs3c 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
  • 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

    0|&pj)Q> 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

    =<9<9u<@amZEl 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�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 z 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 - - - - - - - - - - - - - - - - - - - - - Refactron - The Intelligent Code Refactoring Transformer for Python - - - - - - - - - - -

    - - -
    -
    -

    Refactron

    -

    The Intelligent Code Refactoring Transformer

    -

    - Eliminate technical debt, modernize legacy code, and automate refactoring with AI-powered intelligence. - Built for Python developers who care about code quality and maintainability. -

    - - - -
    - CI Status - Coverage - Python - PyPI version - License -
    - -
    -
    -
    -
    8
    -
    Advanced Analyzers
    -
    -
    -
    5
    -
    Smart Refactorers
    -
    -
    -
    81%
    -
    Test Coverage
    -
    -
    -
    135
    -
    Tests Passing
    -
    -
    -
    -
    -
    - - -
    -
    -
    - -

    Powerful Code Analysis & Refactoring

    -

    - Comprehensive tools to analyze, refactor, and optimize your Python codebase with confidence -

    -
    - -
    -
    -
    🔍
    -

    Comprehensive Analysis

    -

    Deep code inspection with 8 specialized analyzers covering all aspects of code quality

    -
      -
    • Security vulnerability scanning
    • -
    • Code smell detection
    • -
    • Complexity & maintainability metrics
    • -
    • Type hint analysis
    • -
    • Dead code detection
    • -
    • Dependency & import analysis
    • -
    -
    - -
    -
    🔧
    -

    Intelligent Refactoring

    -

    AI-powered code transformations with before/after previews and safety risk scoring

    -
      -
    • Extract magic numbers to constants
    • -
    • Reduce function parameters
    • -
    • Simplify nested conditionals
    • -
    • Auto-generate docstrings
    • -
    • Extract complex methods
    • -
    • Risk scoring for each change
    • -
    -
    - -
    -
    📊
    -

    Rich Reporting

    -

    Actionable insights with multiple output formats and detailed metrics

    -
      -
    • Beautiful terminal output
    • -
    • JSON & HTML export options
    • -
    • Before/after code previews
    • -
    • CI/CD integration support
    • -
    • Technical debt tracking
    • -
    • Trend analysis over time
    • -
    -
    -
    -
    -
    - - -
    -
    -
    - -

    Get Started in Seconds

    -

    - Install Refactron and start analyzing your code immediately -

    -
    - -
    -
    - Installation - $ -
    -
    pip install refactron
    -
    - -
    -
    - Analyze Your Code - $ -
    -
    # Analyze a file or directory
    -refactron analyze your_project/
    -
    -# Get detailed report
    -refactron analyze your_file.py --detailed
    -
    - -
    -
    - Get Refactoring Suggestions - $ -
    -
    # Preview refactorings (safe, doesn't modify files)
    -refactron refactor your_file.py --preview
    -
    -# Apply specific refactoring types
    -refactron refactor your_file.py --types magic_number,reduce_params
    -
    - -
    -
    - Python API -
    -
    from refactron import Refactron
    -from refactron.core.config import RefactronConfig
    -
    -# Initialize with default or custom config
    -config = RefactronConfig.default()
    -refactron = Refactron(config)
    -
    -# Analyze code
    -result = refactron.analyze("your_project/")
    -print(result.summary())
    -
    -# Get refactoring suggestions
    -refactorings = refactron.refactor("your_file.py", preview=True)
    -print(refactorings.show_diff())
    -
    -
    -
    - - -
    -
    -
    - -

    Built for Every Development Scenario

    -

    - From legacy modernization to maintaining high-quality codebases -

    -
    - -
    -
    -
    🏢
    -

    Enterprise Legacy Code

    -

    Modernize decades-old Python code with automated refactoring and security scanning

    -
    - -
    -
    🚀
    -

    Startup MVPs

    -

    Clean up technical debt quickly as your codebase grows and evolves

    -
    - -
    -
    👥
    -

    Team Onboarding

    -

    Help new developers understand code quality standards and patterns

    -
    - -
    -
    🔄
    -

    CI/CD Integration

    -

    Automate code quality checks in your deployment pipeline

    -
    - -
    -
    📚
    -

    Open Source Projects

    -

    Maintain consistent quality across contributions from multiple developers

    -
    - -
    -
    🎓
    -

    Learning & Teaching

    -

    Teach Python best practices with automated feedback and suggestions

    -
    -
    -
    -
    - - -
    -
    -
    -

    Ready to Transform Your Code?

    -

    Join developers using Refactron to write cleaner, safer, more maintainable Python code

    - -
    -
    -
    - - - - - - - - diff --git a/docs/introduction.mdx b/docs/introduction.mdx new file mode 100644 index 0000000..ed51d03 --- /dev/null +++ b/docs/introduction.mdx @@ -0,0 +1,94 @@ +--- +title: Introduction +description: 'Welcome to Refactron - A Python library for intelligent code analysis and refactoring' +--- + + + + +## What is Refactron? + +Refactron is a powerful Python library that analyzes your code for security vulnerabilities, performance issues, code smells, and complexity problems. It provides intelligent refactoring suggestions with safety previews and supports automated code fixes. + + + + Get up and running in minutes + + + Explore command-line tools + + + Python API documentation + + + Learn best practices + + + +## Key Features + + + + Detect SQL injection, code injection, hardcoded secrets, and SSRF vulnerabilities + + + + Identify magic numbers, long functions, excessive parameters, and deep nesting + + + + LLM orchestration with RAG (Retrieval-Augmented Generation) for context-aware refactoring + + + + Learn from your project-specific coding standards and improve over time + + + + AST caching, incremental analysis, and parallel processing for large codebases + + + + 14 automated fixers with configurable safety levels and rollback support + + + +## Why Choose Refactron? + + + + Analyzes security, quality, complexity, and performance in one tool + + + AI-powered suggestions with pattern learning capabilities + + + Preview changes, risk scoring, and Git-integrated rollback system + + + +## Ready to Get Started? + + + Install Refactron and start analyzing your code + diff --git a/docs/images/Refactron-logo-TM.png b/docs/logo/Refactron-logo-TM.png similarity index 100% rename from docs/images/Refactron-logo-TM.png rename to docs/logo/Refactron-logo-TM.png diff --git a/docs/images/Screenshot 2026-01-29 at 17.45.00.png b/docs/logo/Refactron_CLI.png similarity index 100% rename from docs/images/Screenshot 2026-01-29 at 17.45.00.png rename to docs/logo/Refactron_CLI.png diff --git a/docs/logo/image.png b/docs/logo/image.png new file mode 100644 index 0000000000000000000000000000000000000000..a7a0fabde56c12d64019d720b6c4482c8924d415 GIT binary patch literal 380532 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

    )Sda)hI5C2@VI8 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

    =;|5RiLvpzOL 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

    IB2it%~}$(VBW$|FvtO>r_`+0 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

    ^$_$v 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 M07*qoM6N<$g0mivB>(^b literal 0 HcmV?d00001 diff --git a/docs/logo/logo.png b/docs/logo/logo.png new file mode 100644 index 0000000000000000000000000000000000000000..d89f4cca97efb3abed075c025b2ad04ae4f53098 GIT binary patch literal 39180 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 KpuUlPZ1SiwnqH<%g3$%&*{zyhurr;G5Vtnrh&T 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 literal 0 HcmV?d00001 diff --git a/docs/logo/logo.svg b/docs/logo/logo.svg new file mode 100644 index 0000000..1a6bb63 --- /dev/null +++ b/docs/logo/logo.svg @@ -0,0 +1,11 @@ + + + + + + + + + + + diff --git a/docs/quickstart.mdx b/docs/quickstart.mdx new file mode 100644 index 0000000..35f585d --- /dev/null +++ b/docs/quickstart.mdx @@ -0,0 +1,217 @@ +--- +title: Quick Start +description: 'Get started with Refactron in minutes' +--- + +## Installation + +Install Refactron using pip: + +```bash +pip install refactron +``` + + + Refactron requires Python 3.8 or higher + + +## Complete Workflow + +Follow this workflow to get the most out of Refactron: + + + + Authenticate with Refactron to unlock AI features: + ```bash + refactron login + ``` + + + + Set up Refactron in your project: + ```bash + refactron init + ``` + Choose a template (base, django, fastapi, or flask) to get started quickly. + + + + Connect your GitHub repository for enhanced features: + ```bash + refactron repo connect + ``` + + + + Run comprehensive code analysis: + ```bash + refactron analyze . --detailed + ``` + + + + Generate AI-powered refactoring suggestions: + ```bash + refactron suggest myfile.py + ``` + + + + Preview and apply refactoring changes: + ```bash + # Preview changes first + refactron refactor myfile.py --preview + + # Apply when ready + refactron refactor myfile.py --apply + ``` + + + + Create a comprehensive technical debt report: + ```bash + refactron report . --format html -o report.html + ``` + + + + Rollback changes if something goes wrong: + ```bash + refactron rollback + ``` + + + +## Quick Commands + +### Analyze Code + +```bash +# Analyze a file +refactron analyze mycode.py + +# Analyze a directory +refactron analyze myproject/ + +# Get detailed analysis +refactron analyze . --detailed +``` + +### Refactor Code + +```bash +# Preview refactoring suggestions +refactron refactor myfile.py --preview + +# Apply automated fixes +refactron autofix myfile.py --apply + +# Apply specific refactoring +refactron refactor myfile.py --apply +``` + +### AI-Powered Features + +```bash +# Get AI suggestions +refactron suggest myfile.py --query "How can I improve this?" + +# Generate documentation +refactron document myfile.py + +# Use RAG for context-aware suggestions +refactron rag query "How to optimize database queries?" +``` + +## Python API + +Use Refactron programmatically in your Python code: + +```python +from refactron import Refactron + +# Initialize Refactron +refactron = Refactron() + +# Analyze code +analysis = refactron.analyze("path/to/code.py") +print(analysis.report()) + +# Preview refactoring +result = refactron.refactor("path/to/code.py", preview=True) +result.show_diff() + +# Apply refactoring +result = refactron.refactor("path/to/code.py", preview=False) +``` + +## Example Output + +When you run an analysis, you'll see: + + + +```bash Terminal Output +✓ Analyzing myproject/ + Files analyzed: 25 + Issues found: 12 + + CRITICAL (2): + - SQL injection vulnerability (line 45) + - Hardcoded secret detected (line 78) + + ERROR (4): + - High cyclomatic complexity (line 120) + - Deep nesting detected (line 156) + + WARNING (6): + - Magic number usage (line 23) + - Missing type hints (line 67) +``` + +```python Python API +{ + "files_analyzed": 25, + "total_issues": 12, + "by_severity": { + "CRITICAL": 2, + "ERROR": 4, + "WARNING": 6 + } +} +``` + + + +## Next Steps + + + + Customize analyzers and thresholds + + + Learn about analysis features + + + Master refactoring workflows + + + Explore AI-powered capabilities + + diff --git a/docs/resources/changelog.mdx b/docs/resources/changelog.mdx new file mode 100644 index 0000000..2daaf17 --- /dev/null +++ b/docs/resources/changelog.mdx @@ -0,0 +1,168 @@ +--- +title: Changelog +description: 'Release history and version updates' +--- + +## v1.0.15 (2026-02-08) + +### Added + +**LLM/RAG Integration**: Full semantic intelligence suite +- LLM orchestration using Llama 3 via Groq +- ChromaDB for semantic code indexing +- `refactron suggest` - AI-powered refactoring suggestions +- `refactron document` - Automated docstring generation + +**Repository Management**: +- `refactron repo list` - List connected repositories +- `refactron repo connect` - Connect local workspaces +- `refactron repo disconnect` - Disconnect repositories + +**Observability & Metrics**: +- `refactron metrics` - Performance statistics +- `refactron serve-metrics` - Prometheus endpoint +- `refactron telemetry` - Opt-in usage analytics + +**CI/CD Integration**: +- `refactron ci` - Generate GitHub Actions and GitLab CI configs + +### Fixed +- Security hardened URL sanitization +- Python 3.8 compatibility issues +- Missing GroqClient dependency + +--- + +## v1.0.14 (2026-01-30) + +### Changed +- Improved CLI startup sequence +- Better dependency management + +--- + +## v1.0.13 (2026-01-30) + +### Added + +**Pattern Learning System**: +- Pattern learning engine for project-specific patterns +- Suggestion ranking based on historical acceptance +- Interactive feedback collection + +**CLI Enhancements**: +- Welcome animation with system checks +- Interactive dashboard +- Enhanced help formatter + +**Performance**: +- AST caching for faster analysis +- Incremental analysis (only changed files) +- Parallel processing support + +**Backup & Rollback**: +- Git-integrated safety system +- Automatic backups before refactoring + +### Fixed +- Numerous linting and type-checking issues +- Python 3.8 compatibility improvements + +--- + +## v1.0.1 (2025-12-28) + +### Added + +**New Analyzers**: +- Security: SQL injection, SSRF, weak crypto +- Performance: N+1 queries, inefficient loops +- Complexity: Nested loops, method chains + +**False Positive Reduction**: +- Context-aware security analysis +- Confidence scoring for issues +- Rule whitelisting + +**Test Coverage**: +- 96.8% coverage for analyzer modules +- Comprehensive edge case tests + +--- + +## v1.0.0 (2025-10-27) + +### 🎉 Major Release - Production Ready! + +**Auto-fix System**: +- 14 automatic fixers for common issues +- Atomic file writes for safety +- Automatic backups and rollback +- Safety levels (safe/low/moderate/high) + +**Fixers Include**: +- Remove unused imports +- Extract magic numbers +- Add missing docstrings +- Simplify boolean expressions +- Convert to f-strings + +### Test Coverage +- 135 tests (81% coverage) +- Production-ready quality + +--- + +## v0.1.0-beta (2025-10-25) + +### 🎉 Initial Beta Release + +**Core Features**: +- Plugin-based analyzer system +- Refactoring suggestion engine +- Risk scoring (0.0-1.0 scale) +- YAML configuration +- Rich CLI interface + +**Analyzers** (8 total): +- Complexity, Code Smell, Security +- Dependency, Dead Code, Type Hints +- Extract Method, Performance + +**Refactorers** (6 total ): +- Extract constants +- Reduce parameters +- Simplify conditionals +- Add docstrings +- Extract methods + +### Performance +- 4,300 lines/second analysis speed +- CI/CD ready +- Fast pre-commit hooks + +--- + +## Version History + +| Version | Date | Status | Highlights | +|---------|------|--------|------------| +| 1.0.15 | 2026-02-08 | **Stable** | AI/LLM integration, RAG system | +| 1.0.14 | 2026-01-30 | **Stable** | CLI improvements | +| 1.0.13 | 2026-01-30 | **Stable** | Pattern learning, performance | +| 1.0.1 | 2025-12-28 | **Stable** | New analyzers, test coverage | +| 1.0.0 | 2025-10-27 | **Stable** | Auto-fix system | +| 0.1.0 | 2025-10-25 | **Beta** | Initial release | + +--- + +## What's Next + +### Upcoming Features +- Advanced pattern recognition +- VS Code extension +- PyCharm plugin +- Custom rule engine +- Performance profiling improvements + +Stay tuned for more updates! diff --git a/docs/resources/faq.mdx b/docs/resources/faq.mdx new file mode 100644 index 0000000..a7e83c7 --- /dev/null +++ b/docs/resources/faq.mdx @@ -0,0 +1,231 @@ +--- +title: FAQ +description: 'Frequently asked questions' +--- + +## General + + + + Refactron is an intelligent Python code refactoring tool that analyzes your code for issues and suggests automated improvements with safety guarantees. + + + + Yes! Refactron is open source and free to use. Some advanced features require an API key for authentication. + + + + Refactron supports Python 3.8 and above. + + + + Absolutely! Refactron is designed for CI/CD integration. Use `refactron ci` to generate configuration templates. + + + +## Installation & Setup + + + + Install via pip: + ```bash + pip install refactron + ``` + Then login to authenticate: + ```bash + refactron login + ``` + + + + Refactron works out of the box with sensible defaults. For customization, run: + ```bash + refactron init + ``` + This creates a `.refactron.yaml` configuration file. + + + + Refactron automatically installs all required dependencies via pip. For AI features, you'll need a Groq API key (free tier available). + + + +## Usage + + + + Run: + ```bash + refactron analyze myproject/ + ``` + This will scan your code and report issues by severity. + + + + Refactron includes multiple safety features: + - **Preview mode** - See changes before applying + - **Risk scores** - Each suggestion has a risk rating + - **Automatic backups** - All changes are backed up + - **Rollback** - Easily undo changes + + + + Yes! Use the `--type` flag: + ```bash + refactron refactor myfile.py --type extract_constant + ``` + Or configure in `.refactron.yaml`: + ```yaml + enabled_refactorers: + - extract_constant + - add_docstring + ``` + + + + First, set your Groq API key: + ```bash + export GROQ_API_KEY='your-key' + ``` + Then index your codebase: + ```bash + refactron rag index + ``` + Now use AI-powered refactoring: + ```bash + refactron refactor myfile.py --ai + ``` + + + +## AI & RAG + + + + By default, Refactron uses Groq (Llama 3). You can also configure custom LLM providers. + + + + When using AI features with cloud LLM providers (like Groq), code snippets are sent for analysis. The RAG indexing happens locally. You can use local LLM providers for complete privacy. + + + + Re-index after significant code changes: + ```bash + refactron rag index --update + ``` + For complete re-indexing: + ```bash + refactron rag index --force + ``` + + + +## Pattern Learning + + + + Refactron learns from your feedback on refactoring suggestions. When you accept or reject suggestions, it adapts to your project's style and preferences. + + + + Yes, in `.refactron.yaml`: + ```yaml + enable_pattern_learning: false + ``` + + + + By default in `.refactron/patterns/` in your project root. You can customize this: + ```yaml + pattern_storage_dir: /custom/path + ``` + + + +## Troubleshooting + + + + Run `refactron login` to authenticate. Check your authentication status: + ```bash + refactron auth status + ``` + + + + Enable performance optimizations: + ```yaml + enable_ast_cache: true + enable_parallel_processing: true + max_parallel_workers: 4 + ``` + + + + You can: + 1. Provide feedback to pattern learning + 2. Ignore specific issues with inline comments: + ```python + x = 42 # refactron: ignore magic-number + ``` + 3. Exclude files in `.refactron.yaml`: + ```yaml + exclude_patterns: + - "*/tests/*" + ``` + + + + List available rollback sessions: + ```bash + refactron rollback --list + ``` + Rollback specific session: + ```bash + refactron rollback --session + ``` + + + + Create the index first: + ```bash + refactron rag index + ``` + + + +## Advanced + + + + Yes! Extend the `BaseAnalyzer` class: + ```python + from refactron.analyzers.base_analyzer import BaseAnalyzer + + class MyAnalyzer(BaseAnalyzer): + def analyze_file(self, file_path, ast_tree): + # Your analysis logic + return issues + ``` + + + + Yes! Refactron integrates well with: + - **Black** - Code formatting + - **isort** - Import sorting + - **pytest** - Testing + - **pre-commit** - Git hooks + - **Prometheus** - Monitoring + + + + Check out our [GitHub repository](https://github.com/Refactron-ai/Refactron_lib) and see the CONTRIBUTING.md guide! + + + +## Support + + + Can't find your answer? Open an issue on [GitHub](https://github.com/Refactron-ai/Refactron_lib/issues) or check the [full documentation](/introduction). + diff --git a/documentation/docs/ARCHITECTURE.md b/documentation/docs/ARCHITECTURE.md new file mode 100644 index 0000000..af9af7d --- /dev/null +++ b/documentation/docs/ARCHITECTURE.md @@ -0,0 +1,364 @@ +# Refactron Architecture + +## Overview + +Refactron is designed as a modular, extensible Python library for code analysis and refactoring. The architecture follows clean separation of concerns with well-defined interfaces. + +## Project Structure + +``` +refactron/ +├── core/ # Core functionality +│ ├── refactron.py # Main entry point +│ ├── config.py # Configuration management +│ ├── models.py # Data models +│ ├── analysis_result.py # Analysis results +│ └── refactor_result.py # Refactoring results +├── analyzers/ # Code analyzers +│ ├── base_analyzer.py # Abstract base class +│ ├── complexity_analyzer.py +│ └── code_smell_analyzer.py +├── refactorers/ # Code refactorers +│ ├── base_refactorer.py # Abstract base class +│ └── extract_method_refactorer.py +└── cli.py # Command-line interface +``` + +## Core Components + +### 1. Refactron (Main Class) + +The `Refactron` class is the main entry point that orchestrates analysis and refactoring: + +```python +class Refactron: + def __init__(self, config: Optional[RefactronConfig] = None) + def analyze(self, target: Union[str, Path]) -> AnalysisResult + def refactor(self, target: Union[str, Path], ...) -> RefactorResult +``` + +**Responsibilities:** +- Initialize analyzers and refactorers +- Coordinate file discovery +- Run analysis and refactoring operations +- Return structured results + +### 2. Configuration System + +`RefactronConfig` provides flexible configuration: + +```python +@dataclass +class RefactronConfig: + enabled_analyzers: List[str] + enabled_refactorers: List[str] + max_function_complexity: int + # ... other settings +``` + +**Features:** +- Default configuration +- YAML file support +- Per-project customization + +### 3. Data Models + +Core data structures defined in `models.py`: + +- **`CodeIssue`**: Represents detected problems +- **`FileMetrics`**: Metrics for a single file +- **`RefactoringOperation`**: Proposed code changes +- **`IssueLevel`**: Severity enumeration +- **`IssueCategory`**: Issue type enumeration + +## Analyzers + +Analyzers detect code issues and patterns. + +### Base Analyzer + +All analyzers inherit from `BaseAnalyzer`: + +```python +class BaseAnalyzer(ABC): + @abstractmethod + def analyze(self, file_path: Path, source_code: str) -> List[CodeIssue]: + pass + + @property + @abstractmethod + def name(self) -> str: + pass +``` + +### Built-in Analyzers + +1. **ComplexityAnalyzer** + - Cyclomatic complexity + - Function length + - Maintainability index + +2. **CodeSmellAnalyzer** + - Too many parameters + - Deep nesting + - Magic numbers + - Missing docstrings + - Duplicate code patterns + +### Creating a Custom Analyzer + +```python +from refactron.analyzers.base_analyzer import BaseAnalyzer +from refactron.core.models import CodeIssue, IssueLevel, IssueCategory + +class MyAnalyzer(BaseAnalyzer): + @property + def name(self) -> str: + return "my_analyzer" + + def analyze(self, file_path: Path, source_code: str) -> List[CodeIssue]: + issues = [] + + # Your analysis logic here + tree = ast.parse(source_code) + # ... analyze the AST + + # Create issues + issue = CodeIssue( + category=IssueCategory.CODE_SMELL, + level=IssueLevel.WARNING, + message="Problem detected", + file_path=file_path, + line_number=10, + suggestion="Fix it this way", + rule_id="MY001", + ) + issues.append(issue) + + return issues +``` + +**Register in config:** +```yaml +enabled_analyzers: + - my_analyzer +``` + +## Refactorers + +Refactorers propose and apply code transformations. + +### Base Refactorer + +All refactorers inherit from `BaseRefactorer`: + +```python +class BaseRefactorer(ABC): + @abstractmethod + def refactor(self, file_path: Path, source_code: str) -> List[RefactoringOperation]: + pass + + @property + @abstractmethod + def operation_type(self) -> str: + pass +``` + +### Built-in Refactorers + +1. **ExtractMethodRefactorer** + - Identifies opportunities to extract methods + - Suggests breaking down complex functions + +### Creating a Custom Refactorer + +```python +from refactron.refactorers.base_refactorer import BaseRefactorer +from refactron.core.models import RefactoringOperation + +class MyRefactorer(BaseRefactorer): + @property + def operation_type(self) -> str: + return "my_refactoring" + + def refactor(self, file_path: Path, source_code: str) -> List[RefactoringOperation]: + operations = [] + + # Your refactoring logic here + tree = ast.parse(source_code) + # ... find refactoring opportunities + + operation = RefactoringOperation( + operation_type=self.operation_type, + file_path=file_path, + line_number=42, + description="Apply my refactoring", + old_code="old code", + new_code="new code", + risk_score=0.3, # 0.0 = safe, 1.0 = risky + reasoning="This improves readability", + ) + operations.append(operation) + + return operations +``` + +## Analysis Pipeline + +1. **File Discovery** + - Scan directories for Python files + - Apply include/exclude patterns + +2. **File Analysis** + - Read source code + - Parse into AST + - Run each enabled analyzer + - Collect issues + +3. **Metric Calculation** + - Lines of code + - Comment lines + - Complexity metrics + +4. **Result Aggregation** + - Combine all issues + - Generate summary statistics + - Create report + +## Refactoring Pipeline + +1. **Analysis Phase** + - Run analyzers to understand code + +2. **Opportunity Detection** + - Each refactorer identifies opportunities + - Calculate risk scores + +3. **Operation Generation** + - Create RefactoringOperation objects + - Include before/after code + +4. **Preview/Application** + - Show diff (preview mode) + - Apply changes (apply mode) + - Create backups + +## Extension Points + +### 1. Custom Rules + +Add rules via configuration: + +```yaml +custom_rules: + max_class_methods: 20 + enforce_type_hints: true +``` + +Access in analyzers: +```python +custom_value = self.config.custom_rules.get("max_class_methods", 20) +``` + +### 2. Plugin System (Future) + +Planned plugin architecture: + +```python +from refactron.plugins import RefactronPlugin + +class MyPlugin(RefactronPlugin): + def register(self): + return { + "analyzers": [MyAnalyzer], + "refactorers": [MyRefactorer], + } +``` + +### 3. Custom Reporters + +Currently supports: text, JSON, HTML +Future: PDF, Markdown, etc. + +## CLI Architecture + +The CLI (`cli.py`) provides command-line interface: + +```bash +refactron analyze +refactron refactor +refactron report +refactron init +``` + +Built with `click` for: +- Argument parsing +- Help text +- Option handling + +Uses `rich` for: +- Beautiful terminal output +- Tables +- Progress indicators +- Syntax highlighting + +## Design Principles + +1. **Modularity**: Each component has single responsibility +2. **Extensibility**: Easy to add new analyzers/refactorers +3. **Configuration**: Customizable via config files +4. **Safety**: Preview before apply, risk scoring +5. **Clarity**: Clear error messages and suggestions +6. **Performance**: Efficient AST parsing, caching where appropriate + +## Technology Stack + +- **libcst**: Concrete syntax tree (preserves formatting) +- **ast**: Abstract syntax tree (analysis) +- **radon**: Complexity metrics +- **astroid**: Advanced AST analysis +- **click**: CLI framework +- **rich**: Terminal UI +- **pyyaml**: Configuration files +- **pytest**: Testing + +## Testing Strategy + +1. **Unit Tests**: Test individual components +2. **Integration Tests**: Test end-to-end workflows +3. **Example-Based Tests**: Use real code examples +4. **Coverage**: Aim for >80% code coverage + +## Future Enhancements + +1. **Multi-language Support**: JavaScript, TypeScript, etc. +2. **AI Integration**: LLM-powered suggestions +3. **IDE Plugins**: VS Code, PyCharm +4. **CI/CD Integration**: GitHub Actions, GitLab CI +5. **Learning System**: Adapt to project patterns +6. **Batch Processing**: Parallel analysis +7. **Auto-fix**: Automatically apply safe refactorings +8. **Custom Rule Engine**: DSL for defining rules + +## Performance Considerations + +- Use generators for large file sets +- Cache parsed ASTs when possible +- Parallelize analysis across files +- Lazy load analyzers +- Incremental analysis (only changed files) + +## Security Considerations + +- Never execute analyzed code +- Sandbox refactoring operations +- Validate file paths +- Limit file sizes +- Rate limit external API calls (future) + +--- + +For more details, see: +- [API Documentation](docs/api.md) +- [Contributing Guide](CONTRIBUTING.md) +- [Examples](examples/) diff --git a/documentation/docs/CHANGELOG.md b/documentation/docs/CHANGELOG.md new file mode 100644 index 0000000..2fc26da --- /dev/null +++ b/documentation/docs/CHANGELOG.md @@ -0,0 +1,365 @@ +# Changelog + +All notable changes to Refactron will be documented in this file. + +The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), +and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). + +### v1.0.15 (2026-02-08) + +#### Added +- **LLM/RAG Integration**: Full semantic intelligence suite using Llama 3 (via Groq) and ChromaDB. +- **Repository Management**: New `repo` command group (`list`, `connect`, `disconnect`) for managing local workspaces and auto-indexing. +- **AI-Powered Commands**: + - `refactron suggest`: Contextual refactoring proposals. + - `refactron document`: Automated Google-style docstring generation. +- **Observability & Metrics**: + - `refactron metrics`: Detailed performance and analyzer statistics. + - `refactron serve-metrics`: Prometheus-compatible endpoint. + - `refactron telemetry`: Opt-in anonymous usage statistics. +- **CI/CD Integration**: `refactron ci` command to generate GitHub Actions and GitLab CI configurations. +- **Improved CLI UI**: New interactive dashboard and file selector. + +#### Fixed +- **Security**: Hardened URL sanitization in workspace management to prevent injection attacks. +- **Compatibility**: Resolved Python 3.8 issues in RAG parsing, Tree-sitter API, and fingerprinting. +- **Reliability**: Added missing `GroqClient` dependency and cleaned up project-wide linting issues. +- **Indexer Reliability**: Fixed missing `GroqClient` import and clarified error messages in the RAG indexer. + +### Changed +- Improved CLI startup sequence and progress feedback for RAG indexing operations. +- Updated documentation files to reflect the new AI-powered features. +- Applied project-wide linting and code style fixes. + +--- + +## [1.0.14] - 2026-01-30 + +### Changed +- Refactored CLI startup sequence to display animation before authentication prompt. +- Improved dependency management (added `astroid`). + +## [1.0.13] - 2026-01-30 + +### Added + +#### Pattern Learning System +- **Pattern Learning Engine** - Foundation for identifying and learning project-specific refactoring patterns. +- **Project-Specific Rule Tuner** - CLI commands to tune refactoring rules based on project needs. +- **Suggestion Ranking System** - Intelligent ranking of refactoring suggestions based on risk and impact. +- **Feedback Collection System** - Interactive feedback loop to improve pattern recognition over time. + +#### CLI Enhancements +- **Enhanced Welcome Flow** - Sleek startup animation with system checks and rotating quick tips. +- **Interactive Dashboard** - Minimal "Info Center" for quick access to help and version information. +- **Custom Help Formatter** - Beautifully formatted, numbered help output for better command discovery. +- **Authentication Enforcement** - Mandatory authentication for all core commands (analyze, refactor, etc.). + +#### Performance & Reliability +- **AST Cache & Incremental Analysis** - Faster analysis by only processing changed files. +- **Parallel Processing** - Multi-threaded analysis for large codebases. +- **Backup & Rollback System** - Git-integrated safety system to undo refactoring changes. +- **Enhanced Error Handling** - Custom exceptions and graceful degradation for a more robust experience. + +#### Configuration & Integration +- **Advanced Configuration Management** - Support for profiles, validation, and project-specific settings. +- **CI/CD Integration Templates** - Pre-configured templates for GitHub Actions and other CI/CD platforms. +- **Prometheus Metrics** - Built-in support for exporting metrics to Prometheus. + +### Fixed +- Resolved numerous linting and type-checking issues across the codebase. +- Improved Python 3.8 compatibility with explicit type hints. +- Optimized project type detection for large codebases. +- Fixed critical issues in feedback persistence and test isolation. + +--- + +### Planned +- AI-powered pattern recognition +- VS Code extension +- PyCharm plugin +- Advanced custom rule engine +- Performance profiling + +--- + +## [1.0.1] - 2025-12-28 + +### Added + +#### Analyzer Enhancements (#37) +- **New Security Patterns**: + - SQL parameterization detection (SEC009) - Identifies unsafe SQL string formatting + - SSRF (Server-Side Request Forgery) vulnerability detection (SEC010) + - Insecure random number generation detection (SEC011) + - Weak SSL/TLS configuration detection (SEC012, SEC013) + - Cryptographic weaknesses detection (weak hashing algorithms) +- **Complexity Analyzer Improvements**: + - Nested loop depth detection (C003) - Flags deeply nested loops that impact performance + - Method call chain complexity detection (C004) - Identifies overly long method chaining +- **Performance Analyzer** - New analyzer detecting performance antipatterns: + - N+1 query detection (P001) - Identifies database queries inside loops + - Inefficient list comprehensions (P002, P003) - Detects patterns that can be optimized + - Unnecessary iterations (P004) - Finds redundant loops and iterations + - Inefficient string concatenation (P005) - Detects string building in loops + - Redundant list conversions (P006) - Finds unnecessary list() wrappers +- **Code Smell Analyzer Enhancements**: + - Improved unused import detection (S006) - More accurate analysis of import usage + - Repeated code block detection - Identifies duplicate code patterns within functions + +#### False Positive Reduction (#39, #40) +- **Context-Aware Security Analysis** - Adjusts confidence scores based on file context: + - Test files get 60% confidence multiplier for certain rules (eval, pickle, random) + - Example/demo files get 70% confidence multiplier + - Reduces false positives for legitimate test code +- **Rule Whitelisting** - Configuration-based whitelisting of security rules for specific file patterns +- **False Positive Tracking System** - `FalsePositiveTracker` class to learn and track known false positives +- **Confidence Scores** - All security issues now include confidence scores (0.0-1.0) indicating detection certainty +- **Minimum Confidence Filtering** - Filter out low-confidence issues via configuration + +#### Test Coverage Improvements (#47, #48) +- **Comprehensive Edge Case Tests** - Added extensive edge case coverage for all analyzers +- **Real-World Test Datasets** - Test suites with real-world problematic code patterns +- **Integration Tests** - Improved integration test coverage across analyzer modules +- **Achieved 96.8% test coverage** for analyzer modules + +#### Developer Experience +- Pre-commit hooks configuration for automated code quality checks +- SECURITY.md with comprehensive security policy and vulnerability reporting process +- CONTRIBUTING_QUICKSTART.md for fast contributor onboarding (5-minute setup) +- Performance benchmarking suite in benchmarks/ directory +- Pre-commit GitHub Actions workflow for CI/CD +- Enhanced README badges (Black, pre-commit, security scanning) +- Comprehensive documentation for false positive reduction features + +### Changed +- Formatted 10 files with Black in examples/ and real_world_tests/ directories +- Updated README with accurate test coverage (84%) and test count (135) +- Improved contributing documentation with quick start guide +- Updated CI/CD metrics in README +- Security analyzer now uses context-aware confidence scoring +- Enhanced code smell detection accuracy for unused imports + +### Fixed +- Fixed flake8 violations in simplify_conditionals_refactorer.py +- Fixed flake8 violations in reduce_parameters_refactorer.py +- Reduced total flake8 issues from 294 to ~17 (94% improvement) +- Fixed code formatting issues in examples directory +- Improved security analyzer accuracy by reducing false positives in test files + +--- + +## [1.0.0] - 2025-10-27 + +### 🎉 Major Release - Production Ready! + +First stable release with complete auto-fix system and Phase 3 features. + +### Added + +#### Phase 3: Auto-fix System +- **Auto-fix Engine** - Intelligent automatic code fixing with safety guarantees +- **14 Automatic Fixers** - Fix common issues automatically + - 🟢 `remove_unused_imports` - Remove unused import statements (risk: 0.0) + - 🟢 `sort_imports` - Sort imports using isort (risk: 0.0) + - 🟢 `remove_trailing_whitespace` - Clean whitespace (risk: 0.0) + - 🟡 `extract_magic_numbers` - Extract to named constants (risk: 0.2) + - 🟡 `add_docstrings` - Add missing documentation (risk: 0.1) + - 🟡 `remove_dead_code` - Remove unreachable code (risk: 0.1) + - 🟡 `normalize_quotes` - Standardize quote style (risk: 0.1) + - 🟡 `simplify_boolean` - Simplify boolean expressions (risk: 0.3) + - 🟡 `convert_to_fstring` - Modernize string formatting (risk: 0.2) + - 🟡 `remove_unused_variables` - Clean unused variables (risk: 0.2) + - 🟡 `fix_indentation` - Fix tabs/spaces (risk: 0.1) + - 🟡 `add_missing_commas` - Add trailing commas (risk: 0.1) + - 🟡 `remove_print_statements` - Remove debug prints (risk: 0.3) + - 🔴 `fix_type_hints` - Add type hints (risk: 0.4, placeholder) + +#### File Operations & Safety +- **Atomic File Writes** - Safe file operations (temp file → rename) +- **Automatic Backups** - All changes backed up before applying +- **Rollback System** - Undo individual files or all at once +- **Backup Index** - Track all backups with timestamps +- **Safety Levels** - Control fix risk (safe/low/moderate/high) + +#### CLI Enhancements +- **New Command**: `refactron autofix` - Automatic code fixing +- **Safety Level Flags** - `--safety-level` for risk control +- **Preview Mode** - See changes before applying +- **Apply Mode** - Apply fixes with automatic backup + +### Improved +- **Test Coverage** - 135 tests (was 98) → +37 auto-fix tests +- **Overall Coverage** - 81% (maintained high coverage) +- **Production Status** - Changed from Beta to Stable +- **Documentation** - Added comprehensive manual testing guide + +### Fixed +- All existing bugs from v0.1.0-beta +- Edge cases in fixer logic +- File operation safety + +### Technical Details +- Added `refactron/autofix/` module + - `engine.py` - Auto-fix engine (95% coverage) + - `fixers.py` - 14 concrete fixers (88% coverage) + - `file_ops.py` - File operations (87% coverage) + - `models.py` - Data models (100% coverage) +- Added 37 comprehensive tests +- File backup stored in `.refactron_backups/` +- Backup index: `.refactron_backups/index.json` + +--- + +## [0.1.0-beta] - 2025-10-25 + +### 🎉 Initial Beta Release + +First production-ready beta release of Refactron! + +### Recent Improvements (Pre-Release Polish) +- **Fixed** security analyzer false positives for package metadata (`__author__`, `__version__`, etc.) +- **Improved** CLI code quality by extracting helper functions + - `analyze()` function simplified (reduced complexity) + - `refactor()` function simplified (reduced complexity) +- **Added** 11 comprehensive tests for Extract Method refactorer + - Coverage improved from 62% → 97% +- **Increased** overall test coverage from 89% → 90% +- **Increased** total tests from 87 → 98 +- **Eliminated** all critical issues in production code (1 → 0) + +### Added + +#### Core Features +- **Plugin-based analyzer system** for extensibility +- **Refactoring suggestion engine** with before/after previews +- **Risk scoring system** (0.0-1.0 scale) for safe refactoring +- **Configuration management** via YAML files +- **Rich CLI interface** with colors and progress indicators + +#### Analyzers (8 Total) +- **Complexity Analyzer** - Cyclomatic complexity, maintainability index +- **Code Smell Analyzer** - Too many parameters, deep nesting, magic numbers +- **Security Analyzer** - eval/exec detection, hardcoded secrets, injection patterns +- **Dependency Analyzer** - Wildcard imports, unused imports, circular dependencies +- **Dead Code Analyzer** - Unused functions, unreachable code, empty functions +- **Type Hint Analyzer** - Missing type annotations, incomplete generics +- **Extract Method Analyzer** - Identify complex functions that should be split +- **Base Analyzer** - Abstract base for custom analyzers + +#### Refactorers (6 Total) +- **Magic Number Refactorer** - Extract magic numbers to constants +- **Reduce Parameters Refactorer** - Convert parameter lists to config objects +- **Simplify Conditionals Refactorer** - Transform nested if statements to guard clauses +- **Add Docstring Refactorer** - Generate contextual docstrings +- **Extract Method Refactorer** - Suggest method extraction +- **Base Refactorer** - Abstract base for custom refactorers + +#### CLI Commands +- `refactron analyze` - Analyze code for issues +- `refactron refactor` - Generate refactoring suggestions +- `refactron report` - Create detailed reports (text, JSON, HTML) +- `refactron init` - Initialize configuration file + +#### Testing +- **87 tests** with **89% coverage** +- Unit tests for all analyzers +- Integration tests for CLI +- Real-world testing on 5,800 lines of code +- Edge case and error handling tests + +#### Documentation +- Comprehensive README with quick start +- Architecture documentation +- Developer setup guide +- Real-world case study with metrics +- Usage examples (Flask, Data Science, CLI) +- Complete feature matrix + +#### Examples +- Bad code examples for testing +- Flask API with security issues +- Data science workflow issues +- CLI tool best practices +- Refactoring demonstration +- Phase 2 analyzer showcase + +### Performance +- **4,300 lines per second** analysis speed +- Low memory footprint +- Suitable for CI/CD integration +- Fast enough for pre-commit hooks (<2s typical) + +### Quality Metrics +- 89% test coverage +- 0 critical security issues in production code +- 51 issues per 1,000 lines (top 25% for Python projects) +- 100% accuracy on security vulnerability detection + +--- + +## [0.0.1] - 2025-10-23 + +### Initial Development + +- Project structure setup +- Basic AST parsing +- Initial analyzer prototypes +- CLI framework +- Early testing + +--- + +## Version History + +| Version | Date | Status | Highlights | +|---------|------|--------|------------| +| 1.0.1 | 2025-12-28 | **Stable** | Expanded analyzers, false positive reduction, performance analyzer, improved test coverage | +| 1.0.0 | 2025-10-27 | **Stable** | Production-ready with auto-fix system | +| 0.1.0 | 2025-10-25 | **Beta** | First production-ready release | +| 0.0.1 | 2025-10-23 | Alpha | Initial development | + +--- + +## Categories + +### Added +New features and capabilities + +### Changed +Changes to existing functionality + +### Deprecated +Features that will be removed in future releases + +### Removed +Features that have been removed + +### Fixed +Bug fixes + +### Security +Security-related changes and fixes + +--- + +## Notes + +- **v0.1.0** is the first **production-ready** release +- Tested on 5,800 lines of real Python code +- Zero critical issues in production code +- Ready for CI/CD integration +- Suitable for team adoption + +--- + +## Links + +- [GitHub Repository](https://github.com/yourusername/refactron) +- [Documentation](README.md) +- [Contributing Guide](CONTRIBUTING.md) +- [Issue Tracker](https://github.com/yourusername/refactron/issues) + +--- + +**Keep this changelog up to date with every release!** diff --git a/documentation/docs/CLI_REFERENCE.md b/documentation/docs/CLI_REFERENCE.md new file mode 100644 index 0000000..56d58d5 --- /dev/null +++ b/documentation/docs/CLI_REFERENCE.md @@ -0,0 +1,455 @@ +# CLI Reference + +This document contains the reference for all Refactron CLI commands. + +## Global Options + +```bash + +╭────────────────────────────────────────────────────────────────────────────────────────────────────────╮ +│ │ +│ ⚡ REFACTRON │ +│ INTELLIGENT CODE REFACTORING │ +│ │ +╰────────────────────────────────────────────────────────────────────────────────────────────────────────╯ + +COMMAND CENTER +Select a command by name or number + + + ID COMMAND DESCRIPTION + ──────────────────────────────────────────────────────────────────────────────────────────────────────── + 01 ANALYZE Analyze code for issues and technical debt. + 02 AUTH Manage authentication state. + 03 AUTOFIX Automatically fix code issues (Phase 3... + 04 DOCUMENT Generate Google-style docstrings for a... + 05 FEEDBACK Provide feedback on a refactoring operation. + 06 GENERATE-CICD Generate CI/CD integration templates. + 07 INIT Initialize Refactron configuration in the... + 08 LOGIN Log in to Refactron CLI via device-code flow. + 09 LOGOUT Log out of Refactron CLI. + 10 METRICS Display collected metrics from the current... + 11 PATTERNS Pattern learning and project-specific... + 12 RAG RAG (Retrieval-Augmented Generation)... + 13 REFACTOR Refactor code with intelligent... + 14 REPO Manage GitHub repository connections. + 15 REPORT Generate a detailed technical debt report. + 16 ROLLBACK Rollback refactoring changes to restore... + 17 SERVE-METRICS Start a Prometheus metrics HTTP server. + 18 SUGGEST Generate AI-powered refactoring suggestions. + 19 TELEMETRY Manage telemetry settings. + + +GLOBAL OPTIONS +--version Show the version and exit. +--help Show this message and exit. + +USAGE: refactron ... +EXAMPLE: refactron analyze . --detailed + + + +``` + +## analyze + +```bash +Usage: refactron analyze [OPTIONS] [TARGET] + + Analyze code for issues and technical debt. + + TARGET: Path to file or directory to analyze (optional if workspace is + connected) + +Options: + -c, --config PATH Path to configuration file + --detailed / --summary Show detailed or summary report + --log-level [DEBUG|INFO|WARNING|ERROR|CRITICAL] + Set log level + --log-format [json|text] Set log format (json for CI/CD, text for + console) + --metrics / --no-metrics Enable or disable metrics collection + --show-metrics Show metrics summary after analysis + -p, --profile [dev|staging|prod] + Named configuration profile to use (dev, + staging, prod). Profiles typically group + config defaults; if both --profile and + --environment are set, the environment + determines the final effective configuration. + -e, --environment [dev|staging|prod] + Target runtime environment (dev, staging, + prod). When both --profile and --environment + are provided, the environment overrides the + selected profile. + --help Show this message and exit. + +``` + +## auth + +```bash +Usage: refactron auth [OPTIONS] COMMAND [ARGS]... + + Manage authentication state. + +Options: + --help Show this message and exit. + +Commands: + logout Log out of Refactron CLI. + status Show current authentication status. + +``` + +## autofix + +```bash +Usage: refactron autofix [OPTIONS] TARGET + + Automatically fix code issues (Phase 3 feature). + + TARGET: Path to file or directory to fix + + Examples: refactron autofix myfile.py --preview refactron autofix + myproject/ --apply --safety-level moderate + +Options: + -c, --config PATH Path to configuration file + -p, --profile [dev|staging|prod] + Named configuration profile to use (dev, + staging, prod). Profiles typically group + config defaults; if both --profile and + --environment are set, the environment + determines the final effective configuration. + -e, --environment [dev|staging|prod] + Target runtime environment (dev, staging, + prod). When both --profile and --environment + are provided, the environment overrides the + selected profile. + --preview / --apply Preview fixes or apply them + -s, --safety-level [safe|low|moderate|high] + Maximum risk level for automatic fixes + --help Show this message and exit. + +``` + +## document + +```bash +Usage: refactron document [OPTIONS] TARGET + + Generate Google-style docstrings for a Python file. + + Uses AI to analyze code and add comprehensive documentation. + +Options: + --apply / --no-apply Apply the documentation changes to the file + --interactive / --no-interactive + Use interactive mode for apply + --help Show this message and exit. + +``` + +## feedback + +```bash +Usage: refactron feedback [OPTIONS] OPERATION_ID + + Provide feedback on a refactoring operation. + + OPERATION_ID: The unique identifier of the refactoring operation + + Examples: refactron feedback abc-123 --action accepted --reason "Improved + readability" refactron feedback xyz-789 --action rejected --reason "Too + risky" + +Options: + -a, --action [accepted|rejected|ignored] + Feedback action: accepted, rejected, or + ignored [required] + -r, --reason TEXT Optional reason for the feedback + -c, --config PATH Path to configuration file + --help Show this message and exit. + +``` + +## generate-cicd + +```bash +Usage: refactron generate-cicd [OPTIONS] {github|gitlab|pre-commit|all} + + Generate CI/CD integration templates. + + TYPE: Type of template to generate (github, gitlab, pre-commit, all) + + Examples: refactron generate-cicd github --output .github/workflows + refactron generate-cicd gitlab --output . refactron generate-cicd pre-commit + --output . refactron generate-cicd all --output . + +Options: + -o, --output PATH Output directory (default: current directory) + --python-versions TEXT Comma-separated Python versions (default: + 3.8,3.9,3.10,3.11,3.12) + --fail-on-critical / --no-fail-on-critical + Fail build on critical issues (default: True) + --fail-on-errors / --no-fail-on-errors + Fail build on error-level issues (default: + False) + --max-critical INTEGER Maximum allowed critical issues (default: 0) + --max-errors INTEGER Maximum allowed error-level issues (default: + 10) + --help Show this message and exit. + +``` + +## init + +```bash +Usage: refactron init [OPTIONS] + + Initialize Refactron configuration in the current directory. + +Options: + -t, --template [base|django|fastapi|flask] + Configuration template to use (base, django, + fastapi, flask) + --help Show this message and exit. + +``` + +## login + +```bash +Usage: refactron login [OPTIONS] + + Log in to Refactron CLI via device-code flow. + +Options: + --api-base-url TEXT Refactron API base URL [default: + https://api.refactron.dev] + --no-browser Do not open a browser automatically (print the URL + instead) + --timeout INTEGER HTTP timeout in seconds for each request [default: 10] + --force Force re-login even if already logged in + --help Show this message and exit. + +``` + +## logout + +```bash +Usage: refactron logout [OPTIONS] + + Log out of Refactron CLI. + +Options: + --help Show this message and exit. + +``` + +## metrics + +```bash +Usage: refactron metrics [OPTIONS] + + Display collected metrics from the current session. + + Shows performance metrics, analyzer hit counts, and other statistics from + Refactron operations. + + Examples: refactron metrics # Show metrics in text format + refactron metrics --format json # Show metrics in JSON format + +Options: + -f, --format [text|json] Output format + --help Show this message and exit. + +``` + +## patterns + +```bash +Usage: refactron patterns [OPTIONS] COMMAND [ARGS]... + + Pattern learning and project-specific tuning commands. + +Options: + --help Show this message and exit. + +Commands: + analyze Analyze learned patterns for a specific project. + profile Show the current pattern profile for a project. + recommend Show rule tuning recommendations for a project. + tune Apply tuning recommendations to the project profile. + +``` + +## rag + +```bash +Usage: refactron rag [OPTIONS] COMMAND [ARGS]... + + RAG (Retrieval-Augmented Generation) management commands. + +Options: + --help Show this message and exit. + +Commands: + index Index the current workspace for RAG retrieval. + search Search the RAG index for similar code. + status Show RAG index statistics. + +``` + +## refactor + +```bash +Usage: refactron refactor [OPTIONS] [TARGET] + + Refactor code with intelligent transformations. + + TARGET: Path to file or directory to refactor (optional if workspace is + connected) + +Options: + -c, --config PATH Path to configuration file + -p, --profile [dev|staging|prod] + Named configuration profile to use (dev, + staging, prod). Profiles typically group + config defaults; if both --profile and + --environment are set, the environment + determines the final effective configuration. + -e, --environment [dev|staging|prod] + Target runtime environment (dev, staging, + prod). When both --profile and --environment + are provided, the environment overrides the + selected profile. + --preview / --apply Preview changes or apply them + -t, --types TEXT Specific refactoring types to apply + --feedback / --no-feedback Collect interactive feedback on refactoring + suggestions + --help Show this message and exit. + +``` + +## repo + +```bash +Usage: refactron repo [OPTIONS] COMMAND [ARGS]... + + Manage GitHub repository connections. + +Options: + --help Show this message and exit. + +Commands: + connect Connect to a GitHub repository. + disconnect Disconnect a repository and optionally delete local files. + list List all GitHub repositories connected to your account. + +``` + +## report + +```bash +Usage: refactron report [OPTIONS] TARGET + + Generate a detailed technical debt report. + + TARGET: Path to file or directory to analyze + +Options: + -c, --config PATH Path to configuration file + -p, --profile [dev|staging|prod] + Configuration profile to use (dev, staging, + prod) + -e, --environment [dev|staging|prod] + Environment to use (overrides profile) + -f, --format [text|json|html] Report format + -o, --output PATH Output file path + --help Show this message and exit. + +``` + +## rollback + +```bash +Usage: refactron rollback [OPTIONS] [SESSION_ID] + + Rollback refactoring changes to restore original files. + + By default, restores files from the latest backup session. + + Arguments: SESSION_ID: Optional specific session ID to rollback. + + Examples: refactron rollback # Rollback latest session + refactron rollback session_123 # Rollback specific session refactron + rollback --list # List all backup sessions refactron rollback --use- + git # Use Git rollback refactron rollback --clear # Clear all + backups + +Options: + -s, --session TEXT Specific session ID to rollback (deprecated, use argument + instead) + --use-git Use Git rollback instead of file backup + --list List all backup sessions + --clear Clear all backup sessions + --help Show this message and exit. + +``` + +## serve-metrics + +```bash +Usage: refactron serve-metrics [OPTIONS] + + Start a Prometheus metrics HTTP server. + + This command starts a persistent HTTP server that exposes Refactron metrics in + Prometheus format on the /metrics endpoint. + + Examples: refactron serve-metrics # Start on 0.0.0.0:9090 + refactron serve-metrics --port 8080 # Start on port 8080 refactron + serve-metrics --host 127.0.0.1 # Bind to localhost only + +Options: + --host TEXT Host to bind Prometheus metrics server to (default: 127.0.0.1 + for localhost-only) + --port INTEGER Port for Prometheus metrics server + --help Show this message and exit. + +``` + +## suggest + +```bash +Usage: refactron suggest [OPTIONS] [TARGET] + + Generate AI-powered refactoring suggestions. + + Uses RAG and LLM to analyze code and propose fixes. + +Options: + --line INTEGER Specific line number to fix + --interactive / --no-interactive + Use interactive mode + --apply / --no-apply Apply the suggested changes to the file + --help Show this message and exit. + +``` + +## telemetry + +```bash +Usage: refactron telemetry [OPTIONS] + + Manage telemetry settings. + +Options: + --enable Enable telemetry collection + --disable Disable telemetry collection + --status Show current telemetry status + --help Show this message and exit. + +``` + diff --git a/documentation/docs/CODE_OF_CONDUCT.md b/documentation/docs/CODE_OF_CONDUCT.md new file mode 100644 index 0000000..3a84de0 --- /dev/null +++ b/documentation/docs/CODE_OF_CONDUCT.md @@ -0,0 +1,133 @@ +# Contributor Covenant Code of Conduct + +## Our Pledge + +We as members, contributors, and leaders pledge to make participation in our +community a harassment-free experience for everyone, regardless of age, body +size, visible or invisible disability, ethnicity, sex characteristics, gender +identity and expression, level of experience, education, socio-economic status, +nationality, personal appearance, race, caste, color, religion, or sexual +identity and orientation. + +We pledge to act and interact in ways that contribute to an open, welcoming, +diverse, inclusive, and healthy community. + +## Our Standards + +Examples of behavior that contributes to a positive environment for our +community include: + +* Demonstrating empathy and kindness toward other people +* Being respectful of differing opinions, viewpoints, and experiences +* Giving and gracefully accepting constructive feedback +* Accepting responsibility and apologizing to those affected by our mistakes, + and learning from the experience +* Focusing on what is best not just for us as individuals, but for the overall + community + +Examples of unacceptable behavior include: + +* The use of sexualized language or imagery, and sexual attention or advances of + any kind +* Trolling, insulting or derogatory comments, and personal or political attacks +* Public or private harassment +* Publishing others' private information, such as a physical or email address, + without their explicit permission +* Other conduct which could reasonably be considered inappropriate in a + professional setting + +## Enforcement Responsibilities + +Community leaders are responsible for clarifying and enforcing our standards of +acceptable behavior and will take appropriate and fair corrective action in +response to any behavior that they deem inappropriate, threatening, offensive, +or harmful. + +Community leaders have the right and responsibility to remove, edit, or reject +comments, commits, code, wiki edits, issues, and other contributions that are +not aligned to this Code of Conduct, and will communicate reasons for moderation +decisions when appropriate. + +## Scope + +This Code of Conduct applies within all community spaces, and also applies when +an individual is officially representing the community in public spaces. +Examples of representing our community include using an official e-mail address, +posting via an official social media account, or acting as an appointed +representative at an online or offline event. + +## Enforcement + +Instances of abusive, harassing, or otherwise unacceptable behavior may be +reported to the community leaders responsible for enforcement at +[INSERT CONTACT EMAIL]. + +All complaints will be reviewed and investigated promptly and fairly. + +All community leaders are obligated to respect the privacy and security of the +reporter of any incident. + +## Enforcement Guidelines + +Community leaders will follow these Community Impact Guidelines in determining +the consequences for any action they deem in violation of this Code of Conduct: + +### 1. Correction + +**Community Impact**: Use of inappropriate language or other behavior deemed +unprofessional or unwelcome in the community. + +**Consequence**: A private, written warning from community leaders, providing +clarity around the nature of the violation and an explanation of why the +behavior was inappropriate. A public apology may be requested. + +### 2. Warning + +**Community Impact**: A violation through a single incident or series of +actions. + +**Consequence**: A warning with consequences for continued behavior. No +interaction with the people involved, including unsolicited interaction with +those enforcing the Code of Conduct, for a specified period of time. This +includes avoiding interactions in community spaces as well as external channels +like social media. Violating these terms may lead to a temporary or permanent +ban. + +### 3. Temporary Ban + +**Community Impact**: A serious violation of community standards, including +sustained inappropriate behavior. + +**Consequence**: A temporary ban from any sort of interaction or public +communication with the community for a specified period of time. No public or +private interaction with the people involved, including unsolicited interaction +with those enforcing the Code of Conduct, is allowed during this period. +Violating these terms may lead to a permanent ban. + +### 4. Permanent Ban + +**Community Impact**: Demonstrating a pattern of violation of community +standards, including sustained inappropriate behavior, harassment of an +individual, or aggression toward or disparagement of classes of individuals. + +**Consequence**: A permanent ban from any sort of public interaction within the +community. + +## Attribution + +This Code of Conduct is adapted from the [Contributor Covenant][homepage], +version 2.1, available at +[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1]. + +Community Impact Guidelines were inspired by +[Mozilla's code of conduct enforcement ladder][Mozilla CoC]. + +For answers to common questions about this code of conduct, see the FAQ at +[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at +[https://www.contributor-covenant.org/translations][translations]. + +[homepage]: https://www.contributor-covenant.org +[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html +[Mozilla CoC]: https://github.com/mozilla/diversity +[FAQ]: https://www.contributor-covenant.org/faq +[translations]: https://www.contributor-covenant.org/translations diff --git a/docs/ERROR_HANDLING.md b/documentation/docs/ERROR_HANDLING.md similarity index 100% rename from docs/ERROR_HANDLING.md rename to documentation/docs/ERROR_HANDLING.md diff --git a/docs/FALSE_POSITIVE_REDUCTION.md b/documentation/docs/FALSE_POSITIVE_REDUCTION.md similarity index 100% rename from docs/FALSE_POSITIVE_REDUCTION.md rename to documentation/docs/FALSE_POSITIVE_REDUCTION.md diff --git a/documentation/docs/LLM_RAG_INTEGRATION.md b/documentation/docs/LLM_RAG_INTEGRATION.md new file mode 100644 index 0000000..360c244 --- /dev/null +++ b/documentation/docs/LLM_RAG_INTEGRATION.md @@ -0,0 +1,111 @@ +# LLM & RAG Integration Guide + +**Harness the power of Large Language Models for intelligent code refactoring and documentation.** + +--- + +## Overview + +In version v1.0.15, Refactron introduces a powerful AI-driven subsystem that combines LLM reasoning with RAG (Retrieval-Augmented Generation). This allows Refactron to understand your entire project context when suggesting refactorings or generating documentation. + +### Core Components + +1. **LLM Orchestrator**: Coordinates between the code analyzer, retriever, and LLM backends. +2. **RAG System**: Uses a vector database (ChromaDB) to index and retrieve relevant code chunks. +3. **LLM Backends**: Support for high-performance providers like Groq, as well as local or custom backends. +4. **Safety Gate**: Ensures that LLM-generated code adheres to safety standards and doesn't introduce syntax errors. + +--- + +## Getting Started + +### 1. Prerequisites + +- Python 3.8+ +- ChromaDB (`pip install chromadb`) +- Sentence Transformers (`pip install sentence-transformers`) +- LLM API Key (e.g., Groq API Key) + +### 2. Configuration + +Set your LLM API key as an environment variable: + +```bash +export GROQ_API_KEY='your-api-key-here' +``` + +Alternatively, configure it in your `.refactron.yaml`: + +```yaml +llm: + provider: groq + model: llama3-70b-8192 + temperature: 0.1 + max_tokens: 4096 + +rag: + enabled: true + storage_dir: .refactron/rag_index + embedding_model: all-MiniLM-L6-v2 +``` + +--- + +## Usage + +### Indexing your Project + +Before using RAG-powered features, you need to index your repository: + +```bash +refactron rag index +``` + +This will parse your Python files and store embeddings in the local vector database. + +### AI-Powered Refactoring + +When you run the `refactor` command, Refactron can now use the LLM to generate more sophisticated suggestions: + +```bash +refactron refactor myfile.py --ai --preview +``` + +The `--ai` flag enables LLM-based suggestion generation, which uses retrieved context from your project to provide more accurate fixes. + +### Generating Documentation + +Generate comprehensive docstrings and technical documentation using the LLM: + +```bash +refactron docs generate myfile.py +``` + +Refactron will analyze the code structure and use the LLM to write high-quality documentation that follows PEP 257 or your configured style. + +--- + +## Technical Details + +### RAG Workflow + +1. **Parsing**: Code files are parsed into semantic chunks (classes, methods, functions). +2. **Embedding**: Chunks are converted into vector representations using `sentence-transformers`. +3. **Indexing**: Vectors and metadata are stored in `ChromaDB`. +4. **Retrieval**: When an issue is analyzed, the system retrieves the most relevant code chunks as context for the LLM. + +### LLM Orchestration + +The `LLMOrchestrator` handles the prompt engineering, ensuring that the LLM receives the right balance of task instructions and code context. It also includes a JSON cleaning layer to reliably parse LLM outputs. + +--- + +## Best Practices + +- **Keep the Index Updated**: Re-run `refactron rag index` after significant code changes. +- **Model Selection**: Higher-parameter models (like Llama 3 70B) generally provide better refactoring logic but may be slower. +- **Review AI Suggestions**: Always use `--preview` to review AI-generated code before applying it. + +--- + +**Refactron AI** - Bringing semantic understanding to code refactoring! 🚀🤖 diff --git a/docs/MONITORING.md b/documentation/docs/MONITORING.md similarity index 100% rename from docs/MONITORING.md rename to documentation/docs/MONITORING.md diff --git a/docs/PATTERN_LEARNING.md b/documentation/docs/PATTERN_LEARNING.md similarity index 99% rename from docs/PATTERN_LEARNING.md rename to documentation/docs/PATTERN_LEARNING.md index 30da37d..7a0590e 100644 --- a/docs/PATTERN_LEARNING.md +++ b/documentation/docs/PATTERN_LEARNING.md @@ -12,6 +12,7 @@ Refactron's Pattern Learning System learns from your feedback on refactoring sug - **Automatic Learning** - Learns from every refactoring decision you make - **Smart Ranking** - Ranks suggestions by historical acceptance rates +- **AI-Powered Insights** - Integrates with LLMs (v1.0.15+) to provide context-aware pattern recognition and suggestions. - **Project-Specific** - Adapts to your project's coding style and preferences - **Persistent Storage** - Patterns persist across sessions - **Configurable** - Enable/disable features as needed diff --git a/docs/PERFORMANCE_OPTIMIZATION.md b/documentation/docs/PERFORMANCE_OPTIMIZATION.md similarity index 99% rename from docs/PERFORMANCE_OPTIMIZATION.md rename to documentation/docs/PERFORMANCE_OPTIMIZATION.md index 291dd78..bd74c1c 100644 --- a/docs/PERFORMANCE_OPTIMIZATION.md +++ b/documentation/docs/PERFORMANCE_OPTIMIZATION.md @@ -203,7 +203,7 @@ config = RefactronConfig(max_parallel_workers=cpu_count) - ✅ Large codebases (1000+ files) - ✅ Multi-core systems - ✅ I/O-bound operations -- ❌ Small codebases (<10 files) +- ❌ Small codebases (<10 files) - ❌ Single-core systems - ❌ Memory-constrained environments @@ -288,7 +288,7 @@ print(f"Results: {latest['results']}") ## Best Practices -### For Small Projects (<1000 files) +### For Small Projects (<1000 files) ```python config = RefactronConfig( diff --git a/docs/QUICK_REFERENCE.md b/documentation/docs/QUICK_REFERENCE.md similarity index 83% rename from docs/QUICK_REFERENCE.md rename to documentation/docs/QUICK_REFERENCE.md index bc27776..5e7efb2 100644 --- a/docs/QUICK_REFERENCE.md +++ b/documentation/docs/QUICK_REFERENCE.md @@ -26,6 +26,31 @@ refactron refactor # Generate report refactron report --format json -o report.json + +# AI-Powered Commands (v1.0.15) +refactron suggest [--line N] [--apply] +refactron document [--apply] +refactron feedback --action accepted +refactron rag index [--summarize] +refactron rag search "query" [--rerank] +refactron rag status + +# Repository Management (v1.0.15) +refactron repo list +refactron repo connect [--path PATH] +refactron repo disconnect [--delete-files] + +# CI/CD & Integration (v1.0.15) +refactron ci + +# Authentication & Status (v1.0.15) +refactron auth status +refactron auth logout + +# Observability (v1.0.15) +refactron metrics [--format json] +refactron serve-metrics [--port N] +refactron telemetry ``` ### Python API @@ -185,6 +210,11 @@ export REFACTRON_LOG_LEVEL=DEBUG --type TYPE # Filter by type (can use multiple) --no-backup # Don't create backups --risk-level LEVEL # safe|low|moderate|high + +# AI (v1.0.15) +--ai # Use AI reasoning for refactoring +--summarize # Generate AI summaries for RAG chunks +--rerank # AI reranking for semantic search ``` ## Common Issues @@ -222,6 +252,8 @@ refactron patterns --help # Pattern analysis and tuning commands - 📚 [Full Documentation](https://refactron-ai.github.io/Refactron_lib/) - 🚀 [Tutorial](TUTORIAL.md) +- 🤖 [LLM & RAG Guide](LLM_RAG_INTEGRATION.md) +- 📜 [v1.0.15 Release Notes](v1.0.15_RELEASE_NOTES.md) - 🏗️ [Architecture](../ARCHITECTURE.md) - 🤝 [Contributing](../CONTRIBUTING.md) - 🔒 [Security](../SECURITY.md) diff --git a/docs/README.md b/documentation/docs/README.md similarity index 100% rename from docs/README.md rename to documentation/docs/README.md diff --git a/documentation/docs/SECURITY.md b/documentation/docs/SECURITY.md new file mode 100644 index 0000000..e90ab1b --- /dev/null +++ b/documentation/docs/SECURITY.md @@ -0,0 +1,131 @@ +# Security Policy + +## Supported Versions + +We actively support the following versions of Refactron with security updates: + +| Version | Supported | +| ------- | ------------------ | +| 1.x.x | :white_check_mark: | +| < 1.0 | :x: | + +## Reporting a Vulnerability + +We take the security of Refactron seriously. If you discover a security vulnerability, please follow these steps: + +### 1. **Do Not** Open a Public Issue + +Please do not open a public GitHub issue for security vulnerabilities. This helps prevent exploitation before a fix is available. + +### 2. Report Privately + +Report security vulnerabilities by emailing: **security@refactron.us.kg** + +Include the following information: +- Description of the vulnerability +- Steps to reproduce the issue +- Affected versions +- Potential impact +- Suggested fix (if any) + +### 3. Response Timeline + +- **Initial Response**: Within 48 hours of submission +- **Status Update**: Within 7 days with assessment +- **Fix Timeline**: Critical issues within 14 days, others within 30 days + +### 4. Disclosure Policy + +We follow responsible disclosure: +- We will work with you to understand and address the issue +- We will credit you in the security advisory (unless you prefer to remain anonymous) +- We will publicly disclose the vulnerability only after a fix is released +- We typically wait 90 days before full disclosure + +## Security Best Practices + +When using Refactron, follow these security best practices: + +### 1. **Code Execution** +- Refactron analyzes code using AST parsing and **never executes** analyzed code +- It's safe to analyze untrusted code + +### 2. **File Permissions** +- Ensure Refactron has appropriate file permissions +- Review suggested refactorings before applying them +- Always backup your code before applying automated refactorings + +### 3. **Dependencies** +- Keep Refactron and its dependencies up to date +- We use Dependabot to monitor and update dependencies +- Review dependency updates in our release notes + +### 4. **Configuration Files** +- Protect your `.refactron.yaml` configuration files +- Don't commit sensitive information to configuration files +- Use environment variables for sensitive settings + +### 5. **CI/CD Integration** +- When using Refactron in CI/CD pipelines: + - Use read-only mode for analysis + - Review changes before merging + - Limit file system access appropriately + +## Known Security Considerations + +### Static Analysis Only +Refactron performs static analysis and does not: +- Execute analyzed code +- Make network requests (except for updates) +- Access system resources beyond the specified project directory + +### Refactoring Safety +- All refactorings are previewed before application +- Risk scores are provided for each refactoring (0.0 = safe, 1.0 = high risk) +- You must explicitly approve changes before they are applied + +## Security Scanning + +We use multiple tools to ensure code security: + +- **Bandit**: Python security linting +- **Safety**: Dependency vulnerability scanning +- **CodeQL**: Advanced semantic code analysis +- **Dependabot**: Automated dependency updates + +## Third-Party Dependencies + +We carefully vet all dependencies: + +- **libcst**: Concrete syntax tree manipulation (maintained by Instagram/Meta) +- **astroid**: AST analysis (maintained by PyCQA) +- **radon**: Code metrics (well-established tool) +- **click**: CLI framework (maintained by Pallets) +- **rich**: Terminal formatting (actively maintained) +- **pyyaml**: YAML parsing (standard library quality) + +All dependencies are regularly updated and monitored for vulnerabilities. + +## Security Audit History + +| Date | Type | Findings | Status | +|------------|----------------|----------|----------| +| 2024-10-31 | Code Review | 0 | ✅ Clean | +| 2024-10-31 | Dependency | 0 | ✅ Clean | + +## Hall of Fame + +We recognize security researchers who help keep Refactron secure: + +*No security issues reported yet. Be the first!* + +## Questions? + +If you have security questions or concerns that are not vulnerabilities, please: +- Open a discussion on GitHub +- Email: support@refactron.us.kg +- Review our [Contributing Guidelines](CONTRIBUTING.md) + +--- + +**Thank you for helping keep Refactron and its users safe!** 🔒 diff --git a/docs/TUTORIAL.md b/documentation/docs/TUTORIAL.md similarity index 92% rename from docs/TUTORIAL.md rename to documentation/docs/TUTORIAL.md index d4e1516..9c6dff6 100644 --- a/docs/TUTORIAL.md +++ b/documentation/docs/TUTORIAL.md @@ -15,7 +15,8 @@ pip install refactron 3. [Previewing Refactorings](#previewing-refactorings) 4. [Applying Changes](#applying-changes) 5. [Configuration](#configuration) -6. [Advanced Usage](#advanced-usage) +6. [AI-Powered Features (v1.0.15)](#ai-powered-features) +7. [Advanced Usage](#advanced-usage) --- @@ -222,6 +223,30 @@ analysis = refactron.analyze("example.py") --- +## AI-Powered Features (v1.0.15) + +Version v1.0.15 introduces semantic intelligence using LLMs and RAG. + +### Initializing the RAG Index +To give the AI context about your project, you must first index it: +```bash +refactron rag index +``` + +### AI Refactoring Suggestions +Use the `suggest` command for smarter, multi-line refactorings: +```bash +refactron suggest example.py --line 5 +``` + +### Automated Documentation +Generate comprehensive docstrings for your file: +```bash +refactron document example.py --apply +``` + +--- + ## Advanced Usage ### Analyze Multiple Files diff --git a/documentation/docs/api/analyzers.md b/documentation/docs/api/analyzers.md new file mode 100644 index 0000000..cf39613 --- /dev/null +++ b/documentation/docs/api/analyzers.md @@ -0,0 +1,488 @@ +# refactron.analyzers + +Analyzers for detecting code issues and patterns. + +## Classes + +## Functions + + +--- + +# refactron.analyzers.base_analyzer + +Base analyzer class. + +## Classes + +### BaseAnalyzer + +```python +BaseAnalyzer(config: refactron.core.config.RefactronConfig) +``` + +Base class for all analyzers. + +#### BaseAnalyzer.__init__ + +```python +BaseAnalyzer.__init__(self, config: refactron.core.config.RefactronConfig) +``` + +Initialize the analyzer. + +Args: + config: Refactron configuration + +#### BaseAnalyzer.analyze + +```python +BaseAnalyzer.analyze(self, file_path: pathlib._local.Path, source_code: str) -> List[refactron.core.models.CodeIssue] +``` + +Analyze source code and return detected issues. + +Args: + file_path: Path to the file being analyzed + source_code: Source code content + +Returns: + List of detected code issues + +#### BaseAnalyzer.parse_astroid + +```python +BaseAnalyzer.parse_astroid(self, source_code: str, file_path: Optional[pathlib._local.Path] = None) -> Any +``` + +Helper to parse code into an astroid tree. + +Args: + source_code: The code to parse + file_path: Optional path for module naming context + +Returns: + astroid.nodes.Module + +## Functions + + +--- + +# refactron.analyzers.code_smell_analyzer + +Analyzer for code smells and anti-patterns. + +## Classes + +### CodeSmellAnalyzer + +```python +CodeSmellAnalyzer(config: refactron.core.config.RefactronConfig) +``` + +Detects common code smells and anti-patterns. + +#### CodeSmellAnalyzer.__init__ + +```python +CodeSmellAnalyzer.__init__(self, config: refactron.core.config.RefactronConfig) +``` + +Initialize the analyzer. + +Args: + config: Refactron configuration + +#### CodeSmellAnalyzer.analyze + +```python +CodeSmellAnalyzer.analyze(self, file_path: pathlib._local.Path, source_code: str) -> List[refactron.core.models.CodeIssue] +``` + +Analyze code for smells and anti-patterns. + +Args: + file_path: Path to the file + source_code: Source code content + +Returns: + List of detected code smell issues + +#### CodeSmellAnalyzer.parse_astroid + +```python +CodeSmellAnalyzer.parse_astroid(self, source_code: str, file_path: Optional[pathlib._local.Path] = None) -> Any +``` + +Helper to parse code into an astroid tree. + +Args: + source_code: The code to parse + file_path: Optional path for module naming context + +Returns: + astroid.nodes.Module + +## Functions + + +--- + +# refactron.analyzers.complexity_analyzer + +Analyzer for code complexity metrics. + +## Classes + +### ComplexityAnalyzer + +```python +ComplexityAnalyzer(config: refactron.core.config.RefactronConfig) +``` + +Analyzes code complexity using cyclomatic complexity and other metrics. + +#### ComplexityAnalyzer.__init__ + +```python +ComplexityAnalyzer.__init__(self, config: refactron.core.config.RefactronConfig) +``` + +Initialize the analyzer. + +Args: + config: Refactron configuration + +#### ComplexityAnalyzer.analyze + +```python +ComplexityAnalyzer.analyze(self, file_path: pathlib._local.Path, source_code: str) -> List[refactron.core.models.CodeIssue] +``` + +Analyze complexity of the source code. + +Args: + file_path: Path to the file + source_code: Source code content + +Returns: + List of complexity-related issues + +#### ComplexityAnalyzer.parse_astroid + +```python +ComplexityAnalyzer.parse_astroid(self, source_code: str, file_path: Optional[pathlib._local.Path] = None) -> Any +``` + +Helper to parse code into an astroid tree. + +Args: + source_code: The code to parse + file_path: Optional path for module naming context + +Returns: + astroid.nodes.Module + +## Functions + + +--- + +# refactron.analyzers.dead_code_analyzer + +Analyzer for dead code - unused functions, variables, and imports. + +## Classes + +### DeadCodeAnalyzer + +```python +DeadCodeAnalyzer(config: refactron.core.config.RefactronConfig) +``` + +Detects unused code that can be safely removed. + +#### DeadCodeAnalyzer.__init__ + +```python +DeadCodeAnalyzer.__init__(self, config: refactron.core.config.RefactronConfig) +``` + +Initialize the analyzer. + +Args: + config: Refactron configuration + +#### DeadCodeAnalyzer.analyze + +```python +DeadCodeAnalyzer.analyze(self, file_path: pathlib._local.Path, source_code: str) -> List[refactron.core.models.CodeIssue] +``` + +Analyze code for unused elements. + +Args: + file_path: Path to the file + source_code: Source code content + +Returns: + List of dead code issues + +#### DeadCodeAnalyzer.parse_astroid + +```python +DeadCodeAnalyzer.parse_astroid(self, source_code: str, file_path: Optional[pathlib._local.Path] = None) -> Any +``` + +Helper to parse code into an astroid tree. + +Args: + source_code: The code to parse + file_path: Optional path for module naming context + +Returns: + astroid.nodes.Module + +## Functions + + +--- + +# refactron.analyzers.dependency_analyzer + +Analyzer for import dependencies and module relationships. + +## Classes + +### DependencyAnalyzer + +```python +DependencyAnalyzer(config: 'RefactronConfig') -> None +``` + +Analyzes import statements and dependencies. + +#### DependencyAnalyzer.__init__ + +```python +DependencyAnalyzer.__init__(self, config: 'RefactronConfig') -> None +``` + +Initialize the analyzer. + +Args: + config: Refactron configuration + +#### DependencyAnalyzer.analyze + +```python +DependencyAnalyzer.analyze(self, file_path: pathlib._local.Path, source_code: str) -> List[refactron.core.models.CodeIssue] +``` + +Analyze imports and dependencies. + +Args: + file_path: Path to the file + source_code: Source code content + +Returns: + List of dependency-related issues + +#### DependencyAnalyzer.parse_astroid + +```python +DependencyAnalyzer.parse_astroid(self, source_code: str, file_path: Optional[pathlib._local.Path] = None) -> Any +``` + +Helper to parse code into an astroid tree. + +Args: + source_code: The code to parse + file_path: Optional path for module naming context + +Returns: + astroid.nodes.Module + +## Functions + + +--- + +# refactron.analyzers.performance_analyzer + +Analyzer for performance antipatterns. + +## Classes + +### PerformanceAnalyzer + +```python +PerformanceAnalyzer(config: refactron.core.config.RefactronConfig) +``` + +Detects common performance antipatterns and inefficiencies. + +#### PerformanceAnalyzer.__init__ + +```python +PerformanceAnalyzer.__init__(self, config: refactron.core.config.RefactronConfig) +``` + +Initialize the analyzer. + +Args: + config: Refactron configuration + +#### PerformanceAnalyzer.analyze + +```python +PerformanceAnalyzer.analyze(self, file_path: pathlib._local.Path, source_code: str) -> List[refactron.core.models.CodeIssue] +``` + +Analyze code for performance antipatterns. + +Args: + file_path: Path to the file + source_code: Source code content + +Returns: + List of performance-related issues + +#### PerformanceAnalyzer.parse_astroid + +```python +PerformanceAnalyzer.parse_astroid(self, source_code: str, file_path: Optional[pathlib._local.Path] = None) -> Any +``` + +Helper to parse code into an astroid tree. + +Args: + source_code: The code to parse + file_path: Optional path for module naming context + +Returns: + astroid.nodes.Module + +## Functions + + +--- + +# refactron.analyzers.security_analyzer + +Analyzer for security vulnerabilities and unsafe patterns. + +## Classes + +### SecurityAnalyzer + +```python +SecurityAnalyzer(config: refactron.core.config.RefactronConfig) +``` + +Detects common security vulnerabilities and unsafe code patterns. + +#### SecurityAnalyzer.__init__ + +```python +SecurityAnalyzer.__init__(self, config: refactron.core.config.RefactronConfig) +``` + +Initialize the analyzer. + +Args: + config: Refactron configuration + +#### SecurityAnalyzer.analyze + +```python +SecurityAnalyzer.analyze(self, file_path: pathlib._local.Path, source_code: str) -> List[refactron.core.models.CodeIssue] +``` + +Analyze code for security vulnerabilities. + +Args: + file_path: Path to the file + source_code: Source code content + +Returns: + List of security-related issues + +#### SecurityAnalyzer.parse_astroid + +```python +SecurityAnalyzer.parse_astroid(self, source_code: str, file_path: Optional[pathlib._local.Path] = None) -> Any +``` + +Helper to parse code into an astroid tree. + +Args: + source_code: The code to parse + file_path: Optional path for module naming context + +Returns: + astroid.nodes.Module + +## Functions + + +--- + +# refactron.analyzers.type_hint_analyzer + +Analyzer for type hints and type annotations. + +## Classes + +### TypeHintAnalyzer + +```python +TypeHintAnalyzer(config: refactron.core.config.RefactronConfig) +``` + +Analyzes type hint usage and suggests improvements. + +#### TypeHintAnalyzer.__init__ + +```python +TypeHintAnalyzer.__init__(self, config: refactron.core.config.RefactronConfig) +``` + +Initialize the analyzer. + +Args: + config: Refactron configuration + +#### TypeHintAnalyzer.analyze + +```python +TypeHintAnalyzer.analyze(self, file_path: pathlib._local.Path, source_code: str) -> List[refactron.core.models.CodeIssue] +``` + +Analyze type hints in code. + +Args: + file_path: Path to the file + source_code: Source code content + +Returns: + List of type hint issues + +#### TypeHintAnalyzer.parse_astroid + +```python +TypeHintAnalyzer.parse_astroid(self, source_code: str, file_path: Optional[pathlib._local.Path] = None) -> Any +``` + +Helper to parse code into an astroid tree. + +Args: + source_code: The code to parse + file_path: Optional path for module naming context + +Returns: + astroid.nodes.Module + +## Functions + diff --git a/documentation/docs/api/autofix.md b/documentation/docs/api/autofix.md new file mode 100644 index 0000000..0cd2213 --- /dev/null +++ b/documentation/docs/api/autofix.md @@ -0,0 +1,802 @@ +# refactron.autofix + +Auto-fix module for automatically fixing code issues. + +This module provides rule-based code fixes without requiring expensive AI APIs. +All fixers use AST analysis and pattern matching for fast, reliable transformations. + +## Classes + +## Functions + + +--- + +# refactron.autofix.engine + +Auto-fix engine for applying rule-based code transformations. + +This engine uses AST analysis and pattern matching to apply safe +automatic fixes without requiring expensive AI APIs. + +## Classes + +### AutoFixEngine + +```python +AutoFixEngine(safety_level: refactron.autofix.models.FixRiskLevel = ) +``` + +Engine for applying automatic fixes to code issues. + +All fixes use rule-based AST transformations for reliability +and performance. No expensive AI APIs required! + +#### AutoFixEngine.__init__ + +```python +AutoFixEngine.__init__(self, safety_level: refactron.autofix.models.FixRiskLevel = ) +``` + +Initialize the auto-fix engine. + +Args: + safety_level: Maximum risk level to apply automatically + +#### AutoFixEngine.can_fix + +```python +AutoFixEngine.can_fix(self, issue: refactron.core.models.CodeIssue) -> bool +``` + +Check if an issue can be auto-fixed. + +Args: + issue: The issue to check + +Returns: + True if a fixer is available, False otherwise + +#### AutoFixEngine.fix + +```python +AutoFixEngine.fix(self, issue: refactron.core.models.CodeIssue, code: str, preview: bool = True) -> refactron.autofix.models.FixResult +``` + +Apply automatic fix to an issue. + +Args: + issue: The issue to fix + code: The original code + preview: If True, only preview changes (don't apply) + +Returns: + FixResult with success status and details + +#### AutoFixEngine.fix_all + +```python +AutoFixEngine.fix_all(self, issues: list, code: str, preview: bool = True) -> Dict[int, refactron.autofix.models.FixResult] +``` + +Apply fixes to multiple issues. + +Args: + issues: List of issues to fix + code: The original code + preview: If True, only preview changes + +Returns: + Dictionary mapping issue index to fix result + +### BaseFixer + +```python +BaseFixer(name: str, risk_score: float = 0.0) +``` + +Base class for all automatic fixers. + +#### BaseFixer.__init__ + +```python +BaseFixer.__init__(self, name: str, risk_score: float = 0.0) +``` + +Initialize a fixer. + +Args: + name: Name of the fixer + risk_score: Risk level (0.0 = safe, 1.0 = dangerous) + +#### BaseFixer.apply + +```python +BaseFixer.apply(self, issue: refactron.core.models.CodeIssue, code: str) -> refactron.autofix.models.FixResult +``` + +Apply the fix. + +Args: + issue: The issue to fix + code: The original code + +Returns: + FixResult with fixed code + +#### BaseFixer.preview + +```python +BaseFixer.preview(self, issue: refactron.core.models.CodeIssue, code: str) -> refactron.autofix.models.FixResult +``` + +Preview the fix without applying it. + +Args: + issue: The issue to fix + code: The original code + +Returns: + FixResult with diff showing proposed changes + +## Functions + + +--- + +# refactron.autofix.file_ops + +File operations for auto-fix system with backup and rollback support. + +## Classes + +### FileOperations + +```python +FileOperations(backup_dir: Optional[pathlib._local.Path] = None) +``` + +Handle file operations with safety guarantees. + +#### FileOperations.__init__ + +```python +FileOperations.__init__(self, backup_dir: Optional[pathlib._local.Path] = None) +``` + +Initialize file operations. + +Args: + backup_dir: Directory for backups (default: .refactron_backups) + +#### FileOperations.backup_file + +```python +FileOperations.backup_file(self, filepath: pathlib._local.Path) -> pathlib._local.Path +``` + +Create a backup of a file. + +Args: + filepath: Path to file to backup + +Returns: + Path to backup file + +#### FileOperations.clear_backups + +```python +FileOperations.clear_backups(self) -> int +``` + +Clear all backups. + +Returns: + Number of backups cleared + +#### FileOperations.list_backups + +```python +FileOperations.list_backups(self) -> List[Any] +``` + +List all backups. + +Returns: + List of backup information + +#### FileOperations.rollback_all + +```python +FileOperations.rollback_all(self) -> int +``` + +Rollback all backed up files. + +Returns: + Number of files rolled back + +#### FileOperations.rollback_file + +```python +FileOperations.rollback_file(self, filepath: pathlib._local.Path) -> bool +``` + +Rollback a file to its last backup. + +Args: + filepath: Path to file to rollback + +Returns: + True if successful, False otherwise + +#### FileOperations.write_with_backup + +```python +FileOperations.write_with_backup(self, filepath: pathlib._local.Path, content: str) -> Dict +``` + +Write content to file with automatic backup. + +Args: + filepath: Path to file to write + content: Content to write + +Returns: + Dictionary with operation details + +## Functions + + +--- + +# refactron.autofix.fixers + +Concrete fixer implementations for common code issues. + +All fixers use AST-based transformations for reliability and speed. +No expensive AI APIs required! + +## Classes + +### AddDocstringsFixer + +```python +AddDocstringsFixer() -> None +``` + +Adds missing docstrings to functions and classes. + +#### AddDocstringsFixer.__init__ + +```python +AddDocstringsFixer.__init__(self) -> None +``` + +Initialize a fixer. + +Args: + name: Name of the fixer + risk_score: Risk level (0.0 = safe, 1.0 = dangerous) + +#### AddDocstringsFixer.apply + +```python +AddDocstringsFixer.apply(self, issue: refactron.core.models.CodeIssue, code: str) -> refactron.autofix.models.FixResult +``` + +Apply docstring addition. + +#### AddDocstringsFixer.preview + +```python +AddDocstringsFixer.preview(self, issue: refactron.core.models.CodeIssue, code: str) -> refactron.autofix.models.FixResult +``` + +Preview docstring addition. + +### AddMissingCommasFixer + +```python +AddMissingCommasFixer() -> None +``` + +Add missing trailing commas in lists/dicts. + +#### AddMissingCommasFixer.__init__ + +```python +AddMissingCommasFixer.__init__(self) -> None +``` + +Initialize a fixer. + +Args: + name: Name of the fixer + risk_score: Risk level (0.0 = safe, 1.0 = dangerous) + +#### AddMissingCommasFixer.apply + +```python +AddMissingCommasFixer.apply(self, issue: refactron.core.models.CodeIssue, code: str) -> refactron.autofix.models.FixResult +``` + +Apply comma addition. + +#### AddMissingCommasFixer.preview + +```python +AddMissingCommasFixer.preview(self, issue: refactron.core.models.CodeIssue, code: str) -> refactron.autofix.models.FixResult +``` + +Preview comma addition. + +### ConvertToFStringFixer + +```python +ConvertToFStringFixer() -> None +``` + +Convert old-style format strings to f-strings. + +#### ConvertToFStringFixer.__init__ + +```python +ConvertToFStringFixer.__init__(self) -> None +``` + +Initialize a fixer. + +Args: + name: Name of the fixer + risk_score: Risk level (0.0 = safe, 1.0 = dangerous) + +#### ConvertToFStringFixer.apply + +```python +ConvertToFStringFixer.apply(self, issue: refactron.core.models.CodeIssue, code: str) -> refactron.autofix.models.FixResult +``` + +Apply f-string conversion. + +#### ConvertToFStringFixer.preview + +```python +ConvertToFStringFixer.preview(self, issue: refactron.core.models.CodeIssue, code: str) -> refactron.autofix.models.FixResult +``` + +Preview f-string conversion. + +### ExtractMagicNumbersFixer + +```python +ExtractMagicNumbersFixer() -> None +``` + +Extracts magic numbers into named constants. + +#### ExtractMagicNumbersFixer.__init__ + +```python +ExtractMagicNumbersFixer.__init__(self) -> None +``` + +Initialize a fixer. + +Args: + name: Name of the fixer + risk_score: Risk level (0.0 = safe, 1.0 = dangerous) + +#### ExtractMagicNumbersFixer.apply + +```python +ExtractMagicNumbersFixer.apply(self, issue: refactron.core.models.CodeIssue, code: str) -> refactron.autofix.models.FixResult +``` + +Apply magic number extraction. + +#### ExtractMagicNumbersFixer.preview + +```python +ExtractMagicNumbersFixer.preview(self, issue: refactron.core.models.CodeIssue, code: str) -> refactron.autofix.models.FixResult +``` + +Preview magic number extraction. + +### FixIndentationFixer + +```python +FixIndentationFixer(spaces: int = 4) +``` + +Fix inconsistent indentation. + +#### FixIndentationFixer.__init__ + +```python +FixIndentationFixer.__init__(self, spaces: int = 4) +``` + +Initialize a fixer. + +Args: + name: Name of the fixer + risk_score: Risk level (0.0 = safe, 1.0 = dangerous) + +#### FixIndentationFixer.apply + +```python +FixIndentationFixer.apply(self, issue: refactron.core.models.CodeIssue, code: str) -> refactron.autofix.models.FixResult +``` + +Apply indentation fix. + +#### FixIndentationFixer.preview + +```python +FixIndentationFixer.preview(self, issue: refactron.core.models.CodeIssue, code: str) -> refactron.autofix.models.FixResult +``` + +Preview indentation fix. + +### FixTypeHintsFixer + +```python +FixTypeHintsFixer() -> None +``` + +Adds or fixes type hints. + +#### FixTypeHintsFixer.__init__ + +```python +FixTypeHintsFixer.__init__(self) -> None +``` + +Initialize a fixer. + +Args: + name: Name of the fixer + risk_score: Risk level (0.0 = safe, 1.0 = dangerous) + +#### FixTypeHintsFixer.apply + +```python +FixTypeHintsFixer.apply(self, issue: refactron.core.models.CodeIssue, code: str) -> refactron.autofix.models.FixResult +``` + +Apply type hint fix. + +#### FixTypeHintsFixer.preview + +```python +FixTypeHintsFixer.preview(self, issue: refactron.core.models.CodeIssue, code: str) -> refactron.autofix.models.FixResult +``` + +Preview type hint fix. + +### NormalizeQuotesFixer + +```python +NormalizeQuotesFixer(prefer_double: bool = True) +``` + +Normalize string quotes (single → double or vice versa). + +#### NormalizeQuotesFixer.__init__ + +```python +NormalizeQuotesFixer.__init__(self, prefer_double: bool = True) +``` + +Initialize a fixer. + +Args: + name: Name of the fixer + risk_score: Risk level (0.0 = safe, 1.0 = dangerous) + +#### NormalizeQuotesFixer.apply + +```python +NormalizeQuotesFixer.apply(self, issue: refactron.core.models.CodeIssue, code: str) -> refactron.autofix.models.FixResult +``` + +Apply quote normalization. + +#### NormalizeQuotesFixer.preview + +```python +NormalizeQuotesFixer.preview(self, issue: refactron.core.models.CodeIssue, code: str) -> refactron.autofix.models.FixResult +``` + +Preview quote normalization. + +### RemoveDeadCodeFixer + +```python +RemoveDeadCodeFixer() -> None +``` + +Removes dead/unreachable code. + +#### RemoveDeadCodeFixer.__init__ + +```python +RemoveDeadCodeFixer.__init__(self) -> None +``` + +Initialize a fixer. + +Args: + name: Name of the fixer + risk_score: Risk level (0.0 = safe, 1.0 = dangerous) + +#### RemoveDeadCodeFixer.apply + +```python +RemoveDeadCodeFixer.apply(self, issue: refactron.core.models.CodeIssue, code: str) -> refactron.autofix.models.FixResult +``` + +Apply dead code removal. + +#### RemoveDeadCodeFixer.preview + +```python +RemoveDeadCodeFixer.preview(self, issue: refactron.core.models.CodeIssue, code: str) -> refactron.autofix.models.FixResult +``` + +Preview dead code removal. + +### RemovePrintStatementsFixer + +```python +RemovePrintStatementsFixer(convert_to_logging: bool = False) +``` + +Remove or convert print statements to logging. + +#### RemovePrintStatementsFixer.__init__ + +```python +RemovePrintStatementsFixer.__init__(self, convert_to_logging: bool = False) +``` + +Initialize a fixer. + +Args: + name: Name of the fixer + risk_score: Risk level (0.0 = safe, 1.0 = dangerous) + +#### RemovePrintStatementsFixer.apply + +```python +RemovePrintStatementsFixer.apply(self, issue: refactron.core.models.CodeIssue, code: str) -> refactron.autofix.models.FixResult +``` + +Apply print statement removal/conversion. + +#### RemovePrintStatementsFixer.preview + +```python +RemovePrintStatementsFixer.preview(self, issue: refactron.core.models.CodeIssue, code: str) -> refactron.autofix.models.FixResult +``` + +Preview print statement removal/conversion. + +### RemoveTrailingWhitespaceFixer + +```python +RemoveTrailingWhitespaceFixer() -> None +``` + +Remove trailing whitespace from lines. + +#### RemoveTrailingWhitespaceFixer.__init__ + +```python +RemoveTrailingWhitespaceFixer.__init__(self) -> None +``` + +Initialize a fixer. + +Args: + name: Name of the fixer + risk_score: Risk level (0.0 = safe, 1.0 = dangerous) + +#### RemoveTrailingWhitespaceFixer.apply + +```python +RemoveTrailingWhitespaceFixer.apply(self, issue: refactron.core.models.CodeIssue, code: str) -> refactron.autofix.models.FixResult +``` + +Apply whitespace removal. + +#### RemoveTrailingWhitespaceFixer.preview + +```python +RemoveTrailingWhitespaceFixer.preview(self, issue: refactron.core.models.CodeIssue, code: str) -> refactron.autofix.models.FixResult +``` + +Preview whitespace removal. + +### RemoveUnusedImportsFixer + +```python +RemoveUnusedImportsFixer() -> None +``` + +Removes unused import statements. + +#### RemoveUnusedImportsFixer.__init__ + +```python +RemoveUnusedImportsFixer.__init__(self) -> None +``` + +Initialize a fixer. + +Args: + name: Name of the fixer + risk_score: Risk level (0.0 = safe, 1.0 = dangerous) + +#### RemoveUnusedImportsFixer.apply + +```python +RemoveUnusedImportsFixer.apply(self, issue: refactron.core.models.CodeIssue, code: str) -> refactron.autofix.models.FixResult +``` + +Apply the fix to remove unused imports. + +#### RemoveUnusedImportsFixer.preview + +```python +RemoveUnusedImportsFixer.preview(self, issue: refactron.core.models.CodeIssue, code: str) -> refactron.autofix.models.FixResult +``` + +Preview the removal of unused imports. + +### RemoveUnusedVariablesFixer + +```python +RemoveUnusedVariablesFixer() -> None +``` + +Remove unused variables. + +#### RemoveUnusedVariablesFixer.__init__ + +```python +RemoveUnusedVariablesFixer.__init__(self) -> None +``` + +Initialize a fixer. + +Args: + name: Name of the fixer + risk_score: Risk level (0.0 = safe, 1.0 = dangerous) + +#### RemoveUnusedVariablesFixer.apply + +```python +RemoveUnusedVariablesFixer.apply(self, issue: refactron.core.models.CodeIssue, code: str) -> refactron.autofix.models.FixResult +``` + +Apply unused variable removal. + +#### RemoveUnusedVariablesFixer.preview + +```python +RemoveUnusedVariablesFixer.preview(self, issue: refactron.core.models.CodeIssue, code: str) -> refactron.autofix.models.FixResult +``` + +Preview unused variable removal. + +### SimplifyBooleanFixer + +```python +SimplifyBooleanFixer() -> None +``` + +Simplify boolean expressions. + +#### SimplifyBooleanFixer.__init__ + +```python +SimplifyBooleanFixer.__init__(self) -> None +``` + +Initialize a fixer. + +Args: + name: Name of the fixer + risk_score: Risk level (0.0 = safe, 1.0 = dangerous) + +#### SimplifyBooleanFixer.apply + +```python +SimplifyBooleanFixer.apply(self, issue: refactron.core.models.CodeIssue, code: str) -> refactron.autofix.models.FixResult +``` + +Apply boolean simplification. + +#### SimplifyBooleanFixer.preview + +```python +SimplifyBooleanFixer.preview(self, issue: refactron.core.models.CodeIssue, code: str) -> refactron.autofix.models.FixResult +``` + +Preview boolean simplification. + +### SortImportsFixer + +```python +SortImportsFixer() -> None +``` + +Sort and organize imports using isort. + +#### SortImportsFixer.__init__ + +```python +SortImportsFixer.__init__(self) -> None +``` + +Initialize a fixer. + +Args: + name: Name of the fixer + risk_score: Risk level (0.0 = safe, 1.0 = dangerous) + +#### SortImportsFixer.apply + +```python +SortImportsFixer.apply(self, issue: refactron.core.models.CodeIssue, code: str) -> refactron.autofix.models.FixResult +``` + +Apply import sorting. + +#### SortImportsFixer.preview + +```python +SortImportsFixer.preview(self, issue: refactron.core.models.CodeIssue, code: str) -> refactron.autofix.models.FixResult +``` + +Preview import sorting. + +## Functions + + +--- + +# refactron.autofix.models + +Models for auto-fix system. + +## Classes + +### FixResult + +```python +FixResult(success: bool, reason: str = '', diff: Optional[str] = None, original: Optional[str] = None, fixed: Optional[str] = None, risk_score: float = 1.0, files_affected: List[str] = None) -> None +``` + +Result of an automatic fix. + +#### FixResult.__init__ + +```python +FixResult.__init__(self, success: bool, reason: str = '', diff: Optional[str] = None, original: Optional[str] = None, fixed: Optional[str] = None, risk_score: float = 1.0, files_affected: List[str] = None) -> None +``` + +Initialize self. See help(type(self)) for accurate signature. + +### FixRiskLevel + +```python +FixRiskLevel(*values) +``` + +Risk levels for automatic fixes. + +## Functions + diff --git a/documentation/docs/api/cicd.md b/documentation/docs/api/cicd.md new file mode 100644 index 0000000..c8ff4ee --- /dev/null +++ b/documentation/docs/api/cicd.md @@ -0,0 +1,470 @@ +# refactron.cicd + +CI/CD integration templates and utilities for Refactron. + +## Classes + +## Functions + + +--- + +# refactron.cicd.github_actions + +GitHub Actions workflow template generation. + +## Classes + +### GitHubActionsGenerator + +```python +GitHubActionsGenerator() +``` + +Generate GitHub Actions workflow templates for Refactron. + +#### GitHubActionsGenerator.generate_analysis_workflow + +```python +GitHubActionsGenerator.generate_analysis_workflow(python_versions: Optional[List[str]] = None, trigger_on: Optional[List[str]] = None, quality_gate: Optional[Dict[str, Any]] = None, cache_enabled: bool = True, upload_artifacts: bool = True) -> str +``` + +Generate GitHub Actions workflow for code analysis. + +Args: + python_versions: Python versions to test + (default: ['3.8', '3.9', '3.10', '3.11', '3.12']) + trigger_on: Events to trigger on + (default: ['push', 'pull_request']) + quality_gate: Quality gate configuration + cache_enabled: Enable dependency caching + upload_artifacts: Upload analysis reports as artifacts + +Returns: + YAML workflow content + +#### GitHubActionsGenerator.generate_pre_commit_workflow + +```python +GitHubActionsGenerator.generate_pre_commit_workflow(python_version: str = '3.11', trigger_on: Optional[List[str]] = None) -> str +``` + +Generate GitHub Actions workflow for pre-commit analysis. + +Args: + python_version: Python version to use + trigger_on: Events to trigger on + +Returns: + YAML workflow content + +#### GitHubActionsGenerator.save_workflow + +```python +GitHubActionsGenerator.save_workflow(workflow_content: str, output_path: pathlib._local.Path) -> None +``` + +Save workflow to file. + +Args: + workflow_content: Workflow YAML content + output_path: Path to save workflow file + +Raises: + IOError: If file cannot be written + +## Functions + + +--- + +# refactron.cicd.gitlab_ci + +GitLab CI pipeline configuration generation. + +## Classes + +### GitLabCIGenerator + +```python +GitLabCIGenerator() +``` + +Generate GitLab CI pipeline configurations for Refactron. + +#### GitLabCIGenerator.generate_analysis_pipeline + +```python +GitLabCIGenerator.generate_analysis_pipeline(python_versions: Optional[List[str]] = None, quality_gate: Optional[Dict[str, Any]] = None, cache_enabled: bool = True, artifacts_enabled: bool = True) -> str +``` + +Generate GitLab CI pipeline for code analysis. + +Args: + python_versions: Python versions to test + quality_gate: Quality gate configuration + cache_enabled: Enable dependency caching + artifacts_enabled: Save analysis reports as artifacts + +Returns: + YAML pipeline content + +#### GitLabCIGenerator.generate_pre_commit_pipeline + +```python +GitLabCIGenerator.generate_pre_commit_pipeline(python_version: str = '3.11') -> str +``` + +Generate GitLab CI pipeline for pre-commit analysis. + +Args: + python_version: Python version to use + +Returns: + YAML pipeline content + +#### GitLabCIGenerator.save_pipeline + +```python +GitLabCIGenerator.save_pipeline(pipeline_content: str, output_path: pathlib._local.Path) -> None +``` + +Save pipeline configuration to file. + +Args: + pipeline_content: Pipeline YAML content + output_path: Path to save pipeline file + +Raises: + IOError: If file cannot be written + +## Functions + + +--- + +# refactron.cicd.pr_integration + +Pull Request integration utilities for posting comments and suggestions. + +## Classes + +### PRComment + +```python +PRComment(file_path: str, line: int, message: str, level: str, rule_id: Optional[str] = None, suggestion: Optional[str] = None) -> None +``` + +Represents a PR comment. + +#### PRComment.__init__ + +```python +PRComment.__init__(self, file_path: str, line: int, message: str, level: str, rule_id: Optional[str] = None, suggestion: Optional[str] = None) -> None +``` + +Initialize self. See help(type(self)) for accurate signature. + +#### PRComment.to_markdown + +```python +PRComment.to_markdown(self) -> str +``` + +Convert comment to markdown format. + +Returns: + Markdown formatted comment + +### PRIntegration + +```python +PRIntegration() +``` + +Utilities for PR integration and inline comments. + +#### PRIntegration.format_comment_for_github_api + +```python +PRIntegration.format_comment_for_github_api(comment: refactron.cicd.pr_integration.PRComment) -> Dict +``` + +Format comment for GitHub API. + +Args: + comment: PR comment + +Returns: + GitHub API comment format + +#### PRIntegration.generate_github_comment_body + +```python +PRIntegration.generate_github_comment_body(result: refactron.core.analysis_result.AnalysisResult) -> str +``` + +Generate GitHub PR comment body. + +Args: + result: Analysis result + +Returns: + Markdown comment body + +#### PRIntegration.generate_inline_comments + +```python +PRIntegration.generate_inline_comments(result: refactron.core.analysis_result.AnalysisResult, file_path: pathlib._local.Path) -> List[refactron.cicd.pr_integration.PRComment] +``` + +Generate inline comments for a specific file. + +Args: + result: Analysis result + file_path: File to generate comments for + +Returns: + List of PR comments + +#### PRIntegration.generate_pr_summary + +```python +PRIntegration.generate_pr_summary(result: refactron.core.analysis_result.AnalysisResult) -> str +``` + +Generate PR summary from analysis result. + +Args: + result: Analysis result + +Returns: + Markdown formatted summary + +#### PRIntegration.save_comments_json + +```python +PRIntegration.save_comments_json(comments: List[refactron.cicd.pr_integration.PRComment], output_path: pathlib._local.Path) -> None +``` + +Save comments to JSON file for CI/CD integration. + +Args: + comments: List of PR comments + output_path: Path to save JSON file + +Raises: + IOError: If file cannot be written + +## Functions + + +--- + +# refactron.cicd.pre_commit + +Pre-commit hook template generation. + +## Classes + +### PreCommitGenerator + +```python +PreCommitGenerator() +``` + +Generate pre-commit hook templates for Refactron. + +#### PreCommitGenerator.generate_pre_commit_config + +```python +PreCommitGenerator.generate_pre_commit_config(stages: Optional[List[str]] = None, fail_on_critical: bool = True, fail_on_errors: bool = False, max_critical: int = 0, max_errors: int = 10) -> str +``` + +Generate pre-commit hook configuration. + +Args: + stages: Pre-commit stages to run on (default: ['commit', 'push']) + fail_on_critical: Fail commit if critical issues found + fail_on_errors: Fail commit if error-level issues found + max_critical: Maximum allowed critical issues + max_errors: Maximum allowed error-level issues + +Returns: + YAML configuration content + +#### PreCommitGenerator.generate_simple_hook + +```python +PreCommitGenerator.generate_simple_hook() -> str +``` + +Generate simple pre-commit hook script. + +Returns: + Bash script content + +#### PreCommitGenerator.save_config + +```python +PreCommitGenerator.save_config(config_content: str, output_path: pathlib._local.Path) -> None +``` + +Save pre-commit configuration to file. + +Args: + config_content: YAML configuration content + output_path: Path to save configuration file + +Raises: + IOError: If file cannot be written + +#### PreCommitGenerator.save_hook + +```python +PreCommitGenerator.save_hook(hook_content: str, output_path: pathlib._local.Path) -> None +``` + +Save pre-commit hook script to file. + +Args: + hook_content: Hook script content + output_path: Path to save hook file + +Raises: + IOError: If file cannot be written + +## Functions + + +--- + +# refactron.cicd.quality_gates + +Quality gate parsing and enforcement for CI/CD pipelines. + +## Classes + +### QualityGate + +```python +QualityGate(max_critical: int = 0, max_errors: int = 10, max_warnings: int = 50, max_total: Optional[int] = None, fail_on_critical: bool = True, fail_on_errors: bool = False, fail_on_warnings: bool = False, min_success_rate: float = 0.95) -> None +``` + +Configuration for quality gate thresholds. + +#### QualityGate.__init__ + +```python +QualityGate.__init__(self, max_critical: int = 0, max_errors: int = 10, max_warnings: int = 50, max_total: Optional[int] = None, fail_on_critical: bool = True, fail_on_errors: bool = False, fail_on_warnings: bool = False, min_success_rate: float = 0.95) -> None +``` + +Initialize self. See help(type(self)) for accurate signature. + +#### QualityGate.check + +```python +QualityGate.check(self, result: refactron.core.analysis_result.AnalysisResult) -> Tuple[bool, str] +``` + +Check if quality gate passes. + +Args: + result: Analysis result to check + +Returns: + Tuple of (passed, message) + +#### QualityGate.to_dict + +```python +QualityGate.to_dict(self) -> Dict +``` + +Convert quality gate to dictionary. + +### QualityGateParser + +```python +QualityGateParser() +``` + +Parse CLI output and enforce quality gates. + +#### QualityGateParser.enforce_gate + +```python +QualityGateParser.enforce_gate(result: refactron.core.analysis_result.AnalysisResult, gate: refactron.cicd.quality_gates.QualityGate) -> Tuple[bool, str, int] +``` + +Enforce quality gate on analysis result. + +Args: + result: Analysis result + gate: Quality gate configuration + +Returns: + Tuple of (passed, message, exit_code) + +#### QualityGateParser.generate_summary + +```python +QualityGateParser.generate_summary(result: refactron.core.analysis_result.AnalysisResult) -> str +``` + +Generate quality gate summary for CI/CD. + +Args: + result: Analysis result + +Returns: + Formatted summary string + +#### QualityGateParser.parse_exit_code + +```python +QualityGateParser.parse_exit_code(exit_code: int) -> Dict[str, int] +``` + +Parse exit code from refactron analyze. + +Args: + exit_code: Process exit code + +Returns: + Dictionary indicating if build should fail + +#### QualityGateParser.parse_json_output + +```python +QualityGateParser.parse_json_output(json_path: pathlib._local.Path) -> Dict +``` + +Parse JSON output from refactron analyze --format json. + +Args: + json_path: Path to JSON output file + +Returns: + Parsed JSON dictionary + +Raises: + ValueError: If JSON is invalid + FileNotFoundError: If file doesn't exist + +#### QualityGateParser.parse_text_output + +```python +QualityGateParser.parse_text_output(text: str) -> Dict[str, int] +``` + +Parse text output from refactron analyze command. + +Args: + text: Text output from CLI + +Returns: + Dictionary with issue counts + +## Functions + diff --git a/documentation/docs/api/core.md b/documentation/docs/api/core.md new file mode 100644 index 0000000..c71b646 --- /dev/null +++ b/documentation/docs/api/core.md @@ -0,0 +1,2881 @@ +# refactron.core + +Core functionality for Refactron. + +## Classes + +## Functions + + +--- + +# refactron.core.analysis_result + +Analysis result representation. + +## Classes + +### AnalysisResult + +```python +AnalysisResult(file_metrics: List[refactron.core.models.FileMetrics] = , total_files: int = 0, total_issues: int = 0, failed_files: List[refactron.core.analysis_result.FileAnalysisError] = ) -> None +``` + +Result of code analysis. + +#### AnalysisResult.__init__ + +```python +AnalysisResult.__init__(self, file_metrics: List[refactron.core.models.FileMetrics] = , total_files: int = 0, total_issues: int = 0, failed_files: List[refactron.core.analysis_result.FileAnalysisError] = ) -> None +``` + +Initialize self. See help(type(self)) for accurate signature. + +#### AnalysisResult.issues_by_file + +```python +AnalysisResult.issues_by_file(self, file_path: pathlib._local.Path) -> List[refactron.core.models.CodeIssue] +``` + +Get issues for a specific file. + +#### AnalysisResult.issues_by_level + +```python +AnalysisResult.issues_by_level(self, level: refactron.core.models.IssueLevel) -> List[refactron.core.models.CodeIssue] +``` + +Get issues filtered by severity level. + +#### AnalysisResult.report + +```python +AnalysisResult.report(self, detailed: bool = True) -> str +``` + +Generate a text report of the analysis. + +#### AnalysisResult.summary + +```python +AnalysisResult.summary(self) -> Dict[str, int] +``` + +Get a summary of the analysis. + +### FileAnalysisError + +```python +FileAnalysisError(file_path: pathlib._local.Path, error_message: str, error_type: str, recovery_suggestion: Optional[str] = None) -> None +``` + +Represents an error that occurred while analyzing a file. + +#### FileAnalysisError.__init__ + +```python +FileAnalysisError.__init__(self, file_path: pathlib._local.Path, error_message: str, error_type: str, recovery_suggestion: Optional[str] = None) -> None +``` + +Initialize self. See help(type(self)) for accurate signature. + +## Functions + + +--- + +# refactron.core.backup + +Backup and Rollback System for Refactron. + +Provides functionality to: +- Auto-create .refactron-backup/ directory with original files before changes +- Git integration for automatic commits before major refactoring +- Rollback capability to restore original files + +## Classes + +### BackupManager + +```python +BackupManager(root_dir: Optional[pathlib._local.Path] = None) +``` + +Manage backups and rollbacks for refactoring operations. + +#### BackupManager.__init__ + +```python +BackupManager.__init__(self, root_dir: Optional[pathlib._local.Path] = None) +``` + +Initialize the backup manager. + +Args: + root_dir: Root directory for backups. Defaults to current working directory. + +#### BackupManager.backup_file + +```python +BackupManager.backup_file(self, file_path: pathlib._local.Path, session_id: str) -> pathlib._local.Path +``` + +Backup a single file to the backup directory. + +Args: + file_path: Path to the file to backup. + session_id: Session ID for this backup operation. + +Returns: + Path to the backup file. + +#### BackupManager.backup_files + +```python +BackupManager.backup_files(self, file_paths: List[pathlib._local.Path], session_id: str) -> Tuple[List[pathlib._local.Path], List[pathlib._local.Path]] +``` + +Backup multiple files. + +Args: + file_paths: List of file paths to backup. + session_id: Session ID for this backup operation. + +Returns: + Tuple of (successful backup paths, failed file paths). + +#### BackupManager.clear_all_sessions + +```python +BackupManager.clear_all_sessions(self) -> int +``` + +Clear all backup sessions. + +Returns: + Number of sessions cleared. + +#### BackupManager.clear_session + +```python +BackupManager.clear_session(self, session_id: str) -> bool +``` + +Clear a specific backup session. + +Args: + session_id: Session ID to clear. + +Returns: + True if successful, False otherwise. + +#### BackupManager.create_backup_session + +```python +BackupManager.create_backup_session(self, description: str = '') -> str +``` + +Create a new backup session. + +Args: + description: Description of the operation being performed. + +Returns: + Session ID for the backup session. + +#### BackupManager.get_latest_session + +```python +BackupManager.get_latest_session(self) -> Optional[Dict[str, Any]] +``` + +Get the latest backup session. + +Returns: + Latest session information or None if no sessions exist. + +#### BackupManager.get_session + +```python +BackupManager.get_session(self, session_id: str) -> Optional[Dict[str, Any]] +``` + +Get information about a specific session. + +Args: + session_id: Session ID to look up. + +Returns: + Session information or None if not found. + +#### BackupManager.list_sessions + +```python +BackupManager.list_sessions(self) -> List[Dict[str, Any]] +``` + +List all backup sessions. + +Returns: + List of session information dictionaries. + +#### BackupManager.rollback_session + +```python +BackupManager.rollback_session(self, session_id: Optional[str] = None) -> Tuple[int, List[str]] +``` + +Rollback files from a backup session. + +Args: + session_id: Session ID to rollback. If None, uses the latest session. + +Returns: + Tuple of (number of files restored, list of failed file paths). + +#### BackupManager.update_session_git_commit + +```python +BackupManager.update_session_git_commit(self, session_id: str, commit_hash: Optional[str]) -> bool +``` + +Update the Git commit hash for a session. + +Args: + session_id: Session ID to update. + commit_hash: Git commit hash to associate with the session. + +Returns: + True if successful, False if session not found. + +### BackupRollbackSystem + +```python +BackupRollbackSystem(root_dir: Optional[pathlib._local.Path] = None) +``` + +Combined backup and rollback system that integrates file backups with Git. + +#### BackupRollbackSystem.__init__ + +```python +BackupRollbackSystem.__init__(self, root_dir: Optional[pathlib._local.Path] = None) +``` + +Initialize the backup and rollback system. + +Args: + root_dir: Root directory for operations. + +#### BackupRollbackSystem.clear_all + +```python +BackupRollbackSystem.clear_all(self) -> int +``` + +Clear all backup sessions. + +#### BackupRollbackSystem.list_sessions + +```python +BackupRollbackSystem.list_sessions(self) -> List[Dict[str, Any]] +``` + +List all backup sessions. + +#### BackupRollbackSystem.prepare_for_refactoring + +```python +BackupRollbackSystem.prepare_for_refactoring(self, files: List[pathlib._local.Path], description: str = 'refactoring operation', create_git_commit: bool = True) -> Tuple[str, List[pathlib._local.Path]] +``` + +Prepare for a refactoring operation by creating backups and optionally a Git commit. + +Args: + files: List of files to be refactored. + description: Description of the refactoring operation. + create_git_commit: Whether to create a Git commit before refactoring. + +Returns: + Tuple of (session ID, list of files that failed to backup). + +#### BackupRollbackSystem.rollback + +```python +BackupRollbackSystem.rollback(self, session_id: Optional[str] = None, use_git: bool = False) -> Dict[str, Any] +``` + +Rollback changes from a refactoring session. + +Args: + session_id: Session ID to rollback. If None, uses the latest session. + use_git: Whether to use Git rollback instead of file backup. + +Returns: + Dictionary with rollback results. + +### GitIntegration + +```python +GitIntegration(repo_path: Optional[pathlib._local.Path] = None) +``` + +Git integration for automatic commits before refactoring. + +#### GitIntegration.__init__ + +```python +GitIntegration.__init__(self, repo_path: Optional[pathlib._local.Path] = None) +``` + +Initialize Git integration. + +Args: + repo_path: Path to the Git repository. Defaults to current directory. + +#### GitIntegration.create_pre_refactor_commit + +```python +GitIntegration.create_pre_refactor_commit(self, message: Optional[str] = None, files: Optional[List[pathlib._local.Path]] = None) -> Optional[str] +``` + +Create a commit before refactoring. + +Args: + message: Commit message. Defaults to auto-generated message. + files: Specific files to commit. If None, stages and commits all + uncommitted changes (git add -A). Note: This may include + unintended files like temporary files or build artifacts. + +Returns: + Commit hash if successful, None otherwise. + +#### GitIntegration.get_current_branch + +```python +GitIntegration.get_current_branch(self) -> Optional[str] +``` + +Get the current Git branch name. + +#### GitIntegration.get_current_commit + +```python +GitIntegration.get_current_commit(self) -> Optional[str] +``` + +Get the current commit hash. + +#### GitIntegration.git_rollback_to_commit + +```python +GitIntegration.git_rollback_to_commit(self, commit_hash: str) -> bool +``` + +Rollback to a specific commit (soft reset). + +Args: + commit_hash: Commit hash to rollback to. + +Returns: + True if successful, False otherwise. + +#### GitIntegration.has_uncommitted_changes + +```python +GitIntegration.has_uncommitted_changes(self) -> bool +``` + +Check if there are uncommitted changes. + +#### GitIntegration.is_git_repo + +```python +GitIntegration.is_git_repo(self) -> bool +``` + +Check if the current directory is a Git repository. + +## Functions + + +--- + +# refactron.core.cache + +AST caching layer for performance optimization. + +## Classes + +### ASTCache + +```python +ASTCache(cache_dir: Optional[pathlib._local.Path] = None, enabled: bool = True, max_cache_size_mb: int = 100, cleanup_threshold_percent: float = 0.8) +``` + +Cache for parsed AST trees to avoid re-parsing identical files. + +Uses file content hashing to determine cache validity. + +#### ASTCache.__init__ + +```python +ASTCache.__init__(self, cache_dir: Optional[pathlib._local.Path] = None, enabled: bool = True, max_cache_size_mb: int = 100, cleanup_threshold_percent: float = 0.8) +``` + +Initialize the AST cache. + +Args: + cache_dir: Directory to store cache files. If None, uses temporary directory. + enabled: Whether caching is enabled. + max_cache_size_mb: Maximum cache size in megabytes. + cleanup_threshold_percent: Cleanup to this percentage of max when limit exceeded. + +#### ASTCache.clear + +```python +ASTCache.clear(self) -> None +``` + +Clear all cached data. + +#### ASTCache.get + +```python +ASTCache.get(self, file_path: pathlib._local.Path, content: str) -> Optional[Tuple[libcst._nodes.module.Module, Dict[str, Any]]] +``` + +Get cached AST and metadata for a file. + +Args: + file_path: Path to the file. + content: Current content of the file. + +Returns: + Tuple of (AST module, metadata) if cached, None otherwise. + +#### ASTCache.get_stats + +```python +ASTCache.get_stats(self) -> Dict[str, Any] +``` + +Get cache statistics. + +Returns: + Dictionary containing cache statistics. + +#### ASTCache.put + +```python +ASTCache.put(self, file_path: pathlib._local.Path, content: str, ast_module: libcst._nodes.module.Module, metadata: Optional[Dict[str, Any]] = None) -> None +``` + +Store AST and metadata in cache. + +Args: + file_path: Path to the file. + content: Content of the file. + ast_module: Parsed AST module. + metadata: Optional metadata to cache alongside the AST. + +## Functions + + +--- + +# refactron.core.config + +Configuration management for Refactron. + +## Classes + +### RefactronConfig + +```python +RefactronConfig(version: str = , environment: Optional[str] = None, enabled_analyzers: List[str] = , enabled_refactorers: List[str] = , max_function_complexity: int = 10, max_function_length: int = 50, max_file_length: int = 500, max_parameters: int = 5, report_format: str = 'text', show_details: bool = True, require_preview: bool = True, backup_enabled: bool = True, include_patterns: List[str] = , exclude_patterns: List[str] = , custom_rules: Dict[str, Any] = , security_ignore_patterns: List[str] = , security_rule_whitelist: Dict[str, List[str]] = , security_min_confidence: float = 0.5, enable_ast_cache: bool = True, ast_cache_dir: Optional[pathlib._local.Path] = None, max_ast_cache_size_mb: int = 100, enable_incremental_analysis: bool = True, incremental_state_file: Optional[pathlib._local.Path] = None, enable_parallel_processing: bool = True, max_parallel_workers: Optional[int] = None, use_multiprocessing: bool = False, enable_memory_profiling: bool = False, memory_optimization_threshold_mb: float = 5.0, memory_pressure_threshold_percent: float = 80.0, memory_pressure_threshold_available_mb: float = 500.0, cache_cleanup_threshold_percent: float = 0.8, log_level: str = 'INFO', log_format: str = 'text', log_file: Optional[pathlib._local.Path] = None, log_max_bytes: int = 10485760, log_backup_count: int = 5, enable_console_logging: bool = True, enable_file_logging: bool = True, enable_metrics: bool = True, metrics_detailed: bool = True, enable_prometheus: bool = False, prometheus_host: str = '127.0.0.1', prometheus_port: int = 9090, enable_telemetry: bool = False, telemetry_endpoint: Optional[str] = None, enable_pattern_learning: bool = True, pattern_storage_dir: Optional[pathlib._local.Path] = None, pattern_learning_enabled: bool = True, pattern_ranking_enabled: bool = True) -> None +``` + +Configuration for Refactron analysis and refactoring. + +#### RefactronConfig.__init__ + +```python +RefactronConfig.__init__(self, version: str = , environment: Optional[str] = None, enabled_analyzers: List[str] = , enabled_refactorers: List[str] = , max_function_complexity: int = 10, max_function_length: int = 50, max_file_length: int = 500, max_parameters: int = 5, report_format: str = 'text', show_details: bool = True, require_preview: bool = True, backup_enabled: bool = True, include_patterns: List[str] = , exclude_patterns: List[str] = , custom_rules: Dict[str, Any] = , security_ignore_patterns: List[str] = , security_rule_whitelist: Dict[str, List[str]] = , security_min_confidence: float = 0.5, enable_ast_cache: bool = True, ast_cache_dir: Optional[pathlib._local.Path] = None, max_ast_cache_size_mb: int = 100, enable_incremental_analysis: bool = True, incremental_state_file: Optional[pathlib._local.Path] = None, enable_parallel_processing: bool = True, max_parallel_workers: Optional[int] = None, use_multiprocessing: bool = False, enable_memory_profiling: bool = False, memory_optimization_threshold_mb: float = 5.0, memory_pressure_threshold_percent: float = 80.0, memory_pressure_threshold_available_mb: float = 500.0, cache_cleanup_threshold_percent: float = 0.8, log_level: str = 'INFO', log_format: str = 'text', log_file: Optional[pathlib._local.Path] = None, log_max_bytes: int = 10485760, log_backup_count: int = 5, enable_console_logging: bool = True, enable_file_logging: bool = True, enable_metrics: bool = True, metrics_detailed: bool = True, enable_prometheus: bool = False, prometheus_host: str = '127.0.0.1', prometheus_port: int = 9090, enable_telemetry: bool = False, telemetry_endpoint: Optional[str] = None, enable_pattern_learning: bool = True, pattern_storage_dir: Optional[pathlib._local.Path] = None, pattern_learning_enabled: bool = True, pattern_ranking_enabled: bool = True) -> None +``` + +Initialize self. See help(type(self)) for accurate signature. + +#### RefactronConfig.to_file + +```python +RefactronConfig.to_file(self, config_path: pathlib._local.Path) -> None +``` + +Save configuration to a YAML file. + +Args: + config_path: Path where configuration should be saved + +Raises: + ConfigError: If config file cannot be written + +## Functions + + +--- + +# refactron.core.config_loader + +Enhanced configuration loader with profiles, inheritance, and versioning. + +## Classes + +### ConfigLoader + +```python +ConfigLoader() +``` + +Loads and merges configuration with support for profiles and inheritance. + +## Functions + + +--- + +# refactron.core.config_templates + +Configuration templates for common Python frameworks. + +## Classes + +### ConfigTemplates + +```python +ConfigTemplates() +``` + +Pre-configured templates for common Python frameworks. + +#### ConfigTemplates.get_base_template + +```python +ConfigTemplates.get_base_template() -> Dict +``` + +Get base configuration template. + +#### ConfigTemplates.get_django_template + +```python +ConfigTemplates.get_django_template() -> Dict +``` + +Get Django-specific configuration template. + +#### ConfigTemplates.get_fastapi_template + +```python +ConfigTemplates.get_fastapi_template() -> Dict +``` + +Get FastAPI-specific configuration template. + +#### ConfigTemplates.get_flask_template + +```python +ConfigTemplates.get_flask_template() -> Dict +``` + +Get Flask-specific configuration template. + +#### ConfigTemplates.get_template + +```python +ConfigTemplates.get_template(framework: str) -> Dict +``` + +Get configuration template for a specific framework. + +Args: + framework: Framework name (django, fastapi, flask, base) + +Returns: + Configuration template dictionary + +Raises: + ValueError: If framework is not supported + +## Functions + + +--- + +# refactron.core.config_validator + +Configuration schema validation for Refactron. + +## Classes + +### ConfigValidator + +```python +ConfigValidator() +``` + +Validates Refactron configuration against schema. + +## Functions + + +--- + +# refactron.core.credentials + +Local credential storage for Refactron CLI. + +This is intentionally minimal: credentials are stored in a user-only readable file +under ~/.refactron/. For production hardening, an OS keychain integration can be +added later. + +## Classes + +### RefactronCredentials + +```python +RefactronCredentials(api_base_url: 'str', access_token: 'str', token_type: 'str', expires_at: 'Optional[datetime]' = None, email: 'Optional[str]' = None, plan: 'Optional[str]' = None, api_key: 'Optional[str]' = None) -> None +``` + +Stored CLI credentials. + +#### RefactronCredentials.__init__ + +```python +RefactronCredentials.__init__(self, api_base_url: 'str', access_token: 'str', token_type: 'str', expires_at: 'Optional[datetime]' = None, email: 'Optional[str]' = None, plan: 'Optional[str]' = None, api_key: 'Optional[str]' = None) -> None +``` + +Initialize self. See help(type(self)) for accurate signature. + +#### RefactronCredentials.to_dict + +```python +RefactronCredentials.to_dict(self) -> 'Dict[str, Any]' +``` + +No documentation available. + +## Functions + +### credentials_path + +```python +credentials_path() -> 'Path' +``` + +Default credentials file path. + +### delete_credentials + +```python +delete_credentials(path: 'Optional[Path]' = None) -> 'bool' +``` + +Delete stored credentials. Returns True if deleted, False if not present. + +### load_credentials + +```python +load_credentials(path: 'Optional[Path]' = None) -> 'Optional[RefactronCredentials]' +``` + +Load credentials from disk. Returns None if missing or invalid. + +### save_credentials + +```python +save_credentials(creds: 'RefactronCredentials', path: 'Optional[Path]' = None) -> 'None' +``` + +Save credentials to disk (0600 permissions where supported). + + +--- + +# refactron.core.device_auth + +Device-code authentication helpers for Refactron CLI. + +Implements a minimal Device Authorization Grant-like flow against the Refactron API: +- POST /oauth/device to get (device_code, user_code, verification_uri) +- POST /oauth/token to poll until authorized and receive tokens + +## Classes + +### DeviceAuthorization + +```python +DeviceAuthorization(device_code: 'str', user_code: 'str', verification_uri: 'str', expires_in: 'int', interval: 'int') -> None +``` + +DeviceAuthorization(device_code: 'str', user_code: 'str', verification_uri: 'str', expires_in: 'int', interval: 'int') + +#### DeviceAuthorization.__init__ + +```python +DeviceAuthorization.__init__(self, device_code: 'str', user_code: 'str', verification_uri: 'str', expires_in: 'int', interval: 'int') -> None +``` + +Initialize self. See help(type(self)) for accurate signature. + +### TokenResponse + +```python +TokenResponse(access_token: 'str', token_type: 'str', expires_in: 'int', email: 'Optional[str]' = None, plan: 'Optional[str]' = None, api_key: 'Optional[str]' = None) -> None +``` + +TokenResponse(access_token: 'str', token_type: 'str', expires_in: 'int', email: 'Optional[str]' = None, plan: 'Optional[str]' = None, api_key: 'Optional[str]' = None) + +#### TokenResponse.__init__ + +```python +TokenResponse.__init__(self, access_token: 'str', token_type: 'str', expires_in: 'int', email: 'Optional[str]' = None, plan: 'Optional[str]' = None, api_key: 'Optional[str]' = None) -> None +``` + +Initialize self. See help(type(self)) for accurate signature. + +#### TokenResponse.expires_at + +```python +TokenResponse.expires_at(self) -> 'datetime' +``` + +No documentation available. + +## Functions + +### _normalize_base_url + +```python +_normalize_base_url(api_base_url: 'str') -> 'str' +``` + +No documentation available. + +### _post_json + +```python +_post_json(url: 'str', payload: 'Dict[str, Any]', timeout_seconds: 'int' = 10) -> 'Dict[str, Any]' +``` + +No documentation available. + +### poll_for_token + +```python +poll_for_token(device_code: 'str', api_base_url: 'str' = 'https://api.refactron.dev', client_id: 'str' = 'refactron-cli', interval_seconds: 'int' = 5, expires_in_seconds: 'int' = 900, timeout_seconds: 'int' = 10, sleep_fn: 'Callable[[float], None]' = ) -> 'TokenResponse' +``` + +No documentation available. + +### start_device_authorization + +```python +start_device_authorization(api_base_url: 'str' = 'https://api.refactron.dev', client_id: 'str' = 'refactron-cli', timeout_seconds: 'int' = 10) -> 'DeviceAuthorization' +``` + +No documentation available. + + +--- + +# refactron.core.exceptions + +Custom exception types for Refactron. + +This module defines granular exception types for different failure scenarios, +enabling better error handling and recovery strategies. + +## Classes + +### AnalysisError + +```python +AnalysisError(message: str, file_path: Optional[pathlib._local.Path] = None, analyzer_name: Optional[str] = None, recovery_suggestion: Optional[str] = None) +``` + +Raised when code analysis fails. + +This exception is raised when an analyzer encounters an error +while processing source code. Common causes include: +- Syntax errors in the source code +- Unsupported Python language features +- AST parsing failures +- File encoding issues + +#### AnalysisError.__init__ + +```python +AnalysisError.__init__(self, message: str, file_path: Optional[pathlib._local.Path] = None, analyzer_name: Optional[str] = None, recovery_suggestion: Optional[str] = None) +``` + +Initialize the exception. + +Args: + message: Error message describing what went wrong + file_path: Optional path to the file being analyzed + analyzer_name: Name of the analyzer that failed + recovery_suggestion: Optional suggestion for how to recover + +### ConfigError + +```python +ConfigError(message: str, config_path: Optional[pathlib._local.Path] = None, config_key: Optional[str] = None, recovery_suggestion: Optional[str] = None) +``` + +Raised when configuration is invalid or cannot be loaded. + +This exception is raised when there are problems with the +configuration. Common causes include: +- Invalid YAML syntax in config file +- Missing required configuration options +- Invalid configuration values (e.g., negative thresholds) +- Configuration file not found or not readable + +#### ConfigError.__init__ + +```python +ConfigError.__init__(self, message: str, config_path: Optional[pathlib._local.Path] = None, config_key: Optional[str] = None, recovery_suggestion: Optional[str] = None) +``` + +Initialize the exception. + +Args: + message: Error message describing what went wrong + config_path: Optional path to the config file + config_key: Optional specific config key that caused the error + recovery_suggestion: Optional suggestion for how to recover + +### RefactoringError + +```python +RefactoringError(message: str, file_path: Optional[pathlib._local.Path] = None, operation_type: Optional[str] = None, recovery_suggestion: Optional[str] = None) +``` + +Raised when code refactoring fails. + +This exception is raised when a refactoring operation cannot be +completed successfully. Common causes include: +- Unable to parse the source code +- Refactoring would break code semantics +- File write permission issues +- Backup creation failures + +#### RefactoringError.__init__ + +```python +RefactoringError.__init__(self, message: str, file_path: Optional[pathlib._local.Path] = None, operation_type: Optional[str] = None, recovery_suggestion: Optional[str] = None) +``` + +Initialize the exception. + +Args: + message: Error message describing what went wrong + file_path: Optional path to the file being refactored + operation_type: Type of refactoring operation that failed + recovery_suggestion: Optional suggestion for how to recover + +### RefactronError + +```python +RefactronError(message: str, file_path: Optional[pathlib._local.Path] = None, recovery_suggestion: Optional[str] = None) +``` + +Base exception for all Refactron errors. + +All custom exceptions in Refactron inherit from this class, +allowing for easy catching of all Refactron-specific errors. + +#### RefactronError.__init__ + +```python +RefactronError.__init__(self, message: str, file_path: Optional[pathlib._local.Path] = None, recovery_suggestion: Optional[str] = None) +``` + +Initialize the exception. + +Args: + message: Error message describing what went wrong + file_path: Optional path to the file that caused the error + recovery_suggestion: Optional suggestion for how to recover from the error + +## Functions + + +--- + +# refactron.core.false_positive_tracker + +False positive tracking system for security rules. + +## Classes + +### FalsePositiveTracker + +```python +FalsePositiveTracker(storage_path: pathlib._local.Path = None) +``` + +Tracks and learns from false positive patterns. + +#### FalsePositiveTracker.__init__ + +```python +FalsePositiveTracker.__init__(self, storage_path: pathlib._local.Path = None) +``` + +Initialize the false positive tracker. + +Args: + storage_path: Path to store false positive data + +#### FalsePositiveTracker.clear_all + +```python +FalsePositiveTracker.clear_all(self) -> None +``` + +Clear all false positive data. + +#### FalsePositiveTracker.clear_rule + +```python +FalsePositiveTracker.clear_rule(self, rule_id: str) -> None +``` + +Clear all false positives for a specific rule. + +Args: + rule_id: The rule to clear + +#### FalsePositiveTracker.get_false_positive_patterns + +```python +FalsePositiveTracker.get_false_positive_patterns(self, rule_id: str) -> List[str] +``` + +Get all false positive patterns for a rule. + +Args: + rule_id: The rule ID + +Returns: + List of false positive patterns + +#### FalsePositiveTracker.is_false_positive + +```python +FalsePositiveTracker.is_false_positive(self, rule_id: str, pattern: str) -> bool +``` + +Check if a pattern is marked as a false positive. + +Args: + rule_id: The rule to check + pattern: The pattern to check + +Returns: + True if the pattern is a known false positive + +#### FalsePositiveTracker.load + +```python +FalsePositiveTracker.load(self) -> None +``` + +Load false positive data from storage. + +#### FalsePositiveTracker.mark_false_positive + +```python +FalsePositiveTracker.mark_false_positive(self, rule_id: str, pattern: str) -> None +``` + +Mark a pattern as a false positive for a specific rule. + +Args: + rule_id: The rule that produced the false positive + pattern: The pattern that was incorrectly flagged + +#### FalsePositiveTracker.save + +```python +FalsePositiveTracker.save(self) -> None +``` + +Save false positive data to storage. + +## Functions + + +--- + +# refactron.core.incremental + +Incremental analysis tracking for performance optimization. + +## Classes + +### IncrementalAnalysisTracker + +```python +IncrementalAnalysisTracker(state_file: Optional[pathlib._local.Path] = None, enabled: bool = True) +``` + +Track file changes to enable incremental analysis. + +Only analyzes files that have changed since the last run. +Thread-safe for concurrent updates. + +#### IncrementalAnalysisTracker.__init__ + +```python +IncrementalAnalysisTracker.__init__(self, state_file: Optional[pathlib._local.Path] = None, enabled: bool = True) +``` + +Initialize the incremental analysis tracker. + +Args: + state_file: Path to the state file. If None, uses default location. + enabled: Whether incremental analysis is enabled. + +#### IncrementalAnalysisTracker.cleanup_missing_files + +```python +IncrementalAnalysisTracker.cleanup_missing_files(self, valid_file_paths: Set[pathlib._local.Path]) -> None +``` + +Remove files from state that no longer exist or are not in the valid set. + +Args: + valid_file_paths: Set of file paths that are still valid. + +#### IncrementalAnalysisTracker.clear + +```python +IncrementalAnalysisTracker.clear(self) -> None +``` + +Clear all state data. + +#### IncrementalAnalysisTracker.get_changed_files + +```python +IncrementalAnalysisTracker.get_changed_files(self, file_paths: List[pathlib._local.Path]) -> List[pathlib._local.Path] +``` + +Filter list of files to only those that have changed. + +Args: + file_paths: List of file paths to check. + +Returns: + List of files that have changed or are new. + +#### IncrementalAnalysisTracker.get_stats + +```python +IncrementalAnalysisTracker.get_stats(self) -> Dict[str, int] +``` + +Get statistics about the tracked state. + +Returns: + Dictionary containing statistics. + +#### IncrementalAnalysisTracker.has_file_changed + +```python +IncrementalAnalysisTracker.has_file_changed(self, file_path: pathlib._local.Path) -> bool +``` + +Check if a file has changed since the last analysis. + +Args: + file_path: Path to the file to check. + +Returns: + True if the file has changed or is new, False otherwise. + +#### IncrementalAnalysisTracker.remove_file_state + +```python +IncrementalAnalysisTracker.remove_file_state(self, file_path: pathlib._local.Path) -> None +``` + +Remove a file from the state tracking. + +Args: + file_path: Path to the file to remove. + +#### IncrementalAnalysisTracker.save + +```python +IncrementalAnalysisTracker.save(self) -> None +``` + +Save the current state to disk. + +#### IncrementalAnalysisTracker.update_file_state + +```python +IncrementalAnalysisTracker.update_file_state(self, file_path: pathlib._local.Path) -> None +``` + +Update the state for a file after analysis. + +Args: + file_path: Path to the file that was analyzed. + +## Functions + + +--- + +# refactron.core.inference + +Inference engine wrapping astroid for semantic analysis. +Provides capabilities to infer types, values, and resolve symbols. + +## Classes + +### InferenceEngine + +```python +InferenceEngine() +``` + +Wrapper around astroid to provide high-level semantic analysis capabilities. + +#### InferenceEngine.get_node_type_name + +```python +InferenceEngine.get_node_type_name(node: astroid.nodes.node_ng.NodeNG) -> str +``` + +Get the string representation of the inferred type. + +#### InferenceEngine.infer_node + +```python +InferenceEngine.infer_node(node: astroid.nodes.node_ng.NodeNG, context: Optional[astroid.context.InferenceContext] = None) -> List[Any] +``` + +Attempt to infer the value/type of a given node. +Returns a list of potential values (astroid nodes). + +#### InferenceEngine.is_subtype_of + +```python +InferenceEngine.is_subtype_of(node: astroid.nodes.node_ng.NodeNG, type_name: str) -> bool +``` + +Check if node infers to a specific type name (e.g. 'str', 'int', 'MyClass'). + +#### InferenceEngine.parse_file + +```python +InferenceEngine.parse_file(file_path: str) -> astroid.nodes.scoped_nodes.scoped_nodes.Module +``` + +Parse a file into an astroid node tree. + +#### InferenceEngine.parse_string + +```python +InferenceEngine.parse_string(code: str, module_name: str = '') -> astroid.nodes.scoped_nodes.scoped_nodes.Module +``` + +Parse source code string into an astroid node tree. + +## Functions + + +--- + +# refactron.core.logging_config + +Structured logging configuration for Refactron. + +This module provides JSON-formatted logging for CI/CD and log aggregation systems, +with configurable log levels and rotation support. + +## Classes + +### JSONFormatter + +```python +JSONFormatter(fmt=None, datefmt=None, style='%', validate=True, *, defaults=None) +``` + +Custom JSON formatter for structured logging. + +#### JSONFormatter.__init__ + +```python +JSONFormatter.__init__(self, fmt=None, datefmt=None, style='%', validate=True, *, defaults=None) +``` + +Initialize the formatter with specified format strings. + +Initialize the formatter either with the specified format string, or a +default as described above. Allow for specialized date formatting with +the optional datefmt argument. If datefmt is omitted, you get an +ISO8601-like (or RFC 3339-like) format. + +Use a style parameter of '%', '\{' or '$' to specify that you want to +use one of %-formatting, :meth:`str.format` (``{}``) formatting or +:class:`string.Template` formatting in your format string. + +.. versionchanged:: 3.2 + Added the ``style`` parameter. + +#### JSONFormatter.format + +```python +JSONFormatter.format(self, record: logging.LogRecord) -> str +``` + +Format log record as JSON. + +Args: + record: The log record to format + +Returns: + JSON-formatted log string + +#### JSONFormatter.formatException + +```python +JSONFormatter.formatException(self, ei) +``` + +Format and return the specified exception information as a string. + +This default implementation just uses +traceback.print_exception() + +#### JSONFormatter.formatMessage + +```python +JSONFormatter.formatMessage(self, record) +``` + +No documentation available. + +#### JSONFormatter.formatStack + +```python +JSONFormatter.formatStack(self, stack_info) +``` + +This method is provided as an extension point for specialized +formatting of stack information. + +The input data is a string as returned from a call to +:func:`traceback.print_stack`, but with the last trailing newline +removed. + +The base implementation just returns the value passed in. + +#### JSONFormatter.formatTime + +```python +JSONFormatter.formatTime(self, record, datefmt=None) +``` + +Return the creation time of the specified LogRecord as formatted text. + +This method should be called from format() by a formatter which +wants to make use of a formatted time. This method can be overridden +in formatters to provide for any specific requirement, but the +basic behaviour is as follows: if datefmt (a string) is specified, +it is used with time.strftime() to format the creation time of the +record. Otherwise, an ISO8601-like (or RFC 3339-like) format is used. +The resulting string is returned. This function uses a user-configurable +function to convert the creation time to a tuple. By default, +time.localtime() is used; to change this for a particular formatter +instance, set the 'converter' attribute to a function with the same +signature as time.localtime() or time.gmtime(). To change it for all +formatters, for example if you want all logging times to be shown in GMT, +set the 'converter' attribute in the Formatter class. + +#### JSONFormatter.usesTime + +```python +JSONFormatter.usesTime(self) +``` + +Check if the format uses the creation time of the record. + +### StructuredLogger + +```python +StructuredLogger(name: str = 'refactron', level: str = 'INFO', log_file: Optional[pathlib._local.Path] = None, log_format: str = 'json', max_bytes: int = 10485760, backup_count: int = 5, enable_console: bool = True, enable_file: bool = True) +``` + +Structured logger with JSON formatting and rotation support. + +#### StructuredLogger.__init__ + +```python +StructuredLogger.__init__(self, name: str = 'refactron', level: str = 'INFO', log_file: Optional[pathlib._local.Path] = None, log_format: str = 'json', max_bytes: int = 10485760, backup_count: int = 5, enable_console: bool = True, enable_file: bool = True) +``` + +Initialize structured logger. + +Args: + name: Logger name + level: Log level (DEBUG, INFO, WARNING, ERROR, CRITICAL) + log_file: Path to log file (if None, uses default location) + log_format: Log format ('json' or 'text') + max_bytes: Maximum log file size before rotation + backup_count: Number of backup files to keep + enable_console: Enable console logging + enable_file: Enable file logging + +#### StructuredLogger.get_logger + +```python +StructuredLogger.get_logger(self) -> logging.Logger +``` + +Get the configured logger instance. + +Returns: + Configured logger instance + +#### StructuredLogger.log_with_context + +```python +StructuredLogger.log_with_context(self, level: str, message: str, extra_data: Optional[Dict[str, Any]] = None) -> None +``` + +Log message with additional context data. + +Args: + level: Log level (debug, info, warning, error, critical) + message: Log message + extra_data: Additional context data to include in log + +## Functions + +### setup_logging + +```python +setup_logging(level: str = 'INFO', log_file: Optional[pathlib._local.Path] = None, log_format: str = 'json', max_bytes: int = 10485760, backup_count: int = 5, enable_console: bool = True, enable_file: bool = True) -> refactron.core.logging_config.StructuredLogger +``` + +Setup structured logging for Refactron. + +Args: + level: Log level (DEBUG, INFO, WARNING, ERROR, CRITICAL) + log_file: Path to log file + log_format: Log format ('json' or 'text') + max_bytes: Maximum log file size before rotation + backup_count: Number of backup files to keep + enable_console: Enable console logging + enable_file: Enable file logging + +Returns: + Configured StructuredLogger instance + + +--- + +# refactron.core.memory_profiler + +Memory profiling and optimization utilities. + +## Classes + +### MemoryProfiler + +```python +MemoryProfiler(enabled: bool = True, pressure_threshold_percent: float = 80.0, pressure_threshold_available_mb: float = 500.0) +``` + +Memory profiling and optimization utilities. + +Helps track and optimize memory usage for large codebases. + +#### MemoryProfiler.__init__ + +```python +MemoryProfiler.__init__(self, enabled: bool = True, pressure_threshold_percent: float = 80.0, pressure_threshold_available_mb: float = 500.0) +``` + +Initialize the memory profiler. + +Args: + enabled: Whether memory profiling is enabled. + pressure_threshold_percent: Percent threshold for high memory pressure. + pressure_threshold_available_mb: Available memory threshold in MB. + +#### MemoryProfiler.check_memory_pressure + +```python +MemoryProfiler.check_memory_pressure(self) -> bool +``` + +Check if the system is under memory pressure. + +Returns: + True if memory pressure is high (>80% usage). + +#### MemoryProfiler.clear_snapshots + +```python +MemoryProfiler.clear_snapshots(self) -> None +``` + +Clear all stored snapshots. + +#### MemoryProfiler.compare + +```python +MemoryProfiler.compare(self, start_label: str, end_label: str) -> Dict[str, float] +``` + +Compare two memory snapshots. + +Args: + start_label: Label of the starting snapshot. + end_label: Label of the ending snapshot. + +Returns: + Dictionary with memory differences. + +#### MemoryProfiler.get_current_memory + +```python +MemoryProfiler.get_current_memory(self) -> refactron.core.memory_profiler.MemorySnapshot +``` + +Get current memory usage snapshot. + +Returns: + MemorySnapshot with current memory usage. + +#### MemoryProfiler.get_stats + +```python +MemoryProfiler.get_stats(self) -> Dict[str, Any] +``` + +Get memory profiling statistics. + +Returns: + Dictionary containing statistics. + +#### MemoryProfiler.optimize_for_large_files + +```python +MemoryProfiler.optimize_for_large_files(self, file_size_mb: float, threshold_mb: Optional[float] = None) -> bool +``` + +Determine if special optimization is needed for a large file. + +Args: + file_size_mb: File size in megabytes. + threshold_mb: Optional threshold override. If None, uses default of 5.0 MB. + +Returns: + True if optimization is recommended. + +#### MemoryProfiler.profile_function + +```python +MemoryProfiler.profile_function(self, func: Callable[..., ~T], *args: Any, label: Optional[str] = None, **kwargs: Any) -> Tuple[~T, Dict[str, Any]] +``` + +Profile memory usage of a function call. + +Args: + func: Function to profile. + *args: Positional arguments for the function. + label: Optional label for logging. + **kwargs: Keyword arguments for the function. + +Returns: + Tuple of (function result, profiling info). + +#### MemoryProfiler.snapshot + +```python +MemoryProfiler.snapshot(self, label: str) -> refactron.core.memory_profiler.MemorySnapshot +``` + +Take a memory snapshot with a label. + +Args: + label: Label for this snapshot. + +Returns: + MemorySnapshot with current memory usage. + +#### MemoryProfiler.suggest_gc + +```python +MemoryProfiler.suggest_gc(self) -> None +``` + +Suggest garbage collection if memory pressure is high. + +### MemorySnapshot + +```python +MemorySnapshot(rss_mb: float, vms_mb: float, percent: float, available_mb: float) -> None +``` + +Snapshot of memory usage at a point in time. + +#### MemorySnapshot.__init__ + +```python +MemorySnapshot.__init__(self, rss_mb: float, vms_mb: float, percent: float, available_mb: float) -> None +``` + +Initialize self. See help(type(self)) for accurate signature. + +## Functions + +### estimate_file_size_mb + +```python +estimate_file_size_mb(file_path: str) -> float +``` + +Estimate file size in megabytes. + +Args: + file_path: Path to the file. + +Returns: + File size in MB. + +### stream_large_file + +```python +stream_large_file(file_path: str, chunk_size: int = 8192) -> Any +``` + +Stream a large file in chunks instead of reading all at once. + +Args: + file_path: Path to the file. + chunk_size: Size of each chunk in bytes. + +Yields: + Chunks of file content. + + +--- + +# refactron.core.metrics + +Metrics collection and tracking for Refactron. + +This module provides execution metrics tracking including: +- Analysis time per file and total run time +- Refactoring success/failure rates +- Rule hit counts per analyzer/refactorer + +## Classes + +### FileMetric + +```python +FileMetric(file_path: str, analysis_time_ms: float, lines_of_code: int, issues_found: int, analyzers_run: List[str] = , timestamp: str = , success: bool = True, error_message: Optional[str] = None) -> None +``` + +Metrics for a single file analysis. + +#### FileMetric.__init__ + +```python +FileMetric.__init__(self, file_path: str, analysis_time_ms: float, lines_of_code: int, issues_found: int, analyzers_run: List[str] = , timestamp: str = , success: bool = True, error_message: Optional[str] = None) -> None +``` + +Initialize self. See help(type(self)) for accurate signature. + +### MetricsCollector + +```python +MetricsCollector() -> None +``` + +Centralized metrics collection for Refactron operations. + +#### MetricsCollector.__init__ + +```python +MetricsCollector.__init__(self) -> None +``` + +Initialize metrics collector. + +#### MetricsCollector.end_analysis + +```python +MetricsCollector.end_analysis(self) -> None +``` + +Mark the end of an analysis session. + +#### MetricsCollector.end_refactoring + +```python +MetricsCollector.end_refactoring(self) -> None +``` + +Mark the end of a refactoring session. + +#### MetricsCollector.get_analysis_summary + +```python +MetricsCollector.get_analysis_summary(self) -> Dict[str, Any] +``` + +Get summary of analysis metrics. + +Returns: + Dictionary containing analysis summary metrics + +#### MetricsCollector.get_combined_summary + +```python +MetricsCollector.get_combined_summary(self) -> Dict[str, Any] +``` + +Get combined summary of all metrics. + +Returns: + Dictionary containing all metrics summaries + +#### MetricsCollector.get_refactoring_summary + +```python +MetricsCollector.get_refactoring_summary(self) -> Dict[str, Any] +``` + +Get summary of refactoring metrics. + +Returns: + Dictionary containing refactoring summary metrics + +#### MetricsCollector.record_analyzer_hit + +```python +MetricsCollector.record_analyzer_hit(self, analyzer_name: str, issue_type: str) -> None +``` + +Record that an analyzer found an issue. + +Args: + analyzer_name: Name of the analyzer + issue_type: Type of issue found + +#### MetricsCollector.record_file_analysis + +```python +MetricsCollector.record_file_analysis(self, file_path: str, analysis_time_ms: float, lines_of_code: int, issues_found: int, analyzers_run: List[str], success: bool = True, error_message: Optional[str] = None) -> None +``` + +Record metrics for a single file analysis. + +Args: + file_path: Path to the analyzed file + analysis_time_ms: Time taken to analyze the file in milliseconds + lines_of_code: Number of lines of code in the file + issues_found: Number of issues found in the file + analyzers_run: List of analyzer names that were run + success: Whether the analysis succeeded + error_message: Error message if analysis failed + +#### MetricsCollector.record_refactoring + +```python +MetricsCollector.record_refactoring(self, operation_type: str, file_path: str, execution_time_ms: float, success: bool, risk_level: str = 'safe', error_message: Optional[str] = None) -> None +``` + +Record metrics for a single refactoring operation. + +Args: + operation_type: Type of refactoring operation + file_path: Path to the refactored file + execution_time_ms: Time taken to perform refactoring in milliseconds + success: Whether the refactoring succeeded + risk_level: Risk level of the refactoring + error_message: Error message if refactoring failed + +#### MetricsCollector.reset + +```python +MetricsCollector.reset(self) -> None +``` + +Reset all metrics to initial state. + +#### MetricsCollector.start_analysis + +```python +MetricsCollector.start_analysis(self) -> None +``` + +Mark the start of an analysis session. + +#### MetricsCollector.start_refactoring + +```python +MetricsCollector.start_refactoring(self) -> None +``` + +Mark the start of a refactoring session. + +### RefactoringMetric + +```python +RefactoringMetric(operation_type: str, file_path: str, execution_time_ms: float, success: bool, risk_level: str, timestamp: str = , error_message: Optional[str] = None) -> None +``` + +Metrics for a single refactoring operation. + +#### RefactoringMetric.__init__ + +```python +RefactoringMetric.__init__(self, operation_type: str, file_path: str, execution_time_ms: float, success: bool, risk_level: str, timestamp: str = , error_message: Optional[str] = None) -> None +``` + +Initialize self. See help(type(self)) for accurate signature. + +## Functions + +### get_metrics_collector + +```python +get_metrics_collector() -> refactron.core.metrics.MetricsCollector +``` + +Get the global metrics collector instance. + +Returns: + Global MetricsCollector instance + +### reset_metrics_collector + +```python +reset_metrics_collector() -> None +``` + +Reset the global metrics collector. + + +--- + +# refactron.core.models + +Data models for Refactron. + +## Classes + +### CodeIssue + +```python +CodeIssue(category: refactron.core.models.IssueCategory, level: refactron.core.models.IssueLevel, message: str, file_path: pathlib._local.Path, line_number: int, column: int = 0, end_line: Optional[int] = None, code_snippet: Optional[str] = None, suggestion: Optional[str] = None, rule_id: Optional[str] = None, confidence: float = 1.0, metadata: Dict[str, Any] = ) -> None +``` + +Represents a detected code issue. + +#### CodeIssue.__init__ + +```python +CodeIssue.__init__(self, category: refactron.core.models.IssueCategory, level: refactron.core.models.IssueLevel, message: str, file_path: pathlib._local.Path, line_number: int, column: int = 0, end_line: Optional[int] = None, code_snippet: Optional[str] = None, suggestion: Optional[str] = None, rule_id: Optional[str] = None, confidence: float = 1.0, metadata: Dict[str, Any] = ) -> None +``` + +Initialize self. See help(type(self)) for accurate signature. + +### FileMetrics + +```python +FileMetrics(file_path: pathlib._local.Path, lines_of_code: int, comment_lines: int, blank_lines: int, complexity: float, maintainability_index: float, functions: int, classes: int, issues: List[refactron.core.models.CodeIssue] = ) -> None +``` + +Metrics for a single file. + +#### FileMetrics.__init__ + +```python +FileMetrics.__init__(self, file_path: pathlib._local.Path, lines_of_code: int, comment_lines: int, blank_lines: int, complexity: float, maintainability_index: float, functions: int, classes: int, issues: List[refactron.core.models.CodeIssue] = ) -> None +``` + +Initialize self. See help(type(self)) for accurate signature. + +### IssueCategory + +```python +IssueCategory(*values) +``` + +Categories of code issues. + +### IssueLevel + +```python +IssueLevel(*values) +``` + +Severity level of code issues. + +### RefactoringOperation + +```python +RefactoringOperation(operation_type: str, file_path: pathlib._local.Path, line_number: int, description: str, old_code: str, new_code: str, risk_score: float, operation_id: str = , reasoning: Optional[str] = None, metadata: Dict[str, Any] = ) -> None +``` + +Represents a refactoring operation to be applied. + +#### RefactoringOperation.__init__ + +```python +RefactoringOperation.__init__(self, operation_type: str, file_path: pathlib._local.Path, line_number: int, description: str, old_code: str, new_code: str, risk_score: float, operation_id: str = , reasoning: Optional[str] = None, metadata: Dict[str, Any] = ) -> None +``` + +Initialize self. See help(type(self)) for accurate signature. + +## Functions + + +--- + +# refactron.core.parallel + +Parallel processing utilities for performance optimization. + +## Classes + +### ParallelProcessor + +```python +ParallelProcessor(max_workers: Optional[int] = None, use_processes: bool = True, enabled: bool = True) +``` + +Parallel processing manager for analyzing multiple files concurrently. + +Supports both multiprocessing and threading based on the task type. + +#### ParallelProcessor.__init__ + +```python +ParallelProcessor.__init__(self, max_workers: Optional[int] = None, use_processes: bool = True, enabled: bool = True) +``` + +Initialize the parallel processor. + +Args: + max_workers: Maximum number of worker processes/threads. + If None, uses CPU count capped at 8 workers to avoid resource exhaustion. + use_processes: If True, uses multiprocessing; if False, uses threading. + enabled: Whether parallel processing is enabled. + +#### ParallelProcessor.get_config + +```python +ParallelProcessor.get_config(self) -> Dict[str, Any] +``` + +Get the current configuration. + +Returns: + Dictionary containing configuration details. + +#### ParallelProcessor.process_files + +```python +ParallelProcessor.process_files(self, files: List[pathlib._local.Path], process_func: Callable[[pathlib._local.Path], Tuple[Optional[refactron.core.models.FileMetrics], Optional[refactron.core.analysis_result.FileAnalysisError]]], progress_callback: Optional[Callable[[int, int], NoneType]] = None) -> Tuple[List[refactron.core.models.FileMetrics], List[refactron.core.analysis_result.FileAnalysisError]] +``` + +Process multiple files in parallel. + +Args: + files: List of file paths to process. + process_func: Function to process a single file. Should return + (FileMetrics, None) on success or (None, FileAnalysisError) on error. + progress_callback: Optional callback for progress updates (completed, total). + +Returns: + Tuple of (successful results, failed files). + +## Functions + + +--- + +# refactron.core.prometheus_metrics + +Prometheus metrics exporter for Refactron. + +This module provides Prometheus-compatible metrics endpoint for monitoring +Refactron's performance and usage in production environments. + +## Classes + +### MetricsHTTPHandler + +```python +MetricsHTTPHandler(request, client_address, server) +``` + +HTTP handler for Prometheus metrics endpoint. + +#### MetricsHTTPHandler.__init__ + +```python +MetricsHTTPHandler.__init__(self, request, client_address, server) +``` + +Initialize self. See help(type(self)) for accurate signature. + +#### MetricsHTTPHandler.address_string + +```python +MetricsHTTPHandler.address_string(self) +``` + +Return the client address. + +#### MetricsHTTPHandler.date_time_string + +```python +MetricsHTTPHandler.date_time_string(self, timestamp=None) +``` + +Return the current date and time formatted for a message header. + +#### MetricsHTTPHandler.do_GET + +```python +MetricsHTTPHandler.do_GET(self) -> None +``` + +Handle GET requests to /metrics endpoint. + +#### MetricsHTTPHandler.end_headers + +```python +MetricsHTTPHandler.end_headers(self) +``` + +Send the blank line ending the MIME headers. + +#### MetricsHTTPHandler.finish + +```python +MetricsHTTPHandler.finish(self) +``` + +No documentation available. + +#### MetricsHTTPHandler.flush_headers + +```python +MetricsHTTPHandler.flush_headers(self) +``` + +No documentation available. + +#### MetricsHTTPHandler.handle + +```python +MetricsHTTPHandler.handle(self) +``` + +Handle multiple requests if necessary. + +#### MetricsHTTPHandler.handle_expect_100 + +```python +MetricsHTTPHandler.handle_expect_100(self) +``` + +Decide what to do with an "Expect: 100-continue" header. + +If the client is expecting a 100 Continue response, we must +respond with either a 100 Continue or a final response before +waiting for the request body. The default is to always respond +with a 100 Continue. You can behave differently (for example, +reject unauthorized requests) by overriding this method. + +This method should either return True (possibly after sending +a 100 Continue response) or send an error response and return +False. + +#### MetricsHTTPHandler.handle_one_request + +```python +MetricsHTTPHandler.handle_one_request(self) +``` + +Handle a single HTTP request. + +You normally don't need to override this method; see the class +__doc__ string for information on how to handle specific HTTP +commands such as GET and POST. + +#### MetricsHTTPHandler.log_date_time_string + +```python +MetricsHTTPHandler.log_date_time_string(self) +``` + +Return the current time formatted for logging. + +#### MetricsHTTPHandler.log_error + +```python +MetricsHTTPHandler.log_error(self, format, *args) +``` + +Log an error. + +This is called when a request cannot be fulfilled. By +default it passes the message on to log_message(). + +Arguments are the same as for log_message(). + +XXX This should go to the separate error log. + +#### MetricsHTTPHandler.log_message + +```python +MetricsHTTPHandler.log_message(self, format: str, *args: Any) -> None +``` + +Suppress default logging. + +#### MetricsHTTPHandler.log_request + +```python +MetricsHTTPHandler.log_request(self, code='-', size='-') +``` + +Log an accepted request. + +This is called by send_response(). + +#### MetricsHTTPHandler.parse_request + +```python +MetricsHTTPHandler.parse_request(self) +``` + +Parse a request (internal). + +The request should be stored in self.raw_requestline; the results +are in self.command, self.path, self.request_version and +self.headers. + +Return True for success, False for failure; on failure, any relevant +error response has already been sent back. + +#### MetricsHTTPHandler.send_error + +```python +MetricsHTTPHandler.send_error(self, code, message=None, explain=None) +``` + +Send and log an error reply. + +Arguments are +* code: an HTTP error code + 3 digits +* message: a simple optional 1 line reason phrase. + *( HTAB / SP / VCHAR / %x80-FF ) + defaults to short entry matching the response code +* explain: a detailed message defaults to the long entry + matching the response code. + +This sends an error response (so it must be called before any +output has been generated), logs the error, and finally sends +a piece of HTML explaining the error to the user. + +#### MetricsHTTPHandler.send_header + +```python +MetricsHTTPHandler.send_header(self, keyword, value) +``` + +Send a MIME header to the headers buffer. + +#### MetricsHTTPHandler.send_response + +```python +MetricsHTTPHandler.send_response(self, code, message=None) +``` + +Add the response header to the headers buffer and log the +response code. + +Also send two standard headers with the server software +version and the current date. + +#### MetricsHTTPHandler.send_response_only + +```python +MetricsHTTPHandler.send_response_only(self, code, message=None) +``` + +Send the response header only. + +#### MetricsHTTPHandler.setup + +```python +MetricsHTTPHandler.setup(self) +``` + +No documentation available. + +#### MetricsHTTPHandler.version_string + +```python +MetricsHTTPHandler.version_string(self) +``` + +Return the server software version string. + +### PrometheusMetrics + +```python +PrometheusMetrics() -> None +``` + +Prometheus metrics formatter and exporter. + +#### PrometheusMetrics.__init__ + +```python +PrometheusMetrics.__init__(self) -> None +``` + +Initialize Prometheus metrics. + +#### PrometheusMetrics.format_metrics + +```python +PrometheusMetrics.format_metrics(self) -> str +``` + +Format metrics in Prometheus exposition format. + +Returns: + String containing Prometheus-formatted metrics + +### PrometheusMetricsServer + +```python +PrometheusMetricsServer(host: str = '127.0.0.1', port: int = 9090) -> None +``` + +HTTP server for exposing Prometheus metrics. + +#### PrometheusMetricsServer.__init__ + +```python +PrometheusMetricsServer.__init__(self, host: str = '127.0.0.1', port: int = 9090) -> None +``` + +Initialize Prometheus metrics server. + +Args: + host: Host to bind to (default: 127.0.0.1 for localhost-only access) + port: Port to listen on + +#### PrometheusMetricsServer.is_running + +```python +PrometheusMetricsServer.is_running(self) -> bool +``` + +Check if the metrics server is running. + +Returns: + True if server is running, False otherwise + +#### PrometheusMetricsServer.start + +```python +PrometheusMetricsServer.start(self) -> None +``` + +Start the metrics server in a background thread. + +#### PrometheusMetricsServer.stop + +```python +PrometheusMetricsServer.stop(self) -> None +``` + +Stop the metrics server. + +## Functions + +### get_metrics_server + +```python +get_metrics_server() -> Optional[refactron.core.prometheus_metrics.PrometheusMetricsServer] +``` + +Get the global metrics server instance. + +Returns: + PrometheusMetricsServer instance or None if not started + +### start_metrics_server + +```python +start_metrics_server(host: str = '127.0.0.1', port: int = 9090) -> refactron.core.prometheus_metrics.PrometheusMetricsServer +``` + +Start the global Prometheus metrics server. + +Args: + host: Host to bind to (default: 127.0.0.1 for localhost-only access) + port: Port to listen on + +Returns: + PrometheusMetricsServer instance + +### stop_metrics_server + +```python +stop_metrics_server() -> None +``` + +Stop the global Prometheus metrics server. + + +--- + +# refactron.core.refactor_result + +Refactoring result representation. + +## Classes + +### RefactorResult + +```python +RefactorResult(operations: List[refactron.core.models.RefactoringOperation] = , applied: bool = False, preview_mode: bool = True) -> None +``` + +Result of refactoring operations. + +#### RefactorResult.__init__ + +```python +RefactorResult.__init__(self, operations: List[refactron.core.models.RefactoringOperation] = , applied: bool = False, preview_mode: bool = True) -> None +``` + +Initialize self. See help(type(self)) for accurate signature. + +#### RefactorResult.apply + +```python +RefactorResult.apply(self) -> bool +``` + +Apply the refactoring operations to the files. + +#### RefactorResult.get_ranking_score + +```python +RefactorResult.get_ranking_score(self, operation: refactron.core.models.RefactoringOperation) -> float +``` + +Get ranking score for an operation (0.0 if not ranked). + +#### RefactorResult.operations_by_file + +```python +RefactorResult.operations_by_file(self, file_path: pathlib._local.Path) -> List[refactron.core.models.RefactoringOperation] +``` + +Get operations for a specific file. + +#### RefactorResult.operations_by_type + +```python +RefactorResult.operations_by_type(self, operation_type: str) -> List[refactron.core.models.RefactoringOperation] +``` + +Get operations of a specific type. + +#### RefactorResult.show_diff + +```python +RefactorResult.show_diff(self) -> str +``` + +Show a diff of all operations. + +#### RefactorResult.summary + +```python +RefactorResult.summary(self) -> Dict[str, int] +``` + +Get a summary of refactoring operations. + +#### RefactorResult.top_ranked_operations + +```python +RefactorResult.top_ranked_operations(self, top_n: int = 10) -> List[refactron.core.models.RefactoringOperation] +``` + +Get top N ranked operations by ranking score. + +## Functions + + +--- + +# refactron.core.refactron + +Main Refactron class - the entry point for all operations. + +## Classes + +### Refactron + +```python +Refactron(config: Optional[refactron.core.config.RefactronConfig] = None) +``` + +Main Refactron class for code analysis and refactoring. + +Example: + >>> refactron = Refactron() + >>> result = refactron.analyze("mycode.py") + >>> print(result.report()) + +#### Refactron.__init__ + +```python +Refactron.__init__(self, config: Optional[refactron.core.config.RefactronConfig] = None) +``` + +Initialize Refactron. + +Args: + config: Configuration object. If None, uses default config. + +#### Refactron.analyze + +```python +Refactron.analyze(self, target: Union[str, pathlib._local.Path]) -> refactron.core.analysis_result.AnalysisResult +``` + +Analyze a file or directory. + +Args: + target: Path to file or directory to analyze + +Returns: + AnalysisResult containing all detected issues and any errors encountered + +Note: + This method implements graceful degradation - if individual files fail + to analyze, they are logged and skipped, allowing analysis to continue + on remaining files. + +#### Refactron.clear_caches + +```python +Refactron.clear_caches(self) -> None +``` + +Clear all performance-related caches. + +#### Refactron.detect_project_root + +```python +Refactron.detect_project_root(self, file_path: pathlib._local.Path) -> pathlib._local.Path +``` + +Detect project root by looking for common markers in parent directories. + +The search walks up the directory tree from the file's parent directory, +checking for common project markers up to a fixed maximum depth. + +Args: + file_path: Path to a file in the project. + +Returns: + The path to the project root if any of the known markers are found + within the search depth limit, or the file's parent directory if no + markers are detected. + +#### Refactron.get_performance_stats + +```python +Refactron.get_performance_stats(self) -> dict +``` + +Get performance statistics from all optimization components. + +Returns: + Dictionary containing performance statistics. + +#### Refactron.get_python_files + +```python +Refactron.get_python_files(self, directory: pathlib._local.Path) -> List[pathlib._local.Path] +``` + +Get all Python files in a directory, respecting exclude patterns. + +#### Refactron.record_feedback + +```python +Refactron.record_feedback(self, operation_id: str, action: str, reason: Optional[str] = None, operation: Optional[refactron.core.models.RefactoringOperation] = None) -> None +``` + +Record developer feedback on a refactoring suggestion. + +Args: + operation_id: Unique identifier for the refactoring operation + action: Feedback action - "accepted", "rejected", or "ignored" + reason: Optional reason for the feedback + operation: Optional RefactoringOperation object (used to extract metadata) + +Note: + If pattern storage is not initialized, this method will silently fail. + +#### Refactron.refactor + +```python +Refactron.refactor(self, target: Union[str, pathlib._local.Path], preview: bool = True, operation_types: Optional[List[str]] = None) -> refactron.core.refactor_result.RefactorResult +``` + +Refactor a file or directory. + +Args: + target: Path to file or directory to refactor + preview: If True, show changes without applying them + operation_types: Specific refactoring operations to apply (None = all) + +Returns: + RefactorResult containing all proposed operations + +Note: + This method implements graceful degradation - if individual files fail + to refactor, they are logged and skipped, allowing refactoring to continue + on remaining files. + +## Functions + + +--- + +# refactron.core.repositories + +GitHub repository integration for Refactron CLI. + +This module provides functionality to interact with the Refactron backend API +to fetch GitHub repositories connected to the user's account. + +## Classes + +### Repository + +```python +Repository(id: 'int', name: 'str', full_name: 'str', description: 'Optional[str]', private: 'bool', html_url: 'str', clone_url: 'str', ssh_url: 'str', default_branch: 'str', language: 'Optional[str]', updated_at: 'str') -> None +``` + +Represents a GitHub repository. + +#### Repository.__init__ + +```python +Repository.__init__(self, id: 'int', name: 'str', full_name: 'str', description: 'Optional[str]', private: 'bool', html_url: 'str', clone_url: 'str', ssh_url: 'str', default_branch: 'str', language: 'Optional[str]', updated_at: 'str') -> None +``` + +Initialize self. See help(type(self)) for accurate signature. + +## Functions + +### list_repositories + +```python +list_repositories(api_base_url: 'str', timeout_seconds: 'int' = 10) -> 'List[Repository]' +``` + +Fetch all GitHub repositories connected to the user's account. + +Args: + api_base_url: The Refactron API base URL + timeout_seconds: Request timeout in seconds + +Returns: + List of Repository objects + +Raises: + RuntimeError: If the request fails or user is not authenticated + + +--- + +# refactron.core.telemetry + +Opt-in telemetry system for Refactron. + +This module provides anonymous usage data collection to understand real-world +usage patterns and performance characteristics. All telemetry is opt-in and +respects user privacy. + +## Classes + +### TelemetryCollector + +```python +TelemetryCollector(enabled: bool = False, anonymous_id: Optional[str] = None, telemetry_file: Optional[pathlib._local.Path] = None) +``` + +Collects and manages telemetry data with privacy considerations. + +#### TelemetryCollector.__init__ + +```python +TelemetryCollector.__init__(self, enabled: bool = False, anonymous_id: Optional[str] = None, telemetry_file: Optional[pathlib._local.Path] = None) +``` + +Initialize telemetry collector. + +Args: + enabled: Whether telemetry collection is enabled + anonymous_id: Anonymous identifier for this installation + telemetry_file: Path to file where telemetry data is stored + +#### TelemetryCollector.flush + +```python +TelemetryCollector.flush(self) -> None +``` + +Write collected events to disk. + +#### TelemetryCollector.get_summary + +```python +TelemetryCollector.get_summary(self) -> Dict[str, Any] +``` + +Get a summary of collected telemetry events. + +Returns: + Dictionary containing telemetry summary + +#### TelemetryCollector.record_analysis_completed + +```python +TelemetryCollector.record_analysis_completed(self, files_analyzed: int, total_time_ms: float, issues_found: int, analyzers_used: List[str]) -> None +``` + +Record an analysis completion event. + +Args: + files_analyzed: Number of files analyzed + total_time_ms: Total analysis time in milliseconds + issues_found: Number of issues found + analyzers_used: List of analyzers that were used + +#### TelemetryCollector.record_error + +```python +TelemetryCollector.record_error(self, error_type: str, error_category: str, context: Optional[str] = None) -> None +``` + +Record an error event. + +Args: + error_type: Type of error (generic, no specific error messages) + error_category: Category of error (e.g., 'analysis', 'refactoring') + context: Optional context information (should not contain PII) + +#### TelemetryCollector.record_event + +```python +TelemetryCollector.record_event(self, event_type: str, data: Optional[Dict[str, Any]] = None) -> None +``` + +Record a telemetry event. + +Args: + event_type: Type of event (e.g., 'analysis_completed', 'refactoring_applied') + data: Additional event data (should not contain PII) + +#### TelemetryCollector.record_feature_usage + +```python +TelemetryCollector.record_feature_usage(self, feature_name: str, metadata: Optional[Dict[str, Any]] = None) -> None +``` + +Record a feature usage event. + +Args: + feature_name: Name of the feature used + metadata: Optional metadata about feature usage + +#### TelemetryCollector.record_refactoring_applied + +```python +TelemetryCollector.record_refactoring_applied(self, operation_type: str, files_affected: int, total_time_ms: float, success: bool) -> None +``` + +Record a refactoring operation event. + +Args: + operation_type: Type of refactoring operation + files_affected: Number of files affected + total_time_ms: Total refactoring time in milliseconds + success: Whether the refactoring succeeded + +### TelemetryConfig + +```python +TelemetryConfig(config_file: Optional[pathlib._local.Path] = None) +``` + +Configuration for telemetry system. + +#### TelemetryConfig.__init__ + +```python +TelemetryConfig.__init__(self, config_file: Optional[pathlib._local.Path] = None) +``` + +Initialize telemetry configuration. + +Args: + config_file: Path to telemetry configuration file + +#### TelemetryConfig.disable + +```python +TelemetryConfig.disable(self) -> None +``` + +Disable telemetry collection. + +#### TelemetryConfig.enable + +```python +TelemetryConfig.enable(self, anonymous_id: Optional[str] = None) -> None +``` + +Enable telemetry collection. + +Args: + anonymous_id: Optional anonymous identifier (generated if not provided) + +#### TelemetryConfig.save_config + +```python +TelemetryConfig.save_config(self) -> None +``` + +Save telemetry configuration to file. + +### TelemetryEvent + +```python +TelemetryEvent(event_type: str, timestamp: str = , session_id: str = , data: Dict[str, Any] = ) -> None +``` + +Represents a single telemetry event. + +#### TelemetryEvent.__init__ + +```python +TelemetryEvent.__init__(self, event_type: str, timestamp: str = , session_id: str = , data: Dict[str, Any] = ) -> None +``` + +Initialize self. See help(type(self)) for accurate signature. + +## Functions + +### disable_telemetry + +```python +disable_telemetry() -> None +``` + +Disable telemetry collection globally. + +### enable_telemetry + +```python +enable_telemetry() -> None +``` + +Enable telemetry collection globally. + +### get_telemetry_collector + +```python +get_telemetry_collector(enabled: Optional[bool] = None) -> refactron.core.telemetry.TelemetryCollector +``` + +Get the global telemetry collector instance. + +Args: + enabled: Override enabled status (uses config if None) + +Returns: + Global TelemetryCollector instance + + +--- + +# refactron.core.workspace + +Workspace management for Refactron CLI. + +This module handles the mapping between remote GitHub repositories and local +directory paths, enabling seamless navigation and context switching. + +## Classes + +### WorkspaceManager + +```python +WorkspaceManager(config_path: 'Optional[Path]' = None) -> 'None' +``` + +Manages workspace mappings between repositories and local paths. + +#### WorkspaceManager.__init__ + +```python +WorkspaceManager.__init__(self, config_path: 'Optional[Path]' = None) -> 'None' +``` + +Initialize the workspace manager. + +Args: + config_path: Path to the workspaces.json file (default: ~/.refactron/workspaces.json) + +#### WorkspaceManager.add_workspace + +```python +WorkspaceManager.add_workspace(self, mapping: 'WorkspaceMapping') -> 'None' +``` + +Add or update a workspace mapping. + +Args: + mapping: The workspace mapping to add + +#### WorkspaceManager.detect_repository + +```python +WorkspaceManager.detect_repository(self, directory: 'Optional[Path]' = None) -> 'Optional[str]' +``` + +Attempt to detect the GitHub repository from the .git config. + +Args: + directory: Directory to search (default: current directory) + +Returns: + The repository full name (e.g., "user/repo"), or None if not detected + +#### WorkspaceManager.get_workspace + +```python +WorkspaceManager.get_workspace(self, repo_name: 'str') -> 'Optional[WorkspaceMapping]' +``` + +Get a workspace mapping by repository name. + +Args: + repo_name: The repository name (e.g., "repo" or "user/repo") + +Returns: + The workspace mapping, or None if not found + +#### WorkspaceManager.get_workspace_by_path + +```python +WorkspaceManager.get_workspace_by_path(self, local_path: 'str') -> 'Optional[WorkspaceMapping]' +``` + +Get a workspace mapping by local path. + +Args: + local_path: The local directory path + +Returns: + The workspace mapping, or None if not found + +#### WorkspaceManager.list_workspaces + +```python +WorkspaceManager.list_workspaces(self) -> 'list[WorkspaceMapping]' +``` + +List all workspace mappings. + +Returns: + List of all workspace mappings + +#### WorkspaceManager.remove_workspace + +```python +WorkspaceManager.remove_workspace(self, repo_full_name: 'str') -> 'bool' +``` + +Remove a workspace mapping. + +Args: + repo_full_name: The full name of the repository + +Returns: + True if removed, False if not found + +### WorkspaceMapping + +```python +WorkspaceMapping(repo_id: 'int', repo_name: 'str', repo_full_name: 'str', local_path: 'str', connected_at: 'str') -> None +``` + +Represents a mapping between a remote repository and a local path. + +#### WorkspaceMapping.__init__ + +```python +WorkspaceMapping.__init__(self, repo_id: 'int', repo_name: 'str', repo_full_name: 'str', local_path: 'str', connected_at: 'str') -> None +``` + +Initialize self. See help(type(self)) for accurate signature. + +#### WorkspaceMapping.to_dict + +```python +WorkspaceMapping.to_dict(self) -> 'Dict[str, Any]' +``` + +Convert to dictionary for JSON serialization. + +## Functions + diff --git a/documentation/docs/api/llm.md b/documentation/docs/api/llm.md new file mode 100644 index 0000000..a57f9b6 --- /dev/null +++ b/documentation/docs/api/llm.md @@ -0,0 +1,290 @@ +# refactron.llm + +LLM integration for intelligent code suggestions using free cloud APIs. + +## Classes + +## Functions + + +--- + +# refactron.llm.backend_client + +Client for Refactron backend LLM proxy. + +## Classes + +### BackendLLMClient + +```python +BackendLLMClient(backend_url: 'Optional[str]' = None, model: 'str' = 'llama-3.3-70b-versatile', temperature: 'float' = 0.2, max_tokens: 'int' = 2000) +``` + +Client that proxies LLM requests through Refactron backend. + +#### BackendLLMClient.__init__ + +```python +BackendLLMClient.__init__(self, backend_url: 'Optional[str]' = None, model: 'str' = 'llama-3.3-70b-versatile', temperature: 'float' = 0.2, max_tokens: 'int' = 2000) +``` + +Initialize backend client. + +Args: + backend_url: Refactron backend URL + model: Model name to use + temperature: Sampling temperature + max_tokens: Maximum tokens to generate + +#### BackendLLMClient.check_health + +```python +BackendLLMClient.check_health(self) -> 'bool' +``` + +Check if the backend API is accessible. + +Returns: + True if API is accessible, False otherwise + +#### BackendLLMClient.generate + +```python +BackendLLMClient.generate(self, prompt: 'str', system: 'Optional[str]' = None, temperature: 'Optional[float]' = None, max_tokens: 'Optional[int]' = None) -> 'str' +``` + +Generate text using backend API. + +Args: + prompt: The user prompt + system: Optional system prompt + temperature: Override default temperature + max_tokens: Override default max tokens + +Returns: + Generated text + +## Functions + + +--- + +# refactron.llm.client + +Groq cloud API client for free LLM inference. + +## Classes + +### GroqClient + +```python +GroqClient(api_key: 'Optional[str]' = None, model: 'str' = 'llama-3.3-70b-versatile', temperature: 'float' = 0.2, max_tokens: 'int' = 2000) +``` + +Client for Groq cloud API (free LLM inference). + +#### GroqClient.__init__ + +```python +GroqClient.__init__(self, api_key: 'Optional[str]' = None, model: 'str' = 'llama-3.3-70b-versatile', temperature: 'float' = 0.2, max_tokens: 'int' = 2000) +``` + +Initialize Groq client. + +Args: + api_key: Groq API key (defaults to GROQ_API_KEY env var) + model: Model name to use + temperature: Sampling temperature + max_tokens: Maximum tokens to generate + +#### GroqClient.check_health + +```python +GroqClient.check_health(self) -> 'bool' +``` + +Check if the Groq API is accessible. + +Returns: + True if API is accessible, False otherwise + +#### GroqClient.generate + +```python +GroqClient.generate(self, prompt: 'str', system: 'Optional[str]' = None, temperature: 'Optional[float]' = None, max_tokens: 'Optional[int]' = None) -> 'str' +``` + +Generate text using Groq. + +Args: + prompt: The user prompt + system: Optional system prompt + temperature: Override default temperature + max_tokens: Override default max tokens + +Returns: + Generated text + +## Functions + + +--- + +# refactron.llm.models + +Data models for LLM integration. + +## Classes + +### RefactoringSuggestion + +```python +RefactoringSuggestion(issue: refactron.core.models.CodeIssue, original_code: str, context_files: List[str], proposed_code: str, explanation: str, reasoning: str, model_name: str, confidence_score: float, llm_confidence: float = 0.5, status: refactron.llm.models.SuggestionStatus = , safety_result: Optional[refactron.llm.models.SafetyCheckResult] = None, suggestion_id: str = , timestamp: float = ) -> None +``` + +A refactoring suggestion generated by the LLM. + +#### RefactoringSuggestion.__init__ + +```python +RefactoringSuggestion.__init__(self, issue: refactron.core.models.CodeIssue, original_code: str, context_files: List[str], proposed_code: str, explanation: str, reasoning: str, model_name: str, confidence_score: float, llm_confidence: float = 0.5, status: refactron.llm.models.SuggestionStatus = , safety_result: Optional[refactron.llm.models.SafetyCheckResult] = None, suggestion_id: str = , timestamp: float = ) -> None +``` + +Initialize self. See help(type(self)) for accurate signature. + +### SafetyCheckResult + +```python +SafetyCheckResult(passed: bool, score: float, issues: List[str], syntax_valid: bool = False, side_effects: List[str] = ) -> None +``` + +Result of a safety gate validation. + +#### SafetyCheckResult.__init__ + +```python +SafetyCheckResult.__init__(self, passed: bool, score: float, issues: List[str], syntax_valid: bool = False, side_effects: List[str] = ) -> None +``` + +Initialize self. See help(type(self)) for accurate signature. + +### SuggestionStatus + +```python +SuggestionStatus(*values) +``` + +Status of a refactoring suggestion. + +## Functions + + +--- + +# refactron.llm.orchestrator + +Orchestrator for LLM-based refactoring suggestions. + +## Classes + +### LLMOrchestrator + +```python +LLMOrchestrator(retriever: Optional[refactron.rag.retriever.ContextRetriever] = None, llm_client: Union[refactron.llm.client.GroqClient, refactron.llm.backend_client.BackendLLMClient, NoneType] = None, safety_gate: Optional[refactron.llm.safety.SafetyGate] = None) +``` + +Coordinates RAG context retrieval and LLM generation. + +#### LLMOrchestrator.__init__ + +```python +LLMOrchestrator.__init__(self, retriever: Optional[refactron.rag.retriever.ContextRetriever] = None, llm_client: Union[refactron.llm.client.GroqClient, refactron.llm.backend_client.BackendLLMClient, NoneType] = None, safety_gate: Optional[refactron.llm.safety.SafetyGate] = None) +``` + +Initialize self. See help(type(self)) for accurate signature. + +#### LLMOrchestrator.generate_documentation + +```python +LLMOrchestrator.generate_documentation(self, code: str, file_path: str = 'unknown') -> refactron.llm.models.RefactoringSuggestion +``` + +Generate documentation for the provided code. + +Args: + code: The code to document + file_path: Optional file path for context + +Returns: + A suggestion containing the documented code + +#### LLMOrchestrator.generate_suggestion + +```python +LLMOrchestrator.generate_suggestion(self, issue: refactron.core.models.CodeIssue, original_code: str) -> refactron.llm.models.RefactoringSuggestion +``` + +Generate a refactoring suggestion for a code issue. + +Args: + issue: The code issue to fix + original_code: The failing code snippet + +Returns: + A validated refactoring suggestion + +## Functions + + +--- + +# refactron.llm.prompts + +Prompt templates for LLM code suggestions. + +## Classes + +## Functions + + +--- + +# refactron.llm.safety + +Safety gate for validating LLM-generated code. + +## Classes + +### SafetyGate + +```python +SafetyGate(min_confidence: float = 0.7) +``` + +Validates code suggestions for safety and correctness. + +#### SafetyGate.__init__ + +```python +SafetyGate.__init__(self, min_confidence: float = 0.7) +``` + +Initialize self. See help(type(self)) for accurate signature. + +#### SafetyGate.validate + +```python +SafetyGate.validate(self, suggestion: refactron.llm.models.RefactoringSuggestion) -> refactron.llm.models.SafetyCheckResult +``` + +Validate a refactoring suggestion. + +Args: + suggestion: The suggestion to validate + +Returns: + Safety check result + +## Functions + diff --git a/documentation/docs/api/patterns.md b/documentation/docs/api/patterns.md new file mode 100644 index 0000000..3e4bccf --- /dev/null +++ b/documentation/docs/api/patterns.md @@ -0,0 +1,914 @@ +# refactron.patterns + +Pattern Learning System for Refactron. + +## Classes + +## Functions + + +--- + +# refactron.patterns.fingerprint + +Pattern fingerprinting for code pattern identification. + +## Classes + +### PatternFingerprinter + +```python +PatternFingerprinter() -> None +``` + +Generates fingerprints for code patterns using AST-based hashing. + +#### PatternFingerprinter.__init__ + +```python +PatternFingerprinter.__init__(self) -> None +``` + +Initialize the pattern fingerprinter. + +#### PatternFingerprinter.fingerprint_code + +```python +PatternFingerprinter.fingerprint_code(self, code_snippet: str) -> str +``` + +Generate hash fingerprint for a code snippet. + +Args: + code_snippet: Source code to fingerprint + +Returns: + SHA256 hash of the normalized code pattern + +#### PatternFingerprinter.fingerprint_issue_context + +```python +PatternFingerprinter.fingerprint_issue_context(self, issue: refactron.core.models.CodeIssue, source_code: str, context_lines: int = 3) -> str +``` + +Generate fingerprint for issue context. + +Args: + issue: CodeIssue to fingerprint + source_code: Full source code of the file + context_lines: Number of lines before/after to include (default: 3) + +Returns: + SHA256 hash of the normalized issue context pattern + +#### PatternFingerprinter.fingerprint_refactoring + +```python +PatternFingerprinter.fingerprint_refactoring(self, operation: refactron.core.models.RefactoringOperation) -> str +``` + +Generate fingerprint for refactoring operation. + +Args: + operation: RefactoringOperation to fingerprint + +Returns: + SHA256 hash of the normalized refactoring pattern + +## Functions + + +--- + +# refactron.patterns.learner + +Pattern learning engine that learns from feedback and refactoring history. + +## Classes + +### PatternLearner + +```python +PatternLearner(storage: refactron.patterns.storage.PatternStorage, fingerprinter: refactron.patterns.fingerprint.PatternFingerprinter) -> None +``` + +Learns patterns from feedback and refactoring history. + +#### PatternLearner.__init__ + +```python +PatternLearner.__init__(self, storage: refactron.patterns.storage.PatternStorage, fingerprinter: refactron.patterns.fingerprint.PatternFingerprinter) -> None +``` + +Initialize pattern learner. + +Args: + storage: PatternStorage instance for loading/saving patterns + fingerprinter: PatternFingerprinter for generating code fingerprints + +Raises: + ValueError: If storage or fingerprinter is None + +#### PatternLearner.batch_learn + +```python +PatternLearner.batch_learn(self, feedback_list: List[Tuple[refactron.core.models.RefactoringOperation, refactron.patterns.models.RefactoringFeedback]]) -> Dict[str, int] +``` + +Process multiple feedback records efficiently. + +Args: + feedback_list: List of (operation, feedback) tuples to process + +Returns: + Dictionary with statistics: \{'processed': int, 'created': int, + 'updated': int, 'failed': int\} + +Raises: + ValueError: If feedback_list is None or contains None values + +#### PatternLearner.learn_from_feedback + +```python +PatternLearner.learn_from_feedback(self, operation: refactron.core.models.RefactoringOperation, feedback: refactron.patterns.models.RefactoringFeedback) -> Optional[str] +``` + +Learn from a single feedback record. + +Args: + operation: RefactoringOperation that was evaluated + feedback: Feedback record containing developer decision + +Returns: + Pattern ID if pattern was created/updated, None if skipped + +Raises: + ValueError: If operation or feedback is None + RuntimeError: If pattern storage operations fail + +#### PatternLearner.update_pattern_metrics + +```python +PatternLearner.update_pattern_metrics(self, pattern_id: str, before_metrics: refactron.core.models.FileMetrics, after_metrics: refactron.core.models.FileMetrics) -> None +``` + +Update metrics for a pattern based on before/after comparison. + +Args: + pattern_id: ID of the pattern to update + before_metrics: FileMetrics before refactoring + after_metrics: FileMetrics after refactoring + +Raises: + ValueError: If pattern_id is empty or metrics are None + RuntimeError: If pattern not found or update fails + +## Functions + + +--- + +# refactron.patterns.learning_service + +Background service for pattern learning and maintenance. + +## Classes + +### LearningService + +```python +LearningService(storage: refactron.patterns.storage.PatternStorage, learner: Optional[refactron.patterns.learner.PatternLearner] = None) -> None +``` + +Background service for pattern learning and maintenance. + +#### LearningService.__init__ + +```python +LearningService.__init__(self, storage: refactron.patterns.storage.PatternStorage, learner: Optional[refactron.patterns.learner.PatternLearner] = None) -> None +``` + +Initialize learning service. + +Args: + storage: PatternStorage instance for data access + learner: PatternLearner instance (created if None) + +Raises: + ValueError: If storage is None + +#### LearningService.cleanup_old_patterns + +```python +LearningService.cleanup_old_patterns(self, days: int = 90) -> Dict[str, int] +``` + +Remove patterns that haven't been seen recently. + +Args: + days: Number of days of inactivity before removal (default: 90) + +Returns: + Dictionary with cleanup statistics: \{'removed': int, 'total': int\} + +Raises: + ValueError: If days is negative + RuntimeError: If cleanup fails + +#### LearningService.process_pending_feedback + +```python +LearningService.process_pending_feedback(self, limit: Optional[int] = None) -> Dict[str, int] +``` + +Process any pending feedback records that haven't been learned from yet. + +Args: + limit: Maximum number of feedback records to process (None = all) + +Returns: + Dictionary with processing statistics + +Raises: + RuntimeError: If processing fails critically + +#### LearningService.update_pattern_scores + +```python +LearningService.update_pattern_scores(self) -> Dict[str, int] +``` + +Recalculate scores for all patterns. + +This updates acceptance rates and benefit scores based on current feedback. + +Returns: + Dictionary with update statistics: \{'updated': int, 'total': int\} + +Raises: + RuntimeError: If update fails + +## Functions + + +--- + +# refactron.patterns.matcher + +Pattern matching for finding similar code patterns. + +## Classes + +### PatternMatcher + +```python +PatternMatcher(storage: refactron.patterns.storage.PatternStorage, cache_ttl_seconds: int = 300) +``` + +Matches code patterns against learned patterns with scoring. + +#### PatternMatcher.__init__ + +```python +PatternMatcher.__init__(self, storage: refactron.patterns.storage.PatternStorage, cache_ttl_seconds: int = 300) +``` + +Initialize pattern matcher. + +Args: + storage: PatternStorage instance for loading patterns + cache_ttl_seconds: Cache time-to-live in seconds (default: 300 seconds / 5 minutes) + +#### PatternMatcher.calculate_pattern_score + +```python +PatternMatcher.calculate_pattern_score(self, pattern: refactron.patterns.models.RefactoringPattern, project_profile: Optional[refactron.patterns.models.ProjectPatternProfile] = None) -> float +``` + +Calculate score for pattern suggestion. + +The scoring algorithm applies multiple bonuses multiplicatively: +- Project weight: 0.0-1.0 (disabled patterns get 0.0) +- Enabled pattern bonus: 1.2x (20% bonus) +- Recency bonus: up to 1.2x (20% bonus for patterns seen in last 30 days) +- Frequency bonus: up to 1.3x (30% bonus based on log scale of occurrences) +- Benefit bonus: up to 1.15x (15% bonus based on average_benefit_score) + +These bonuses can compound to exceed 1.0, but the final score is normalized +to the range [0.0, 1.0] using min/max clipping. + +Args: + pattern: Pattern to score + project_profile: Optional project-specific profile for weighting + +Returns: + Score between 0.0 and 1.0 (higher = better suggestion) + +#### PatternMatcher.clear_cache + +```python +PatternMatcher.clear_cache(self) -> None +``` + +Clear the pattern cache (force reload on next access). + +#### PatternMatcher.find_best_matches + +```python +PatternMatcher.find_best_matches(self, code_hash: str, operation_type: Optional[str] = None, project_profile: Optional[refactron.patterns.models.ProjectPatternProfile] = None, limit: int = 10) -> List[Tuple[refactron.patterns.models.RefactoringPattern, float]] +``` + +Find best matching patterns with scores. + +Args: + code_hash: Hash of the code pattern to match + operation_type: Optional operation type to filter by + project_profile: Optional project-specific profile for weighting + limit: Maximum number of results to return + +Returns: + List of tuples (pattern, score) sorted by score (highest first) + +#### PatternMatcher.find_similar_patterns + +```python +PatternMatcher.find_similar_patterns(self, code_hash: str, operation_type: Optional[str] = None, limit: Optional[int] = None) -> List[refactron.patterns.models.RefactoringPattern] +``` + +Find patterns similar to given code hash. + +Optimized with O(1) hash-based lookup instead of O(n) linear search. + +Args: + code_hash: Hash of the code pattern to match + operation_type: Optional operation type to filter by + limit: Optional maximum number of results to return + +Returns: + List of similar patterns, sorted by acceptance rate + +## Functions + + +--- + +# refactron.patterns.models + +Data models for Pattern Learning System. + +## Classes + +### PatternMetric + +```python +PatternMetric(pattern_id: str, complexity_reduction: float = 0.0, maintainability_improvement: float = 0.0, lines_of_code_change: int = 0, issue_resolution_count: int = 0, before_metrics: Dict[str, float] = , after_metrics: Dict[str, float] = , total_evaluations: int = 0) -> None +``` + +Metrics for evaluating pattern effectiveness. + +#### PatternMetric.__init__ + +```python +PatternMetric.__init__(self, pattern_id: str, complexity_reduction: float = 0.0, maintainability_improvement: float = 0.0, lines_of_code_change: int = 0, issue_resolution_count: int = 0, before_metrics: Dict[str, float] = , after_metrics: Dict[str, float] = , total_evaluations: int = 0) -> None +``` + +Initialize self. See help(type(self)) for accurate signature. + +#### PatternMetric.to_dict + +```python +PatternMetric.to_dict(self) -> Dict[str, Any] +``` + +Convert metrics to dictionary for serialization. + +#### PatternMetric.update + +```python +PatternMetric.update(self, complexity_reduction: float, maintainability_improvement: float, lines_of_code_change: int, issue_resolution_count: int, before_metrics: Dict[str, float], after_metrics: Dict[str, float]) -> 'PatternMetric' +``` + +Update metrics with new evaluation data (in-place mutation). + +Returns: + self to enable method chaining + +Note: + This method modifies the object in-place. The return value + is provided to enable method chaining. + +### ProjectPatternProfile + +```python +ProjectPatternProfile(project_id: str, project_path: pathlib._local.Path, enabled_patterns: Set[str] = , disabled_patterns: Set[str] = , pattern_weights: Dict[str, float] = , rule_thresholds: Dict[str, float] = , last_updated: datetime.datetime = , metadata: Dict[str, Any] = ) -> None +``` + +Project-specific pattern tuning and rules. + +#### ProjectPatternProfile.__init__ + +```python +ProjectPatternProfile.__init__(self, project_id: str, project_path: pathlib._local.Path, enabled_patterns: Set[str] = , disabled_patterns: Set[str] = , pattern_weights: Dict[str, float] = , rule_thresholds: Dict[str, float] = , last_updated: datetime.datetime = , metadata: Dict[str, Any] = ) -> None +``` + +Initialize self. See help(type(self)) for accurate signature. + +#### ProjectPatternProfile.disable_pattern + +```python +ProjectPatternProfile.disable_pattern(self, pattern_id: str) -> None +``` + +Disable a pattern for this project. + +#### ProjectPatternProfile.enable_pattern + +```python +ProjectPatternProfile.enable_pattern(self, pattern_id: str) -> None +``` + +Enable a pattern for this project. + +#### ProjectPatternProfile.get_pattern_weight + +```python +ProjectPatternProfile.get_pattern_weight(self, pattern_id: str, default: float = 1.0) -> float +``` + +Get weight for a pattern, returning default if not set. + +#### ProjectPatternProfile.is_pattern_enabled + +```python +ProjectPatternProfile.is_pattern_enabled(self, pattern_id: str) -> bool +``` + +Check if a pattern is enabled for this project. + +#### ProjectPatternProfile.set_pattern_weight + +```python +ProjectPatternProfile.set_pattern_weight(self, pattern_id: str, weight: float) -> None +``` + +Set custom weight for a pattern. + +#### ProjectPatternProfile.set_rule_threshold + +```python +ProjectPatternProfile.set_rule_threshold(self, rule_id: str, threshold: float) -> None +``` + +Set custom threshold for a rule. + +#### ProjectPatternProfile.to_dict + +```python +ProjectPatternProfile.to_dict(self) -> Dict[str, Any] +``` + +Convert profile to dictionary for serialization. + +### RefactoringFeedback + +```python +RefactoringFeedback(operation_id: str, operation_type: str, file_path: pathlib._local.Path, timestamp: datetime.datetime, action: str, reason: Optional[str] = None, code_pattern_hash: Optional[str] = None, project_path: Optional[pathlib._local.Path] = None, metadata: Dict[str, Any] = ) -> None +``` + +Tracks developer acceptance/rejection of refactoring suggestions. + +#### RefactoringFeedback.__init__ + +```python +RefactoringFeedback.__init__(self, operation_id: str, operation_type: str, file_path: pathlib._local.Path, timestamp: datetime.datetime, action: str, reason: Optional[str] = None, code_pattern_hash: Optional[str] = None, project_path: Optional[pathlib._local.Path] = None, metadata: Dict[str, Any] = ) -> None +``` + +Initialize self. See help(type(self)) for accurate signature. + +#### RefactoringFeedback.to_dict + +```python +RefactoringFeedback.to_dict(self) -> Dict[str, Any] +``` + +Convert feedback to dictionary for serialization. + +### RefactoringPattern + +```python +RefactoringPattern(pattern_id: str, pattern_hash: str, operation_type: str, code_snippet_before: str, code_snippet_after: str, acceptance_rate: float = 0.0, total_occurrences: int = 0, accepted_count: int = 0, rejected_count: int = 0, ignored_count: int = 0, average_benefit_score: float = 0.0, first_seen: datetime.datetime = , last_seen: datetime.datetime = , project_context: Dict[str, Any] = , metadata: Dict[str, Any] = ) -> None +``` + +Represents a learned pattern from successful refactorings. + +#### RefactoringPattern.__init__ + +```python +RefactoringPattern.__init__(self, pattern_id: str, pattern_hash: str, operation_type: str, code_snippet_before: str, code_snippet_after: str, acceptance_rate: float = 0.0, total_occurrences: int = 0, accepted_count: int = 0, rejected_count: int = 0, ignored_count: int = 0, average_benefit_score: float = 0.0, first_seen: datetime.datetime = , last_seen: datetime.datetime = , project_context: Dict[str, Any] = , metadata: Dict[str, Any] = ) -> None +``` + +Initialize self. See help(type(self)) for accurate signature. + +#### RefactoringPattern.calculate_benefit_score + +```python +RefactoringPattern.calculate_benefit_score(self, metric: Optional[refactron.patterns.models.PatternMetric] = None) -> float +``` + +Calculate overall benefit score for this pattern. + +#### RefactoringPattern.to_dict + +```python +RefactoringPattern.to_dict(self) -> Dict[str, Any] +``` + +Convert pattern to dictionary for serialization. + +#### RefactoringPattern.update_from_feedback + +```python +RefactoringPattern.update_from_feedback(self, action: str) -> None +``` + +Update pattern statistics from feedback. + +## Functions + + +--- + +# refactron.patterns.ranker + +Ranking engine for refactoring suggestions based on learned patterns. + +## Classes + +### RefactoringRanker + +```python +RefactoringRanker(storage: refactron.patterns.storage.PatternStorage, matcher: refactron.patterns.matcher.PatternMatcher, fingerprinter: refactron.patterns.fingerprint.PatternFingerprinter) +``` + +Ranks refactoring suggestions based on learned patterns and project context. + +#### RefactoringRanker.__init__ + +```python +RefactoringRanker.__init__(self, storage: refactron.patterns.storage.PatternStorage, matcher: refactron.patterns.matcher.PatternMatcher, fingerprinter: refactron.patterns.fingerprint.PatternFingerprinter) +``` + +Initialize refactoring ranker. + +Args: + storage: PatternStorage instance for accessing patterns and profiles + matcher: PatternMatcher instance for finding similar patterns + fingerprinter: PatternFingerprinter instance for generating code hashes + +#### RefactoringRanker.get_ranked_with_scores + +```python +RefactoringRanker.get_ranked_with_scores(self, operations: List[refactron.core.models.RefactoringOperation], project_path: Optional[pathlib._local.Path] = None) -> List[Tuple[refactron.core.models.RefactoringOperation, float, Optional[refactron.patterns.models.RefactoringPattern]]] +``` + +Get ranked operations with scores and matching patterns. + +Args: + operations: List of refactoring operations to rank + project_path: Optional project path for project-specific scoring + +Returns: + List of tuples (operation, score, best_matching_pattern) + sorted by score descending + +#### RefactoringRanker.get_top_suggestions + +```python +RefactoringRanker.get_top_suggestions(self, operations: List[refactron.core.models.RefactoringOperation], project_path: Optional[pathlib._local.Path] = None, top_n: int = 10) -> List[refactron.core.models.RefactoringOperation] +``` + +Get top N ranked suggestions. + +Args: + operations: List of refactoring operations to rank + project_path: Optional project path for project-specific scoring + top_n: Number of top suggestions to return (default: 10) + +Returns: + List of top N RefactoringOperation instances, sorted by score descending + +#### RefactoringRanker.rank_operations + +```python +RefactoringRanker.rank_operations(self, operations: List[refactron.core.models.RefactoringOperation], project_path: Optional[pathlib._local.Path] = None) -> List[Tuple[refactron.core.models.RefactoringOperation, float]] +``` + +Rank refactoring operations by predicted value based on learned patterns. + +Scoring factors: +1. Pattern acceptance rate (base score) +2. Project-specific weights (from ProjectPatternProfile) +3. Pattern recency (recent patterns weighted higher) +4. Pattern frequency (more occurrences = more reliable) +5. Metrics improvement (complexity reduction, maintainability) +6. Risk penalty (higher risk = lower score) + +Args: + operations: List of refactoring operations to rank + project_path: Optional project path for project-specific scoring + +Returns: + List of tuples (operation, score) sorted by score descending + Score range: 0.0 (lowest priority) to 1.0 (highest priority) + +## Functions + + +--- + +# refactron.patterns.storage + +Storage management for Pattern Learning System. + +## Classes + +### PatternStorage + +```python +PatternStorage(storage_dir: Optional[pathlib._local.Path] = None) +``` + +Manages persistent storage for pattern learning data. + +#### PatternStorage.__init__ + +```python +PatternStorage.__init__(self, storage_dir: Optional[pathlib._local.Path] = None) +``` + +Initialize pattern storage. + +Args: + storage_dir: Directory to store pattern data. If None, uses default: + - First checks project root (.refactron/patterns/) + - Falls back to ~/.refactron/patterns/ + +#### PatternStorage.clear_cache + +```python +PatternStorage.clear_cache(self) -> None +``` + +Clear in-memory caches (force reload from disk). + +#### PatternStorage.get_pattern + +```python +PatternStorage.get_pattern(self, pattern_id: str) -> Optional[refactron.patterns.models.RefactoringPattern] +``` + +Get a specific pattern by ID. + +Args: + pattern_id: Pattern ID to retrieve + +Returns: + Pattern if found, None otherwise + +#### PatternStorage.get_pattern_metric + +```python +PatternStorage.get_pattern_metric(self, pattern_id: str) -> Optional[refactron.patterns.models.PatternMetric] +``` + +Get metric for a specific pattern. + +Args: + pattern_id: Pattern ID to retrieve metric for + +Returns: + Metric if found, None otherwise + +#### PatternStorage.get_project_profile + +```python +PatternStorage.get_project_profile(self, project_path: pathlib._local.Path) -> refactron.patterns.models.ProjectPatternProfile +``` + +Get or create project profile for a project. + +Args: + project_path: Path to project root + +Returns: + Project profile (created if doesn't exist) + +#### PatternStorage.load_feedback + +```python +PatternStorage.load_feedback(self, pattern_id: Optional[str] = None, project_path: Optional[pathlib._local.Path] = None) -> List[refactron.patterns.models.RefactoringFeedback] +``` + +Load feedback records from storage. + +Note: For large feedback datasets, this filters in Python after loading +all records. Consider implementing pagination or separate indices if +performance becomes an issue with very large datasets. + +Args: + pattern_id: Optional pattern ID to filter by + project_path: Optional project path to filter by + +Returns: + List of feedback records matching filters + +#### PatternStorage.load_pattern_metrics + +```python +PatternStorage.load_pattern_metrics(self) -> Dict[str, refactron.patterns.models.PatternMetric] +``` + +Load all pattern metrics from storage. + +Returns: + Dictionary mapping pattern_id to PatternMetric + Note: Returns a copy to prevent external modifications to cache. + +#### PatternStorage.load_patterns + +```python +PatternStorage.load_patterns(self) -> Dict[str, refactron.patterns.models.RefactoringPattern] +``` + +Load all patterns from storage. + +Returns: + Dictionary mapping pattern_id to RefactoringPattern + Note: Returns a copy to prevent external modifications to cache. + +#### PatternStorage.load_project_profiles + +```python +PatternStorage.load_project_profiles(self) -> Dict[str, refactron.patterns.models.ProjectPatternProfile] +``` + +Load all project profiles from storage. + +Returns: + Dictionary mapping project_id to ProjectPatternProfile + Note: Returns a copy to prevent external modifications to cache. + +#### PatternStorage.replace_patterns + +```python +PatternStorage.replace_patterns(self, patterns: Dict[str, refactron.patterns.models.RefactoringPattern]) -> None +``` + +Replace all patterns in storage with the provided dictionary. + +This method completely replaces the pattern storage, useful for cleanup +operations where patterns need to be removed. + +Args: + patterns: Dictionary mapping pattern_id to RefactoringPattern + +#### PatternStorage.save_feedback + +```python +PatternStorage.save_feedback(self, feedback: refactron.patterns.models.RefactoringFeedback) -> None +``` + +Save feedback record to storage. + +Args: + feedback: Feedback record to save + +#### PatternStorage.save_pattern + +```python +PatternStorage.save_pattern(self, pattern: refactron.patterns.models.RefactoringPattern) -> None +``` + +Save pattern to storage. + +Args: + pattern: Pattern to save + +#### PatternStorage.save_pattern_metric + +```python +PatternStorage.save_pattern_metric(self, metric: refactron.patterns.models.PatternMetric) -> None +``` + +Save pattern metric to storage. + +Args: + metric: Metric to save + +#### PatternStorage.save_project_profile + +```python +PatternStorage.save_project_profile(self, profile: refactron.patterns.models.ProjectPatternProfile) -> None +``` + +Save project profile to storage. + +Args: + profile: Profile to save + +#### PatternStorage.update_pattern_stats + +```python +PatternStorage.update_pattern_stats(self, pattern_id: str, action: str) -> None +``` + +Update pattern statistics from feedback. + +Args: + pattern_id: Pattern ID to update + action: Action taken ("accepted", "rejected", "ignored") + +## Functions + + +--- + +# refactron.patterns.tuner + +Project-specific rule tuning based on pattern learning history. + +## Classes + +### PatternStats + +```python +PatternStats(pattern_id: 'str', pattern_hash: 'str', operation_type: 'str', accepted_count: 'int' = 0, rejected_count: 'int' = 0, ignored_count: 'int' = 0) -> None +``` + +Aggregated statistics for a pattern within a specific project. + +#### PatternStats.__init__ + +```python +PatternStats.__init__(self, pattern_id: 'str', pattern_hash: 'str', operation_type: 'str', accepted_count: 'int' = 0, rejected_count: 'int' = 0, ignored_count: 'int' = 0) -> None +``` + +Initialize self. See help(type(self)) for accurate signature. + +### RuleTuner + +```python +RuleTuner(storage: 'PatternStorage') -> 'None' +``` + +Tunes rules based on project-specific pattern history. + +#### RuleTuner.__init__ + +```python +RuleTuner.__init__(self, storage: 'PatternStorage') -> 'None' +``` + +Initialize self. See help(type(self)) for accurate signature. + +#### RuleTuner.analyze_project_patterns + +```python +RuleTuner.analyze_project_patterns(self, project_path: 'Path') -> 'Dict[str, Any]' +``` + +Analyze patterns for a specific project. + +Returns a dictionary with: +- project_id +- project_path +- patterns: list of per-pattern statistics combining project and global data + +#### RuleTuner.apply_tuning + +```python +RuleTuner.apply_tuning(self, project_path: 'Path', recommendations: 'Dict[str, Any]') -> 'ProjectPatternProfile' +``` + +Apply tuning recommendations to project profile. + +recommendations is expected to have keys: +- "to_disable": List[str] of pattern_ids to disable +- "to_enable": List[str] of pattern_ids to enable +- "weights": Dict[str, float] of pattern_id -> weight + +#### RuleTuner.generate_recommendations + +```python +RuleTuner.generate_recommendations(self, project_path: 'Path') -> 'Dict[str, Any]' +``` + +Generate rule tuning recommendations for a project. + +Heuristics: +- Disable patterns with sufficient feedback and low acceptance. +- Enable patterns with high acceptance. +- Adjust pattern weights based on project acceptance. + +## Functions + diff --git a/documentation/docs/api/rag.md b/documentation/docs/api/rag.md new file mode 100644 index 0000000..930892e --- /dev/null +++ b/documentation/docs/api/rag.md @@ -0,0 +1,351 @@ +# refactron.rag + +RAG (Retrieval-Augmented Generation) infrastructure for code indexing and retrieval. + +## Classes + +## Functions + + +--- + +# refactron.rag.chunker + +Code chunking strategies for RAG indexing. + +## Classes + +### CodeChunk + +```python +CodeChunk(content: 'str', chunk_type: 'str', file_path: 'str', line_range: 'Tuple[int, int]', name: 'str', dependencies: 'List[str]', metadata: 'Dict[str, Any]') -> None +``` + +Represents a semantic chunk of code. + +#### CodeChunk.__init__ + +```python +CodeChunk.__init__(self, content: 'str', chunk_type: 'str', file_path: 'str', line_range: 'Tuple[int, int]', name: 'str', dependencies: 'List[str]', metadata: 'Dict[str, Any]') -> None +``` + +Initialize self. See help(type(self)) for accurate signature. + +### CodeChunker + +```python +CodeChunker(parser: 'CodeParser') +``` + +Chunks parsed code into semantic units for embedding. + +#### CodeChunker.__init__ + +```python +CodeChunker.__init__(self, parser: 'CodeParser') +``` + +Initialize the chunker. + +Args: + parser: CodeParser instance for parsing files + +#### CodeChunker.chunk_file + +```python +CodeChunker.chunk_file(self, file_path: 'Path') -> 'List[CodeChunk]' +``` + +Chunk a file into semantic units. + +Args: + file_path: Path to the Python file + +Returns: + List of code chunks + +## Functions + + +--- + +# refactron.rag.indexer + +Vector index management using ChromaDB. + +## Classes + +### IndexStats + +```python +IndexStats(total_chunks: 'int', total_files: 'int', chunk_types: 'dict', embedding_model: 'str', index_path: 'str') -> None +``` + +Statistics about the RAG index. + +#### IndexStats.__init__ + +```python +IndexStats.__init__(self, total_chunks: 'int', total_files: 'int', chunk_types: 'dict', embedding_model: 'str', index_path: 'str') -> None +``` + +Initialize self. See help(type(self)) for accurate signature. + +### RAGIndexer + +```python +RAGIndexer(workspace_path: 'Path', embedding_model: 'str' = 'all-MiniLM-L6-v2', collection_name: 'str' = 'code_chunks', llm_client: 'Optional[GroqClient]' = None) +``` + +Manages code indexing for RAG retrieval. + +#### RAGIndexer.__init__ + +```python +RAGIndexer.__init__(self, workspace_path: 'Path', embedding_model: 'str' = 'all-MiniLM-L6-v2', collection_name: 'str' = 'code_chunks', llm_client: 'Optional[GroqClient]' = None) +``` + +Initialize the RAG indexer. + +Args: + workspace_path: Path to the workspace directory + embedding_model: Name of the sentence-transformers model + collection_name: Name of the ChromaDB collection + llm_client: Optional LLM client for code summarization + +#### RAGIndexer.add_chunks + +```python +RAGIndexer.add_chunks(self, chunks: 'List[CodeChunk]') -> 'None' +``` + +Add code chunks to the vector index. + +Args: + chunks: List of code chunks to add + +#### RAGIndexer.get_stats + +```python +RAGIndexer.get_stats(self) -> 'IndexStats' +``` + +Get statistics about the current index. + +Returns: + Index statistics + +#### RAGIndexer.index_repository + +```python +RAGIndexer.index_repository(self, repo_path: 'Optional[Path]' = None, summarize: 'bool' = False) -> 'IndexStats' +``` + +Index an entire repository. + +Args: + repo_path: Path to repository (defaults to workspace_path) + summarize: Whether to use AI to summarize code for better retrieval + +Returns: + Statistics about the indexed content + +## Functions + + +--- + +# refactron.rag.parser + +Code parser using tree-sitter for AST-aware code analysis. + +## Classes + +### CodeParser + +```python +CodeParser() +``` + +AST-aware code parser using tree-sitter. + +#### CodeParser.__init__ + +```python +CodeParser.__init__(self) +``` + +Initialize the parser. + +#### CodeParser.parse_file + +```python +CodeParser.parse_file(self, file_path: 'Path') -> 'ParsedFile' +``` + +Parse a Python file. + +Args: + file_path: Path to the Python file + +Returns: + ParsedFile object containing all parsed elements + +### ParsedClass + +```python +ParsedClass(name: 'str', body: 'str', docstring: 'Optional[str]', line_range: 'Tuple[int, int]', methods: 'List[ParsedFunction]') -> None +``` + +Represents a parsed class. + +#### ParsedClass.__init__ + +```python +ParsedClass.__init__(self, name: 'str', body: 'str', docstring: 'Optional[str]', line_range: 'Tuple[int, int]', methods: 'List[ParsedFunction]') -> None +``` + +Initialize self. See help(type(self)) for accurate signature. + +### ParsedFile + +```python +ParsedFile(file_path: 'str', imports: 'List[str]', functions: 'List[ParsedFunction]', classes: 'List[ParsedClass]', module_docstring: 'Optional[str]') -> None +``` + +Represents a parsed Python file. + +#### ParsedFile.__init__ + +```python +ParsedFile.__init__(self, file_path: 'str', imports: 'List[str]', functions: 'List[ParsedFunction]', classes: 'List[ParsedClass]', module_docstring: 'Optional[str]') -> None +``` + +Initialize self. See help(type(self)) for accurate signature. + +### ParsedFunction + +```python +ParsedFunction(name: 'str', body: 'str', docstring: 'Optional[str]', line_range: 'Tuple[int, int]', params: 'List[str]') -> None +``` + +Represents a parsed function. + +#### ParsedFunction.__init__ + +```python +ParsedFunction.__init__(self, name: 'str', body: 'str', docstring: 'Optional[str]', line_range: 'Tuple[int, int]', params: 'List[str]') -> None +``` + +Initialize self. See help(type(self)) for accurate signature. + +## Functions + + +--- + +# refactron.rag.retriever + +Context retrieval from the RAG index. + +## Classes + +### ContextRetriever + +```python +ContextRetriever(workspace_path: 'Path', embedding_model: 'str' = 'all-MiniLM-L6-v2', collection_name: 'str' = 'code_chunks') +``` + +Retrieves relevant code context from the RAG index. + +#### ContextRetriever.__init__ + +```python +ContextRetriever.__init__(self, workspace_path: 'Path', embedding_model: 'str' = 'all-MiniLM-L6-v2', collection_name: 'str' = 'code_chunks') +``` + +Initialize the context retriever. + +Args: + workspace_path: Path to the workspace directory + embedding_model: Name of the sentence-transformers model + collection_name: Name of the ChromaDB collection + +#### ContextRetriever.retrieve_by_file + +```python +ContextRetriever.retrieve_by_file(self, file_path: 'str') -> 'List[RetrievedContext]' +``` + +Retrieve all chunks from a specific file. + +Args: + file_path: Path to the file + +Returns: + List of all chunks from the file + +#### ContextRetriever.retrieve_classes + +```python +ContextRetriever.retrieve_classes(self, query: 'str', top_k: 'int' = 5) -> 'List[RetrievedContext]' +``` + +Retrieve similar classes. + +Args: + query: The search query + top_k: Number of results to return + +Returns: + List of similar class chunks + +#### ContextRetriever.retrieve_functions + +```python +ContextRetriever.retrieve_functions(self, query: 'str', top_k: 'int' = 5) -> 'List[RetrievedContext]' +``` + +Retrieve similar functions. + +Args: + query: The search query + top_k: Number of results to return + +Returns: + List of similar function chunks + +#### ContextRetriever.retrieve_similar + +```python +ContextRetriever.retrieve_similar(self, query: 'str', top_k: 'int' = 5, chunk_type: 'Optional[str]' = None) -> 'List[RetrievedContext]' +``` + +Retrieve similar code chunks. + +Args: + query: The search query + top_k: Number of results to return + chunk_type: Optional filter by chunk type (function/class/module) + +Returns: + List of retrieved contexts sorted by relevance + +### RetrievedContext + +```python +RetrievedContext(content: 'str', file_path: 'str', chunk_type: 'str', name: 'str', line_range: 'tuple', distance: 'float', metadata: 'dict') -> None +``` + +Represents a retrieved code context. + +#### RetrievedContext.__init__ + +```python +RetrievedContext.__init__(self, content: 'str', file_path: 'str', chunk_type: 'str', name: 'str', line_range: 'tuple', distance: 'float', metadata: 'dict') -> None +``` + +Initialize self. See help(type(self)) for accurate signature. + +## Functions + diff --git a/documentation/docs/api/refactorers.md b/documentation/docs/api/refactorers.md new file mode 100644 index 0000000..696ca5d --- /dev/null +++ b/documentation/docs/api/refactorers.md @@ -0,0 +1,278 @@ +# refactron.refactorers + +Refactorers for automated code transformations. + +## Classes + +## Functions + + +--- + +# refactron.refactorers.add_docstring_refactorer + +Refactorer for adding docstrings to functions and classes. + +## Classes + +### AddDocstringRefactorer + +```python +AddDocstringRefactorer(config: refactron.core.config.RefactronConfig) +``` + +Suggests adding docstrings to undocumented functions and classes. + +#### AddDocstringRefactorer.__init__ + +```python +AddDocstringRefactorer.__init__(self, config: refactron.core.config.RefactronConfig) +``` + +Initialize the refactorer. + +Args: + config: Refactron configuration + +#### AddDocstringRefactorer.refactor + +```python +AddDocstringRefactorer.refactor(self, file_path: pathlib._local.Path, source_code: str) -> List[refactron.core.models.RefactoringOperation] +``` + +Find functions/classes without docstrings and suggest adding them. + +Args: + file_path: Path to the file + source_code: Source code content + +Returns: + List of add docstring operations + +## Functions + + +--- + +# refactron.refactorers.base_refactorer + +Base refactorer class. + +## Classes + +### BaseRefactorer + +```python +BaseRefactorer(config: refactron.core.config.RefactronConfig) +``` + +Base class for all refactorers. + +#### BaseRefactorer.__init__ + +```python +BaseRefactorer.__init__(self, config: refactron.core.config.RefactronConfig) +``` + +Initialize the refactorer. + +Args: + config: Refactron configuration + +#### BaseRefactorer.refactor + +```python +BaseRefactorer.refactor(self, file_path: pathlib._local.Path, source_code: str) -> List[refactron.core.models.RefactoringOperation] +``` + +Analyze source code and return refactoring operations. + +Args: + file_path: Path to the file being refactored + source_code: Source code content + +Returns: + List of refactoring operations + +## Functions + + +--- + +# refactron.refactorers.extract_method_refactorer + +Refactorer for extracting methods from complex functions. + +## Classes + +### ExtractMethodRefactorer + +```python +ExtractMethodRefactorer(config: refactron.core.config.RefactronConfig) +``` + +Suggests extracting methods from overly complex functions. + +#### ExtractMethodRefactorer.__init__ + +```python +ExtractMethodRefactorer.__init__(self, config: refactron.core.config.RefactronConfig) +``` + +Initialize the refactorer. + +Args: + config: Refactron configuration + +#### ExtractMethodRefactorer.refactor + +```python +ExtractMethodRefactorer.refactor(self, file_path: pathlib._local.Path, source_code: str) -> List[refactron.core.models.RefactoringOperation] +``` + +Find opportunities to extract methods. + +Args: + file_path: Path to the file + source_code: Source code content + +Returns: + List of extract method operations + +## Functions + + +--- + +# refactron.refactorers.magic_number_refactorer + +Refactorer for extracting magic numbers into named constants. + +## Classes + +### MagicNumberRefactorer + +```python +MagicNumberRefactorer(config: refactron.core.config.RefactronConfig) +``` + +Suggests extracting magic numbers into named constants. + +#### MagicNumberRefactorer.__init__ + +```python +MagicNumberRefactorer.__init__(self, config: refactron.core.config.RefactronConfig) +``` + +Initialize the refactorer. + +Args: + config: Refactron configuration + +#### MagicNumberRefactorer.refactor + +```python +MagicNumberRefactorer.refactor(self, file_path: pathlib._local.Path, source_code: str) -> List[refactron.core.models.RefactoringOperation] +``` + +Find magic numbers and suggest extracting them to constants. + +Args: + file_path: Path to the file + source_code: Source code content + +Returns: + List of extract constant operations + +## Functions + + +--- + +# refactron.refactorers.reduce_parameters_refactorer + +Refactorer for reducing function parameters using configuration objects. + +## Classes + +### ReduceParametersRefactorer + +```python +ReduceParametersRefactorer(config: refactron.core.config.RefactronConfig) +``` + +Suggests using configuration objects for functions with many parameters. + +#### ReduceParametersRefactorer.__init__ + +```python +ReduceParametersRefactorer.__init__(self, config: refactron.core.config.RefactronConfig) +``` + +Initialize the refactorer. + +Args: + config: Refactron configuration + +#### ReduceParametersRefactorer.refactor + +```python +ReduceParametersRefactorer.refactor(self, file_path: pathlib._local.Path, source_code: str) -> List[refactron.core.models.RefactoringOperation] +``` + +Find functions with too many parameters and suggest config objects. + +Args: + file_path: Path to the file + source_code: Source code content + +Returns: + List of parameter reduction operations + +## Functions + + +--- + +# refactron.refactorers.simplify_conditionals_refactorer + +Refactorer for simplifying complex conditional statements. + +## Classes + +### SimplifyConditionalsRefactorer + +```python +SimplifyConditionalsRefactorer(config: refactron.core.config.RefactronConfig) +``` + +Suggests simplifying deeply nested conditionals. + +#### SimplifyConditionalsRefactorer.__init__ + +```python +SimplifyConditionalsRefactorer.__init__(self, config: refactron.core.config.RefactronConfig) +``` + +Initialize the refactorer. + +Args: + config: Refactron configuration + +#### SimplifyConditionalsRefactorer.refactor + +```python +SimplifyConditionalsRefactorer.refactor(self, file_path: pathlib._local.Path, source_code: str) -> List[refactron.core.models.RefactoringOperation] +``` + +Find deeply nested conditionals and suggest simplifications. + +Args: + file_path: Path to the file + source_code: Source code content + +Returns: + List of simplification operations + +## Functions + diff --git a/documentation/docs/images/Refactron-logo-TM.png b/documentation/docs/images/Refactron-logo-TM.png new file mode 100644 index 0000000000000000000000000000000000000000..94adc70257da68f42c4219c352f22bf5cc72bfdb GIT binary patch literal 45976 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 literal 0 HcmV?d00001 diff --git a/documentation/docs/images/Screenshot 2026-01-29 at 17.45.00.png b/documentation/docs/images/Screenshot 2026-01-29 at 17.45.00.png new file mode 100644 index 0000000000000000000000000000000000000000..d6252b59f93ec6d8da11cb7c2927f7c97dd880a7 GIT binary patch literal 578533 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

  • r2D~ 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
    vwP~ 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 KpuUlPZ1SiwnqH<%g3$%&*{zyhurr;G5Vtnrh&T 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 literal 0 HcmV?d00001 diff --git a/docs/v1.0.13_RELEASE_GUIDE.md b/documentation/docs/v1.0.13_RELEASE_GUIDE.md similarity index 100% rename from docs/v1.0.13_RELEASE_GUIDE.md rename to documentation/docs/v1.0.13_RELEASE_GUIDE.md diff --git a/documentation/docs/v1.0.15_DETAILED_CHANGELOG.md b/documentation/docs/v1.0.15_DETAILED_CHANGELOG.md new file mode 100644 index 0000000..81d75c2 --- /dev/null +++ b/documentation/docs/v1.0.15_DETAILED_CHANGELOG.md @@ -0,0 +1,76 @@ +# Refactron v1.0.15 - Detailed Changelog & Architecture Update + +## 🚀 Major Architectural Change: CLI Modularization + +Refactron v1.0.15 introduces a significant architectural improvement to the Command-Line Interface (CLI). The previously monolithic `cli.py` (over 3,500 lines) has been refactored into a modular package structure `refactron.cli`. + +### Motivation +- **Maintainability**: The single file had become unwieldy, making navigation and updates difficult. +- **Scalability**: As new commands (RAG, Repo, AI) were added, the file size exploded. +- **Separation of Concerns**: UI logic, authentication, and business logic were intertwined. + +### New CLI Structure (`refactron/cli/`) +The CLI is now organized into logical modules based on functionality: + +| Module | Description | Commands | +|--------|-------------|----------| +| `main.py` | Entry point, global options, and subcommand registration. | `main` (group) | +| `auth.py` | Authentication and telemetry management. | `login`, `logout`, `auth`, `telemetry` | +| `analysis.py` | Core code analysis and reporting. | `analyze`, `report`, `metrics`, `serve-metrics`, `suggest` | +| `refactor.py` | Refactoring operations and automation. | `refactor`, `autofix`, `rollback`, `document` | +| `patterns.py` | Pattern learning and rule tuning. | `patterns` (group) | +| `repo.py` | Repository and workspace management. | `repo` (group) | +| `rag.py` | RAG (Retrieval-Augmented Generation) index management. | `rag` (group) | +| `cicd.py` | CI/CD template generation and feedback. | `generate-cicd`, `feedback`, `init` | +| `ui.py` | Shared Rich-based UI components (Theme, Console, Banners). | N/A (Internal) | +| `utils.py` | Shared utilities (Logging, Config loading, Validation). | N/A (Internal) | + +### Backward Compatibility +- The entry point `refactron.cli:main` remains valid (updated in `pyproject.toml` if necessary, though the package structure supports `__init__.py` exposing `main`). +- All command arguments and flags remain unchanged for end-users. + +--- + +## ✨ New Features (v1.0.15) + +### 🤖 Semantic Code Intelligence (AI & RAG) +Refactron now leverages LLMs (Llama 3 via Groq) and RAG (ChromaDB) to understand your code's intent. + +- **`refactron suggest `**: Generates context-aware refactoring proposals. It analyzes the code using RAG to understand dependencies and proposes safe, idiomatic improvements. +- **`refactron document `**: Automatically generates comprehensive Google-style docstrings for functions and classes, inferring context from usage. +- **Background Indexing**: Connecting a repository automatically triggers a background process to index your codebase for RAG retrieval. + +### 📂 Repository & Workspace Management +Bridge the gap between local development and cloud capabilities. + +- **`refactron repo connect `**: Connects a GitHub repository. If the repo is not found locally, it clones it to `~/.refactron/workspaces/`. +- **`refactron repo list`**: Displays all connected repositories and their status. +- **Workspaces**: Manages mapping between remote repositories and local directories. + +### 📊 Observability & Metrics +Deep insights into Refactron's performance and usage. + +- **`refactron metrics`**: Shows detailed statistics: + - Analysis time per file. + - Success/Failure rates. + - Hit counts for specific analyzers and refactorers. +- **`refactron serve-metrics`**: Starts a Prometheus-compatible HTTP server (default: port 9090) to export metrics to your monitoring stack. +- **Telemetry**: Optional, anonymous usage tracking to help improve the tool (manage with `refactron telemetry`). + +### 🚀 CI/CD Integration +- **`refactron generate-cicd`**: Instantly generate workflow configuration files. + - Supports: **GitHub Actions**, **GitLab CI**, and **Pre-commit** hooks. + - Configurable failure thresholds (fail on critical issues, etc.). + +### 🛠️ Improved Developer Experience +- **Interactive Dashboard**: Running `refactron` without arguments now launches an interactive dashboard. +- **Interactive File Selector**: When running commands like `analyze` without a target, an interactive file picker helps you select files from your workspace. +- **Styled Output**: Enhanced Rich-based output with a premium theme (Indigo/Mint/Amber palette). + +--- + +## 🔒 Security & Reliability + +- **Security Fix**: Resolved a potential URL injection vulnerability in workspace management by implementing strict URL parsing and validation. +- **Compatibility**: Restored full Python 3.8 compatibility for RAG parsing libraries. +- **Dependencies**: Added `groq` and `chromadb` as core dependencies for AI features. diff --git a/documentation/docs/v1.0.15_RELEASE_NOTES.md b/documentation/docs/v1.0.15_RELEASE_NOTES.md new file mode 100644 index 0000000..3f9528b --- /dev/null +++ b/documentation/docs/v1.0.15_RELEASE_NOTES.md @@ -0,0 +1,47 @@ +# Refactron v1.0.15 Release Notes + +## Overview +Refactron v1.0.15 is a major release introducing semantic code intelligence through **LLM Orchestration** and **Retrieval-Augmented Generation (RAG)**. This version enables Refactron to understand the intent of your code and provide highly accurate, context-aware suggestions and documentation. + +## New Features + +### 📂 Repository Management (`refactron repo`) +Bridge the gap between your local code and the cloud. +- **`refactron repo connect `**: Links a GitHub repository to a local directory or auto-clones it. +- **Auto-Indexing**: Connecting a repo triggers a background RAG indexing process so Refactron is ready for AI suggestions immediately. +- **Workspaces**: Manages local mappings in `~/.refactron/workspaces/`. + +### 🤖 AI-Powered Commands +- **`refactron suggest [path]`**: Contextual refactoring proposals that understand your project's logic. +- **`refactron document [path]`**: Automated Google-style docstrings for your entire codebase. +- **Safety Gate**: Built-in syntax and safety verification for all AI-generated code. +- **Feedback Loop**: Use `refactron feedback` to rate AI suggestions and improve pattern accuracy. + +### 📊 Observability & Metrics +- **`refactron metrics`**: Real-time statistics on analysis performance and analyzer "hits". +- **`refactron serve-metrics`**: Spin up a Prometheus-compatible metrics server. +- **Telemetry**: Opt-in anonymous usage data helps us improve Refactron for everyone. + +### 🚀 CI/CD Integration +- **`refactron ci `**: Instantly generate workflow files for GitHub Actions, GitLab CI, or pre-commit hooks. +- **Automated Gates**: Configure builds to fail on critical code debt or security issues. + +### ✨ Improved CLI Experience +- **Stylized Dashboard**: A new interactive startup screen. +- **Interactive Selectors**: Navigate and select files/folders directly within the CLI. + +## Security Fixes +- **Critical Fix**: Resolved an incomplete URL sanitization vulnerability in workspace management. All URL hostname checks now use robust parsing to prevent injection attacks. + +## Compatibility Improvements +- **Python 3.8 Support**: Restored full compatibility for older Python 3 environments, particularly for RAG parsing and fingerprinting. +- **Tree-sitter API**: Adaptive layer for stability across different Tree-sitter versions. + +--- + +**Get Started with v1.0.15:** +```bash +pip install refactron --upgrade +refactron rag index +refactron suggest myfile.py +```

    Bej@hgN%a1|5 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%0D1=TFco0VI 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%0DHX5>ql%Kd76>oU39$r#>3&Uqb_0ocv4S_DXzUS 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