code2llm 0.5.52__tar.gz → 0.5.53__tar.gz

{code2llm-0.5.52 → code2llm-0.5.53}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code2llm
-Version: 0.5.52
+Version: 0.5.53
 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

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

{code2llm-0.5.52 → code2llm-0.5.53}/code2llm/cli_analysis.py

@@ -42,7 +42,7 @@ def _run_standard_analysis(args, source_path: Path, output_dir: Path):
         if args.streaming or args.strategy in ['quick', 'deep']:
             result = _run_streaming_analysis(args, config, source_path)
         else:
-            analyzer = ProjectAnalyzer(config)
+            analyzer = ProjectAnalyzer(config, source_path)
             result = analyzer.analyze_project(str(source_path))
 
         if args.verbose:
@@ -57,13 +57,29 @@ def _run_standard_analysis(args, source_path: Path, output_dir: Path):
 
 def _build_config(args, output_dir: Path):
     """Build analysis Config from CLI args."""
-    from .core.config import Config
+    from .core.config import Config, FilterConfig
+    
+    # Start with default filter config
+    filter_config = FilterConfig()
+    
+    # Apply custom exclude patterns if provided
+    if hasattr(args, 'exclude') and args.exclude:
+        default_patterns = filter_config.exclude_patterns
+        custom_patterns = [f"*{pattern}*" if not pattern.startswith('*') and not pattern.endswith('*') else pattern 
+                          for pattern in args.exclude]
+        filter_config.exclude_patterns = list(set(default_patterns + custom_patterns))
+    
+    # Apply gitignore setting
+    if hasattr(args, 'no_gitignore') and args.no_gitignore:
+        filter_config.gitignore_enabled = False
+    
     return Config(
         mode=args.mode,
         max_depth_enumeration=args.max_depth,
         detect_state_machines=not args.no_patterns,
         detect_recursion=not args.no_patterns,
-        output_dir=str(output_dir)
+        output_dir=str(output_dir),
+        filters=filter_config
     )
 
 
@@ -173,19 +189,34 @@ def _analyze_all_subprojects(args, subprojects, output_dir: Path) -> list:
 def _analyze_subproject(args, subproject, output_dir: Path):
     """Analyze and export a single subproject."""
     from .core.analyzer import ProjectAnalyzer
-    from .core.config import Config
+    from .core.config import Config, FilterConfig
     from .cli_exports import _export_simple_formats, _export_evolution
 
+    # Start with default filter config
+    filter_config = FilterConfig()
+    
+    # Apply custom exclude patterns if provided
+    if hasattr(args, 'exclude') and args.exclude:
+        default_patterns = filter_config.exclude_patterns
+        custom_patterns = [f"*{pattern}*" if not pattern.startswith('*') and not pattern.endswith('*') else pattern 
+                          for pattern in args.exclude]
+        filter_config.exclude_patterns = list(set(default_patterns + custom_patterns))
+    
+    # Apply gitignore setting
+    if hasattr(args, 'no_gitignore') and args.no_gitignore:
+        filter_config.gitignore_enabled = False
+
     config = Config(
         mode=args.mode,
         max_depth_enumeration=args.max_depth,
         detect_state_machines=not args.no_patterns,
         detect_recursion=not args.no_patterns,
         output_dir=str(output_dir),
-        verbose=args.verbose
+        verbose=args.verbose,
+        filters=filter_config
     )
 
-    analyzer = ProjectAnalyzer(config)
+    analyzer = ProjectAnalyzer(config, subproject.path)
 
     try:
         result = analyzer.analyze_project(str(subproject.path))

{code2llm-0.5.52 → code2llm-0.5.53}/code2llm/cli_exports/formats.py

@@ -11,7 +11,7 @@ from ..exporters import (
     EvolutionExporter, READMEExporter, ProjectYAMLExporter,
     ToonViewGenerator, ContextViewGenerator,
     ArticleViewGenerator, HTMLDashboardGenerator,
-    load_project_yaml,
+    load_project_yaml, IndexHTMLGenerator,
 )
 
 
@@ -224,3 +224,19 @@ def _export_refactor_prompts(args, result, output_dir: Path):
     else:
         if args.verbose:
             print("  - Refactoring: No code smells detected.")
+
+
+def _export_index_html(args, output_dir: Path) -> None:
+    """Generate index.html for browsing all generated files."""
+    # Only generate index.html when 'all' formats is used
+    if 'all' not in args.format:
+        return
+    
+    try:
+        generator = IndexHTMLGenerator(output_dir)
+        index_path = generator.generate()
+        if args.verbose:
+            print(f"  - INDEX (file browser): {index_path}")
+    except Exception as e:
+        if args.verbose:
+            print(f"  - INDEX generation failed: {e}", file=sys.stderr)

{code2llm-0.5.52 → code2llm-0.5.53}/code2llm/cli_exports/orchestrator.py

@@ -12,6 +12,7 @@ from .formats import (
     _export_context_fallback,
     _export_readme,
     _export_refactor_prompts,
+    _export_index_html,
 )
 from .code2logic import _export_code2logic
 from .prompt import _export_prompt_txt, _export_chunked_prompt_txt
@@ -57,6 +58,9 @@ def _export_single_project(args, result, output_dir: Path, formats: list, source
         _export_refactor_prompts(args, result, output_dir)
 
     _export_readme(args, result, output_dir)
+    
+    # Generate index.html for browsing all files (only when 'all' formats used)
+    _export_index_html(args, output_dir)
 
 
 def _export_chunked_results(args, result, output_dir: Path, source_path: Path, formats: list):
@@ -94,3 +98,6 @@ def _export_chunked_results(args, result, output_dir: Path, source_path: Path, f
         _export_chunked_prompt_txt(args, output_dir, formats, source_path, subprojects)
 
     _export_readme(args, result, output_dir)
+    
+    # Generate index.html for browsing all files (only when 'all' formats used)
+    _export_index_html(args, output_dir)

{code2llm-0.5.52 → code2llm-0.5.53}/code2llm/cli_parser.py

@@ -229,6 +229,19 @@ Strategy Options (--strategy):
         help='Analyze only specific subproject (e.g., --only-subproject src)'
     )
     
+    parser.add_argument(
+        '--exclude',
+        nargs='+',
+        default=[],
+        help='Exclude specific directories or patterns (e.g., --exclude vendor build test)'
+    )
+    
+    parser.add_argument(
+        '--no-gitignore',
+        action='store_true',
+        help='Disable .gitignore support (include all files)'
+    )
+    
     parser.add_argument(
         '--validate',
         action='store_true',

{code2llm-0.5.52 → code2llm-0.5.53}/code2llm/core/analyzer.py

@@ -15,13 +15,14 @@ from .core import FileCache, FastFileFilter, FileAnalyzer, RefactoringAnalyzer,
 class ProjectAnalyzer:
     """Main analyzer with parallel processing."""
     
-    def __init__(self, config: Optional[Config] = None):
+    def __init__(self, config: Optional[Config] = None, project_path: Optional[Path] = None):
         self.config = config or FAST_CONFIG
+        self.project_path = project_path
         self.cache = FileCache(
             self.config.performance.cache_dir,
             self.config.performance.cache_ttl_hours
         ) if self.config.performance.enable_cache else None
-        self.file_filter = FastFileFilter(self.config.filters)
+        self.file_filter = FastFileFilter(self.config.filters, project_path)
         self.refactoring_analyzer = RefactoringAnalyzer(self.config, self.file_filter)
     
     def analyze_project(self, project_path: str) -> AnalysisResult:
@@ -32,6 +33,11 @@ class ProjectAnalyzer:
         if not project_path.exists():
             raise FileNotFoundError(f"Project path does not exist: {project_path}")
         
+        # Update project path for gitignore support if not set during init
+        if not self.project_path:
+            self.project_path = project_path
+            self.file_filter = FastFileFilter(self.config.filters, project_path)
+        
         # Collect Python files
         files = self._collect_files(project_path)
         

{code2llm-0.5.52 → code2llm-0.5.53}/code2llm/core/config.py

@@ -46,6 +46,7 @@ class FilterConfig:
     skip_private: bool = False
     skip_properties: bool = True
     skip_accessors: bool = True
+    gitignore_enabled: bool = True
 
 
 @dataclass

{code2llm-0.5.52 → code2llm-0.5.53}/code2llm/core/core/file_filter.py

@@ -1,21 +1,35 @@
 """Fast file filtering with pattern matching."""
 
 import fnmatch
+from pathlib import Path
 from ..config import FilterConfig
+from ..gitignore import load_gitignore_patterns
 
 
 class FastFileFilter:
     """Fast file filtering with pattern matching."""
     
-    def __init__(self, config: FilterConfig):
+    def __init__(self, config: FilterConfig, project_path: Path = None):
         self.config = config
+        self.project_path = project_path
         self._exclude_patterns = [p.lower() for p in config.exclude_patterns]
         self._include_patterns = [p.lower() for p in config.include_patterns]
+        
+        # Load gitignore patterns if enabled and project path is provided
+        self._gitignore_parser = None
+        if config.gitignore_enabled and project_path:
+            self._gitignore_parser = load_gitignore_patterns(project_path)
     
     def should_process(self, file_path: str) -> bool:
         """Check if file should be processed."""
         path_lower = file_path.lower()
         
+        # Check gitignore patterns first
+        if self._gitignore_parser and self.project_path:
+            file_path_obj = Path(file_path)
+            if self._gitignore_parser.is_ignored(file_path_obj, self.project_path):
+                return False
+        
         # Check exclude patterns
         for pattern in self._exclude_patterns:
             if fnmatch.fnmatch(path_lower, pattern) or pattern in path_lower:

{code2llm-0.5.52 → code2llm-0.5.53}/code2llm/core/core/lang/cpp.py

@@ -34,11 +34,35 @@ def analyze_cpp(content: str, file_path: str, module_name: str,
     current_namespace = None
     brace_depth = 0
     class_brace_depth = 0
+    in_block_comment = False
+    in_line_comment = False
 
     for line_no, line in enumerate(lines, 1):
         raw_line = line
         line = line.strip()
-        if not line or line.startswith('//'):
+        
+        # Handle block comments (/* ... */) and line comments
+        if not in_block_comment:
+            if '/*' in raw_line:
+                in_block_comment = True
+                # Remove everything after /* start
+                raw_line = raw_line.split('/*')[0]
+                line = raw_line.strip()
+            elif line.startswith('//'):
+                # Single line comment, skip entirely
+                continue
+        else:
+            if '*/' in raw_line:
+                # End of block comment
+                in_block_comment = False
+                # Remove everything before */ end
+                raw_line = raw_line.split('*/')[1]
+                line = raw_line.strip()
+            else:
+                # Still in block comment, skip this line
+                continue
+        
+        if not line:
             continue
 
         # Track brace depth for class scope
@@ -89,9 +113,11 @@ def analyze_cpp(content: str, file_path: str, module_name: str,
         func_match = func_pattern.match(line)
         if func_match:
             func_name = func_match.group(1)
-            # Skip keywords that look like functions
+            # Skip keywords that look like functions, plus common license terms
             if func_name in ('if', 'for', 'while', 'switch', 'catch', 'return',
-                             'sizeof', 'decltype', 'typeof', 'new', 'delete'):
+                             'sizeof', 'decltype', 'typeof', 'new', 'delete',
+                             'Copyright', 'License', 'TORT', 'WITHOUT', 'WARRANTY',
+                             'Permission', 'Redistribution', 'Conditions', 'Disclaimer'):
                 continue
 
             if current_class:

code2llm-0.5.53/code2llm/core/gitignore.py

@@ -0,0 +1,125 @@
+"""Gitignore support for code2llm file filtering."""
+
+from pathlib import Path
+from typing import List, Set
+import re
+
+
+class GitIgnoreParser:
+    """Parse and apply .gitignore patterns to file paths."""
+    
+    def __init__(self, gitignore_path: Path = None):
+        """Initialize parser with optional .gitignore file path."""
+        self.patterns: List[re.Pattern] = []
+        self.dir_patterns: List[re.Pattern] = []
+        self.negated_patterns: List[re.Pattern] = []
+        
+        if gitignore_path and gitignore_path.exists():
+            self._load_gitignore(gitignore_path)
+    
+    def _load_gitignore(self, gitignore_path: Path) -> None:
+        """Load and parse .gitignore file."""
+        try:
+            with open(gitignore_path, 'r', encoding='utf-8') as f:
+                for line_num, line in enumerate(f, 1):
+                    line = line.rstrip()
+                    
+                    # Skip empty lines and comments
+                    if not line or line.startswith('#'):
+                        continue
+                    
+                    # Parse pattern
+                    pattern = self._parse_pattern(line)
+                    if pattern:
+                        self.patterns.append(pattern)
+        except (OSError, UnicodeDecodeError):
+            # Silently ignore gitignore parsing errors
+            pass
+    
+    def _parse_pattern(self, pattern: str) -> re.Pattern:
+        """Parse a single gitignore pattern into regex."""
+        is_negated = pattern.startswith('!')
+        if is_negated:
+            pattern = pattern[1:]
+        
+        is_dir_only = pattern.endswith('/')
+        if is_dir_only:
+            pattern = pattern[:-1]
+        
+        # Handle absolute patterns (starting with /)
+        if pattern.startswith('/'):
+            pattern = pattern[1:]
+            # Match from beginning of path
+            regex_pattern = f'^{self._wildcard_to_regex(pattern)}'
+        else:
+            # Match anywhere in path
+            regex_pattern = self._wildcard_to_regex(pattern)
+        
+        # Match directory or file
+        if is_dir_only:
+            regex_pattern += f'(/.*)?$'
+        else:
+            regex_pattern += f'(/.*)?$'
+        
+        try:
+            compiled = re.compile(regex_pattern)
+            if is_negated:
+                self.negated_patterns.append(compiled)
+            elif is_dir_only:
+                self.dir_patterns.append(compiled)
+                # Also add to main patterns for directory matching
+                return compiled
+            else:
+                return compiled
+        except re.error:
+            # Skip invalid regex patterns
+            pass
+        
+        return None
+    
+    def _wildcard_to_regex(self, pattern: str) -> str:
+        """Convert gitignore wildcards to regex."""
+        # Escape regex special characters except *, ?, []
+        escaped = re.escape(pattern)
+        
+        # Unescape gitignore wildcards
+        escaped = escaped.replace(r'\*', '.*')  # * matches any sequence
+        escaped = escaped.replace(r'\?', '.')   # ? matches any single character
+        
+        # Handle character classes [abc]
+        escaped = re.sub(r'\\(\[.*?\])', r'\1', escaped)
+        
+        return escaped
+    
+    def is_ignored(self, file_path: Path, project_root: Path) -> bool:
+        """Check if file should be ignored based on gitignore patterns."""
+        # Convert to relative path from project root
+        try:
+            rel_path = file_path.relative_to(project_root)
+            path_str = str(rel_path).replace('\\', '/')  # Use forward slashes
+        except ValueError:
+            # File is outside project root, don't ignore
+            return False
+        
+        # Check negated patterns first (they override)
+        for pattern in self.negated_patterns:
+            if pattern.search(path_str):
+                return False
+        
+        # Check regular patterns
+        for pattern in self.patterns:
+            if pattern and pattern.search(path_str):
+                return True
+        
+        # Check directory patterns
+        for pattern in self.dir_patterns:
+            if pattern and pattern.search(path_str):
+                return True
+        
+        return False
+
+
+def load_gitignore_patterns(project_path: Path) -> GitIgnoreParser:
+    """Load gitignore patterns from project directory."""
+    gitignore_path = project_path / '.gitignore'
+    return GitIgnoreParser(gitignore_path)

{code2llm-0.5.52 → code2llm-0.5.53}/code2llm/exporters/__init__.py

@@ -31,6 +31,7 @@ from .report_generators import (
     ArticleViewGenerator, HTMLDashboardGenerator,
     load_project_yaml,
 )
+from .index_generator import IndexHTMLGenerator
 
 __all__ = [
     'Exporter',
@@ -49,5 +50,6 @@ __all__ = [
     'ContextViewGenerator',
     'ArticleViewGenerator',
     'HTMLDashboardGenerator',
+    'IndexHTMLGenerator',
     'load_project_yaml',
 ]