Add release notes

Signed-off-by: Rahul Krishna <[email protected]>

Author: rahlk

RELEASE.md

@@ -0,0 +1,146 @@
+## 🎉 CodeAnalyzer Python v0.1.0 Release
+
+**Python Static Analysis Backend for CodeLLM DevKit (CLDK)**
+
+Initial release of **CodeAnalyzer Python**: A comprehensive static analysis tool designed specifically as the Python backend for the CodeLLM DevKit ecosystem. This tool provides deep code understanding capabilities through symbol table generation, with future support for call graph analysis and semantic analysis using industry-standard tools.
+
+### 🚀 Key Features
+
+#### **Symbol Table Generation**
+- **Complete AST Analysis**: Extracts classes, functions, variables, imports, and comments from Python source code
+- **Type Inference**: Leverages Jedi for intelligent type inference and symbol resolution
+- **Rich Metadata**: Captures cyclomatic complexity, parameter details, call sites, and code structure
+- **Comprehensive Coverage**: Supports modules, classes, functions, variables, imports, and docstrings
+
+#### **Smart Project Processing**
+- **Intelligent File Discovery**: Automatically excludes virtual environments, site-packages, and cache directories
+- **Progress Tracking**: Beautiful Rich-based progress bars with real-time feedback
+- **Error Resilience**: Continues processing on individual file failures with detailed error reporting
+- **Caching Support**: Efficient caching system with customizable cache directories
+
+#### **Modern CLI Interface**
+- **Rich Terminal UI**: Beautiful, colorful output with Rich integration
+- **Flexible Logging**: Multiple verbosity levels (`-v`, `-vv`, `-vvv`) with structured logging
+- **Multiple Output Formats**: JSON output to stdout or file
+- **Comprehensive Options**: Eager/lazy analysis, cache management, and output control
+
+### 🛠️ Technical Highlights
+
+#### **Built with Modern Python**
+- **Python 3.12+**: Leverages latest Python features and type hints
+- **uv Package Manager**: Fast, reliable dependency management
+- **Pydantic Models**: Type-safe data structures with validation
+- **Rich Progress Bars**: Non-blocking progress indication that preserves log output
+
+#### **Advanced Code Analysis**
+- **Jedi Integration**: Professional-grade code intelligence and type inference
+- **AST Processing**: Deep abstract syntax tree analysis
+- **Builder Pattern**: Fluent, type-safe object construction
+- **Comprehensive Schema**: Detailed Python code representation models
+
+#### **Production Ready**
+- **Error Handling**: Graceful failure handling with detailed logging
+- **Memory Efficient**: Processes large codebases without memory issues
+- **Configurable**: Extensive customization options for different use cases
+- **Well Tested**: Comprehensive test suite with CLI testing
+
+### 📋 Usage Examples
+
+**Basic Symbol Table Generation:**
+```bash
+uv run codeanalyzer --input ./my-python-project
+```
+
+**Save Results to File:**
+```bash
+uv run codeanalyzer --input ./project --output ./analysis-results
+```
+
+**Verbose Analysis with Custom Cache:**
+```bash
+uv run codeanalyzer --input ./project -vv --cache-dir ./custom-cache --eager
+```
+
+### 🔧 Installation
+
+```bash
+# Clone the repository
+git clone https://github.com/codellm-devkit/codeanalyzer-python
+cd codeanalyzer-python
+
+# Install with uv
+uv sync --all-groups
+
+# Run analysis
+uv run codeanalyzer --input /path/to/your/project
+```
+
+### 🎯 What's Included
+
+#### **Core Modules**
+- **`SymbolTableBuilder`**: Main analysis engine with comprehensive Python code parsing
+- **`ProgressBar`**: Smart progress indication that respects logging levels
+- **`PySchema`**: Rich data models for representing Python code structures
+- **`AnalyzerCore`**: Central orchestration with caching and virtual environment support
+
+#### **Advanced Features**
+- **Virtual Environment Detection**: Automatic Python environment discovery and setup
+- **CodeQL Integration**: Foundation for future semantic analysis (in development)
+- **Extensible Architecture**: Modular design ready for additional analysis backends
+
+### 🔮 Future Roadmap
+
+#### **Planned Features**
+- **Call Graph Analysis** (`--analysis-level 2`): Complete function call relationship mapping
+- **CodeQL Semantic Analysis**: Advanced code pattern detection and vulnerability analysis
+- **WALA Integration**: Additional semantic analysis capabilities
+- **Performance Optimizations**: Parallel processing and incremental analysis
+
+### 🏗️ Architecture Improvements in v0.1.0
+
+#### **Logging System Overhaul**
+- **Replaced Loguru with Rich Logging**: Better terminal integration and formatting
+- **Centralized Logger**: Consistent logging across all modules
+- **Progress-Aware Logging**: Error messages don't interfere with progress bars
+
+#### **Progress Bar Enhancement**
+- **Rich Integration**: Beautiful, informative progress indication
+- **Logger-Aware**: Automatically disables when logging level is high
+- **Error Collection**: Batches error messages to display after progress completion
+
+#### **Dependency Management**
+- **Switched from tqdm to Rich**: Unified UI framework
+- **Cleaner Dependencies**: Removed redundant packages
+- **Better Error Handling**: More robust dependency resolution
+
+### 🧪 Quality Assurance
+
+#### **Testing Infrastructure**
+- **CLI Testing**: Comprehensive command-line interface validation
+- **Symbol Table Testing**: Verification of analysis accuracy
+- **Error Handling Tests**: Robust failure mode testing
+
+#### **Code Quality**
+- **Type Safety**: Full type hints with mypy compatibility
+- **Modern Python**: Leverages Python 3.12+ features
+- **Clean Architecture**: Modular, testable design patterns
+
+### 🎊 Perfect for CodeLLM DevKit
+
+This release establishes CodeAnalyzer Python as the foundational static analysis backend for the CodeLLM DevKit ecosystem, providing:
+
+- **Structured Code Representation**: Rich JSON output perfect for LLM consumption
+- **Comprehensive Metadata**: All the context needed for intelligent code understanding
+- **Extensible Design**: Ready to integrate with additional CLDK tools and workflows
+- **Production Scalability**: Handles enterprise-scale Python codebases efficiently
+
+### 📖 Documentation & Support
+
+- **Comprehensive README**: Detailed installation and usage instructions
+- **Rich CLI Help**: Built-in help system with examples
+- **Type-Safe APIs**: Full type hints for IDE integration
+- **Open Source**: Apache 2.0 license with community contributions welcome
+
+---
+
+*For issues, feature requests, or contributions, visit our [GitHub repository](https://github.com/codellm-devkit/codeanalyzer-python).*

pyproject.toml

@@ -17,9 +17,9 @@ dependencies = [
     "pandas>=2.3.0",
     "pydantic>=2.11.7",
     "requests>=2.32.4",
+    "rich>=14.0.0",
     "ruff>=0.12.2",
     "toml>=0.10.2",
-    "tqdm>=4.67.1",
     "typer>=0.16.0",
 ]
 

src/codeanalyzer/__main__.py

@@ -1,37 +1,13 @@
 from contextlib import nullcontext
 import sys
-from loguru import logger
 import typer
 from typing import Optional, Annotated
 from pathlib import Path
-from codeanalyzer.core import AnalyzerCore
-import json
-
-
-def _setup_logger(level: str = "INFO") -> None:
-    """
-    Setup the logger with the specified level.
-
-    Args:
-        level (str): The logging level to set. Default is "INFO".
-    """
-    if __name__ != "__main__":
-        return  # Avoid reconfiguring logger if not running as a cli application
+from codeanalyzer.utils import _set_log_level
 
-    logger.remove()
-
-    if level == "OFF":
-        return  # If logging is turned off, we do not add any handlers.
-
-    logger.add(
-        sys.stderr,
-        format="{time:YYYY-MM-DD at HH:mm:ss} | {level} | {message}",
-        level=level,
-        colorize=True,
-    )
+from codeanalyzer.core import AnalyzerCore
 
 
-@logger.catch
 def main(
     input: Annotated[
         Path, typer.Option("-i", "--input", help="Path to the project root directory.")
@@ -51,40 +27,35 @@ def main(
         bool,
         typer.Option(
             "--eager/--lazy",
-            help="Enable eager or lazy analysis. Eager will rebuild the analysis cache at every run and lazy will use the cache if available. Defaults to lazy.",
+            help="Enable eager or lazy analysis. Defaults to lazy.",
         ),
     ] = False,
     cache_dir: Annotated[
         Optional[Path],
         typer.Option(
             "-c",
             "--cache-dir",
-            help="Directory to store analysis cache. If not specified, the cache will be stored in the current working directory under `.codeanalyzer`. Defaults to None.",
+            help="Directory to store analysis cache.",
         ),
     ] = None,
     clear_cache: Annotated[
         bool,
         typer.Option("--clear-cache/--keep-cache", help="Clear cache after analysis."),
     ] = True,
-    verbose: Annotated[
-        bool, typer.Option("-v/-q", "--verbose/--quiet", help="Enable verbose output.")
-    ] = True,
+    verbosity: Annotated[
+        int, typer.Option("-v", count=True, help="Increase verbosity: -v, -vv, -vvv")
+    ] = 0,
 ):
-    """Static Analysis on Python source code using Jedi, Asteroid, and Treesitter."""
-    if verbose:
-        _setup_logger("DEBUG")
-    else:
-        _setup_logger("OFF")
+    """Static Analysis on Python source code using Jedi, Astroid, and Treesitter."""
+    _set_log_level(verbosity)
 
     with AnalyzerCore(
         input, analysis_level, using_codeql, rebuild_analysis, cache_dir, clear_cache
     ) as analyzer:
         artifacts = analyzer.analyze()
-        # Default to printing the artifacts to stdout
         print_stream = sys.stdout
         stream_context = nullcontext(print_stream)
 
-        # If output is specified, redirect to file
         if output is not None:
             output.mkdir(parents=True, exist_ok=True)
             output_file = output / "analysis.json"

src/codeanalyzer/core.py

@@ -5,7 +5,7 @@
 from pathlib import Path
 import sys
 from typing import Any, Dict, Union, Optional
-from loguru import logger
+from codeanalyzer.utils import logger
 
 from codeanalyzer.schema.py_schema import PyApplication, PyModule
 from codeanalyzer.semantic_analysis.codeql import CodeQLLoader
@@ -120,23 +120,6 @@ def __enter__(self) -> "AnalyzerCore":
             # Find python in the virtual environment
             venv_python = venv_path / "bin" / "python"
 
-            # Upgrade pip + install build backend dependencies
-            self._cmd_exec_helper(
-                [
-                    str(venv_python),
-                    "-m",
-                    "pip",
-                    "install",
-                    "--upgrade",
-                    "--editable",
-                    "pip",
-                    "build",
-                    "setuptools",
-                    "wheel",
-                ],
-                check=True,
-            )
-
             # Install the project itself (reads pyproject.toml)
             self._cmd_exec_helper(
                 [str(venv_python), "-m", "pip", "install", "-U", f"{self.project_dir}"],

src/codeanalyzer/schema/py_schema.py

@@ -21,8 +21,7 @@
 """
 
 from pathlib import Path
-import sys
-from typing import Any, Dict, List, Optional, get_type_hints
+from typing import Any, Dict, List, Optional
 from typing_extensions import Literal
 from pydantic import BaseModel
 
@@ -287,7 +286,7 @@ class PyClassAttribute(BaseModel):
     """
 
     name: str
-    type: str = None
+    type: Optional[str] = None
     comments: List[PyComment] = []
     start_line: int = -1
     end_line: int = -1

src/codeanalyzer/semantic_analysis/codeql/codeql_loader.py

@@ -2,7 +2,7 @@
 import requests
 import zipfile
 from pathlib import Path
-from loguru import logger
+from codeanalyzer.utils import logger
 from tqdm import tqdm
 
 

src/codeanalyzer/syntactic_analysis/symbol_table_builder.py

@@ -4,9 +4,10 @@
 from typing import Dict, List, Optional
 import astor
 import jedi
-from loguru import logger
+from codeanalyzer.utils import logger
 from jedi.api.project import Project
 from jedi.api import Script
+from rich.progress import track
 from codeanalyzer.schema.py_schema import (
     PyCallable,
     PyCallableParameter,
@@ -22,6 +23,8 @@
 import ast
 from ast import AST, ClassDef
 
+from codeanalyzer.utils.progress_bar import ProgressBar
+
 
 class SymbolTableBuilder:
     """A class for building a symbol table for a Python project."""
@@ -875,16 +878,26 @@ def build(self) -> Dict[str, PyModule]:
         functions, and variables defined in those files.
         """
         symbol_table: Dict[str, PyModule] = {}
-        for directory in self.project_dir.iterdir():
-            if directory.is_dir() and directory.name.startswith("."):
-                continue
-            for py_file in directory.rglob("*.py"):
-                if py_file.name.startswith("__"):
-                    continue
+        # Get all Python files first to show accurate progress
+        py_files = [
+            py_file
+            for py_file in self.project_dir.rglob("*.py")
+            if "site-packages"
+            not in py_file.resolve().__str__()  # exclude site-packages
+            and ".venv"
+            not in py_file.resolve().__str__()  # exclude virtual environments
+            and ".codeanalyzer"
+            not in py_file.resolve().__str__()  # exclude internal cache directories
+        ]
+
+        with ProgressBar(len(py_files), "Building symbol table") as progress:
+            for py_file in py_files:
                 try:
-                    py_module: PyModule = self._module(py_file)
-                    symbol_table.update({py_file: py_module})
+                    py_module = self._module(py_file)
+                    symbol_table[str(py_file)] = py_module
                 except Exception as e:
                     logger.error(f"Failed to process {py_file}: {e}")
-                    continue
+                progress.advance()
+            progress.finish("✅ Symbol table generation complete.")
+
         return symbol_table

src/codeanalyzer/utils/__init__.py

@@ -0,0 +1,5 @@
+from .logging import logger
+from .logging import _set_log_level
+from .progress_bar import ProgressBar
+
+__all__ = ["logger", "_set_log_level", "ProgressBar"]

src/codeanalyzer/utils/logging.py

@@ -0,0 +1,18 @@
+from rich.console import Console
+from rich.logging import RichHandler
+import logging
+
+# Set up base logger with RichHandler
+console = Console()
+handler = RichHandler(console=console, show_time=True, show_level=True, show_path=False)
+
+logger = logging.getLogger("codeanalyzer")
+logger.setLevel(logging.ERROR)  # Default level
+logger.addHandler(handler)
+logger.propagate = False  # Prevent double logs
+
+
+def _set_log_level(verbosity: int) -> None:
+    levels = [logging.ERROR, logging.WARNING, logging.INFO, logging.DEBUG]
+    level = levels[min(verbosity, len(levels) - 1)]
+    logger.setLevel(level)