code2llm 0.5.121__tar.gz → 0.5.122__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code2llm
-Version: 0.5.121
+Version: 0.5.122
 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.122-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.122}/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.122-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.122}/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.122"
 __author__ = "STTS Project"
 
 # Core analysis components (lightweight, always needed)

{code2llm-0.5.121 → code2llm-0.5.122}/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.122}/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.122}/code2llm/core/config.py

@@ -1,10 +1,42 @@
 """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
+
+
 class AnalysisMode(str, Enum):
     """Available analysis modes."""
     STATIC = "static"
@@ -19,17 +51,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 +158,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.122}/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.122}/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.122}/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.122}/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.122}/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

{code2llm-0.5.121 → code2llm-0.5.122}/code2llm/generators/mermaid.py

@@ -254,9 +254,23 @@ def _fix_class_line(line: str):
     return None
 
 
+def _is_png_fresh(mmd_file: Path, output_dir: Path) -> bool:
+    """Check if PNG exists and is newer than MMD source."""
+    png_file = output_dir / f"{mmd_file.stem}.png"
+    if not png_file.exists():
+        return False
+    # PNG is fresh if newer than MMD
+    return png_file.stat().st_mtime >= mmd_file.stat().st_mtime
+
+
 def _prepare_and_render(mmd_file: Path, output_dir: Path, timeout: int) -> bool:
     """Validate, optionally fix, then render a single .mmd file to PNG."""
     output_file = output_dir / f"{mmd_file.stem}.png"
+    
+    # Skip if PNG is already fresh
+    if _is_png_fresh(mmd_file, output_dir):
+        return True
+    
     errors = validate_mermaid_file(mmd_file)
     if errors:
         print(f"  Fixing {mmd_file.name}: {len(errors)} issues")
@@ -268,12 +282,22 @@ def _prepare_and_render(mmd_file: Path, output_dir: Path, timeout: int) -> bool:
     return generate_single_png(mmd_file, output_file, timeout)
 
 
-def generate_pngs(input_dir: Path, output_dir: Path, timeout: int = 60, max_workers: int = 4) -> int:
-    """Generate PNG files from all .mmd files in input_dir (parallel)."""
+def generate_pngs(
+    input_dir: Path, output_dir: Path, timeout: int = 60, max_workers: int = 0
+) -> int:
+    """Generate PNG files from all .mmd files in input_dir (parallel).
+
+    Args:
+        max_workers: Number of parallel workers (0 = auto-detect from CPU count)
+    """
     mmd_files = list(input_dir.glob('*.mmd'))
     if not mmd_files:
         return 0
 
+    # Auto-detect workers if not specified
+    if max_workers <= 0:
+        max_workers = os.cpu_count() or 4
+
     success_count = 0
     with ThreadPoolExecutor(max_workers=min(max_workers, len(mmd_files))) as pool:
         futures = {pool.submit(_prepare_and_render, f, output_dir, timeout): f for f in mmd_files}

{code2llm-0.5.121 → code2llm-0.5.122}/code2llm/nlp/__init__.py

@@ -4,7 +4,7 @@ Provides query normalization, intent matching, and entity resolution
 with multilingual support and fuzzy matching.
 """
 
-__version__ = "0.5.121"
+__version__ = "0.5.122"
 
 from .pipeline import NLPPipeline
 from .normalization import QueryNormalizer

{code2llm-0.5.121 → code2llm-0.5.122}/code2llm.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code2llm
-Version: 0.5.121
+Version: 0.5.122
 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.122-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.122}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "code2llm"
-version = "0.5.121"
+version = "0.5.122"
 description = "High-performance Python code flow analysis with optimized TOON format - CFG, DFG, call graphs, and intelligent code queries"
 readme = "README.md"
 requires-python = ">=3.8"

{code2llm-0.5.121 → code2llm-0.5.122}/setup.py

@@ -4,7 +4,7 @@ from setuptools import setup, find_packages
 import os
 
 # Read version
-version = "0.5.120"
+version = "0.5.121"
 
 # Read long description
 def read_readme():