code-assembler-pro 4.2.1__py3-none-any.whl

code_assembler/__init__.py

@@ -0,0 +1,16 @@
+"""
+Code Assembler Pro - A tool for consolidating source code for LLM analysis.
+"""
+
+from .core import assemble_codebase, assemble_from_config
+from .config import AssemblerConfig
+from .constants import __version__
+from .interactive import run_interactive_mode
+
+__all__ = [
+    "assemble_codebase",
+    "assemble_from_config",
+    "AssemblerConfig",
+    "run_interactive_mode",
+    "__version__",
+]

code_assembler/__main__.py

@@ -0,0 +1,23 @@
+"""
+Entry point for the code_assembler package execution.
+"""
+import sys
+from pathlib import Path
+
+# Calculate the 'src' directory path (one level above this file)
+src_path = str(Path(__file__).resolve().parent.parent)
+
+# Add it to the Python search path if it's not already there
+if src_path not in sys.path:
+    sys.path.insert(0, src_path)
+
+# Now perform an ABSOLUTE import (without the dot)
+# This works because 'src' is in the path, making 'code_assembler' visible
+try:
+    from code_assembler.cli import main
+except ImportError:
+    # Fallback for when the package is already properly installed via pip
+    from .cli import main
+
+if __name__ == "__main__":
+    main()

code_assembler/analyzers.py

@@ -0,0 +1,152 @@
+"""
+Architecture and Quality analyzers for Code Assembler Pro.
+
+This module extracts structural data and patterns from the codebase
+without handling formatting (delegated to templates).
+"""
+import os
+from collections import defaultdict
+from pathlib import Path
+from typing import List, Dict, Set, Any
+
+from .config import FileEntry, CodebaseStats
+from .constants import LANGUAGE_MAP
+
+
+class ArchitectureAnalyzer:
+    """Analyzes codebase structure and detects patterns, returning raw data."""
+
+    def __init__(self, entries: List[FileEntry], stats: CodebaseStats):
+        """
+        Initialize analyzer.
+
+        Args:
+            entries: List of file entries
+            stats: Codebase statistics
+        """
+        self.entries = entries
+        self.stats = stats
+
+    def analyze_data(self) -> Dict[str, Any]:
+        """
+        Perform complete architecture analysis and return raw data.
+        """
+        # Calculate depth distribution first to update self.stats.max_depth
+        depth_dist = self._get_depth_distribution()
+
+        return {
+            "components": self._get_components(),
+            "distribution": self._get_distribution(),
+            "patterns": self._get_patterns(),
+            "max_depth": self.stats.max_depth,
+            "depth_distribution": depth_dist
+        }
+
+    def _get_components(self) -> List[Dict[str, Any]]:
+        """Identify top-level components relative to the entries."""
+        if not self.entries:
+            return []
+
+        # Find the common path to determine the root
+        all_paths = [Path(e.path) for e in self.entries]
+        root_path = Path(os.path.commonpath([str(p) for p in all_paths]))
+
+        results = []
+        top_dirs = set()
+
+        for entry in self.entries:
+            try:
+                # Calculate relative path from common root
+                rel_path = Path(entry.path).relative_to(root_path)
+                if len(rel_path.parts) > 1:
+                    top_dirs.add(rel_path.parts[0])
+            except ValueError:
+                continue
+
+        for dir_name in sorted(top_dirs):
+            # Count files belonging to this component
+            count = sum(1 for e in self.entries if e.is_file and dir_name in Path(e.path).parts)
+            results.append({"name": dir_name, "count": count})
+
+        return results
+
+    def _get_depth_distribution(self) -> Dict[int, int]:
+        """Count files at each directory depth level and sync max_depth."""
+        depth_counts = defaultdict(int)
+        for e in self.entries:
+            if e.is_file:
+                depth_counts[e.depth] += 1
+
+        if depth_counts:
+            self.stats.max_depth = max(depth_counts.keys())
+
+        return dict(sorted(depth_counts.items()))
+
+    def _get_distribution(self) -> List[Dict[str, Any]]:
+        """Get file distribution by extension and language."""
+        results = []
+        if not self.stats.files_by_ext:
+            return results
+
+        # Sort by count descending
+        sorted_exts = sorted(
+            self.stats.files_by_ext.items(),
+            key=lambda x: x[1],
+            reverse=True
+        )
+
+        for ext, count in sorted_exts:
+            lang = LANGUAGE_MAP.get(ext, "unknown")
+            percentage = (count / self.stats.total_files * 100) if self.stats.total_files > 0 else 0
+            results.append({
+                "ext": ext,
+                "lang": lang,
+                "count": count,
+                "percentage": round(percentage, 1)
+            })
+        return results
+
+    def _get_patterns(self) -> List[str]:
+        """Detect common design patterns based on filenames."""
+        dir_files: Dict[str, Set[str]] = defaultdict(set)
+        for entry in self.entries:
+            if entry.is_file:
+                parent = str(Path(entry.path).parent)
+                filename = Path(entry.path).name.lower()
+                dir_files[parent].add(filename)
+
+        detected = []
+        patterns_map = {
+            'MVC': {
+                'indicators': ['model.py', 'view.py', 'controller.py'],
+                'description': 'Model-View-Controller pattern detected'
+            },
+            'Testing': {
+                'indicators': ['test_', '__test__', 'tests.py', 'test.py'],
+                'description': 'Organized test structure'
+            },
+            'Configuration': {
+                'indicators': ['.env', 'config.py', 'settings.py', 'config.yml', 'pyproject.toml'],
+                'description': 'Centralized configuration files'
+            },
+            'Documentation': {
+                'indicators': ['readme.md', 'docs/', 'documentation/'],
+                'description': 'Structured documentation'
+            },
+            'API': {
+                'indicators': ['routes.py', 'api.py', 'endpoints.py', 'views.py'],
+                'description': 'API/Routes architecture'
+            },
+            'Database': {
+                'indicators': ['models.py', 'schema.py', 'migrations/', 'db.py'],
+                'description': 'Persistence/Database layer'
+            },
+        }
+
+        for pattern_info in patterns_map.values():
+            for files in dir_files.values():
+                if any(any(ind in f for f in files) for ind in pattern_info['indicators']):
+                    detected.append(pattern_info['description'])
+                    break
+
+        return sorted(list(set(detected)))

code_assembler/cli.py

@@ -0,0 +1,148 @@
+"""
+Command Line Interface for Code Assembler Pro.
+"""
+
+import argparse
+import sys
+from pathlib import Path
+from typing import List
+
+from .core import assemble_codebase, assemble_from_config
+from .constants import __version__, DEFAULT_MAX_FILE_SIZE_MB
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Consolidate a codebase into a single Markdown file for LLM analysis."
+    )
+
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}"
+    )
+
+    # Interactive mode
+    parser.add_argument(
+        "--interactive", "-i",
+        action="store_true",
+        help="Launch interactive wizard mode"
+    )
+
+    # Config file mode
+    parser.add_argument(
+        "--config", "-c",
+        type=str,
+        help="Path to a JSON configuration file"
+    )
+
+    # Main arguments (used if --config is not present)
+    parser.add_argument(
+        "paths",
+        nargs="*",
+        help="Files or directories to analyze"
+    )
+
+    parser.add_argument(
+        "--ext", "-e",
+        dest="extensions",
+        nargs="+",
+        help="Extensions to include (e.g., py md json)"
+    )
+
+    parser.add_argument(
+        "--output", "-o",
+        default="codebase.md",
+        help="Output file name (default: codebase.md)"
+    )
+
+    parser.add_argument(
+        "--exclude", "-x",
+        dest="exclude_patterns",
+        nargs="+",
+        help="Patterns to exclude (added to defaults)"
+    )
+
+    # Boolean flags
+    parser.add_argument(
+        "--no-recursive",
+        action="store_false",
+        dest="recursive",
+        help="Do not traverse subdirectories recursively"
+    )
+
+    parser.add_argument(
+        "--no-readmes",
+        action="store_false",
+        dest="include_readmes",
+        help="Do not automatically include README files"
+    )
+
+    parser.add_argument(
+        "--no-default-excludes",
+        action="store_false",
+        dest="use_default_excludes",
+        help="Do not use the default exclusion list"
+    )
+
+    parser.add_argument(
+        "--max-size",
+        type=float,
+        default=DEFAULT_MAX_FILE_SIZE_MB,
+        help=f"Maximum file size in MB (default: {DEFAULT_MAX_FILE_SIZE_MB})"
+    )
+
+    # Set defaults for flags
+    parser.set_defaults(
+        recursive=True,
+        include_readmes=True,
+        use_default_excludes=True
+    )
+
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+
+    try:
+        if args.config:
+            # JSON Configuration Mode
+            print(f"Loading configuration from: {args.config}")
+            assemble_from_config(args.config)
+        else:
+            # CLI Arguments Mode
+            if not args.paths:
+                print("Error: No path specified.")
+                print("Usage: code-assembler path/to/code --ext py js")
+                sys.exit(1)
+
+            if not args.extensions:
+                print("Error: No extensions specified.")
+                print("Use --ext or -e (e.g., --ext py md)")
+                sys.exit(1)
+
+            # Normalize extensions (add leading dot if missing)
+            extensions = [
+                e if e.startswith('.') else f'.{e}'
+                for e in args.extensions
+            ]
+
+            assemble_codebase(
+                paths=args.paths,
+                extensions=extensions,
+                exclude_patterns=args.exclude_patterns,
+                output=args.output,
+                recursive=args.recursive,
+                include_readmes=args.include_readmes,
+                max_file_size_mb=args.max_size,
+                use_default_excludes=args.use_default_excludes
+            )
+
+    except Exception as e:
+        print(f"\n❌ An error occurred: {str(e)}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

code_assembler/config.py

@@ -0,0 +1,136 @@
+"""
+Configuration classes for Code Assembler Pro.
+
+This module defines all configuration dataclasses and validation logic.
+"""
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import List, Optional
+
+from .constants import DEFAULT_EXCLUDE_PATTERNS, DEFAULT_MAX_FILE_SIZE_MB
+
+
+@dataclass
+class AssemblerConfig:
+    """
+    Main configuration for codebase assembly.
+
+    Attributes:
+        paths: List of file/directory paths to process
+        extensions: File extensions to include (with or without leading dot)
+        exclude_patterns: Patterns to exclude from processing
+        output_file: Output markdown filename
+        recursive: Whether to recursively traverse directories
+        include_readmes: Whether to automatically include README files
+        max_file_size_mb: Maximum file size in MB to process
+        truncate_large_files: If True, truncates files exceeding max_file_size_mb
+        truncation_limit_lines: Number of lines to keep if truncated
+        show_progress: Whether to show progress information
+        use_default_excludes: Whether to use default exclude patterns
+    """
+
+    paths: List[str]
+    extensions: List[str]
+    exclude_patterns: List[str] = field(default_factory=list)
+    output_file: str = "codebase.md"
+    recursive: bool = True
+    include_readmes: bool = True
+    max_file_size_mb: float = DEFAULT_MAX_FILE_SIZE_MB
+    truncate_large_files: bool = True
+    truncation_limit_lines: int = 500
+    show_progress: bool = True
+    use_default_excludes: bool = True
+
+    def __post_init__(self):
+        """Validate and normalize configuration after initialization."""
+        if not self.paths:
+            raise ValueError("At least one path must be specified")
+
+        if not self.extensions:
+            raise ValueError("At least one extension must be specified")
+
+        # Normalize extensions to include leading dot
+        self.extensions = [
+            ext if ext.startswith('.') else f'.{ext}'
+            for ext in self.extensions
+        ]
+
+        # Add default excludes if requested
+        if self.use_default_excludes:
+            self.exclude_patterns = list(set(
+                self.exclude_patterns + DEFAULT_EXCLUDE_PATTERNS
+            ))
+
+        if self.max_file_size_mb <= 0:
+            raise ValueError("max_file_size_mb must be positive")
+
+    @classmethod
+    def from_dict(cls, config_dict: dict) -> "AssemblerConfig":
+        return cls(**config_dict)
+
+    def to_dict(self) -> dict:
+        return {
+            "paths": self.paths,
+            "extensions": self.extensions,
+            "exclude_patterns": self.exclude_patterns,
+            "output_file": self.output_file,
+            "recursive": self.recursive,
+            "include_readmes": self.include_readmes,
+            "max_file_size_mb": self.max_file_size_mb,
+            "truncate_large_files": self.truncate_large_files,
+            "truncation_limit_lines": self.truncation_limit_lines,
+            "show_progress": self.show_progress,
+            "use_default_excludes": self.use_default_excludes,
+        }
+
+
+@dataclass
+class FileEntry:
+    """Represents a file or directory entry in the table of contents."""
+    path: str
+    type: str  # 'file' or 'dir'
+    depth: int
+    size_bytes: int = 0
+    line_count: int = 0
+
+    @property
+    def name(self) -> str:
+        return Path(self.path).name
+
+    @property
+    def is_file(self) -> bool:
+        return self.type == 'file'
+
+    @property
+    def is_directory(self) -> bool:
+        return self.type == 'dir'
+
+
+@dataclass
+class CodebaseStats:
+    """Statistics about the assembled codebase."""
+    total_files: int = 0
+    total_lines: int = 0
+    total_chars: int = 0
+    estimated_tokens: int = 0
+    files_by_ext: dict = field(default_factory=dict)
+    largest_file: Optional[tuple] = None
+    max_depth: int = 0
+    skipped_files: List[str] = field(default_factory=list)
+
+    def update_largest_file(self, path: str, size: int):
+        if not self.largest_file or size > self.largest_file[1]:
+            self.largest_file = (path, size)
+
+    def add_file(self, extension: str, lines: int, size: int):
+        self.total_files += 1
+        self.total_lines += lines
+
+        if extension not in self.files_by_ext:
+            self.files_by_ext[extension] = 0
+        self.files_by_ext[extension] += 1
+
+    def skip_file(self, path: str, reason: str = ""):
+        entry = f"{path}" + (f" ({reason})" if reason else "")
+        self.skipped_files.append(entry)

code_assembler/constants.py

@@ -0,0 +1,203 @@
+"""
+Constants for Code Assembler Pro.
+
+This module contains all constant values used throughout the package,
+including language mappings, file extensions, and default configurations.
+"""
+
+from typing import Dict
+
+# In code_assembler/constants.py
+
+# Version
+__version__ = "4.2.1"  # Changed from 4.1.0
+
+# Language mapping for syntax highlighting
+LANGUAGE_MAP: Dict[str, str] = {
+    # Programming languages
+    ".py": "python",
+    ".pyw": "python",
+    ".pyi": "python",
+    ".js": "javascript",
+    ".jsx": "jsx",
+    ".mjs": "javascript",
+    ".cjs": "javascript",
+    ".ts": "typescript",
+    ".tsx": "tsx",
+    ".java": "java",
+    ".kt": "kotlin",
+    ".kts": "kotlin",
+    ".scala": "scala",
+    ".c": "c",
+    ".h": "c",
+    ".cpp": "cpp",
+    ".cc": "cpp",
+    ".cxx": "cpp",
+    ".hpp": "cpp",
+    ".hh": "cpp",
+    ".hxx": "cpp",
+    ".cs": "csharp",
+    ".go": "go",
+    ".rs": "rust",
+    ".rb": "ruby",
+    ".php": "php",
+    ".swift": "swift",
+    ".m": "objective-c",
+    ".r": "r",
+    ".jl": "julia",
+    ".lua": "lua",
+    ".pl": "perl",
+    ".pm": "perl",
+    ".dart": "dart",
+    ".elm": "elm",
+    ".ex": "elixir",
+    ".exs": "elixir",
+    ".erl": "erlang",
+    ".hrl": "erlang",
+    ".clj": "clojure",
+    ".cljs": "clojure",
+    ".fs": "fsharp",
+    ".fsx": "fsharp",
+    ".hs": "haskell",
+    ".ml": "ocaml",
+    ".v": "verilog",
+    ".vhd": "vhdl",
+
+    # Web & markup
+    ".html": "html",
+    ".htm": "html",
+    ".xml": "xml",
+    ".svg": "xml",
+    ".css": "css",
+    ".scss": "scss",
+    ".sass": "sass",
+    ".less": "less",
+    ".vue": "vue",
+    ".svelte": "svelte",
+
+    # Data & config
+    ".json": "json",
+    ".yaml": "yaml",
+    ".yml": "yaml",
+    ".toml": "toml",
+    ".ini": "ini",
+    ".cfg": "ini",
+    ".conf": "ini",
+    ".csv": "csv",
+    ".tsv": "csv",
+
+    # Documentation
+    ".md": "markdown",
+    ".markdown": "markdown",
+    ".rst": "rst",
+    ".txt": "text",
+    ".adoc": "asciidoc",
+
+    # Shell & scripts
+    ".sh": "bash",
+    ".bash": "bash",
+    ".zsh": "zsh",
+    ".fish": "fish",
+    ".ps1": "powershell",
+    ".psm1": "powershell",
+    ".bat": "batch",
+    ".cmd": "batch",
+
+    # Database
+    ".sql": "sql",
+    ".psql": "sql",
+    ".mysql": "sql",
+    ".pgsql": "sql",
+
+    # Build & CI/CD
+    ".dockerfile": "dockerfile",
+    ".dockerignore": "text",
+    ".gitignore": "text",
+    ".gitattributes": "text",
+    ".editorconfig": "ini",
+
+    # Other
+    ".env": "bash",
+    ".properties": "properties",
+    ".gradle": "gradle",
+    ".makefile": "makefile",
+    ".cmake": "cmake",
+    ".proto": "protobuf",
+    ".graphql": "graphql",
+    ".gql": "graphql",
+}
+
+# Default exclude patterns
+DEFAULT_EXCLUDE_PATTERNS = [
+    "__pycache__",
+    ".pyc",
+    ".pyo",
+    ".pyd",
+    ".so",
+    ".dll",
+    ".dylib",
+    ".egg-info",
+    ".eggs",
+    "dist",
+    "build",
+    ".git",
+    ".svn",
+    ".hg",
+    ".venv",
+    "venv",
+    "env",
+    "node_modules",
+    ".idea",
+    ".vscode",
+    ".DS_Store",
+    "Thumbs.db",
+]
+
+# Common README filenames
+README_FILENAMES = [
+    "README.md",
+    "README.MD",
+    "README.rst",
+    "README.txt",
+    "README",
+    "readme.md",
+    "Readme.md",
+]
+
+# Token estimation constants
+CHARS_PER_TOKEN = 4  # Average characters per token (rough estimate)
+
+# File size limits
+DEFAULT_MAX_FILE_SIZE_MB = 10.0
+MAX_SAFE_FILE_SIZE_MB = 100.0
+
+# Emojis for output formatting
+EMOJI = {
+    "folder": "📁",
+    "file": "📄",
+    "readme": "ℹ️",
+    "success": "✅",
+    "warning": "⚠️",
+    "error": "❌",
+    "rocket": "🚀",
+    "chart": "📊",
+    "target": "🎯",
+    "building": "🏛️",
+    "map": "🗺️",
+    "book": "📖",
+    "bug": "🐛",
+    "memo": "📝",
+    "mag": "🔍",
+    "test": "🧪",
+    "recycle": "🔄",
+    "bulb": "💡",
+    "floppy": "💾",
+}
+
+# Header templates
+HEADER_LEVELS = {
+    "document": 1,
+    "section": 2,
+    "subsection": 3,
+    "file": 2,
+}