code2llm 0.5.100__tar.gz → 0.5.102__tar.gz

{code2llm-0.5.100 → code2llm-0.5.102}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code2llm
-Version: 0.5.100
+Version: 0.5.102
 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
@@ -56,7 +56,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.100-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.102-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-51.2h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
 
 - 🤖 **LLM usage:** $7.5000 (148 commits)

{code2llm-0.5.100 → code2llm-0.5.102}/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.100-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.102-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-51.2h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
 
 - 🤖 **LLM usage:** $7.5000 (148 commits)

{code2llm-0.5.100 → code2llm-0.5.102}/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.100"
+__version__ = "0.5.102"
 __author__ = "STTS Project"
 
 # Core analysis components (lightweight, always needed)

code2llm-0.5.102/code2llm/core/export_pipeline.py

@@ -0,0 +1,153 @@
+"""Export pipeline — shared context computed once for all exporters.
+
+Instead of each exporter building its own context from scratch, the pipeline
+pre-computes shared data (metrics aggregations, call graph, etc.) and passes
+it to all exporters in sequence.
+"""
+
+from typing import Any, Dict, List, Optional
+
+from code2llm.core.models import AnalysisResult
+
+
+class SharedExportContext:
+    """Pre-computed context shared across all exporters.
+
+    Lazy-computes expensive aggregations on first access.
+    """
+
+    __slots__ = ("_result", "_computed")
+
+    def __init__(self, result: AnalysisResult):
+        self._result = result
+        self._computed: Dict[str, Any] = {}
+
+    @property
+    def result(self) -> AnalysisResult:
+        return self._result
+
+    @property
+    def functions(self) -> Dict:
+        return self._result.functions
+
+    @property
+    def classes(self) -> Dict:
+        return self._result.classes
+
+    @property
+    def modules(self) -> Dict:
+        return self._result.modules
+
+    @property
+    def entry_points(self) -> List[str]:
+        return self._result.entry_points
+
+    @property
+    def metrics_summary(self) -> Dict[str, Any]:
+        """Aggregate metrics — computed once, cached."""
+        if "metrics_summary" not in self._computed:
+            self._computed["metrics_summary"] = self._compute_metrics_summary()
+        return self._computed["metrics_summary"]
+
+    @property
+    def complexity_distribution(self) -> Dict[str, int]:
+        """CC rank distribution — computed once, cached."""
+        if "cc_dist" not in self._computed:
+            self._computed["cc_dist"] = self._compute_cc_distribution()
+        return self._computed["cc_dist"]
+
+    @property
+    def call_graph_edges(self) -> List[tuple]:
+        """Flattened call graph as (caller, callee) tuples."""
+        if "cg_edges" not in self._computed:
+            edges = []
+            for fname, finfo in self._result.functions.items():
+                for callee in finfo.calls:
+                    edges.append((fname, callee))
+            self._computed["cg_edges"] = edges
+        return self._computed["cg_edges"]
+
+    @property
+    def high_complexity_functions(self) -> List[str]:
+        """Functions with CC >= 10 (ranks C/D)."""
+        if "high_cc" not in self._computed:
+            high = []
+            for fname, finfo in self._result.functions.items():
+                cc = getattr(finfo, "complexity", None)
+                if cc and cc.get("cyclomatic_complexity", 0) >= 10:
+                    high.append(fname)
+            self._computed["high_cc"] = high
+        return self._computed["high_cc"]
+
+    # ------------------------------------------------------------------
+    # Internal computation
+    # ------------------------------------------------------------------
+
+    def _compute_metrics_summary(self) -> Dict[str, Any]:
+        funcs = self._result.functions
+        classes = self._result.classes
+
+        total_cc = 0
+        cc_count = 0
+        for f in funcs.values():
+            cc_data = getattr(f, "complexity", None)
+            if cc_data:
+                total_cc += cc_data.get("cyclomatic_complexity", 1)
+                cc_count += 1
+
+        return {
+            "total_functions": len(funcs),
+            "total_classes": len(classes),
+            "total_modules": len(self._result.modules),
+            "average_cc": round(total_cc / cc_count, 2) if cc_count else 0,
+            "entry_points": len(self._result.entry_points),
+        }
+
+    def _compute_cc_distribution(self) -> Dict[str, int]:
+        dist = {"A": 0, "B": 0, "C": 0, "D": 0, "unknown": 0}
+        for f in self._result.functions.values():
+            cc_data = getattr(f, "complexity", None)
+            if cc_data:
+                rank = cc_data.get("cc_rank", "unknown")
+                dist[rank] = dist.get(rank, 0) + 1
+            else:
+                dist["unknown"] += 1
+        return dist
+
+
+class ExportPipeline:
+    """Run multiple exporters with a single shared context.
+
+    Usage::
+
+        pipeline = ExportPipeline(analysis_result)
+        pipeline.run([
+            ToonExporter(config),
+            MermaidExporter(config),
+            ContextExporter(config),
+        ], output_dir="/path/to/output")
+    """
+
+    def __init__(self, result: AnalysisResult):
+        self._ctx = SharedExportContext(result)
+
+    @property
+    def context(self) -> SharedExportContext:
+        return self._ctx
+
+    def run(self, exporters: List, output_dir: str) -> Dict[str, bool]:
+        """Run all exporters in sequence, returning success status per exporter."""
+        results = {}
+        for exporter in exporters:
+            name = type(exporter).__name__
+            try:
+                # Exporters that support shared context
+                if hasattr(exporter, "export_with_context"):
+                    exporter.export_with_context(self._ctx, output_dir)
+                else:
+                    # Fallback: pass raw AnalysisResult
+                    exporter.export(self._ctx.result, output_dir)
+                results[name] = True
+            except Exception as e:
+                results[name] = False
+        return results

code2llm-0.5.102/code2llm/core/incremental.py

@@ -0,0 +1,150 @@
+"""Incremental analysis — hash-based skip for unchanged files.
+
+On repeated runs, files whose mtime+size match the cached state are skipped,
+and their previous analysis results are reused. This dramatically speeds up
+CI/CD and iterative development workflows.
+"""
+
+import json
+import logging
+import os
+from pathlib import Path
+from typing import Any, Dict, Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+CACHE_FILE = ".code2llm_incremental.json"
+
+
+def _file_signature(filepath: str) -> Tuple[int, int]:
+    """Return (mtime_ns, size) for a file — fast freshness check."""
+    try:
+        s = os.stat(filepath)
+        return (s.st_mtime_ns, s.st_size)
+    except OSError:
+        return (0, 0)
+
+
+class IncrementalAnalyzer:
+    """Track file signatures to skip unchanged files on subsequent runs.
+
+    Usage::
+
+        inc = IncrementalAnalyzer(project_dir)
+
+        for filepath in files:
+            if inc.needs_analysis(filepath):
+                result = analyze(filepath)
+                inc.update(filepath, result)
+            else:
+                result = inc.get_cached_result(filepath)
+
+        inc.save()  # persist state for next run
+    """
+
+    def __init__(self, project_dir: str):
+        self._project_dir = Path(project_dir).resolve()
+        self._cache_path = self._project_dir / CACHE_FILE
+        self._state: Dict[str, Dict[str, Any]] = self._load_cache()
+        self._dirty = False
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def needs_analysis(self, filepath: str) -> bool:
+        """Return True if file has changed since last cached analysis."""
+        key = self._normalize_key(filepath)
+        sig = _file_signature(filepath)
+
+        cached = self._state.get(key)
+        if not cached:
+            return True
+
+        cached_sig = (cached.get("mtime_ns", 0), cached.get("size", 0))
+        return sig != cached_sig
+
+    def get_cached_result(self, filepath: str) -> Optional[Dict]:
+        """Return previously cached analysis result, or None."""
+        key = self._normalize_key(filepath)
+        cached = self._state.get(key)
+        if cached:
+            return cached.get("result")
+        return None
+
+    def update(self, filepath: str, result: Dict) -> None:
+        """Store analysis result and file signature for future runs."""
+        key = self._normalize_key(filepath)
+        sig = _file_signature(filepath)
+
+        self._state[key] = {
+            "mtime_ns": sig[0],
+            "size": sig[1],
+            "result": result,
+        }
+        self._dirty = True
+
+    def invalidate(self, filepath: str) -> None:
+        """Remove cached state for a file (e.g. after deletion)."""
+        key = self._normalize_key(filepath)
+        if key in self._state:
+            del self._state[key]
+            self._dirty = True
+
+    def save(self) -> None:
+        """Persist incremental state to disk."""
+        if not self._dirty:
+            return
+
+        try:
+            # Write atomically via temp file
+            tmp_path = self._cache_path.with_suffix(".tmp")
+            with open(tmp_path, "w", encoding="utf-8") as f:
+                json.dump(self._state, f, indent=2, default=str)
+            tmp_path.replace(self._cache_path)
+            self._dirty = False
+            logger.debug("Saved incremental cache: %d files", len(self._state))
+        except OSError as e:
+            logger.warning("Cannot save incremental cache: %s", e)
+
+    def clear(self) -> None:
+        """Clear all cached state (force full re-analysis)."""
+        self._state.clear()
+        self._dirty = True
+        if self._cache_path.exists():
+            try:
+                self._cache_path.unlink()
+            except OSError:
+                pass
+
+    @property
+    def cached_count(self) -> int:
+        """Number of files in cache."""
+        return len(self._state)
+
+    # ------------------------------------------------------------------
+    # Internal
+    # ------------------------------------------------------------------
+
+    def _load_cache(self) -> Dict[str, Dict[str, Any]]:
+        """Load previous cache from disk, or return empty dict."""
+        if not self._cache_path.exists():
+            return {}
+
+        try:
+            with open(self._cache_path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+                if isinstance(data, dict):
+                    return data
+        except (OSError, json.JSONDecodeError) as e:
+            logger.debug("Cannot load incremental cache: %s", e)
+
+        return {}
+
+    def _normalize_key(self, filepath: str) -> str:
+        """Normalize filepath to relative path from project root."""
+        try:
+            return str(Path(filepath).resolve().relative_to(self._project_dir))
+        except ValueError:
+            # File outside project — use absolute path
+            return str(Path(filepath).resolve())

code2llm-0.5.102/code2llm/core/lang/csharp.py

@@ -0,0 +1,42 @@
+"""C# analyzer (regex-based)."""
+
+import re
+from typing import Dict
+
+from code2llm.core.lang.base import analyze_c_family
+
+# C#-specific patterns
+_CSHARP_PATTERNS = {
+    'import': re.compile(r'^\s*using\s+([\w.]+)\s*;'),
+    'class': re.compile(
+        r'^\s*(?:public\s+|private\s+|internal\s+|protected\s+)?'
+        r'(?:abstract\s+|sealed\s+)?'
+        r'class\s+(\w+)'
+        r'(?:\s*:\s*(\w+))?'
+    ),
+    'interface': re.compile(
+        r'^\s*(?:public\s+|private\s+|internal\s+)?interface\s+(\w+)'
+    ),
+    'function': re.compile(
+        r'^\s*(?:public\s+|private\s+|protected\s+|internal\s+)?'
+        r'(?:static\s+|virtual\s+|override\s+|abstract\s+)?'
+        r'(?:async\s+)?'
+        r'(?:[\w<>,\[\]]+\s+)?'
+        r'(\w+)\s*\([^)]*\)'
+    ),
+}
+
+_CSHARP_CONFIG = {
+    'index_files': (),
+    'brace_track': True,
+    'reserved': {'if', 'for', 'while', 'switch', 'return', 'catch', 'class', 'namespace'},
+}
+
+
+def analyze_csharp(content: str, file_path: str, module_name: str,
+                   ext: str, stats: Dict) -> Dict:
+    """Analyze C# files using shared C-family extraction."""
+    return analyze_c_family(
+        content, file_path, module_name, stats,
+        _CSHARP_PATTERNS, _CSHARP_CONFIG,
+    )

code2llm-0.5.102/code2llm/core/lang/java.py

@@ -0,0 +1,43 @@
+"""Java analyzer (regex-based)."""
+
+import re
+from typing import Dict
+
+from code2llm.core.lang.base import analyze_c_family
+
+# Java-specific patterns
+_JAVA_PATTERNS = {
+    'import': re.compile(r'^\s*import\s+([\w.]+)\s*;'),
+    'class': re.compile(
+        r'^\s*(?:public\s+|private\s+|protected\s+)?'
+        r'(?:abstract\s+|final\s+)?'
+        r'class\s+(\w+)'
+        r'(?:\s+extends\s+(\w+))?'
+        r'(?:\s+implements\s+([\w,\s]+))?'
+    ),
+    'interface': re.compile(
+        r'^\s*(?:public\s+|private\s+|protected\s+)?'
+        r'interface\s+(\w+)'
+    ),
+    'function': re.compile(
+        r'^\s*(?:public\s+|private\s+|protected\s+)?'
+        r'(?:static\s+|final\s+|abstract\s+|synchronized\s+)?'
+        r'(?:[\w<>,\[\]]+\s+)?'
+        r'(\w+)\s*\([^)]*\)'
+    ),
+}
+
+_JAVA_CONFIG = {
+    'index_files': (),
+    'brace_track': True,
+    'reserved': {'if', 'for', 'while', 'switch', 'return', 'catch', 'class', 'interface'},
+}
+
+
+def analyze_java(content: str, file_path: str, module_name: str,
+                 ext: str, stats: Dict) -> Dict:
+    """Analyze Java files using shared C-family extraction."""
+    return analyze_c_family(
+        content, file_path, module_name, stats,
+        _JAVA_PATTERNS, _JAVA_CONFIG,
+    )

{code2llm-0.5.100 → code2llm-0.5.102}/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.100"
+__version__ = "0.5.102"
 
 from .pipeline import NLPPipeline
 from .normalization import QueryNormalizer

{code2llm-0.5.100 → code2llm-0.5.102}/code2llm.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code2llm
-Version: 0.5.100
+Version: 0.5.102
 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
@@ -56,7 +56,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.100-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.102-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-51.2h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
 
 - 🤖 **LLM usage:** $7.5000 (148 commits)

{code2llm-0.5.100 → code2llm-0.5.102}/code2llm.egg-info/SOURCES.txt

@@ -36,10 +36,12 @@ code2llm/core/__init__.py
 code2llm/core/analyzer.py
 code2llm/core/ast_registry.py
 code2llm/core/config.py
+code2llm/core/export_pipeline.py
 code2llm/core/file_analyzer.py
 code2llm/core/file_cache.py
 code2llm/core/file_filter.py
 code2llm/core/gitignore.py
+code2llm/core/incremental.py
 code2llm/core/large_repo.py
 code2llm/core/models.py
 code2llm/core/refactoring.py

{code2llm-0.5.100 → code2llm-0.5.102}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "code2llm"
-version = "0.5.100"
+version = "0.5.102"
 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.100 → code2llm-0.5.102}/setup.py

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

code2llm-0.5.100/code2llm/core/lang/csharp.py

@@ -1,49 +0,0 @@
-"""C# analyzer (regex-based)."""
-
-import re
-from typing import Dict
-
-from code2llm.core.models import ClassInfo, FunctionInfo, ModuleInfo
-from code2llm.core.lang.base import calculate_complexity_regex, extract_calls_regex, _extract_declarations
-
-
-def analyze_csharp(content: str, file_path: str, module_name: str,
-                   ext: str, stats: Dict) -> Dict:
-    """Analyze C# files using shared extraction."""
-    
-    patterns = {
-        'import': re.compile(r'^\s*using\s+([\w.]+)\s*;'),
-        'class': re.compile(
-            r'^\s*(?:public\s+|private\s+|internal\s+|protected\s+)?'
-            r'(?:abstract\s+|sealed\s+)?'
-            r'class\s+(\w+)'
-            r'(?:\s*:\s*(\w+))?'
-        ),
-        'interface': re.compile(
-            r'^\s*(?:public\s+|private\s+|internal\s+)?interface\s+(\w+)'
-        ),
-        'function': re.compile(
-            r'^\s*(?:public\s+|private\s+|protected\s+|internal\s+)?'
-            r'(?:static\s+|virtual\s+|override\s+|abstract\s+)?'
-            r'(?:async\s+)?'
-            r'(?:[\w<>,\[\]]+\s+)?'  # return type with generics
-            r'(\w+)\s*\([^)]*\)'  # name and params
-        ),
-    }
-    
-    lang_config = {
-        'index_files': (),  
-        'brace_track': True,
-        'reserved': {'if', 'for', 'while', 'switch', 'return', 'catch', 'class', 'namespace'},
-    }
-    
-    result = _extract_declarations(
-        content, file_path, module_name,
-        patterns, stats, lang_config
-    )
-    
-    calculate_complexity_regex(content, result, lang='c_family')
-    extract_calls_regex(content, module_name, result)
-    
-    stats['files_processed'] += 1
-    return result

code2llm-0.5.100/code2llm/core/lang/java.py

@@ -1,50 +0,0 @@
-"""Java analyzer (regex-based)."""
-
-import re
-from typing import Dict
-
-from code2llm.core.models import ClassInfo, FunctionInfo, ModuleInfo
-from code2llm.core.lang.base import calculate_complexity_regex, extract_calls_regex, _extract_declarations
-
-
-def analyze_java(content: str, file_path: str, module_name: str,
-                 ext: str, stats: Dict) -> Dict:
-    """Analyze Java files using shared extraction."""
-    
-    patterns = {
-        'import': re.compile(r'^\s*import\s+([\w.]+)\s*;'),
-        'class': re.compile(
-            r'^\s*(?:public\s+|private\s+|protected\s+)?'
-            r'(?:abstract\s+|final\s+)?'
-            r'class\s+(\w+)'
-            r'(?:\s+extends\s+(\w+))?'
-            r'(?:\s+implements\s+([\w,\s]+))?'
-        ),
-        'interface': re.compile(
-            r'^\s*(?:public\s+|private\s+|protected\s+)?'
-            r'interface\s+(\w+)'
-        ),
-        'function': re.compile(
-            r'^\s*(?:public\s+|private\s+|protected\s+)?'
-            r'(?:static\s+|final\s+|abstract\s+|synchronized\s+)?'
-            r'(?:[\w<>,\[\]]+\s+)?'  # return type with generics
-            r'(\w+)\s*\([^)]*\)'  # name and params
-        ),
-    }
-    
-    lang_config = {
-        'index_files': (),
-        'brace_track': True,
-        'reserved': {'if', 'for', 'while', 'switch', 'return', 'catch', 'class', 'interface'},
-    }
-    
-    result = _extract_declarations(
-        content, file_path, module_name,
-        patterns, stats, lang_config
-    )
-    
-    calculate_complexity_regex(content, result, lang='c_family')
-    extract_calls_regex(content, module_name, result)
-    
-    stats['files_processed'] += 1
-    return result