code2llm 0.5.107__tar.gz → 0.5.109__tar.gz

{code2llm-0.5.107 → code2llm-0.5.109}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code2llm
-Version: 0.5.107
+Version: 0.5.109
 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
@@ -50,6 +50,7 @@ Requires-Dist: tree-sitter-ruby>=0.21
 Provides-Extra: dev
 Requires-Dist: pytest>=6.2; extra == "dev"
 Requires-Dist: pytest-cov>=2.12; extra == "dev"
+Requires-Dist: pytest-xdist>=3.0; extra == "dev"
 Requires-Dist: black>=21.0; extra == "dev"
 Requires-Dist: flake8>=3.9; extra == "dev"
 Requires-Dist: mypy>=0.910; extra == "dev"
@@ -66,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.107-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.109-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-53.7h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
 
 - 🤖 **LLM usage:** $7.5000 (154 commits)

{code2llm-0.5.107 → code2llm-0.5.109}/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.107-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.109-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-53.7h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
 
 - 🤖 **LLM usage:** $7.5000 (154 commits)

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

{code2llm-0.5.107 → code2llm-0.5.109}/code2llm/cli_commands.py

@@ -109,71 +109,101 @@ def print_start_info(args, source_path: Path, output_dir: Path) -> None:
 
 def validate_chunked_output(output_dir: Path, args) -> bool:
     """Validate generated chunked output.
-    
+
     Checks:
     1. All chunks have required files (analysis.toon, context.md, evolution.toon.yaml)
     2. Files are not empty
     3. Report summary
-    
+
     Returns True if valid, False otherwise.
     """
     if not output_dir.exists():
         print(f"✗ Output directory does not exist: {output_dir}", file=sys.stderr)
         return False
-    
-    # Find all chunk directories
-    chunk_dirs = [d for d in output_dir.iterdir() if d.is_dir()]
-    
+
+    chunk_dirs = _get_chunk_dirs(output_dir)
     if not chunk_dirs:
         print(f"✗ No chunk directories found in: {output_dir}", file=sys.stderr)
         return False
-    
+
     required_files = ['analysis.toon.yaml', 'context.md', 'evolution.toon.yaml']
+    issues, valid_chunks = _validate_chunks(chunk_dirs, required_files)
+
+    _print_validation_summary(chunk_dirs, valid_chunks, issues)
+    return len(issues) == 0
+
+
+def _get_chunk_dirs(output_dir: Path) -> list[Path]:
+    """Find all chunk directories in output directory."""
+    return [d for d in output_dir.iterdir() if d.is_dir()]
+
+
+def _validate_chunks(chunk_dirs: list[Path], required_files: list[str]) -> tuple:
+    """Validate all chunks and return issues and valid chunks."""
     issues = []
     valid_chunks = []
-    
-    print(f"\n🔍 Validating {len(chunk_dirs)} chunks in: {output_dir}")
+
+    print(f"\n🔍 Validating {len(chunk_dirs)} chunks")
     print("-" * 50)
-    
+
     for chunk_dir in sorted(chunk_dirs):
-        chunk_name = chunk_dir.name
-        chunk_issues = []
-        
-        for req_file in required_files:
-            file_path = chunk_dir / req_file
-            if not file_path.exists():
-                chunk_issues.append(f"  missing {req_file}")
-            elif file_path.stat().st_size == 0:
-                chunk_issues.append(f"  empty {req_file}")
-        
+        chunk_issues = _validate_single_chunk(chunk_dir, required_files)
+
         if chunk_issues:
-            issues.append((chunk_name, chunk_issues))
-            print(f"✗ {chunk_name}")
-            for issue in chunk_issues:
-                print(f"    {issue}")
+            issues.append((chunk_dir.name, chunk_issues))
+            _print_chunk_errors(chunk_dir.name, chunk_issues)
         else:
-            # Get file sizes
-            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")
-            valid_chunks.append(chunk_name)
-            print(f"✓ {chunk_name} ({', '.join(sizes)})")
-    
+            sizes = _get_file_sizes(chunk_dir, required_files)
+            valid_chunks.append(chunk_dir.name)
+            print(f"✓ {chunk_dir.name} ({sizes})")
+
     print("-" * 50)
+    return issues, valid_chunks
+
+
+def _validate_single_chunk(chunk_dir: Path, required_files: list[str]) -> list[str]:
+    """Validate a single chunk directory. Returns list of issues."""
+    chunk_issues = []
+
+    for req_file in required_files:
+        file_path = chunk_dir / req_file
+        if not file_path.exists():
+            chunk_issues.append(f"  missing {req_file}")
+        elif file_path.stat().st_size == 0:
+            chunk_issues.append(f"  empty {req_file}")
+
+    return chunk_issues
+
+
+def _get_file_sizes(chunk_dir: Path, required_files: list[str]) -> str:
+    """Get formatted file sizes for a chunk."""
+    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")
+    return ", ".join(sizes)
+
+
+def _print_chunk_errors(chunk_name: str, chunk_issues: list[str]) -> None:
+    """Print errors for a chunk."""
+    print(f"✗ {chunk_name}")
+    for issue in chunk_issues:
+        print(f"    {issue}")
+
+
+def _print_validation_summary(chunk_dirs: list, valid_chunks: list, issues: list) -> None:
+    """Print validation summary report."""
     print(f"\n📊 Validation Summary:")
     print(f"  Total chunks: {len(chunk_dirs)}")
     print(f"  Valid: {len(valid_chunks)}")
     print(f"  Issues: {len(issues)}")
-    
+
     if issues:
         print(f"\n⚠️  {len(issues)} chunk(s) have issues:")
-        for chunk_name, chunk_issues in issues:
+        for chunk_name, _ in issues:
             print(f"    - {chunk_name}")
-        return False
     else:
         print(f"\n✅ All {len(valid_chunks)} chunks are valid!")
-        return True
 
 
 def generate_llm_context(args_list):

{code2llm-0.5.107 → code2llm-0.5.109}/code2llm/cli_exports/orchestrator.py

@@ -103,6 +103,9 @@ def _export_chunked_results(
     _export_simple_formats(args, result, output_dir, ['toon', 'context'])
     _export_evolution(args, result, output_dir)
 
+    if 'calls' in formats:
+        _export_calls(args, result, output_dir)
+
     if 'all' in requested_formats:
         _export_project_toon(args, result, output_dir)
 

{code2llm-0.5.107 → code2llm-0.5.109}/code2llm/exporters/yaml_exporter.py

@@ -117,53 +117,107 @@ class YAMLExporter(Exporter):
         - modules: grouping of functions by module
         - stats: summary statistics
         """
-        # Collect connected nodes and edges
+        connected, edges = self._collect_edges(result, max_calls_per_func, max_edges)
+        nodes = self._build_nodes(result, connected)
+        modules = self._group_by_module(result, connected)
+        
+        calls_data = self._build_calls_data(result, nodes, edges, modules)
+        
+        Path(output_path).parent.mkdir(parents=True, exist_ok=True)
+        with open(output_path, 'w', encoding='utf-8') as f:
+            yaml.dump(calls_data, f, default_flow_style=False, allow_unicode=True, sort_keys=False)
+
+    def _collect_edges(self, result: AnalysisResult, max_calls: int, max_edges: int) -> Tuple[Set[str], List[Dict]]:
+        """Collect connected nodes and edges from function calls."""
         connected: Set[str] = set()
         edges: List[Dict] = []
         seen_pairs: Set[Tuple[str, str]] = set()
-        
+
         for func_name, fi in result.functions.items():
-            for callee in fi.calls[:max_calls_per_func]:
-                resolved = self._resolve_callee(callee, result.functions)
-                if resolved and resolved != func_name:
-                    connected.add(func_name)
-                    connected.add(resolved)
-                    pair = (func_name, resolved)
-                    if pair not in seen_pairs:
-                        seen_pairs.add(pair)
-                        edges.append({
-                            'caller': func_name,
-                            'callee': resolved,
-                            'call_type': 'direct' if callee == resolved.split('.')[-1] else 'resolved'
-                        })
-                        if len(edges) >= max_edges:
-                            break
             if len(edges) >= max_edges:
                 break
-        
-        # Build nodes data
+            self._process_function_calls(
+                func_name, fi, result.functions, max_calls, max_edges,
+                connected, edges, seen_pairs
+            )
+
+        return connected, edges
+
+    def _process_function_calls(
+        self, func_name: str, fi: FunctionInfo, functions: Dict[str, FunctionInfo],
+        max_calls: int, max_edges: int, connected: Set[str], edges: List[Dict],
+        seen_pairs: Set[Tuple[str, str]]
+    ) -> None:
+        """Process calls for a single function."""
+        for callee in fi.calls[:max_calls]:
+            if len(edges) >= max_edges:
+                break
+            resolved = self._resolve_callee(callee, functions)
+            if self._should_add_edge(func_name, resolved, seen_pairs):
+                connected.add(func_name)
+                connected.add(resolved)
+                seen_pairs.add((func_name, resolved))
+                edges.append(self._create_edge(func_name, resolved, callee))
+
+    @staticmethod
+    def _should_add_edge(func_name: str, resolved: Optional[str], seen_pairs: Set[Tuple[str, str]]) -> bool:
+        """Check if edge should be added (valid callee and not duplicate)."""
+        if not resolved or resolved == func_name:
+            return False
+        return (func_name, resolved) not in seen_pairs
+
+    @staticmethod
+    def _create_edge(caller: str, resolved: str, callee: str) -> Dict:
+        """Create edge dict with call type classification."""
+        return {
+            'caller': caller,
+            'callee': resolved,
+            'call_type': 'direct' if callee == resolved.split('.')[-1] else 'resolved'
+        }
+
+    def _build_nodes(self, result: AnalysisResult, connected: Set[str]) -> Dict[str, Dict]:
+        """Build node data for all connected functions."""
         nodes: Dict[str, Dict] = {}
         for fn in connected:
             fi = result.functions.get(fn)
             if fi:
-                cc = self._get_cc(fi)
-                nodes[fn] = {
-                    'name': fi.name,
-                    'module': fi.module,
-                    'line': fi.line,
-                    'cyclomatic_complexity': cc,
-                    'calls_out': len(fi.calls),
-                    'calls_in': sum(1 for f in result.functions.values() if fn in [self._resolve_callee(c, result.functions) for c in f.calls]),
-                }
-        
-        # Group by module
+                nodes[fn] = self._create_node(fi, fn, result)
+        return nodes
+
+    def _create_node(self, fi: FunctionInfo, fn: str, result: AnalysisResult) -> Dict:
+        """Create node dict with function metadata."""
+        return {
+            'name': fi.name,
+            'module': fi.module,
+            'line': fi.line,
+            'cyclomatic_complexity': self._get_cc(fi),
+            'calls_out': len(fi.calls),
+            'calls_in': self._count_calls_in(fn, result),
+        }
+
+    def _count_calls_in(self, fn: str, result: AnalysisResult) -> int:
+        """Count how many functions call the given function."""
+        count = 0
+        for f in result.functions.values():
+            for c in f.calls:
+                resolved = self._resolve_callee(c, result.functions)
+                if resolved == fn:
+                    count += 1
+                    break
+        return count
+
+    @staticmethod
+    def _group_by_module(result: AnalysisResult, connected: Set[str]) -> Dict[str, List[str]]:
+        """Group connected functions by their module."""
         modules: Dict[str, List[str]] = defaultdict(list)
         for fn in connected:
             fi = result.functions.get(fn)
             if fi:
                 modules[fi.module].append(fn)
-        
-        # Build output structure
+        return {mod: sorted(funcs) for mod, funcs in sorted(modules.items())}
+
+    def _build_calls_data(self, result: AnalysisResult, nodes: Dict, edges: List, modules: Dict) -> Dict:
+        """Build the final calls.yaml data structure."""
         calls_data = {
             'project': result.project_path,
             'generated_from': 'code2llm call graph analysis',
@@ -174,16 +228,13 @@ class YAMLExporter(Exporter):
             },
             'nodes': nodes,
             'edges': edges,
-            'modules': {mod: sorted(funcs) for mod, funcs in sorted(modules.items())},
+            'modules': modules,
         }
         
-        # Add entry points if available
         if result.entry_points:
             calls_data['entry_points'] = sorted(result.entry_points)
         
-        Path(output_path).parent.mkdir(parents=True, exist_ok=True)
-        with open(output_path, 'w', encoding='utf-8') as f:
-            yaml.dump(calls_data, f, default_flow_style=False, allow_unicode=True, sort_keys=False)
+        return calls_data
 
     @staticmethod
     def _resolve_callee(callee: str, funcs: Dict[str, FunctionInfo]) -> Optional[str]:

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

{code2llm-0.5.107 → code2llm-0.5.109}/code2llm.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code2llm
-Version: 0.5.107
+Version: 0.5.109
 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
@@ -50,6 +50,7 @@ Requires-Dist: tree-sitter-ruby>=0.21
 Provides-Extra: dev
 Requires-Dist: pytest>=6.2; extra == "dev"
 Requires-Dist: pytest-cov>=2.12; extra == "dev"
+Requires-Dist: pytest-xdist>=3.0; extra == "dev"
 Requires-Dist: black>=21.0; extra == "dev"
 Requires-Dist: flake8>=3.9; extra == "dev"
 Requires-Dist: mypy>=0.910; extra == "dev"
@@ -66,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.107-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.109-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-53.7h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
 
 - 🤖 **LLM usage:** $7.5000 (154 commits)

{code2llm-0.5.107 → code2llm-0.5.109}/code2llm.egg-info/requires.txt

@@ -24,6 +24,7 @@ tree-sitter-ruby>=0.21
 [dev]
 pytest>=6.2
 pytest-cov>=2.12
+pytest-xdist>=3.0
 black>=21.0
 flake8>=3.9
 mypy>=0.910

{code2llm-0.5.107 → code2llm-0.5.109}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "code2llm"
-version = "0.5.107"
+version = "0.5.109"
 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"
@@ -67,6 +67,7 @@ dependencies = [
 dev = [
     "pytest>=6.2",
     "pytest-cov>=2.12",
+    "pytest-xdist>=3.0",
     "black>=21.0",
     "flake8>=3.9",
     "mypy>=0.910",
@@ -94,6 +95,10 @@ ignore_missing_imports = true
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 python_files = "test_*.py"
+addopts = "-n auto"  # Run tests in parallel using pytest-xdist
+markers = [
+    "slow: marks tests as slow (deselect with '-m \"not slow\"')"
+]
 
 [tool.pfix]
 # Self-healing Python configuration

{code2llm-0.5.107 → code2llm-0.5.109}/setup.py

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

{code2llm-0.5.107 → code2llm-0.5.109}/tests/test_edge_cases.py

@@ -50,22 +50,23 @@ class TestEdgeCases:
         finally:
             shutil.rmtree(tmp_dir)
     
+    @pytest.mark.slow
     def test_very_large_file(self):
         """Handle very large Python file."""
         tmp_dir = Path(tempfile.mkdtemp())
         try:
-            # Create large file (1000 functions)
-            lines = [f"def func_{i}(): pass" for i in range(1000)]
+            # Create large file (200 functions - reduced from 1000 for faster tests)
+            lines = [f"def func_{i}(): pass" for i in range(200)]
             (tmp_dir / "large.py").write_text('\n'.join(lines))
-            
+
             config = Config(
                 mode="static",
                 filters=FilterConfig(exclude_patterns=[], min_function_lines=1)
             )
             analyzer = ProjectAnalyzer(config)
             result = analyzer.analyze_project(str(tmp_dir))
-            
-            assert result.get_function_count() >= 1000
+
+            assert result.get_function_count() >= 200
         finally:
             shutil.rmtree(tmp_dir)