code2llm 0.5.156__tar.gz → 0.5.157__tar.gz

{code2llm-0.5.156/code2llm.egg-info → code2llm-0.5.157}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code2llm
-Version: 0.5.156
+Version: 0.5.157
 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
@@ -66,11 +66,11 @@ Dynamic: requires-python
 
 ## AI Cost Tracking
 
-![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.5.156-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-79.7h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
+![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.5.157-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-80.7h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
 
-- 🤖 **LLM usage:** $7.5000 (211 commits)
-- 👤 **Human dev:** ~$7972 (79.7h @ $100/h, 30min dedup)
+- 🤖 **LLM usage:** $7.5000 (212 commits)
+- 👤 **Human dev:** ~$8072 (80.7h @ $100/h, 30min dedup)
 
 Generated on 2026-05-25 using [openrouter/qwen/qwen3-coder-next](https://openrouter.ai/qwen/qwen3-coder-next)
 

{code2llm-0.5.156 → code2llm-0.5.157}/README.md

@@ -2,11 +2,11 @@
 
 ## AI Cost Tracking
 
-![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.5.156-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-79.7h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
+![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.5.157-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-80.7h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
 
-- 🤖 **LLM usage:** $7.5000 (211 commits)
-- 👤 **Human dev:** ~$7972 (79.7h @ $100/h, 30min dedup)
+- 🤖 **LLM usage:** $7.5000 (212 commits)
+- 👤 **Human dev:** ~$8072 (80.7h @ $100/h, 30min dedup)
 
 Generated on 2026-05-25 using [openrouter/qwen/qwen3-coder-next](https://openrouter.ai/qwen/qwen3-coder-next)
 

code2llm-0.5.157/VERSION

@@ -0,0 +1 @@
+0.5.157

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

code2llm-0.5.157/code2llm/analysis/_data_impl.py

@@ -0,0 +1,360 @@
+"""Private implementation helpers for DataAnalyzer.
+
+Extracted to keep data_analysis.py under the MI hard-gate threshold.
+All functions here are module-private (leading underscore) and called
+exclusively from DataAnalyzer in data_analysis.py.
+"""
+
+from typing import Any, Dict, List
+from code2llm.core.models import AnalysisResult
+
+
+# ---------------------------------------------------------------------------
+# Flow finders
+# ---------------------------------------------------------------------------
+
+
+def _find_data_pipelines(result: AnalysisResult, categorize_fn, make_stage_fn, max_pipelines: int) -> list:
+    """Find data transformation pipelines in the codebase."""
+    input_funcs, transform_funcs, output_funcs = categorize_fn(result)
+
+    pipelines: list = []
+    for in_name, in_func in input_funcs[:20]:
+        for t_name, t_func in transform_funcs[:30]:
+            if t_name not in in_func.calls:
+                continue
+            for out_name, out_func in output_funcs[:20]:
+                if out_name not in t_func.calls:
+                    continue
+                pipelines.append(
+                    {
+                        "pipeline_id": f"pipeline_{len(pipelines) + 1}",
+                        "stages": [
+                            make_stage_fn("input", in_name, in_func),
+                            make_stage_fn("transform", t_name, t_func),
+                            make_stage_fn("output", out_name, out_func),
+                        ],
+                        "data_flow": f"{in_name} → {t_name} → {out_name}",
+                    }
+                )
+                if len(pipelines) >= max_pipelines:
+                    return pipelines
+    return pipelines
+
+
+def _find_state_patterns(result: AnalysisResult) -> list:
+    """Find state management patterns."""
+    patterns: list = []
+    state_indicators = ["state", "status", "mode", "phase", "lifecycle", "session", "context"]
+    transition_indicators = ["transition", "change", "update", "set_state", "switch"]
+
+    for func_name, func in result.functions.items():
+        name_lower = func.name.lower()
+        if any(ind in name_lower for ind in state_indicators + transition_indicators):
+            affected_states = []
+            for call in list(func.calls)[:10]:
+                call_func = result.functions.get(call)
+                if call_func and any(ind in call_func.name.lower() for ind in state_indicators):
+                    affected_states.append(call)
+            patterns.append(
+                {
+                    "function": func_name,
+                    "type": "state_manager"
+                    if "set" in name_lower or "update" in name_lower
+                    else "state_reader",
+                    "affects_states": affected_states[:5],
+                    "description": func.docstring[:150] if func.docstring else "N/A",
+                }
+            )
+            if len(patterns) >= 20:
+                break
+    return patterns
+
+
+def _find_data_dependencies(result: AnalysisResult) -> list:
+    """Find cross-module data dependencies."""
+    module_data_flow: Dict[Any, Any] = {}
+    for func_name, func in result.functions.items():
+        func_module = func_name.rsplit(".", 1)[0] if "." in func_name else "root"
+        for called in list(func.calls)[:15]:
+            called_module = called.rsplit(".", 1)[0] if "." in called else "root"
+            if func_module != called_module and called in result.functions:
+                key = (func_module, called_module)
+                if key not in module_data_flow:
+                    module_data_flow[key] = {
+                        "from_module": func_module,
+                        "to_module": called_module,
+                        "data_functions": [],
+                        "call_count": 0,
+                    }
+                module_data_flow[key]["data_functions"].append({"caller": func_name, "callee": called})
+                module_data_flow[key]["call_count"] += 1
+    deps = sorted(module_data_flow.values(), key=lambda x: x["call_count"], reverse=True)
+    for dep in deps:
+        dep["data_functions"] = dep["data_functions"][:10]
+    return deps[:15]
+
+
+def _find_event_flows(result: AnalysisResult) -> list:
+    """Find event-driven patterns."""
+    flows: list = []
+    event_indicators = ["event", "emit", "trigger", "notify", "callback", "handler", "listen", "subscribe"]
+    hook_indicators = ["hook", "on_", "before_", "after_", "pre_", "post_"]
+    for func_name, func in result.functions.items():
+        name_lower = func.name.lower()
+        if any(ind in name_lower for ind in event_indicators) or any(
+            name_lower.startswith(ind) for ind in hook_indicators
+        ):
+            handlers = []
+            for called in list(func.calls)[:10]:
+                called_func = result.functions.get(called)
+                if called_func and any(
+                    ind in called_func.name.lower() for ind in event_indicators + ["handle", "process"]
+                ):
+                    handlers.append(called)
+            flows.append(
+                {
+                    "event_source": func_name,
+                    "type": "emitter" if "emit" in name_lower or "trigger" in name_lower else "handler",
+                    "handlers": handlers[:5],
+                    "description": func.docstring[:150] if func.docstring else "N/A",
+                }
+            )
+            if len(flows) >= 20:
+                break
+    return flows
+
+
+# ---------------------------------------------------------------------------
+# Type analysis helpers
+# ---------------------------------------------------------------------------
+
+
+def _detect_types_from_name(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"],
+        "str": ["string", "text", "content", "message"],
+        "int": ["int", "count", "index", "number", "id"],
+        "float": ["float", "decimal", "score", "probability"],
+        "bool": ["bool", "flag", "is_", "has_"],
+        "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(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(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 _infer_parameter_types(func) -> list:
+    """Infer parameter types from function name patterns."""
+    params: List[str] = []
+    name = func.name.lower()
+    if "list" in name or "items" in name:
+        params.append("list")
+    if "dict" in name or "map" in name:
+        params.append("dict")
+    if "text" in name or "string" in name:
+        params.append("str")
+    if "count" in name or "index" in name:
+        params.append("int")
+    return params
+
+
+def _infer_return_types(func) -> list:
+    """Infer return types from function name patterns."""
+    returns: List[str] = []
+    name = func.name.lower()
+    if name.startswith(("get_", "find_")):
+        returns.append("dict")
+    if name.startswith(("is_", "has_")):
+        returns.append("bool")
+    if name.startswith(("count_", "len_")):
+        returns.append("int")
+    if name.startswith(("list_", "get_all_")):
+        returns.append("list")
+    return returns
+
+
+def _analyze_data_types(result: AnalysisResult) -> list:
+    """Analyze data types and usage across all functions."""
+    data_types: Dict[str, Any] = {}
+    for func_name, func in result.functions.items():
+        doc = func.docstring.lower() if func.docstring else ""
+        detected = _detect_types_from_name(func.name, doc)
+        params = _infer_parameter_types(func)
+        returns = _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] = _create_type_entry(type_key, detected, params, returns)
+            func_module = func_name.rsplit(".", 1)[0] if "." in func_name else "root"
+            _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)
+
+
+# ---------------------------------------------------------------------------
+# Graph and process analysis helpers
+# ---------------------------------------------------------------------------
+
+
+def _get_function_data_types(func) -> list:
+    """Derive data type labels for a function from its name and docstring."""
+    types: List[str] = []
+    name = func.name.lower()
+    if "list" in name or "items" in name:
+        types.append("list")
+    if "dict" in name or "map" in name:
+        types.append("dict")
+    if "text" in name or "string" in name:
+        types.append("str")
+    if "count" in name or "index" in name:
+        types.append("int")
+    if func.docstring:
+        doc = func.docstring.lower()
+        if "list" in doc:
+            types.append("list")
+        if "dict" in doc:
+            types.append("dict")
+        if "string" in doc or "text" in doc:
+            types.append("str")
+    return list(set(types))
+
+
+def _build_data_flow_graph(result: AnalysisResult) -> dict:
+    """Build data flow graph from function relationships."""
+    nodes: Dict[str, Any] = {}
+    edges: list = []
+    for func_name, func in result.functions.items():
+        nodes[func_name] = {
+            "id": func_name,
+            "name": func.name.split(".")[-1],
+            "module": func_name.rsplit(".", 1)[0] if "." in func_name else "root",
+            "data_types": _get_function_data_types(func),
+            "in_degree": len(func.called_by),
+            "out_degree": len(func.calls),
+            "is_hub": len(func.calls) > 5 or len(func.called_by) > 5,
+        }
+    for func_name, func in result.functions.items():
+        for called in list(func.calls)[:15]:
+            if called in result.functions:
+                edges.append({"from": func_name, "to": called, "data_flow": True, "weight": 1})
+    return {
+        "nodes": nodes,
+        "edges": edges,
+        "stats": {
+            "total_nodes": len(nodes),
+            "total_edges": len(edges),
+            "hub_nodes": sum(1 for n in nodes.values() if n["is_hub"]),
+        },
+    }
+
+
+def _identify_process_patterns(result: AnalysisResult) -> list:
+    """Identify common data processing patterns (filter, map, reduce, etc.)."""
+    patterns: Dict[str, list] = {
+        "filter": [], "map": [], "reduce": [], "aggregate": [], "transform": [], "validate": [],
+    }
+    indicators = {
+        "filter": ["filter", "select", "where", "find"],
+        "map": ["map", "transform", "process"],
+        "reduce": ["reduce", "sum", "count", "aggregate"],
+        "aggregate": ["group", "bucket", "cluster"],
+        "transform": ["transform", "convert", "normalize"],
+        "validate": ["validate", "check", "verify"],
+    }
+    for func_name, func in result.functions.items():
+        name = func.name.lower()
+        doc = func.docstring.lower() if func.docstring else ""
+        for p_type, inds in indicators.items():
+            if any(ind in name or ind in doc for ind in inds):
+                patterns[p_type].append(
+                    {
+                        "function": func_name,
+                        "description": func.docstring[:100] if func.docstring else "N/A",
+                        "data_flow": f"{len(func.called_by)} → {func_name} → {len(func.calls)}",
+                    }
+                )
+                break
+    res = []
+    for p_type, funcs in patterns.items():
+        res.append({"pattern_type": p_type, "functions": funcs[:10], "count": len(funcs)})
+    return sorted(res, key=lambda x: x["count"], reverse=True)
+
+
+def _analyze_optimization_opportunities(
+    result: AnalysisResult, data_types: list, dfg: dict
+) -> dict:
+    """Analyze optimization opportunities in data handling."""
+    opt: Dict[str, Any] = {
+        "potential_score": 0.0,
+        "type_consolidation": [],
+        "process_consolidation": [],
+        "hub_optimization": [],
+        "recommendations": [],
+    }
+    similar: Dict[str, list] = {}
+    for dt in data_types:
+        sig = ",".join(sorted(dt["detected_types"]))
+        if sig not in similar:
+            similar[sig] = []
+        similar[sig].append(dt)
+    for _sig, sims in similar.items():
+        if len(sims) > 1:
+            usage = sum(s["usage_count"] for s in sims)
+            if usage > 10:
+                opt["type_consolidation"].append(
+                    {
+                        "type_signature": _sig,
+                        "similar_types": [s["type_name"] for s in sims],
+                        "total_usage": usage,
+                        "potential_reduction": len(sims) - 1,
+                    }
+                )
+    for p in _identify_process_patterns(result):
+        if p["count"] > 5:
+            opt["process_consolidation"].append(
+                {
+                    "pattern_type": p["pattern_type"],
+                    "function_count": p["count"],
+                    "potential_reduction": p["count"] // 3,
+                }
+            )
+    for hub in [n for n in dfg["nodes"].values() if n["is_hub"]][:10]:
+        opt["hub_optimization"].append(
+            {
+                "function": hub["id"],
+                "connections": hub["in_degree"] + hub["out_degree"],
+                "optimization_type": "split" if hub["out_degree"] > 10 else "cache",
+            }
+        )
+    opt["potential_score"] = (
+        len(opt["type_consolidation"]) * 10
+        + len(opt["process_consolidation"]) * 15
+        + len(opt["hub_optimization"]) * 5
+    ) / 100.0
+    return opt

code2llm-0.5.157/code2llm/analysis/data_analysis.py

@@ -0,0 +1,177 @@
+"""Data Analysis logic for code2llm - split into focused analyzers.
+
+This module provides three analyzers:
+  - DataFlowAnalyzer: data pipelines, state patterns, dependencies, event flows
+  - OptimizationAdvisor: data types, optimization opportunities, process patterns
+  - DataAnalyzer: facade combining both analyzers (backward compatibility)
+
+Heavy implementation details live in _data_impl to keep this file's MI above
+the regix hard-gate threshold.
+"""
+
+from typing import Any, Dict, Tuple
+from code2llm.core.models import AnalysisResult
+from code2llm.analysis._data_impl import (
+    _find_data_pipelines,
+    _find_state_patterns,
+    _find_data_dependencies,
+    _find_event_flows,
+    _analyze_data_types,
+    _build_data_flow_graph,
+    _identify_process_patterns,
+    _analyze_optimization_opportunities,
+)
+
+
+_INPUT_INDICATORS = [
+    "parse",
+    "load",
+    "read",
+    "fetch",
+    "get",
+    "input",
+    "receive",
+    "extract",
+]
+_TRANSFORM_INDICATORS = [
+    "transform",
+    "convert",
+    "process",
+    "validate",
+    "filter",
+    "map",
+    "reduce",
+    "compute",
+]
+_OUTPUT_INDICATORS = [
+    "serialize",
+    "format",
+    "write",
+    "save",
+    "send",
+    "output",
+    "render",
+    "encode",
+]
+_MAX_PIPELINES = 15
+
+
+def _categorize_functions(result: "AnalysisResult") -> Tuple[list, list, list]:
+    """Categorize functions into input/transform/output based on name patterns."""
+    input_funcs, transform_funcs, output_funcs = [], [], []
+    for func_name, func in result.functions.items():
+        name_lower = func.name.lower()
+        if any(ind in name_lower for ind in _INPUT_INDICATORS):
+            input_funcs.append((func_name, func))
+        elif any(ind in name_lower for ind in _TRANSFORM_INDICATORS):
+            transform_funcs.append((func_name, func))
+        elif any(ind in name_lower for ind in _OUTPUT_INDICATORS):
+            output_funcs.append((func_name, func))
+    return input_funcs, transform_funcs, output_funcs
+
+
+def _make_stage(label: str, func_name: str, func) -> Dict[str, str]:
+    """Build a single pipeline stage dict."""
+    return {
+        "stage": label,
+        "function": func_name,
+        "description": func.docstring[:100] if func.docstring else "N/A",
+    }
+
+
+class DataAnalyzer:
+    """Analyze data flows, structures, and optimization opportunities."""
+
+    def analyze_data_flow(self, result: AnalysisResult) -> Dict[str, Any]:
+        """Perform detailed data flow analysis."""
+        return {
+            "data_pipelines": _find_data_pipelines(result, _categorize_functions, _make_stage, _MAX_PIPELINES),
+            "state_patterns": _find_state_patterns(result),
+            "data_dependencies": _find_data_dependencies(result),
+            "event_flows": _find_event_flows(result),
+        }
+
+    def analyze_data_structures(self, result: AnalysisResult) -> Dict[str, Any]:
+        """Analyze data structures and optimization opportunities."""
+        data_types = _analyze_data_types(result)
+        data_flow_graph = _build_data_flow_graph(result)
+        process_patterns = _identify_process_patterns(result)
+        optimization_analysis = _analyze_optimization_opportunities(
+            result, data_types, data_flow_graph
+        )
+        return {
+            "data_types": data_types,
+            "data_flow_graph": data_flow_graph,
+            "process_patterns": process_patterns,
+            "optimization_analysis": optimization_analysis,
+        }
+
+
+
+# ---------------------------------------------------------------------------
+# Focused analyzer classes
+# ---------------------------------------------------------------------------
+
+
+class DataFlowAnalyzer:
+    """Analyze data flows: pipelines, state patterns, dependencies, and event flows."""
+
+    def analyze(self, result: AnalysisResult) -> Dict[str, Any]:
+        """Perform complete data flow analysis."""
+        return {
+            "data_pipelines": self.find_data_pipelines(result),
+            "state_patterns": self.find_state_patterns(result),
+            "data_dependencies": self.find_data_dependencies(result),
+            "event_flows": self.find_event_flows(result),
+        }
+
+    def find_data_pipelines(self, result: AnalysisResult) -> list:
+        """Find data transformation pipelines."""
+        return _find_data_pipelines(result, _categorize_functions, _make_stage, _MAX_PIPELINES)
+
+    def find_state_patterns(self, result: AnalysisResult) -> list:
+        """Find state management patterns."""
+        return _find_state_patterns(result)
+
+    def find_data_dependencies(self, result: AnalysisResult) -> list:
+        """Find cross-module data dependencies."""
+        return _find_data_dependencies(result)
+
+    def find_event_flows(self, result: AnalysisResult) -> list:
+        """Find event-driven patterns."""
+        return _find_event_flows(result)
+
+
+class OptimizationAdvisor:
+    """Analyze optimization opportunities: data types and process patterns."""
+
+    def analyze(self, result: AnalysisResult) -> Dict[str, Any]:
+        """Perform complete optimization analysis."""
+        data_types = _analyze_data_types(result)
+        data_flow_graph = _build_data_flow_graph(result)
+        process_patterns = _identify_process_patterns(result)
+        optimization_analysis = _analyze_optimization_opportunities(result, data_types, data_flow_graph)
+        return {
+            "data_types": data_types,
+            "data_flow_graph": data_flow_graph,
+            "process_patterns": process_patterns,
+            "optimization_analysis": optimization_analysis,
+        }
+
+    def analyze_data_types(self, result: AnalysisResult) -> list:
+        """Analyze data types and usage."""
+        return _analyze_data_types(result)
+
+    def build_data_flow_graph(self, result: AnalysisResult) -> dict:
+        """Build data flow graph from function relationships."""
+        return _build_data_flow_graph(result)
+
+    def identify_process_patterns(self, result: AnalysisResult) -> list:
+        """Identify common data processing patterns."""
+        return _identify_process_patterns(result)
+
+    def analyze_optimization_opportunities(
+        self, result: AnalysisResult, data_types: list, dfg: dict
+    ) -> dict:
+        """Analyze optimization opportunities in data handling."""
+        return _analyze_optimization_opportunities(result, data_types, dfg)