refactor(goal): code analysis engine

changes:
  - file: analyzer.py
    area: analyzer
    modified: [ProjectAnalyzer, __init__, _scan_files, analyze, _print_status]
  - file: cli.py
    area: cli
    modified: [main]
    removed: [_maybe_print_pretty_help]
  - file: similarity.py
    area: core
    modified: [__init__, SimilarityDetector, find_similar_functions]

dependencies:
  flow: "cli→analyzer→similarity"
  - analyzer.py -> similarity.py
  - cli.py -> analyzer.py

stats:
  lines: "+98/-72 (net +26)"
  files: 3
  complexity: "+70% complexity (monitor)"

Author: tom-sapletta-com

CHANGELOG.md

@@ -1,3 +1,16 @@
+## [1.0.45] - 2026-02-26
+
+### Summary
+
+refactor(goal): code analysis engine
+
+### Other
+
+- update code2logic/analyzer.py
+- update code2logic/cli.py
+- update code2logic/similarity.py
+
+
 ## [1.0.44] - 2026-02-26
 
 ### Summary

VERSION

@@ -1 +1 @@
-1.0.44
+1.0.45

code2logic/__init__.py

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

code2logic/analyzer.py

@@ -4,7 +4,9 @@
 Provides the high-level API for analyzing codebases.
 """
 
+import logging
 import sys
+import time
 from collections import defaultdict
 from datetime import datetime
 from pathlib import Path
@@ -16,6 +18,8 @@
 from .parsers import TREE_SITTER_AVAILABLE, TreeSitterParser, UniversalParser
 from .similarity import RAPIDFUZZ_AVAILABLE, SimilarityDetector
 
+log = logging.getLogger(__name__)
+
 
 class ProjectAnalyzer:
     """
@@ -103,6 +107,7 @@ def __init__(
         use_treesitter: bool = True,
         verbose: bool = False,
         include_private: bool = False,
+        enable_similarity: bool = True,
     ):
         """
         Initialize the project analyzer.
@@ -112,10 +117,12 @@ def __init__(
             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 +144,10 @@ def __init__(
     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 +157,49 @@ def analyze(self) -> ProjectInfo:
         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,
@@ -221,14 +259,14 @@ def _scan_files(self):
                     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)
+                    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:
-                        print(f"Fallback parser failed for {rel_path}: {e}", file=sys.stderr)
+                        log.debug("Fallback parser failed for %s: %s", rel_path, e)
                     continue
 
             if module:

code2logic/cli.py

@@ -10,6 +10,7 @@
 
 import argparse
 import json
+import logging
 import os
 import signal
 import subprocess
@@ -508,24 +509,12 @@ def _code2logic_llm_cli(argv: list[str]) -> None:
         return
 
 
-def main():
-    """Main CLI entry point."""
-    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
-
+def main(argv=None):
     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 +540,6 @@ def main():
   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 +644,11 @@ def _maybe_print_pretty_help() -> bool:
         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 +691,10 @@ def _maybe_print_pretty_help() -> bool:
     )
 
     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 +708,11 @@ def _maybe_print_pretty_help() -> bool:
     # 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 +805,7 @@ def _maybe_print_pretty_help() -> bool:
 
     # 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 +826,8 @@ def _maybe_print_pretty_help() -> bool:
     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/similarity.py

@@ -4,11 +4,15 @@
 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 @@ def __init__(self, threshold: float = 80.0):
             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 @@ def find_similar_functions(self, modules: List[ModuleInfo]) -> Dict[str, List[st
         if not RAPIDFUZZ_AVAILABLE:
             return {}
 
+        start = time.time()
+
         # Collect all functions
         all_funcs: List[dict] = []
         for m in modules:
@@ -76,15 +84,35 @@ def find_similar_functions(self, modules: List[ModuleInfo]) -> Dict[str, List[st
         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 @@ def find_similar_functions(self, modules: List[ModuleInfo]) -> Dict[str, List[st
             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]]:

logic2code/__init__.py

@@ -14,5 +14,5 @@
 from .generator import CodeGenerator, GeneratorConfig, GenerationResult
 from .renderers import PythonRenderer
 
-__version__ = '1.0.44'
+__version__ = '1.0.45'
 __all__ = ['CodeGenerator', 'GeneratorConfig', 'GenerationResult', 'PythonRenderer']

logic2test/__init__.py

@@ -15,5 +15,5 @@
 from .parsers import LogicParser
 from .templates import TestTemplate
 
-__version__ = '1.0.44'
+__version__ = '1.0.45'
 __all__ = ['TestGenerator', 'GeneratorConfig', 'GenerationResult', 'LogicParser', 'TestTemplate']