code2logic 1.0.44__tar.gz → 1.0.46__tar.gz

{code2logic-1.0.44 → code2logic-1.0.46}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code2logic
-Version: 1.0.44
+Version: 1.0.46
 Summary: Code2Logic - Source code to logical representation converter for LLM analysis, featuring Tree-sitter parsing, dependency graph analysis, and multi-language support.
 License: Apache-2.0
 License-File: LICENSE

{code2logic-1.0.44 → code2logic-1.0.46}/code2logic/__init__.py

@@ -18,7 +18,7 @@ Example:
     >>> print(output)
 """
 
-__version__ = "1.0.44"
+__version__ = "1.0.46"
 __author__ = "Softreck"
 __email__ = "info@softreck.dev"
 __license__ = "MIT"

{code2logic-1.0.44 → code2logic-1.0.46}/code2logic/analyzer.py

@@ -4,7 +4,10 @@ Main project analyzer orchestrating all analysis components.
 Provides the high-level API for analyzing codebases.
 """
 
+import logging
+import os
 import sys
+import time
 from collections import defaultdict
 from datetime import datetime
 from pathlib import Path
@@ -16,6 +19,8 @@ from .models import ModuleInfo, ProjectInfo
 from .parsers import TREE_SITTER_AVAILABLE, TreeSitterParser, UniversalParser
 from .similarity import RAPIDFUZZ_AVAILABLE, SimilarityDetector
 
+log = logging.getLogger(__name__)
+
 
 class ProjectAnalyzer:
     """
@@ -103,6 +108,7 @@ class ProjectAnalyzer:
         use_treesitter: bool = True,
         verbose: bool = False,
         include_private: bool = False,
+        enable_similarity: bool = True,
     ):
         """
         Initialize the project analyzer.
@@ -112,10 +118,12 @@ class ProjectAnalyzer:
             use_treesitter: Whether to use Tree-sitter for parsing
             verbose: Whether to print status messages
             include_private: Whether to include private functions/classes
+            enable_similarity: Whether to enable similarity detection
         """
         self.root_path = Path(root_path).resolve()
         self.verbose = verbose
         self.include_private = include_private
+        self.enable_similarity = enable_similarity
         self.modules: List[ModuleInfo] = []
         self.languages: Dict[str, int] = defaultdict(int)
 
@@ -137,10 +145,10 @@ class ProjectAnalyzer:
     def _print_status(self):
         """Print library availability status."""
         parts = []
-        parts.append("TS✓" if TREE_SITTER_AVAILABLE else "TS✗")
-        parts.append("NX✓" if NETWORKX_AVAILABLE else "NX✗")
-        parts.append("RF✓" if RAPIDFUZZ_AVAILABLE else "RF✗")
-        parts.append("NLP✓" if (SPACY_AVAILABLE or NLTK_AVAILABLE) else "NLP✗")
+        parts.append("TS" if TREE_SITTER_AVAILABLE else "TS")
+        parts.append("NX" if NETWORKX_AVAILABLE else "NX")
+        parts.append("RF" if RAPIDFUZZ_AVAILABLE else "RF")
+        parts.append("NLP" if (SPACY_AVAILABLE or NLTK_AVAILABLE) else "NLP")
         print(f"Libs: {' '.join(parts)}", file=sys.stderr)
 
     def analyze(self) -> ProjectInfo:
@@ -150,18 +158,49 @@ class ProjectAnalyzer:
         Returns:
             ProjectInfo with complete analysis results
         """
+        analyze_start = time.time()
+
         # Scan and parse files
+        t0 = time.time()
         self._scan_files()
+        t_scan = time.time() - t0
+        if self.verbose:
+            log.info(
+                "Scan complete: modules=%d languages=%s time=%.2fs",
+                len(self.modules),
+                dict(self.languages),
+                t_scan,
+            )
 
         # Build dependency graph
+        t0 = time.time()
         dep_graph = self.dep_analyzer.build_graph(self.modules)
         dep_metrics = self.dep_analyzer.analyze_metrics()
+        t_dep = time.time() - t0
+        if self.verbose:
+            log.info("Dependency analysis complete: nodes=%d time=%.2fs", len(dep_graph or {}), t_dep)
 
         # Detect entry points
+        t0 = time.time()
         entrypoints = self._detect_entrypoints()
+        t_ep = time.time() - t0
+        if self.verbose:
+            log.info("Entrypoint detection complete: entrypoints=%d time=%.2fs", len(entrypoints), t_ep)
 
         # Find similar functions
-        similar = self.sim_detector.find_similar_functions(self.modules)
+        similar: Dict[str, List[str]] = {}
+        if self.enable_similarity:
+            t0 = time.time()
+            similar = self.sim_detector.find_similar_functions(self.modules)
+            t_sim = time.time() - t0
+            if self.verbose:
+                log.info("Similarity detection complete: matches=%d time=%.2fs", len(similar), t_sim)
+        else:
+            if self.verbose:
+                log.info("Similarity detection skipped (--no-similarity)")
+
+        if self.verbose:
+            log.info("Total analysis time: %.2fs", time.time() - analyze_start)
 
         return ProjectInfo(
             name=self.root_path.name,
@@ -180,63 +219,89 @@ class ProjectAnalyzer:
 
     def _scan_files(self):
         """Scan and parse all source files."""
-        for fp in self.root_path.rglob('*'):
-            if not fp.is_file():
-                continue
-
-            # Skip ignored directories
-            if any(d in fp.parts for d in self.IGNORE_DIRS):
-                continue
-
-            # Skip ignored files
-            if fp.name in self.IGNORE_FILES:
-                continue
-
-            ext = fp.suffix.lower()
-            language = self.LANGUAGE_EXTENSIONS.get(ext)
-            if language is None and ext == '':
-                try:
-                    with fp.open('r', encoding='utf-8', errors='ignore') as f:
-                        language = self._language_from_shebang(f.readline())
-                except Exception:
-                    language = None
-
-            if language is None:
-                continue
+        scan_start = time.time()
+        files_seen = 0
+        files_parsed = 0
+        files_matched = 0
+        scan_progress_every = 500
+
+        for root, dirnames, filenames in os.walk(self.root_path):
+            dirnames[:] = [d for d in dirnames if d not in self.IGNORE_DIRS]
+            for filename in filenames:
+                files_seen += 1
+                fp = Path(root) / filename
+
+                if filename in self.IGNORE_FILES:
+                    continue
 
-            self.languages[language] += 1
+                ext = fp.suffix.lower()
+                language = self.LANGUAGE_EXTENSIONS.get(ext)
+                if language is None and ext == '':
+                    try:
+                        with fp.open('r', encoding='utf-8', errors='ignore') as f:
+                            language = self._language_from_shebang(f.readline())
+                    except Exception:
+                        language = None
 
-            # Read file
-            try:
-                content = fp.read_text(encoding='utf-8', errors='ignore')
-            except Exception:
-                continue
+                if language is None:
+                    continue
 
-            rel_path = str(fp.relative_to(self.root_path))
+                files_matched += 1
+                self.languages[language] += 1
 
-            # Try Tree-sitter first, then fallback
-            module = None
-            try:
-                if self.ts_parser and self.ts_parser.is_available(language):
-                    module = self.ts_parser.parse(rel_path, content, language)
-            except Exception as e:
-                if self.verbose:
-                    print(f"Tree-sitter parser failed for {rel_path}: {e}", file=sys.stderr)
+                if self.verbose and files_seen > 0 and (files_seen % scan_progress_every) == 0:
+                    log.info(
+                        "Scan progress: seen=%d matched=%d parsed=%d modules=%d time=%.2fs",
+                        files_seen,
+                        files_matched,
+                        files_parsed,
+                        len(self.modules),
+                        time.time() - scan_start,
+                    )
 
-            if module is None:
                 try:
-                    module = self.fallback_parser.parse(rel_path, content, language)
-                except Exception as e:
-                    if self.verbose:
-                        print(f"Fallback parser failed for {rel_path}: {e}", file=sys.stderr)
+                    content = fp.read_text(encoding='utf-8', errors='ignore')
+                except Exception:
                     continue
 
-            if module:
                 try:
-                    module.file_bytes = fp.stat().st_size
+                    rel_path = str(fp.relative_to(self.root_path))
                 except Exception:
-                    module.file_bytes = len(content.encode('utf-8', errors='ignore'))
-                self.modules.append(module)
+                    rel_path = str(fp)
+
+                module = None
+                try:
+                    if self.ts_parser and self.ts_parser.is_available(language):
+                        module = self.ts_parser.parse(rel_path, content, language)
+                except Exception as e:
+                    if self.verbose:
+                        log.debug("Tree-sitter parser failed for %s: %s", rel_path, e)
+
+                if module is None:
+                    try:
+                        module = self.fallback_parser.parse(rel_path, content, language)
+                    except Exception as e:
+                        if self.verbose:
+                            log.debug("Fallback parser failed for %s: %s", rel_path, e)
+                        continue
+
+                if module:
+                    files_parsed += 1
+                    try:
+                        module.file_bytes = fp.stat().st_size
+                    except Exception:
+                        module.file_bytes = len(content.encode('utf-8', errors='ignore'))
+                    self.modules.append(module)
+
+        if self.verbose:
+            log.info(
+                "Scan finished: seen=%d matched=%d parsed=%d modules=%d time=%.2fs",
+                files_seen,
+                files_matched,
+                files_parsed,
+                len(self.modules),
+                time.time() - scan_start,
+            )
 
     def _detect_entrypoints(self) -> List[str]:
         """Detect project entry points."""

{code2logic-1.0.44 → code2logic-1.0.46}/code2logic/cli.py

@@ -10,6 +10,7 @@ Usage:
 
 import argparse
 import json
+import logging
 import os
 import signal
 import subprocess
@@ -508,24 +509,13 @@ def _code2logic_llm_cli(argv: list[str]) -> None:
         return
 
 
-def main():
-    """Main CLI entry point."""
+def main(argv=None):
     cli_start = time.time()
-
-    try:
-        signal.signal(signal.SIGPIPE, signal.SIG_DFL)
-    except Exception:
-        pass
-
-    if len(sys.argv) > 1 and sys.argv[1] == 'llm':
-        _code2logic_llm_cli(sys.argv[2:])
-        return
-
     parser = argparse.ArgumentParser(
-        prog='code2logic',
-        description='Convert source code to logical representation for LLM analysis',
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog='''
+        description='Analyze source code and generate logical representations',
+        formatter_class=argparse.RawDescriptionHelpFormatter
+    )
+    epilog='''
 Examples:
   code2logic /path/to/project                    # Standard Markdown
   code2logic /path/to/project -f csv             # CSV (best for LLM, ~50% smaller)
@@ -551,41 +541,6 @@ Detail levels (columns in csv/json/yaml):
   standard - + intent, category, domain, imports (8 columns)
   full     - + calls, lines, complexity, hash (16 columns)
 '''
-    )
-
-    def _maybe_print_pretty_help() -> bool:
-        """Print colorized help as markdown when appropriate.
-
-        Returns True if help was printed and the CLI should exit early.
-        """
-        force_pretty = os.environ.get("CODE2LOGIC_PRETTY_HELP") == "1" or bool(os.environ.get("FORCE_COLOR"))
-        if not force_pretty:
-            if not hasattr(sys.stdout, "isatty") or not sys.stdout.isatty():
-                return False
-        try:
-            from .terminal import render
-        except Exception:
-            return False
-
-        help_md = f"""# code2logic
-
-Convert source code to logical representation for LLM analysis.
-
-## Usage
-
-```bash
-code2logic [path] [options]
-```
-
-## Help
-
-```text
-{parser.format_help().rstrip()}
-```
-"""
-        render.markdown(help_md)
-        return True
-
     parser.add_argument(
         'path',
         nargs='?',
@@ -690,6 +645,11 @@ code2logic [path] [options]
         action='store_true',
         help='Disable Tree-sitter (use fallback parser)'
     )
+    parser.add_argument(
+        '--no-similarity',
+        action='store_true',
+        help='Disable similarity detection (RapidFuzz) to speed up analysis on large projects'
+    )
     parser.add_argument(
         '-v', '--verbose',
         action='store_true',
@@ -732,11 +692,10 @@ code2logic [path] [options]
     )
 
     if len(sys.argv) == 1 or any(a in ("-h", "--help") for a in sys.argv[1:]):
-        if not _maybe_print_pretty_help():
-            parser.print_help()
+        parser.print_help()
         return
 
-    args = parser.parse_args()
+    args = parser.parse_args(argv)
 
     if not args.no_install and os.environ.get("CODE2LOGIC_NO_INSTALL") in ("1", "true", "True", "yes", "YES"):
         args.no_install = True
@@ -750,6 +709,11 @@ code2logic [path] [options]
     # Initialize logger
     log = Logger(verbose=args.verbose, debug=args.debug)
 
+    logging.basicConfig(
+        level=(logging.DEBUG if args.debug else (logging.INFO if args.verbose else logging.WARNING)),
+        format='[%(levelname)s] %(message)s',
+    )
+
     if args.verbose and not args.quiet:
         log.header("CODE2LOGIC")
         log.detail(f"Version: {__version__}")
@@ -842,9 +806,7 @@ code2logic [path] [options]
 
     # Path is required for analysis
     if args.path is None:
-        # Keep behavior consistent with --help
-        if not _maybe_print_pretty_help():
-            parser.print_help()
+        parser.print_help()
         return
 
     # Validate path
@@ -865,7 +827,8 @@ code2logic [path] [options]
     analyzer = ProjectAnalyzer(
         args.path,
         use_treesitter=not args.no_treesitter,
-        verbose=args.debug
+        verbose=args.verbose or args.debug,
+        enable_similarity=not args.no_similarity,
     )
     project = analyzer.analyze()
     analyze_time = time.time() - analyze_start

{code2logic-1.0.44 → code2logic-1.0.46}/code2logic/similarity.py

@@ -4,11 +4,15 @@ Similarity detector using Rapidfuzz.
 Detects similar functions across modules to identify
 potential duplicates and refactoring opportunities.
 """
-
+import logging
+import time
+from collections import defaultdict
 from typing import Dict, List
 
 from .models import ModuleInfo
 
+log = logging.getLogger(__name__)
+
 # Optional Rapidfuzz import
 RAPIDFUZZ_AVAILABLE = False
 try:
@@ -43,6 +47,8 @@ class SimilarityDetector:
             threshold: Minimum similarity score (0-100) to consider as similar
         """
         self.threshold = threshold
+        self.max_functions = 8000
+        self.progress_every = 250
 
     def find_similar_functions(self, modules: List[ModuleInfo]) -> Dict[str, List[str]]:
         """
@@ -58,6 +64,8 @@ class SimilarityDetector:
         if not RAPIDFUZZ_AVAILABLE:
             return {}
 
+        start = time.time()
+
         # Collect all functions
         all_funcs: List[dict] = []
         for m in modules:
@@ -76,15 +84,35 @@ class SimilarityDetector:
         if len(all_funcs) < 2:
             return {}
 
+        if len(all_funcs) > self.max_functions:
+            log.warning(
+                "Skipping similarity detection: too many functions (%d > %d). Use --no-similarity to silence this.",
+                len(all_funcs),
+                self.max_functions,
+            )
+            return {}
+
         # Find similar functions
         similar: Dict[str, List[str]] = {}
         names = [f['name'] for f in all_funcs]
 
+        name_to_fulls: Dict[str, List[str]] = defaultdict(list)
+        for f in all_funcs:
+            name_to_fulls[f['name']].append(f['full'])
+
         for i, func in enumerate(all_funcs):
             # Skip common names that would produce false positives
             if func['name'] in ('__init__', 'constructor', 'toString', 'valueOf'):
                 continue
 
+            if i > 0 and (i % self.progress_every) == 0:
+                log.debug(
+                    "Similarity progress: %d/%d (%.2fs)",
+                    i,
+                    len(all_funcs),
+                    time.time() - start,
+                )
+
             matches = process.extract(
                 func['name'],
                 names[:i] + names[i+1:],
@@ -95,15 +123,13 @@ class SimilarityDetector:
             sim_list = []
             for match_name, score, _ in matches:
                 if score >= self.threshold and match_name != func['name']:
-                    # Find full name
-                    for other in all_funcs:
-                        if other['name'] == match_name:
-                            sim_list.append(f"{other['full']} ({score}%)")
-                            break
+                    for full in name_to_fulls.get(match_name, [])[:3]:
+                        sim_list.append(f"{full} ({score}%)")
 
             if sim_list:
                 similar[func['full']] = sim_list
 
+        log.debug("Similarity finished: funcs=%d matches=%d time=%.2fs", len(all_funcs), len(similar), time.time() - start)
         return similar
 
     def find_duplicate_signatures(self, modules: List[ModuleInfo]) -> Dict[str, List[str]]:

{code2logic-1.0.44 → code2logic-1.0.46}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "code2logic"
-version = "1.0.44"
+version = "1.0.46"
 description = "Code2Logic - Source code to logical representation converter for LLM analysis, featuring Tree-sitter parsing, dependency graph analysis, and multi-language support."
 readme = "README.md"
 license = "Apache-2.0"