code2llm 0.5.153__tar.gz → 0.5.155__tar.gz

{code2llm-0.5.153/code2llm.egg-info → code2llm-0.5.155}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code2llm
-Version: 0.5.153
+Version: 0.5.155
 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.153-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-77.3h-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.155-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.1h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
 
-- 🤖 **LLM usage:** $7.5000 (206 commits)
-- 👤 **Human dev:** ~$7734 (77.3h @ $100/h, 30min dedup)
+- 🤖 **LLM usage:** $7.5000 (208 commits)
+- 👤 **Human dev:** ~$7906 (79.1h @ $100/h, 30min dedup)
 
 Generated on 2026-05-24 using [openrouter/qwen/qwen3-coder-next](https://openrouter.ai/qwen/qwen3-coder-next)
 

{code2llm-0.5.153 → code2llm-0.5.155}/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.153-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-77.3h-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.155-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.1h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
 
-- 🤖 **LLM usage:** $7.5000 (206 commits)
-- 👤 **Human dev:** ~$7734 (77.3h @ $100/h, 30min dedup)
+- 🤖 **LLM usage:** $7.5000 (208 commits)
+- 👤 **Human dev:** ~$7906 (79.1h @ $100/h, 30min dedup)
 
 Generated on 2026-05-24 using [openrouter/qwen/qwen3-coder-next](https://openrouter.ai/qwen/qwen3-coder-next)
 

code2llm-0.5.155/VERSION

@@ -0,0 +1 @@
+0.5.155

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

{code2llm-0.5.153 → code2llm-0.5.155}/code2llm/cli_exports/orchestrator.py

@@ -100,6 +100,33 @@ def _should_skip_export_cache(args, is_chunked: bool) -> bool:
     )
 
 
+def _try_serve_from_cache(
+    args, formats: list, output_dir: Path, source_path: Path
+) -> bool:
+    """Return True and restore output from cache if a valid cached export exists."""
+    cache = PersistentCache(str(source_path))
+    config_dict = _build_export_config(args, formats)
+    cached_export_dir = cache.get_export_cache_dir(config_dict)
+    if not cached_export_dir:
+        return False
+    if args.verbose:
+        print(f"  Using cached export from: {cached_export_dir}")
+    _copy_cached_export(cached_export_dir, output_dir, verbose=args.verbose)
+    return True
+
+
+def _save_to_export_cache(args, formats: list, output_dir: Path, source_path: Path) -> None:
+    """Persist the just-produced output_dir contents into the export cache."""
+    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}")
+
+
 def _run_exports(args, result, output_dir: Path, source_path: Optional[Path] = None):
     """Export analysis results in requested formats.
 
@@ -112,10 +139,8 @@ def _run_exports(args, result, output_dir: Path, source_path: Optional[Path] = N
     if getattr(args, "planfile_apply", False) and "planfile" not in formats:
         formats.append("planfile")
     is_chunked = getattr(args, "chunk", False)
-    dry_run = getattr(args, "dry_run", False)
 
-    # Dry-run: show what would be exported without writing
-    if dry_run:
+    if getattr(args, "dry_run", False):
         _show_dry_run_plan(formats, output_dir, is_chunked, result)
         return
 
@@ -124,15 +149,7 @@ def _run_exports(args, result, output_dir: Path, source_path: Optional[Path] = N
     skip_cache = _should_skip_export_cache(args, is_chunked)
 
     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)
+        if _try_serve_from_cache(args, formats, output_dir, source_path):
             return
 
     try:
@@ -145,16 +162,8 @@ def _run_exports(args, result, output_dir: Path, source_path: Optional[Path] = N
                 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}")
+            _save_to_export_cache(args, formats, output_dir, source_path)
 
     except Exception as e:
         print(f"Error during export: {e}", file=sys.stderr)

{code2llm-0.5.153 → code2llm-0.5.155}/code2llm/cli_parser.py

@@ -56,11 +56,8 @@ Format Options (-f):
   flow         — Data-flow analysis (flow.toon) — legacy, explicit opt-in
   code2logic   — Generate project logic (legacy project.toon) via external code2logic
   project-yaml — Legacy project.yaml export (single source of truth) + generated views
-    planfile     — Planfile ticket suggestions (planfile-tickets.yaml);
-                                 use --planfile-apply to create tickets
-    all          — Generate core formats (analysis.toon, map.toon.yaml,
-                                 evolution.toon.yaml, context, mermaid, planfile-tickets.yaml)
-                                 plus project.toon.yaml and prompt.txt; PNG remains opt-in via --png
+  planfile     — Planfile ticket suggestions (planfile-tickets.yaml); use --planfile-apply to create tickets
+  all          — Generate core formats (analysis.toon, map.toon.yaml, evolution.toon.yaml, context, mermaid, planfile-tickets.yaml) plus project.toon.yaml and prompt.txt; PNG remains opt-in via --png
 
 Strategy Options (--strategy):
   quick     — Fast overview, fewer files analyzed

code2llm-0.5.153/code2llm/core/lang/base.py → code2llm-0.5.155/code2llm/core/lang/_c_parser.py

@@ -1,301 +1,6 @@
-"""Shared utilities for regex-based language analyzers."""
-
-import re
-from typing import Dict, List
-
-from code2llm.core.config import (
-    CC_LOW_THRESHOLD,
-    CC_MEDIUM_THRESHOLD,
-    CC_HIGH_THRESHOLD,
-)
-
-
-# Branching keywords per language family
-CC_PATTERNS = {
-    "c_family": re.compile(
-        r"\b(?:if|else\s+if|for|while|do|switch|case|catch)\b"
-        r"|&&|\|\||\?\?|\?\."  # logical operators (not word chars)
-        r"|\?\s*[^:]*\s*:"  # ternary
-    ),
-    "go": re.compile(
-        r"\b(?:if|for|switch|case|select|go|defer)\b"
-        r"|&&|\|\|"
-    ),
-    "rust": re.compile(
-        r"\b(?:if|else\s+if|for|while|loop|match)\b"
-        r"|&&|\|\||\?"
-    ),
-}
-
-CALL_PATTERN_C_FAMILY = re.compile(
-    r"(?<!\bfunction\b\s)"  # not a function declaration
-    r"(?<!\bclass\b\s)"  # not a class declaration
-    r"\b([a-zA-Z_]\w*)\s*\("  # simple call: foo(
-    r"|"
-    r"(?:this|self)\s*\.\s*(\w+)\s*\("  # this.method( / self.method(
-    r"|"
-    r"\b(\w+)\s*\.\s*(\w+)\s*\("  # obj.method(
-)
-
-
-def extract_function_body(content: str, start_line: int) -> str:
-    """Extract the body of a function between braces from a start line (1-indexed)."""
-    lines = content.split("\n")
-    if start_line < 1 or start_line > len(lines):
-        return ""
-    depth = 0
-    body_lines = []
-    started = False
-    for line in lines[start_line - 1 :]:
-        for ch in line:
-            if ch == "{":
-                depth += 1
-                started = True
-            elif ch == "}":
-                depth -= 1
-        if started:
-            body_lines.append(line)
-        if started and depth <= 0:
-            break
-    return "\n".join(body_lines)
-
-
-def calculate_complexity_regex(
-    content: str, result: Dict, lang: str = "c_family"
-) -> None:
-    """Estimate cyclomatic complexity for every function using regex keyword counting."""
-    pattern = CC_PATTERNS.get(lang, CC_PATTERNS["c_family"])
-    for func_info in result["functions"].values():
-        body = extract_function_body(content, func_info.line)
-        if not body:
-            cc = 1
-        else:
-            cc = 1 + len(pattern.findall(body))
-        rank = (
-            "A"
-            if cc <= CC_LOW_THRESHOLD
-            else (
-                "B"
-                if cc <= CC_MEDIUM_THRESHOLD
-                else ("C" if cc <= CC_HIGH_THRESHOLD else "D")
-            )
-        )
-        func_info.complexity = {
-            "cyclomatic_complexity": cc,
-            "cc_rank": rank,
-        }
-
-
-_CALL_KEYWORDS = frozenset(
-    {
-        "if",
-        "for",
-        "while",
-        "switch",
-        "catch",
-        "return",
-        "throw",
-        "new",
-        "typeof",
-        "instanceof",
-        "import",
-        "export",
-        "require",
-        "console",
-        "super",
-        "class",
-        "function",
-        "async",
-        "await",
-        "delete",
-        "void",
-        "case",
-        "default",
-    }
-)
+"""C-family declaration parser helpers (classes, functions, methods, decorators)."""
 
-
-def _resolve_call(
-    simple_call: str,
-    func_qname: str,
-    module_name: str,
-    known_simple: Dict[str, List[str]],
-    calls_seen: set,
-    func_info,
-) -> None:
-    """Resolve a single call name and append to func_info.calls if novel."""
-    if simple_call in known_simple:
-        candidates = known_simple[simple_call]
-        my_module = func_qname.rsplit(".", 1)[0]
-        resolved = next(
-            (c for c in candidates if c.rsplit(".", 1)[0] == my_module),
-            candidates[0],
-        )
-        if resolved != func_qname and resolved not in calls_seen:
-            func_info.calls.append(resolved)
-            calls_seen.add(resolved)
-    else:
-        ext_name = f"{module_name}.{simple_call}"
-        if ext_name not in calls_seen:
-            func_info.calls.append(ext_name)
-            calls_seen.add(ext_name)
-
-
-def extract_calls_regex(content: str, module_name: str, result: Dict) -> None:
-    """Extract function calls from function bodies using regex."""
-    known_simple: Dict[str, List[str]] = {}
-    for qname in result["functions"]:
-        simple = qname.rsplit(".", 1)[-1]
-        known_simple.setdefault(simple, []).append(qname)
-
-    for func_qname, func_info in result["functions"].items():
-        body = extract_function_body(content, func_info.line)
-        if not body:
-            continue
-        calls_seen: set = set()
-        for m in CALL_PATTERN_C_FAMILY.finditer(body):
-            simple_call = m.group(1) or m.group(2) or m.group(4)
-            if not simple_call or simple_call in _CALL_KEYWORDS:
-                continue
-            _resolve_call(
-                simple_call,
-                func_qname,
-                module_name,
-                known_simple,
-                calls_seen,
-                func_info,
-            )
-
-
-# Shared declaration extraction for language parsers
-def _extract_declarations(
-    content: str,
-    file_path: str,
-    module_name: str,
-    patterns: Dict,
-    stats: Dict,
-    lang_config: Dict,
-) -> Dict:
-    """Shared extraction logic for language parsers.
-
-    Args:
-        content: File content
-        file_path: Path to file
-        module_name: Module name
-        patterns: Dict of compiled regex patterns
-        stats: Statistics dict to update
-        lang_config: Language-specific config dict
-    """
-    from ..models import ModuleInfo
-    from pathlib import Path
-
-    result = {
-        "module": ModuleInfo(
-            name=module_name,
-            file=file_path,
-            is_package=Path(file_path).name in lang_config.get("index_files", []),
-        ),
-        "functions": {},
-        "classes": {},
-        "nodes": {},
-        "edges": [],
-    }
-
-    lines = content.split("\n")
-    current_class = None
-    class_brace_depth = 0
-    brace_depth = 0
-    pending_decorators = []
-
-    import_re = patterns.get("import")
-    decorator_re = patterns.get("decorator")
-    class_re = patterns.get("class")
-    interface_re = patterns.get("interface")
-    func_re = patterns.get("function")
-    arrow_re = patterns.get("arrow_func")
-    method_re = patterns.get("method")
-    arrow_prop_re = patterns.get("arrow_prop")
-
-    track_braces = lang_config.get("brace_track", True)
-    reserved = lang_config.get(
-        "reserved", {"if", "for", "while", "switch", "return", "catch"}
-    )
-
-    for line_no, line in enumerate(lines, 1):
-        raw_line = line
-        line = line.strip()
-        # Skip empty lines and comments, but NOT preprocessor directives like #include
-        if not line:
-            continue
-        if line.startswith(("//", "/*", "*")):
-            continue
-        # Skip # comments (Python, Ruby, shell) but NOT #include/#define (C-family)
-        if (
-            line.startswith("#")
-            and not line.startswith("#include")
-            and not line.startswith("#define")
-        ):
-            continue
-
-        # Update brace tracking
-        brace_depth, current_class, class_brace_depth = _update_brace_tracking(
-            raw_line, brace_depth, current_class, class_brace_depth, track_braces
-        )
-
-        # Process decorators
-        pending_decorators = _process_decorators(decorator_re, line, pending_decorators)
-
-        # Process imports
-        if import_re:
-            im = import_re.match(line)
-            if im:
-                result["module"].imports.append(im.group(1))
-                continue
-
-        # Process classes and interfaces
-        current_class, class_brace_depth, pending_decorators = _process_classes(
-            class_re,
-            interface_re,
-            line,
-            line_no,
-            file_path,
-            module_name,
-            result,
-            stats,
-            current_class,
-            class_brace_depth,
-            pending_decorators,
-        )
-
-        # Process functions
-        pending_decorators = _process_functions(
-            func_re,
-            arrow_re,
-            method_re,
-            arrow_prop_re,
-            line,
-            line_no,
-            file_path,
-            module_name,
-            result,
-            stats,
-            current_class,
-            pending_decorators,
-            reserved,
-        )
-
-        # Clear orphaned decorators
-        pending_decorators = _clear_orphaned_decorators(
-            line,
-            pending_decorators,
-            func_re,
-            arrow_re,
-            class_re,
-            interface_re,
-            method_re,
-        )
-
-    return result
+from typing import Dict
 
 
 def _update_brace_tracking(
@@ -340,7 +45,6 @@ def _process_classes(
     """Process class and interface declarations."""
     from ..models import ClassInfo
 
-    # Process classes
     if class_re:
         cm = class_re.match(line)
         if cm:
@@ -364,11 +68,9 @@ def _process_classes(
             result["module"].classes.append(qual)
             stats["classes_found"] += 1
             current_class = qual
-            class_brace_depth = class_brace_depth  # Will be updated by caller
             pending_decorators.clear()
             return current_class, class_brace_depth, pending_decorators
 
-    # Process interfaces
     if interface_re:
         imt = interface_re.match(line)
         if imt:
@@ -575,48 +277,115 @@ def _clear_orphaned_decorators(
     return pending_decorators
 
 
-def analyze_c_family(
+def _extract_declarations(
     content: str,
     file_path: str,
     module_name: str,
-    stats: Dict,
     patterns: Dict,
+    stats: Dict,
     lang_config: Dict,
-    cc_lang: str = "c_family",
-    ext: str = "",
 ) -> Dict:
-    """Shared analyzer for C-family languages (Java, C#, C++, etc.).
+    """Shared extraction logic for language parsers."""
+    from pathlib import Path
 
-    Uses tree-sitter when available (10× faster), falls back to regex.
-    """
-    result = None
-
-    # Try tree-sitter first (much faster)
-    if ext:
-        try:
-            from .ts_parser import parse_source
-            from .ts_extractors import extract_declarations_ts
-
-            tree = parse_source(content, ext)
-            if tree:
-                result = extract_declarations_ts(
-                    tree, content.encode("utf-8"), ext, file_path, module_name
-                )
-        except ImportError:
-            pass  # tree-sitter not installed
-
-    # Fallback to regex
-    if result is None:
-        result = _extract_declarations(
-            content,
+    from ..models import ModuleInfo
+
+    result = {
+        "module": ModuleInfo(
+            name=module_name,
+            file=file_path,
+            is_package=Path(file_path).name in lang_config.get("index_files", []),
+        ),
+        "functions": {},
+        "classes": {},
+        "nodes": {},
+        "edges": [],
+    }
+
+    lines = content.split("\n")
+    current_class = None
+    class_brace_depth = 0
+    brace_depth = 0
+    pending_decorators = []
+
+    import_re = patterns.get("import")
+    decorator_re = patterns.get("decorator")
+    class_re = patterns.get("class")
+    interface_re = patterns.get("interface")
+    func_re = patterns.get("function")
+    arrow_re = patterns.get("arrow_func")
+    method_re = patterns.get("method")
+    arrow_prop_re = patterns.get("arrow_prop")
+
+    track_braces = lang_config.get("brace_track", True)
+    reserved = lang_config.get(
+        "reserved", {"if", "for", "while", "switch", "return", "catch"}
+    )
+
+    for line_no, line in enumerate(lines, 1):
+        raw_line = line
+        line = line.strip()
+        if not line:
+            continue
+        if line.startswith(("//", "/*", "*")):
+            continue
+        if (
+            line.startswith("#")
+            and not line.startswith("#include")
+            and not line.startswith("#define")
+        ):
+            continue
+
+        brace_depth, current_class, class_brace_depth = _update_brace_tracking(
+            raw_line, brace_depth, current_class, class_brace_depth, track_braces
+        )
+
+        pending_decorators = _process_decorators(decorator_re, line, pending_decorators)
+
+        if import_re:
+            im = import_re.match(line)
+            if im:
+                result["module"].imports.append(im.group(1))
+                continue
+
+        current_class, class_brace_depth, pending_decorators = _process_classes(
+            class_re,
+            interface_re,
+            line,
+            line_no,
+            file_path,
+            module_name,
+            result,
+            stats,
+            current_class,
+            class_brace_depth,
+            pending_decorators,
+        )
+
+        pending_decorators = _process_functions(
+            func_re,
+            arrow_re,
+            method_re,
+            arrow_prop_re,
+            line,
+            line_no,
             file_path,
             module_name,
-            patterns,
+            result,
             stats,
-            lang_config,
+            current_class,
+            pending_decorators,
+            reserved,
+        )
+
+        pending_decorators = _clear_orphaned_decorators(
+            line,
+            pending_decorators,
+            func_re,
+            arrow_re,
+            class_re,
+            interface_re,
+            method_re,
         )
 
-    calculate_complexity_regex(content, result, lang=cc_lang)
-    extract_calls_regex(content, module_name, result)
-    stats["files_processed"] += 1
     return result