code2llm 0.5.121__tar.gz → 0.5.123__tar.gz

{code2llm-0.5.121 → code2llm-0.5.123}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code2llm
-Version: 0.5.121
+Version: 0.5.123
 Summary: High-performance Python code flow analysis with optimized TOON format - CFG, DFG, call graphs, and intelligent code queries
 Home-page: https://github.com/wronai/stts
 Author: STTS Project
@@ -67,7 +67,7 @@ Dynamic: requires-python
 
 ## AI Cost Tracking
 
-![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.5.121-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
+![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.5.123-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
 ![AI Cost](https://img.shields.io/badge/AI%20Cost-$7.50-orange) ![Human Time](https://img.shields.io/badge/Human%20Time-57.3h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
 
 - 🤖 **LLM usage:** $7.5000 (166 commits)

{code2llm-0.5.121 → code2llm-0.5.123}/README.md

@@ -3,7 +3,7 @@
 
 ## AI Cost Tracking
 
-![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.5.121-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
+![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.5.123-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
 ![AI Cost](https://img.shields.io/badge/AI%20Cost-$7.50-orange) ![Human Time](https://img.shields.io/badge/Human%20Time-57.3h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
 
 - 🤖 **LLM usage:** $7.5000 (166 commits)

{code2llm-0.5.121 → code2llm-0.5.123}/code2llm/__init__.py

@@ -8,7 +8,7 @@ Includes NLP Processing Pipeline for query normalization, intent matching,
 and entity resolution with multilingual support.
 """
 
-__version__ = "0.5.121"
+__version__ = "0.5.123"
 __author__ = "STTS Project"
 
 # Core analysis components (lightweight, always needed)

{code2llm-0.5.121 → code2llm-0.5.123}/code2llm/cli_commands.py

@@ -6,6 +6,7 @@ from pathlib import Path
 from typing import Optional
 
 from .cli_exports import _run_report
+from .core.config import DEFAULT_CACHE_MAX_AGE_DAYS, KB
 
 
 def handle_special_commands() -> Optional[int]:
@@ -39,18 +40,18 @@ def handle_cache_command(args_list) -> int:
     parser.add_argument('action', choices=['status', 'clear', 'gc'], help='Cache action')
     parser.add_argument('--all', action='store_true', dest='all_projects',
                         help='Apply to all cached projects (clear only)')
-    parser.add_argument('--max-age', type=int, default=30, metavar='DAYS',
-                        help='Max age in days for gc (default: 30)')
+    parser.add_argument('--max-age', type=int, default=DEFAULT_CACHE_MAX_AGE_DAYS, metavar='DAYS',
+                        help=f'Max age in days for gc (default: {DEFAULT_CACHE_MAX_AGE_DAYS})')
     args = parser.parse_args(args_list)
 
     if args.action == 'status':
         projects = get_all_projects()
         root = _DEFAULT_ROOT
-        total_mb = sum(p.get('cache_size_bytes', 0) for p in projects) / (1024 * 1024)
+        total_mb = sum(p.get('cache_size_bytes', 0) for p in projects) / (KB * KB)
         print(f"Cache: {root}")
         print(f"  Projects: {len(projects)}   Total: {total_mb:.1f} MB")
         for p in projects:
-            size_mb = p.get('cache_size_bytes', 0) / (1024 * 1024)
+            size_mb = p.get('cache_size_bytes', 0) / (KB * KB)
             updated = p.get('updated_at', 0)
             age_min = int((time.time() - updated) / 60) if updated else 0
             age_str = f"{age_min}m ago" if age_min < 120 else f"{age_min//60}h ago"
@@ -246,7 +247,7 @@ def _get_file_sizes(chunk_dir: Path, required_files: list[str]) -> str:
     sizes = []
     for req_file in required_files:
         size = (chunk_dir / req_file).stat().st_size
-        sizes.append(f"{req_file}:{size//1024}KB" if size > 1024 else f"{req_file}:{size}B")
+        sizes.append(f"{req_file}:{size//KB}KB" if size > KB else f"{req_file}:{size}B")
     return ", ".join(sizes)
 
 

{code2llm-0.5.121 → code2llm-0.5.123}/code2llm/cli_exports/orchestrator.py

@@ -4,10 +4,18 @@ Refactored to use EXPORT_REGISTRY for core format dispatch.
 Maintains backward compatibility with all existing --format values.
 """
 
+import shutil
 import sys
 from pathlib import Path
 from typing import Optional, List, Dict, Any
 
+# Optional progress bar support
+try:
+    from tqdm import tqdm
+    _HAS_TQDM = True
+except ImportError:
+    _HAS_TQDM = False
+
 from code2llm.exporters import (
     get_exporter,
     EXPORT_REGISTRY,
@@ -17,6 +25,8 @@ from code2llm.exporters import (
     IndexHTMLGenerator,
 )
 from code2llm.exporters.project_yaml.evolution import load_previous_evolution
+from code2llm.core.persistent_cache import PersistentCache
+from code2llm.core.config import DEFAULT_PROGRESS_BAR_THRESHOLD
 
 
 # Format output filenames
@@ -46,26 +56,103 @@ FORMAT_LABELS: Dict[str, str] = {
 }
 
 
+def _build_export_config(args, formats: List[str]) -> Dict[str, Any]:
+    """Build config dict for export caching."""
+    return {
+        'formats': sorted(formats),
+        'png': getattr(args, 'png', False),
+        'no_png': getattr(args, 'no_png', False),
+        'flow_include_examples': getattr(args, 'flow_include_examples', False),
+        'full': getattr(args, 'full', False),
+        'refactor': getattr(args, 'refactor', False),
+        'data_structures': getattr(args, 'data_structures', False),
+    }
+
+
 def _run_exports(args, result, output_dir: Path, source_path: Optional[Path] = None):
     """Export analysis results in requested formats.
 
     Uses EXPORT_REGISTRY for core format dispatch.
     For chunked analysis, exports to subproject subdirectories.
+    Supports export-level caching for repeated runs.
     """
     requested_formats = [f.strip() for f in args.format.split(',')]
     formats = _expand_all_formats(requested_formats, getattr(args, 'png', False))
     is_chunked = getattr(args, 'chunk', False)
 
+    # Skip cache for chunked or when explicitly disabled
+    skip_cache = is_chunked or getattr(args, 'no_cache', False)
+
+    if not skip_cache and source_path:
+        cache = PersistentCache(str(source_path))
+        config_dict = _build_export_config(args, formats)
+        cached_export_dir = cache.get_export_cache_dir(config_dict)
+
+        if cached_export_dir:
+            if args.verbose:
+                print(f"  Using cached export from: {cached_export_dir}")
+            # Copy cached files to output_dir
+            _copy_cached_export(cached_export_dir, output_dir, verbose=args.verbose)
+            return
+
     try:
         if is_chunked and source_path:
             _export_chunked(args, result, output_dir, source_path, formats, requested_formats)
         else:
             _export_single(args, result, output_dir, formats, requested_formats, source_path)
+
+        # Mark export as complete in cache
+        if not skip_cache and source_path:
+            cache = PersistentCache(str(source_path))
+            config_dict = _build_export_config(args, formats)
+            export_cache_dir = cache.create_export_cache_dir(config_dict)
+            _copy_to_cache(output_dir, export_cache_dir, verbose=args.verbose)
+            cache.mark_export_complete(export_cache_dir)
+            cache.save()
+            if args.verbose:
+                print(f"  Export cached at: {export_cache_dir}")
+
     except Exception as e:
         print(f"Error during export: {e}", file=sys.stderr)
         sys.exit(1)
 
 
+def _copy_cached_export(cached_dir: Path, output_dir: Path, verbose: bool = False) -> None:
+    """Copy files from cached export to output directory."""
+    output_dir.mkdir(parents=True, exist_ok=True)
+    items = [item for item in cached_dir.iterdir() if item.name != '_complete']
+
+    # Progress bar for large cache restores
+    use_tqdm = _HAS_TQDM and not verbose and len(items) > DEFAULT_PROGRESS_BAR_THRESHOLD
+    item_iterator = tqdm(items, desc="Restoring from cache") if use_tqdm else items
+
+    for item in item_iterator:
+        dest = output_dir / item.name
+        if item.is_dir():
+            shutil.copytree(item, dest, dirs_exist_ok=True)
+        else:
+            shutil.copy2(item, dest)
+
+
+def _copy_to_cache(output_dir: Path, cache_dir: Path, verbose: bool = False) -> None:
+    """Copy export files to cache directory."""
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    if not output_dir.exists():
+        return
+
+    items = list(output_dir.iterdir())
+    # Progress bar for large cache saves
+    use_tqdm = _HAS_TQDM and not verbose and len(items) > DEFAULT_PROGRESS_BAR_THRESHOLD
+    item_iterator = tqdm(items, desc="Saving to cache") if use_tqdm else items
+
+    for item in item_iterator:
+        dest = cache_dir / item.name
+        if item.is_dir():
+            shutil.copytree(item, dest, dirs_exist_ok=True)
+        else:
+            shutil.copy2(item, dest)
+
+
 def _expand_all_formats(requested: List[str], include_png: bool = False) -> List[str]:
     """Expand 'all' to concrete format list."""
     if 'all' not in requested:
@@ -121,7 +208,18 @@ def _export_single(
 
 def _export_registry_formats(args, result, output_dir: Path, formats: List[str]):
     """Export core formats via EXPORT_REGISTRY lookup."""
-    for fmt in formats:
+    # Use progress bar when many formats and not in verbose mode
+    use_tqdm = (
+        _HAS_TQDM and
+        not args.verbose and
+        len(formats) > DEFAULT_PROGRESS_BAR_THRESHOLD
+    )
+
+    format_iterator = formats
+    if use_tqdm:
+        format_iterator = tqdm(formats, desc="Exporting formats")
+
+    for fmt in format_iterator:
         exporter_cls = get_exporter(fmt)
         if exporter_cls is None:
             continue

{code2llm-0.5.121 → code2llm-0.5.123}/code2llm/cli_parser.py

@@ -147,6 +147,18 @@ Strategy Options (--strategy):
         help='Force re-analysis and re-export even when cache is valid (alias for --no-cache)'
     )
 
+    parser.add_argument(
+        '--dry-run',
+        action='store_true',
+        help='Show what would be exported without writing files'
+    )
+
+    parser.add_argument(
+        '--watch',
+        action='store_true',
+        help='Auto-detect changed files and only re-analyze those (faster subsequent runs)'
+    )
+
     parser.add_argument(
         '--strategy',
         choices=['quick', 'standard', 'deep'],

{code2llm-0.5.121 → code2llm-0.5.123}/code2llm/core/analyzer.py

@@ -7,9 +7,16 @@ from concurrent.futures import ProcessPoolExecutor, as_completed
 from pathlib import Path
 from typing import Dict, List, Optional, Tuple
 
+# Optional tqdm for progress bars
+try:
+    from tqdm import tqdm
+    _HAS_TQDM = True
+except ImportError:
+    _HAS_TQDM = False
+
 logger = logging.getLogger(__name__)
 
-from .config import Config, FAST_CONFIG, ALL_EXTENSIONS, LANGUAGE_EXTENSIONS
+from .config import Config, FAST_CONFIG, ALL_EXTENSIONS, LANGUAGE_EXTENSIONS, DEFAULT_PROGRESS_BAR_THRESHOLD
 from .models import AnalysisResult, FlowEdge, FlowNode, Pattern
 from code2llm.analysis.call_graph import CallGraphExtractor
 
@@ -41,24 +48,15 @@ class ProjectAnalyzer:
 
         if self.config.verbose:
             print(f"Found {len(files)} files to analyze")
-            print(f"  - Parallel: {self.config.performance.parallel_enabled}, Workers: {self.config.performance.parallel_workers}")
+            workers = self.config.performance.get_workers()
+            print(f"  - Parallel: {self.config.performance.parallel_enabled}, Workers: {workers}")
 
         pcache, cached_results, files_to_analyze = self._load_from_persistent_cache(files, project_path)
         fresh_results = self._run_analysis(files_to_analyze)
         self._store_to_persistent_cache(pcache, files_to_analyze, fresh_results)
 
         merged = self._merge_results(cached_results + fresh_results, str(project_path))
-        self._build_call_graph(merged)
-        if not self.config.performance.skip_pattern_detection:
-            self._detect_patterns(merged)
-        if self.config.verbose:
-            print(f"  - Running refactoring analysis...", flush=True)
-        self.refactoring_analyzer.perform_refactoring_analysis(merged)
-        if self.config.verbose:
-            print(f"  - Refactoring analysis complete", flush=True)
-        merged.stats = self._build_stats(files, cached_results + fresh_results, merged, start_time)
-        if self.config.verbose:
-            self._print_summary(merged)
+        self._post_process(merged, files, cached_results + fresh_results, start_time)
         return merged
 
     def _resolve_project_path(self, project_path: str) -> Path:
@@ -146,6 +144,26 @@ class ProjectAnalyzer:
         print(f"  Classes: {len(merged.classes)}")
         print(f"  CFG Nodes: {len(merged.nodes)}")
         print(f"  Patterns: {len(merged.patterns)}")
+
+    def _post_process(
+        self,
+        merged: AnalysisResult,
+        files: List,
+        results: List[Dict],
+        start_time: float,
+    ) -> None:
+        """Run post-processing: call graph, patterns, refactoring, stats."""
+        self._build_call_graph(merged)
+        if not self.config.performance.skip_pattern_detection:
+            self._detect_patterns(merged)
+        if self.config.verbose:
+            print("  - Running refactoring analysis...", flush=True)
+        self.refactoring_analyzer.perform_refactoring_analysis(merged)
+        if self.config.verbose:
+            print("  - Refactoring analysis complete", flush=True)
+        merged.stats = self._build_stats(files, results, merged, start_time)
+        if self.config.verbose:
+            self._print_summary(merged)
     
     def _collect_files(self, project_path: Path) -> List[Tuple[str, str]]:
         """Collect all source files with their module names for all supported languages.
@@ -197,7 +215,7 @@ class ProjectAnalyzer:
     def _analyze_parallel(self, files: List[Tuple[str, str]]) -> List[Dict]:
         """Analyze files in parallel."""
         results = []
-        workers = min(self.config.performance.parallel_workers, len(files))
+        workers = min(self.config.performance.get_workers(), len(files))
         
         # Convert config to dict for pickle compatibility
         config_dict = {
@@ -215,9 +233,13 @@ class ProjectAnalyzer:
                 for file_path, module_name in files
             }
             
-            # Collect results as they complete
+            # Collect results as they complete (with optional progress bar)
             completed = 0
-            for future in as_completed(future_to_file):
+            iterator = as_completed(future_to_file)
+            if not self.config.verbose and len(files) > DEFAULT_PROGRESS_BAR_THRESHOLD and _HAS_TQDM:
+                iterator = tqdm(iterator, total=len(files), desc="Analyzing")
+            
+            for future in iterator:
                 file_path, module_name = future_to_file[future]
                 try:
                     result = future.result()
@@ -238,7 +260,12 @@ class ProjectAnalyzer:
         analyzer = FileAnalyzer(self.config, self.cache)
         total = len(files)
         
-        for i, (file_path, module_name) in enumerate(files, 1):
+        # Use tqdm for large projects in non-verbose mode
+        file_iterator = enumerate(files, 1)
+        if not self.config.verbose and total > DEFAULT_PROGRESS_BAR_THRESHOLD and _HAS_TQDM:
+            file_iterator = tqdm(list(file_iterator), desc="Analyzing", total=total)
+        
+        for i, (file_path, module_name) in file_iterator:
             try:
                 result = analyzer.analyze_file(file_path, module_name)
                 if result:
@@ -355,47 +382,19 @@ class ProjectAnalyzer:
     
     def analyze_files(self, files: List[Tuple[str, str]], project_path: str) -> AnalysisResult:
         """Analyze specific list of files (for chunked analysis).
-        
+
         Args:
             files: List of (file_path, module_name) tuples
             project_path: Base project path for the result
         """
         start_time = time.time()
-        
+
         if self.config.verbose:
             print(f"Analyzing {len(files)} specific files")
-        
-        # Analyze files
-        if self.config.performance.parallel_enabled and len(files) > 1:
-            results = self._analyze_parallel(files)
-        else:
-            results = self._analyze_sequential(files)
-        
-        # Merge results
+
+        results = self._run_analysis(files)
         merged = self._merge_results(results, project_path)
-        
-        # Build call graph
-        self._build_call_graph(merged)
-        
-        if not self.config.performance.skip_pattern_detection:
-            self._detect_patterns(merged)
-        
-        # Refactoring analysis
-        self.refactoring_analyzer.perform_refactoring_analysis(merged)
-        
-        # Calculate stats
-        elapsed = time.time() - start_time
-        merged.stats = {
-            'files_processed': len(files),
-            'functions_found': len(merged.functions),
-            'classes_found': len(merged.classes),
-            'nodes_created': len(merged.nodes),
-            'edges_created': len(merged.edges),
-            'patterns_detected': len(merged.patterns),
-            'analysis_time_seconds': round(elapsed, 2),
-            'cache_hits': sum(r.get('cache_hits', 0) for r in results),
-        }
-        
+        self._post_process(merged, files, results, start_time)
         return merged
     
     def _detect_patterns(self, result: AnalysisResult) -> None:

{code2llm-0.5.121 → code2llm-0.5.123}/code2llm/core/config.py

@@ -1,10 +1,62 @@
 """Configuration and constants for code2llm."""
 
+import os
+import psutil
 from dataclasses import dataclass, field
 from typing import List, Set
 from enum import Enum
 
 
+def _get_optimal_workers(default: int = 4, max_per_gb: float = 2.0) -> int:
+    """Calculate optimal parallel workers based on CPU and available RAM.
+
+    Args:
+        default: Default workers if detection fails
+        max_per_gb: Max workers per GB of RAM
+
+    Returns:
+        Optimal worker count (at least 1)
+    """
+    try:
+        cpu_count = os.cpu_count() or default
+        available_ram_gb = psutil.virtual_memory().available / (1024 ** 3)
+        # Limit workers by RAM (assume each worker needs ~500MB)
+        ram_limited = int(available_ram_gb * max_per_gb)
+        # Take minimum of CPU and RAM limits, but at least 1
+        return max(1, min(cpu_count, ram_limited))
+    except Exception:
+        return default
+
+
+# Performance limits (named constants for magic numbers)
+DEFAULT_MAX_NODES_PER_FILE = 1000
+DEFAULT_MAX_TOTAL_NODES = 10000
+DEFAULT_MAX_EDGES = 50000
+DEFAULT_CACHE_TTL_HOURS = 24
+DEFAULT_MAX_MEMORY_MB = 2048
+DEFAULT_PROGRESS_BAR_THRESHOLD = 50  # File count threshold for progress bar
+
+# Complexity thresholds
+CC_LOW_THRESHOLD = 5      # Rank A
+CC_MEDIUM_THRESHOLD = 10  # Rank B
+CC_HIGH_THRESHOLD = 20    # Rank C
+CC_CRITICAL_THRESHOLD = 50  # For warnings
+
+# Size limits
+KB = 1024
+MB = 1024 * 1024
+MAX_FILE_SIZE_KB = 256
+CHUNK_SIZE_KB = 256
+
+# Timeouts
+DEFAULT_PNG_TIMEOUT = 60
+DEFAULT_MERMAID_MAX_TEXT_SIZE = 2_000_000
+DEFAULT_MERMAID_MAX_EDGES = 20_000
+
+# Cache settings
+DEFAULT_CACHE_MAX_AGE_DAYS = 30
+
+
 class AnalysisMode(str, Enum):
     """Available analysis modes."""
     STATIC = "static"
@@ -19,17 +71,23 @@ class PerformanceConfig:
     """Performance optimization settings."""
     enable_cache: bool = True
     cache_dir: str = ".code2llm_cache"
-    cache_ttl_hours: int = 24
-    parallel_workers: int = 4
+    cache_ttl_hours: int = DEFAULT_CACHE_TTL_HOURS
+    parallel_workers: int = 0  # 0 = auto-detect based on CPU/RAM
     parallel_enabled: bool = True
-    max_memory_mb: int = 2048
-    max_nodes_per_file: int = 1000
-    max_total_nodes: int = 10000
-    max_edges: int = 50000
+    max_memory_mb: int = DEFAULT_MAX_MEMORY_MB
+    max_nodes_per_file: int = DEFAULT_MAX_NODES_PER_FILE
+    max_total_nodes: int = DEFAULT_MAX_TOTAL_NODES
+    max_edges: int = DEFAULT_MAX_EDGES
     fast_mode: bool = False
     skip_data_flow: bool = False
     skip_pattern_detection: bool = False
 
+    def get_workers(self) -> int:
+        """Get effective worker count (auto-detect if set to 0)."""
+        if self.parallel_workers <= 0:
+            return _get_optimal_workers(default=4)
+        return self.parallel_workers
+
 
 @dataclass
 class FilterConfig:
@@ -120,7 +178,7 @@ FAST_CONFIG = Config(
         skip_data_flow=True,
         skip_pattern_detection=True,
         parallel_enabled=True,
-        parallel_workers=8,
+        parallel_workers=0,  # auto-detect
         max_nodes_per_file=500,
         max_total_nodes=5000,
     ),

{code2llm-0.5.121 → code2llm-0.5.123}/code2llm/core/file_analyzer.py

@@ -1,17 +1,13 @@
 """File analyzer for analyzing individual source files across multiple languages."""
 
 import ast
-import re
 from pathlib import Path
 from typing import Dict, List, Optional
 
 from radon.complexity import cc_visit, cc_rank
 
-from .config import Config, LANGUAGE_EXTENSIONS
-from .models import (
-    AnalysisResult, ClassInfo, FlowEdge, FlowNode,
-    FunctionInfo, ModuleInfo
-)
+from .config import Config
+from .models import ClassInfo, FlowEdge, FlowNode, FunctionInfo, ModuleInfo
 from code2llm.analysis.dfg import DFGExtractor
 from code2llm.analysis.call_graph import CallGraphExtractor
 from .file_filter import FastFileFilter

{code2llm-0.5.121 → code2llm-0.5.123}/code2llm/core/gitignore.py

@@ -1,7 +1,7 @@
 """Gitignore support for code2llm file filtering."""
 
 from pathlib import Path
-from typing import List, Set
+from typing import List
 import re
 
 

{code2llm-0.5.121 → code2llm-0.5.123}/code2llm/core/lang/__init__.py

@@ -8,11 +8,9 @@ Provides:
 """
 
 from abc import ABC, abstractmethod
-from typing import Dict, Any, Callable, Set, Optional
+from typing import Dict, Any, Callable, Optional
 from pathlib import Path
 
-from code2llm.core.models import ModuleInfo, FunctionInfo, ClassInfo
-
 
 # Type alias for parser results
 ParserResult = Dict[str, Any]

{code2llm-0.5.121 → code2llm-0.5.123}/code2llm/core/lang/base.py

@@ -3,6 +3,12 @@
 import re
 from typing import Dict, List
 
+from code2llm.core.config import (
+    CC_LOW_THRESHOLD,
+    CC_MEDIUM_THRESHOLD,
+    CC_HIGH_THRESHOLD,
+)
+
 
 # Branching keywords per language family
 CC_PATTERNS = {
@@ -64,7 +70,11 @@ def calculate_complexity_regex(content: str, result: Dict,
             cc = 1
         else:
             cc = 1 + len(pattern.findall(body))
-        rank = 'A' if cc <= 5 else ('B' if cc <= 10 else ('C' if cc <= 20 else 'D'))
+        rank = (
+            'A' if cc <= CC_LOW_THRESHOLD
+            else ('B' if cc <= CC_MEDIUM_THRESHOLD
+                  else ('C' if cc <= CC_HIGH_THRESHOLD else 'D'))
+        )
         func_info.complexity = {
             'cyclomatic_complexity': cc,
             'cc_rank': rank,

{code2llm-0.5.121 → code2llm-0.5.123}/code2llm/core/models.py

@@ -1,6 +1,5 @@
 from dataclasses import dataclass, field, asdict
 from typing import List, Dict, Set, Optional, Any
-from pathlib import Path
 
 
 class BaseModel:

{code2llm-0.5.121 → code2llm-0.5.123}/code2llm/core/refactoring.py

@@ -1,7 +1,6 @@
 """Refactoring analysis for code2llm."""
 
 from pathlib import Path
-from typing import Optional
 
 from .config import Config
 from .models import AnalysisResult