code2llm 0.5.6__tar.gz → 0.5.7__tar.gz

{code2llm-0.5.6 → code2llm-0.5.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code2llm
-Version: 0.5.6
+Version: 0.5.7
 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
@@ -95,6 +95,12 @@ code2llm ./ -f all
 code2llm ./ -f context
 ```
 
+Przykład z projektu toonic, z użyciem modelu Kimi K2.5 w VScode Windsurf:
+![img_1.png](img_1.png)
+```bash
+code2llm ./ -f toon,evolution -o ./project
+```
+
 ### Performance Options
 ```bash
 # Fast analysis for large projects
@@ -355,3 +361,11 @@ code2llm ./ -f yaml --separate-orphans
 **Modules**: 76  
 
 For more information about code2llm, visit: https://github.com/tom-sapletta/code2llm
+
+## License
+
+Apache License 2.0 - see [LICENSE](LICENSE) for details.
+
+## Author
+
+Created by **Tom Sapletta** - [tom@sapletta.com](mailto:tom@sapletta.com)

{code2llm-0.5.6 → code2llm-0.5.7}/README.md

@@ -46,6 +46,12 @@ code2llm ./ -f all
 code2llm ./ -f context
 ```
 
+Przykład z projektu toonic, z użyciem modelu Kimi K2.5 w VScode Windsurf:
+![img_1.png](img_1.png)
+```bash
+code2llm ./ -f toon,evolution -o ./project
+```
+
 ### Performance Options
 ```bash
 # Fast analysis for large projects
@@ -306,3 +312,11 @@ code2llm ./ -f yaml --separate-orphans
 **Modules**: 76  
 
 For more information about code2llm, visit: https://github.com/tom-sapletta/code2llm
+
+## License
+
+Apache License 2.0 - see [LICENSE](LICENSE) for details.
+
+## Author
+
+Created by **Tom Sapletta** - [tom@sapletta.com](mailto:tom@sapletta.com)

{code2llm-0.5.6 → code2llm-0.5.7}/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.2"
+__version__ = "0.5.7"
 __author__ = "STTS Project"
 
 # Core analysis components

{code2llm-0.5.6 → code2llm-0.5.7}/code2llm/analysis/data_analysis.py

@@ -130,9 +130,8 @@ class DataAnalyzer:
                 if len(flows) >= 20: break
         return flows
 
-    def _analyze_data_types(self, result: AnalysisResult) -> list:
-        """Analyze data types and usage."""
-        data_types = {}
+    def _detect_types_from_name(self, func_name: str, doc: str) -> list:
+        """Detect data types from function name and docstring."""
         type_indicators = {
             'list': ['list', 'array', 'items', 'elements', 'collection', 'sequence'],
             'dict': ['dict', 'map', 'mapping', 'key_value', 'record', 'object'],
@@ -143,23 +142,45 @@ class DataAnalyzer:
             'tuple': ['tuple', 'pair'],
             'set': ['set', 'unique'],
         }
+        name_lower = func_name.lower()
+        return [t for t, inds in type_indicators.items() if any(ind in name_lower or ind in doc for ind in inds)]
+
+    def _create_type_entry(self, type_key: str, detected: list, params: list, returns: list) -> dict:
+        """Create a new data type entry."""
+        return {
+            'type_name': type_key,
+            'detected_types': list(set(detected)),
+            'parameter_types': list(set(params)),
+            'return_types': list(set(returns)),
+            'functions': [],
+            'usage_count': 0,
+            'cross_module_usage': 0
+        }
+
+    def _update_type_stats(self, entry: dict, func_name: str, func_module: str, calls: list) -> None:
+        """Update type entry with function info and check cross-module usage."""
+        entry['functions'].append(func_name)
+        entry['usage_count'] += 1
+        for called in list(calls)[:10]:
+            called_module = called.rsplit('.', 1)[0] if '.' in called else 'root'
+            if called_module != func_module:
+                entry['cross_module_usage'] += 1
+                break
+
+    def _analyze_data_types(self, result: AnalysisResult) -> list:
+        """Analyze data types and usage."""
+        data_types = {}
         for func_name, func in result.functions.items():
-            name_lower = func.name.lower()
             doc = func.docstring.lower() if func.docstring else ''
-            detected = [t for t, inds in type_indicators.items() if any(ind in name_lower or ind in doc for ind in inds)]
+            detected = self._detect_types_from_name(func.name, doc)
             params = self._infer_parameter_types(func)
             returns = self._infer_return_types(func)
             if detected or params or returns:
                 type_key = ",".join(sorted(set(detected + params + returns)))
                 if type_key not in data_types:
-                    data_types[type_key] = {'type_name': type_key, 'detected_types': list(set(detected)), 'parameter_types': list(set(params)), 'return_types': list(set(returns)), 'functions': [], 'usage_count': 0, 'cross_module_usage': 0}
-                data_types[type_key]['functions'].append(func_name)
-                data_types[type_key]['usage_count'] += 1
-                mod = func_name.rsplit('.', 1)[0] if '.' in func_name else 'root'
-                for called in list(func.calls)[:10]:
-                    if (called.rsplit('.', 1)[0] if '.' in called else 'root') != mod:
-                        data_types[type_key]['cross_module_usage'] += 1
-                        break
+                    data_types[type_key] = self._create_type_entry(type_key, detected, params, returns)
+                func_module = func_name.rsplit('.', 1)[0] if '.' in func_name else 'root'
+                self._update_type_stats(data_types[type_key], func_name, func_module, func.calls)
         return sorted(data_types.values(), key=lambda x: x['usage_count'], reverse=True)
 
     def _infer_parameter_types(self, func) -> list:

{code2llm-0.5.6 → code2llm-0.5.7}/code2llm/cli.py

@@ -8,6 +8,7 @@ Analyze control flow, data flow, and call graphs of Python codebases.
 import argparse
 import sys
 from pathlib import Path
+from typing import List, Optional
 
 from .core.config import Config, ANALYSIS_MODES
 from .core.analyzer import ProjectAnalyzer
@@ -203,20 +204,18 @@ Strategy Options (--strategy):
     return parser
 
 
-def main():
-    """Main CLI entry point."""
-    # Handle special sub-commands first
+def _handle_special_commands() -> Optional[int]:
+    """Handle special sub-commands (llm-flow, llm-context)."""
     if len(sys.argv) > 1 and sys.argv[1] == 'llm-flow':
         from .generators.llm_flow import main as llm_flow_main
         return llm_flow_main(sys.argv[2:])
-
     if len(sys.argv) > 1 and sys.argv[1] == 'llm-context':
         return generate_llm_context(sys.argv[2:])
+    return None
 
-    # Parse arguments
-    parser = create_parser()
-    args = parser.parse_args()
 
+def _validate_and_setup(args) -> tuple[Path, Path]:
+    """Validate source path and setup output directory."""
     if not args.source:
         print("Error: missing required argument: source", file=sys.stderr)
         print("Usage: code2llm <source> [options]", file=sys.stderr)
@@ -230,12 +229,31 @@ def main():
 
     output_dir = Path(args.output)
     output_dir.mkdir(parents=True, exist_ok=True)
+    return source_path, output_dir
+
 
+def _print_start_info(args, source_path: Path, output_dir: Path) -> None:
+    """Print analysis start information if verbose."""
     if args.verbose:
         print(f"Analyzing: {source_path}")
         print(f"Mode: {args.mode}")
         print(f"Output: {output_dir}")
 
+
+def main():
+    """Main CLI entry point."""
+    # Handle special sub-commands first
+    special_result = _handle_special_commands()
+    if special_result is not None:
+        return special_result
+
+    # Parse arguments
+    parser = create_parser()
+    args = parser.parse_args()
+
+    source_path, output_dir = _validate_and_setup(args)
+    _print_start_info(args, source_path, output_dir)
+
     # Analyze → Export
     result = _run_analysis(args, source_path, output_dir)
     _run_exports(args, result, output_dir)
@@ -321,56 +339,70 @@ def _run_streaming_analysis(args, config, source_path: Path):
     return analyzer.analyze_project(str(source_path))
 
 
+def _export_evolution(args, result, output_dir: Path):
+    """Export evolution.toon format."""
+    if 'evolution' not in [f.strip() for f in args.format.split(',')] and 'all' not in [f.strip() for f in args.format.split(',')]:
+        return
+    exporter = EvolutionExporter()
+    filepath = output_dir / 'evolution.toon'
+    exporter.export(result, str(filepath))
+    if args.verbose:
+        print(f"  - EVOLUTION (refactoring queue): {filepath}")
+
+
+def _export_data_structures(args, result, output_dir: Path):
+    """Export data structures YAML."""
+    if not args.data_structures:
+        return
+    exporter = YAMLExporter()
+    struct_path = output_dir / 'data_structures.yaml'
+    exporter.export_data_structures(result, str(struct_path), compact=True)
+    if args.verbose:
+        print(f"  - Data structures: {struct_path}")
+
+
+def _export_context_fallback(args, result, output_dir: Path, formats: list):
+    """Export context.md if not in formats."""
+    if 'context' in formats or 'all' in formats:
+        return
+    exporter = ContextExporter()
+    filepath = output_dir / 'context.md'
+    exporter.export(result, str(filepath))
+    if args.verbose:
+        print(f"  - CONTEXT (LLM narrative): {filepath}")
+
+
+def _export_readme(args, result, output_dir: Path):
+    """Export README.md documentation."""
+    if not args.readme or args.no_readme:
+        return
+    exporter = READMEExporter()
+    filepath = output_dir / 'README.md'
+    exporter.export(result, str(filepath))
+    if args.verbose:
+        print(f"  - README (documentation): {filepath}")
+
+
 def _run_exports(args, result, output_dir: Path):
     """Export analysis results in requested formats."""
     formats = [f.strip() for f in args.format.split(',')]
-
     if 'all' in formats:
         formats = ['toon', 'map', 'flow', 'context', 'yaml', 'json', 'mermaid', 'evolution']
 
     try:
-        # Simple format exports
         _export_simple_formats(args, result, output_dir, formats)
-
-        # Mermaid (complex — 3 files + PNG)
+        
         if 'mermaid' in formats:
             _export_mermaid(args, result, output_dir)
-
-        # Evolution
-        if 'evolution' in formats:
-            exporter = EvolutionExporter()
-            filepath = output_dir / 'evolution.toon'
-            exporter.export(result, str(filepath))
-            if args.verbose:
-                print(f"  - EVOLUTION (refactoring queue): {filepath}")
-
-        # Data structures (optional flag)
-        if args.data_structures:
-            exporter = YAMLExporter()
-            struct_path = output_dir / 'data_structures.yaml'
-            exporter.export_data_structures(result, str(struct_path), compact=True)
-            if args.verbose:
-                print(f"  - Data structures: {struct_path}")
-
-        # Backward compat: always generate context.md
-        if 'context' not in formats:
-            exporter = ContextExporter()
-            filepath = output_dir / 'context.md'
-            exporter.export(result, str(filepath))
-            if args.verbose:
-                print(f"  - CONTEXT (LLM narrative): {filepath}")
-
-        # AI-driven refactoring prompts
+        
+        _export_evolution(args, result, output_dir)
+        _export_data_structures(args, result, output_dir)
+        _export_context_fallback(args, result, output_dir, formats)
+        
         if args.refactor:
             _export_refactor_prompts(args, result, output_dir)
-
-        # README documentation (default enabled)
-        if args.readme and not args.no_readme:
-            exporter = READMEExporter()
-            filepath = output_dir / 'README.md'
-            exporter.export(result, str(filepath))
-            if args.verbose:
-                print(f"  - README (documentation): {filepath}")
+        
+        _export_readme(args, result, output_dir)
 
     except Exception as e:
         print(f"Error during export: {e}", file=sys.stderr)

{code2llm-0.5.6 → code2llm-0.5.7}/code2llm/exporters/context_exporter.py

@@ -177,31 +177,48 @@ class ContextExporter(Exporter):
         lines.extend(["```", ""])
         return lines
 
+    def _group_calls_by_module(self, calls: list, func_name: str) -> dict:
+        """Group function calls by their module."""
+        module = func_name.rsplit('.', 1)[0] if '.' in func_name else 'root'
+        calls_by_module = {}
+        for called in calls[:5]:
+            mod = called.rsplit('.', 1)[0] if '.' in called else 'root'
+            if mod not in calls_by_module:
+                calls_by_module[mod] = []
+            calls_by_module[mod].append(called)
+        return calls_by_module, module
+
+    def _format_sub_flow(self, sub_flow: str, called: str, is_cross_module: bool) -> list:
+        """Format sub-flow lines with proper indentation."""
+        lines = []
+        cross = " →" if is_cross_module else ""
+        lines.append(f"  └─{cross}> {called.split('.')[-1]}")
+        for sub in sub_flow.split('\n')[1:][:3]:
+            lines.append("    " + sub)
+        return lines
+
     def _trace_flow(self, func_name: str, func, result: AnalysisResult, depth: int, visited: set = None) -> str:
         """Trace execution flow from a function with cycle detection."""
-        if visited is None: visited = set()
-        if func_name in visited or depth <= 0: return func_name.split('.')[-1]
+        if visited is None:
+            visited = set()
+        if func_name in visited or depth <= 0:
+            return func_name.split('.')[-1]
         
         visited.add(func_name)
         short_name = func_name.split('.')[-1]
         module = func_name.rsplit('.', 1)[0] if '.' in func_name else 'root'
         lines = [f"{short_name} [{module}]"]
         
-        calls_by_module = {}
-        for called in func.calls[:5]:
-            mod = called.rsplit('.', 1)[0] if '.' in called else 'root'
-            if mod not in calls_by_module: calls_by_module[mod] = []
-            calls_by_module[mod].append(called)
+        calls_by_module, func_module = self._group_calls_by_module(func.calls, func_name)
         
         shown = 0
-        for mod, calls in sorted(calls_by_module.items(), key=lambda x: x[0] != module):
+        for mod, calls in sorted(calls_by_module.items(), key=lambda x: x[0] != func_module):
             for called in calls[:2]:
-                if shown >= 3: break
+                if shown >= 3:
+                    break
                 called_func = result.functions.get(called)
                 if called_func and called not in visited:
                     sub_flow = self._trace_flow(called, called_func, result, depth - 1, visited.copy())
-                    cross = " →" if mod != module else ""
-                    lines.append(f"  └─{cross}> {called.split('.')[-1]}")
-                    for sub in sub_flow.split('\n')[1:][:3]: lines.append("    " + sub)
+                    lines.extend(self._format_sub_flow(sub_flow, called, mod != func_module))
                     shown += 1
         return '\n'.join(lines)

{code2llm-0.5.6 → code2llm-0.5.7}/code2llm/exporters/evolution_exporter.py

@@ -103,24 +103,38 @@ class EvolutionExporter(Exporter):
             })
         return sorted(func_data, key=lambda x: x["impact"], reverse=True)
 
-    def _compute_god_modules(self, result: AnalysisResult) -> List[Dict]:
-        """Identify god modules (≥500 lines) from project files."""
-        file_stats = defaultdict(lambda: {"lines": 0, "funcs": 0, "classes": set(), "max_cc": 0})
-        pp = Path(result.project_path) if result.project_path else None
-
-        # Scan file sizes
-        if pp and pp.is_dir():
-            for py in pp.rglob("*.py"):
-                fpath = str(py)
-                if self._is_excluded(fpath):
-                    continue
-                try:
-                    lc = len(py.read_text(encoding="utf-8", errors="ignore").splitlines())
-                    file_stats[fpath]["lines"] = lc
-                except Exception:
-                    pass
-
-        # Aggregate function/class data
+    def _scan_file_sizes(self, project_path: Optional[Path]) -> Dict[str, int]:
+        """Scan Python files and return line counts."""
+        file_lines: Dict[str, int] = {}
+        if not project_path or not project_path.is_dir():
+            return file_lines
+        
+        for py in project_path.rglob("*.py"):
+            fpath = str(py)
+            if self._is_excluded(fpath):
+                continue
+            try:
+                lc = len(py.read_text(encoding="utf-8", errors="ignore").splitlines())
+                file_lines[fpath] = lc
+            except Exception:
+                pass
+        return file_lines
+
+    def _aggregate_file_stats(
+        self, 
+        result: AnalysisResult, 
+        file_lines: Dict[str, int]
+    ) -> Dict[str, Dict]:
+        """Aggregate function and class data per file."""
+        file_stats: Dict[str, Dict] = defaultdict(
+            lambda: {"lines": 0, "funcs": 0, "classes": set(), "max_cc": 0}
+        )
+        
+        # Initialize with line counts
+        for fpath, lc in file_lines.items():
+            file_stats[fpath]["lines"] = lc
+        
+        # Aggregate function data
         for qname, fi in result.functions.items():
             if self._is_excluded(fi.file):
                 continue
@@ -129,28 +143,47 @@ class EvolutionExporter(Exporter):
             fs["max_cc"] = max(fs["max_cc"], fi.complexity.get("cyclomatic_complexity", 0))
             if fi.class_name:
                 fs["classes"].add(fi.class_name)
+        
+        # Aggregate class data
         for qname, ci in result.classes.items():
             if not self._is_excluded(ci.file):
                 file_stats[ci.file]["classes"].add(ci.name)
-
-        # Filter to god modules
+        
+        return file_stats
+
+    def _make_relative_path(self, fpath: str, project_path: Optional[Path]) -> str:
+        """Convert absolute path to relative path."""
+        if not project_path:
+            return fpath
+        try:
+            return str(Path(fpath).relative_to(project_path))
+        except ValueError:
+            return fpath
+
+    def _filter_god_modules(self, file_stats: Dict[str, Dict], project_path: Optional[Path]) -> List[Dict]:
+        """Filter files to god modules (≥500 lines)."""
         god_modules = []
         for fpath, stats in file_stats.items():
             if stats["lines"] >= GOD_MODULE_LINES:
-                rel = fpath
-                if pp:
-                    try:
-                        rel = str(Path(fpath).relative_to(pp))
-                    except ValueError:
-                        pass
+                rel = self._make_relative_path(fpath, project_path)
                 god_modules.append({
-                    "file": rel, "lines": stats["lines"],
-                    "funcs": stats["funcs"], "classes": len(stats["classes"]),
+                    "file": rel, 
+                    "lines": stats["lines"],
+                    "funcs": stats["funcs"], 
+                    "classes": len(stats["classes"]),
                     "max_cc": stats["max_cc"],
                 })
         god_modules.sort(key=lambda x: x["lines"], reverse=True)
         return god_modules
 
+    def _compute_god_modules(self, result: AnalysisResult) -> List[Dict]:
+        """Identify god modules (≥500 lines) from project files."""
+        pp = Path(result.project_path) if result.project_path else None
+        
+        file_lines = self._scan_file_sizes(pp)
+        file_stats = self._aggregate_file_stats(result, file_lines)
+        return self._filter_god_modules(file_stats, pp)
+
     def _compute_hub_types(self, result: AnalysisResult) -> List[Dict]:
         """Identify hub types consumed by many functions."""
         type_consumers: Dict[str, int] = defaultdict(int)

code2llm-0.5.7/code2llm/exporters/flow_constants.py

@@ -0,0 +1,29 @@
+"""Stałe dla FlowExporter.
+
+Zawiera progi, wzorce wykluczeń i rekomendacje dotyczące podziału typów hub.
+"""
+
+# Progi dla wykrywania problemów
+CC_HIGH = 15
+FAN_OUT_THRESHOLD = 10
+HUB_TYPE_THRESHOLD = 10
+
+# Wzorce do wykluczenia (venv, cache, etc.)
+EXCLUDE_PATTERNS = {
+    'venv', '.venv', 'env', '.env', 'publish-env', 'test-env',
+    'site-packages', 'node_modules', '__pycache__', '.git',
+    'dist', 'build', 'egg-info', '.tox', '.mypy_cache',
+}
+
+# Rekomendacje podziału typów hub: typ -> sugerowane pod-interfejsy
+HUB_SPLIT_RECOMMENDATIONS = {
+    "AnalysisResult": [
+        "StructureResult (modules, classes, functions)",
+        "MetricsResult (complexity, coupling)",
+        "FlowResult (call_graph, cfg, dfg)",
+    ],
+    "dict": ["replace with typed alternatives (dataclass/TypedDict)"],
+    "str": [],  # primitive, expected to be ubiquitous
+    "list": [],
+    "Any": [],
+}