codebase-digest-ai 0.1.1__tar.gz

codebase_digest_ai-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Codebase Digest
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

codebase_digest_ai-0.1.1/MANIFEST.in

@@ -0,0 +1,25 @@
+include README.md
+include LICENSE
+include pyproject.toml
+
+# Python source
+recursive-include codebase_digest *.py
+
+# Templates + report assets (CRITICAL)
+recursive-include codebase_digest *.html
+recursive-include codebase_digest *.md
+recursive-include codebase_digest *.j2
+recursive-include codebase_digest *.json
+
+# Cleanup
+recursive-exclude * __pycache__
+recursive-exclude * *.py[co]
+
+exclude .gitignore
+exclude install.py
+
+prune example_project
+prune lib
+prune .digest
+prune .vscode
+prune tests

codebase_digest_ai-0.1.1/PKG-INFO

@@ -0,0 +1,233 @@
+Metadata-Version: 2.4
+Name: codebase-digest-ai
+Version: 0.1.1
+Summary: AI-native code intelligence engine for semantic codebase analysis
+Author: Harsh Bothara
+License: MIT
+Project-URL: Homepage, https://github.com/codebase-digest/codebase-digest
+Project-URL: Documentation, https://github.com/codebase-digest/codebase-digest#readme
+Project-URL: Repository, https://github.com/codebase-digest/codebase-digest
+Project-URL: Issues, https://github.com/codebase-digest/codebase-digest/issues
+Keywords: code-analysis,ast,static-analysis,documentation,ai,developer-tools
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Documentation
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer>=0.9.0
+Requires-Dist: networkx>=3.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: jinja2>=3.1.0
+Requires-Dist: pathspec>=0.11.0
+Requires-Dist: pyvis>=0.3.2
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: isort>=5.12.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: build>=0.10.0; extra == "dev"
+Requires-Dist: twine>=4.0.0; extra == "dev"
+Dynamic: license-file
+
+# codebase-digest
+
+🚀 **AI-Native Code Intelligence Engine**
+
+Transform any codebase into semantic architectural understanding, execution flows, and human-readable engineering reports.
+
+## 🧱 What It Does
+
+This is NOT a repo summarizer. This is a code intelligence engine that explains:
+- **What this system does** - Infers project purpose from domain entities
+- **How data flows** - Maps execution paths and call relationships  
+- **Where logic lives** - Identifies core components and their responsibilities
+- **What domains exist** - Detects business entities (User, Payment, Wallet, etc.)
+- **What files matter** - Highlights entry points and key modules
+
+## ✨ Features
+
+- **🔍 Semantic Analysis**: Extract functions, classes, methods, and imports with full context
+- **📊 Interactive Call Graphs**: Visualize function relationships and execution flows
+- **🏗️ Domain Entity Detection**: Automatically identify core business objects
+- **🔄 Execution Flow Mapping**: Trace request paths through the system
+- **📋 Project README Generation**: Auto-generate documentation for new developers
+- **📈 Multi-format Output**: HTML dashboards + Markdown reports + JSON data + Interactive graphs
+
+## 🚀 Quick Start
+
+```bash
+# Install
+pip install codebase-digest
+
+# Analyze current directory
+codebase-digest build
+
+# Analyze specific directory  
+codebase-digest build /path/to/project
+
+# Generate with interactive call graph
+codebase-digest build --graph
+
+# Quick stats
+codebase-digest stats
+
+# Search for patterns
+codebase-digest query "wallet"
+```
+
+## 📁 Output Structure
+
+Generates `.digest/` directory with comprehensive analysis:
+```
+.digest/
+├── README.md          # Project documentation for developers
+├── callgraph.html     # Interactive call graph visualization
+├── report.html        # Comprehensive HTML dashboard
+├── architecture.md    # Technical architecture breakdown
+├── flows.md           # Execution flow documentation
+├── ai-context.md      # AI-optimized context file
+└── entities.json      # Structured analysis data
+```
+
+## 📊 Example Output
+
+For a Python financial services project:
+
+```
+📊 Codebase Statistics
+┏━━━━━━━━━━━━━━━━━━┳━━━━━━━━┓
+┃ Total Files      ┃ 4      ┃
+┃ Lines of Code    ┃ 189    ┃
+┃ Languages        ┃ Python ┃
+┃ Functions        ┃ 24     ┃
+┃ Classes          ┃ 8      ┃
+┃ Domain Entities  ┃ 7      ┃
+┃ Execution Flows  ┃ 4      ┃
+┃ Complexity Score ┃ 1.8    ┃
+┗━━━━━━━━━━━━━━━━━━┻━━━━━━━━┛
+
+Graph Stats: 29 nodes, 27 edges, 7 components
+```
+
+**Generated README.md excerpt:**
+```markdown
+# Project Overview
+
+This is a financial services application that provides user management, 
+payment processing, and digital wallet functionality. The system is built 
+with a service-oriented architecture using Python dataclasses for domain 
+modeling and separate service layers for business logic.
+
+## Architecture
+
+The application follows a layered architecture with clear separation of concerns:
+- **Domain Layer**: Contains core business entities (User, Payment, Wallet)
+- **Service Layer**: Implements business logic (UserService, PaymentService)  
+- **Application Layer**: Handles bootstrapping and orchestration
+```
+
+## 💡 Commands
+
+```bash
+# Full analysis with all outputs
+codebase-digest build [PATH]
+
+# Specific formats
+codebase-digest build --format html       # HTML dashboard only
+codebase-digest build --format markdown   # Markdown reports only  
+codebase-digest build --format json       # JSON data only
+
+# Interactive call graph with depth filtering
+codebase-digest build --graph --graph-depth 3
+
+# Quick metrics and search
+codebase-digest stats [PATH]              # Project statistics
+codebase-digest query "search term" [PATH] # Search patterns
+```
+
+## 🎯 Key Features
+
+### 🕸️ Interactive Call Graph
+- **Probabilistic entrypoint detection** - Finds real execution starting points
+- **Noise filtering** - Removes builtin calls and isolated nodes  
+- **Depth filtering** - Focus on core execution spine
+- **Professional UI** - GitHub/Linear/Notion inspired design
+
+### 📝 Smart README Generation  
+- **Project type inference** - Detects financial, e-commerce, CMS patterns
+- **Architecture analysis** - Service-oriented vs modular detection
+- **Run instructions** - Inferred from entry points
+- **Future improvements** - Realistic enhancement suggestions
+
+### 🔍 Semantic Understanding
+- **Symbol-aware analysis** - True function-level relationships
+- **Domain entity detection** - Business object identification
+- **Execution flow mapping** - Startup and runtime sequences
+- **Cross-file analysis** - Import and dependency tracking
+
+## 🛠️ Tech Stack
+
+- **Python 3.10+** - Core language
+- **AST parsing** - Deep Python code analysis
+- **NetworkX** - Call graph analysis and visualization
+- **vis.js** - Interactive graph rendering
+- **Typer** - CLI interface
+- **Rich** - Beautiful terminal output
+
+## 📋 Supported Languages
+
+- ✅ **Python** - Full AST analysis with call graphs
+- 🚧 **JavaScript/TypeScript** - Parser implemented, integration in progress
+- 🚧 **Java** - Planned
+- 🚧 **Go** - Planned
+
+## 🎯 Use Cases
+
+- **New Developer Onboarding** - Understand unfamiliar codebases quickly
+- **Code Reviews** - Architectural overview and impact analysis  
+- **Documentation Generation** - Auto-generate project documentation
+- **Refactoring Planning** - Identify core components and dependencies
+- **AI-Assisted Development** - Provide context for LLM code assistance
+
+## 🔧 Development
+
+```bash
+# Install development dependencies
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+
+# Format code  
+black .
+isort .
+
+# Type checking
+mypy codebase_digest/
+```
+
+## 🤝 Contributing
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/amazing-feature`)
+3. Make your changes
+4. Add tests if applicable
+5. Submit a pull request
+
+## 📄 License
+
+MIT License - see LICENSE file for details.
+
+## 🙏 Acknowledgments
+
+- Built with modern Python tooling and best practices
+- Inspired by professional developer tools (JetBrains, Sourcegraph)
+- Designed for AI-native development workflows

codebase_digest_ai-0.1.1/README.md

@@ -0,0 +1,194 @@
+# codebase-digest
+
+🚀 **AI-Native Code Intelligence Engine**
+
+Transform any codebase into semantic architectural understanding, execution flows, and human-readable engineering reports.
+
+## 🧱 What It Does
+
+This is NOT a repo summarizer. This is a code intelligence engine that explains:
+- **What this system does** - Infers project purpose from domain entities
+- **How data flows** - Maps execution paths and call relationships  
+- **Where logic lives** - Identifies core components and their responsibilities
+- **What domains exist** - Detects business entities (User, Payment, Wallet, etc.)
+- **What files matter** - Highlights entry points and key modules
+
+## ✨ Features
+
+- **🔍 Semantic Analysis**: Extract functions, classes, methods, and imports with full context
+- **📊 Interactive Call Graphs**: Visualize function relationships and execution flows
+- **🏗️ Domain Entity Detection**: Automatically identify core business objects
+- **🔄 Execution Flow Mapping**: Trace request paths through the system
+- **📋 Project README Generation**: Auto-generate documentation for new developers
+- **📈 Multi-format Output**: HTML dashboards + Markdown reports + JSON data + Interactive graphs
+
+## 🚀 Quick Start
+
+```bash
+# Install
+pip install codebase-digest
+
+# Analyze current directory
+codebase-digest build
+
+# Analyze specific directory  
+codebase-digest build /path/to/project
+
+# Generate with interactive call graph
+codebase-digest build --graph
+
+# Quick stats
+codebase-digest stats
+
+# Search for patterns
+codebase-digest query "wallet"
+```
+
+## 📁 Output Structure
+
+Generates `.digest/` directory with comprehensive analysis:
+```
+.digest/
+├── README.md          # Project documentation for developers
+├── callgraph.html     # Interactive call graph visualization
+├── report.html        # Comprehensive HTML dashboard
+├── architecture.md    # Technical architecture breakdown
+├── flows.md           # Execution flow documentation
+├── ai-context.md      # AI-optimized context file
+└── entities.json      # Structured analysis data
+```
+
+## 📊 Example Output
+
+For a Python financial services project:
+
+```
+📊 Codebase Statistics
+┏━━━━━━━━━━━━━━━━━━┳━━━━━━━━┓
+┃ Total Files      ┃ 4      ┃
+┃ Lines of Code    ┃ 189    ┃
+┃ Languages        ┃ Python ┃
+┃ Functions        ┃ 24     ┃
+┃ Classes          ┃ 8      ┃
+┃ Domain Entities  ┃ 7      ┃
+┃ Execution Flows  ┃ 4      ┃
+┃ Complexity Score ┃ 1.8    ┃
+┗━━━━━━━━━━━━━━━━━━┻━━━━━━━━┛
+
+Graph Stats: 29 nodes, 27 edges, 7 components
+```
+
+**Generated README.md excerpt:**
+```markdown
+# Project Overview
+
+This is a financial services application that provides user management, 
+payment processing, and digital wallet functionality. The system is built 
+with a service-oriented architecture using Python dataclasses for domain 
+modeling and separate service layers for business logic.
+
+## Architecture
+
+The application follows a layered architecture with clear separation of concerns:
+- **Domain Layer**: Contains core business entities (User, Payment, Wallet)
+- **Service Layer**: Implements business logic (UserService, PaymentService)  
+- **Application Layer**: Handles bootstrapping and orchestration
+```
+
+## 💡 Commands
+
+```bash
+# Full analysis with all outputs
+codebase-digest build [PATH]
+
+# Specific formats
+codebase-digest build --format html       # HTML dashboard only
+codebase-digest build --format markdown   # Markdown reports only  
+codebase-digest build --format json       # JSON data only
+
+# Interactive call graph with depth filtering
+codebase-digest build --graph --graph-depth 3
+
+# Quick metrics and search
+codebase-digest stats [PATH]              # Project statistics
+codebase-digest query "search term" [PATH] # Search patterns
+```
+
+## 🎯 Key Features
+
+### 🕸️ Interactive Call Graph
+- **Probabilistic entrypoint detection** - Finds real execution starting points
+- **Noise filtering** - Removes builtin calls and isolated nodes  
+- **Depth filtering** - Focus on core execution spine
+- **Professional UI** - GitHub/Linear/Notion inspired design
+
+### 📝 Smart README Generation  
+- **Project type inference** - Detects financial, e-commerce, CMS patterns
+- **Architecture analysis** - Service-oriented vs modular detection
+- **Run instructions** - Inferred from entry points
+- **Future improvements** - Realistic enhancement suggestions
+
+### 🔍 Semantic Understanding
+- **Symbol-aware analysis** - True function-level relationships
+- **Domain entity detection** - Business object identification
+- **Execution flow mapping** - Startup and runtime sequences
+- **Cross-file analysis** - Import and dependency tracking
+
+## 🛠️ Tech Stack
+
+- **Python 3.10+** - Core language
+- **AST parsing** - Deep Python code analysis
+- **NetworkX** - Call graph analysis and visualization
+- **vis.js** - Interactive graph rendering
+- **Typer** - CLI interface
+- **Rich** - Beautiful terminal output
+
+## 📋 Supported Languages
+
+- ✅ **Python** - Full AST analysis with call graphs
+- 🚧 **JavaScript/TypeScript** - Parser implemented, integration in progress
+- 🚧 **Java** - Planned
+- 🚧 **Go** - Planned
+
+## 🎯 Use Cases
+
+- **New Developer Onboarding** - Understand unfamiliar codebases quickly
+- **Code Reviews** - Architectural overview and impact analysis  
+- **Documentation Generation** - Auto-generate project documentation
+- **Refactoring Planning** - Identify core components and dependencies
+- **AI-Assisted Development** - Provide context for LLM code assistance
+
+## 🔧 Development
+
+```bash
+# Install development dependencies
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+
+# Format code  
+black .
+isort .
+
+# Type checking
+mypy codebase_digest/
+```
+
+## 🤝 Contributing
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/amazing-feature`)
+3. Make your changes
+4. Add tests if applicable
+5. Submit a pull request
+
+## 📄 License
+
+MIT License - see LICENSE file for details.
+
+## 🙏 Acknowledgments
+
+- Built with modern Python tooling and best practices
+- Inspired by professional developer tools (JetBrains, Sourcegraph)
+- Designed for AI-native development workflows

codebase_digest_ai-0.1.1/codebase_digest/__init__.py

@@ -0,0 +1,8 @@
+"""
+Codebase Digest - AI-native code intelligence engine.
+
+Transform any codebase into semantic architectural understanding,
+execution flows, and human-readable engineering reports.
+"""
+
+__version__ = "0.1.0"

codebase_digest_ai-0.1.1/codebase_digest/analyzer/__init__.py

@@ -0,0 +1,7 @@
+"""Analysis modules for codebase intelligence."""
+
+from .codebase_analyzer import CodebaseAnalyzer
+from .flow_analyzer import FlowAnalyzer
+from .metrics_analyzer import MetricsAnalyzer
+
+__all__ = ["CodebaseAnalyzer", "FlowAnalyzer", "MetricsAnalyzer"]

codebase_digest_ai-0.1.1/codebase_digest/analyzer/codebase_analyzer.py

@@ -0,0 +1,183 @@
+"""Main codebase analyzer that orchestrates parsing and analysis."""
+
+import os
+from pathlib import Path
+from typing import Dict, List, Set
+
+from ..models import CodebaseAnalysis
+from ..parser import PythonParser, JavaScriptParser, BaseParser
+from .flow_analyzer import FlowAnalyzer
+from .metrics_analyzer import MetricsAnalyzer
+
+
+class CodebaseAnalyzer:
+    """Main analyzer that coordinates parsing and analysis of a codebase."""
+    
+    def __init__(self, root_path: Path):
+        self.root_path = Path(root_path)
+        self.parsers: Dict[str, BaseParser] = {}
+        self._register_parsers()
+        
+        # Ignore patterns
+        self.ignore_patterns = {
+            '__pycache__', '.git', '.svn', '.hg', 'node_modules',
+            '.pytest_cache', '.mypy_cache', '.tox', 'venv', 'env',
+            '.venv', 'dist', 'build', '*.egg-info', '.DS_Store'
+        }
+    
+    def _register_parsers(self):
+        """Register available parsers."""
+        # Register parsers by extension without instantiating
+        python_extensions = ['.py']
+        js_extensions = ['.js', '.jsx', '.ts', '.tsx']
+        
+        for ext in python_extensions:
+            self.parsers[ext] = PythonParser
+        
+        for ext in js_extensions:
+            self.parsers[ext] = JavaScriptParser
+    
+    def analyze(self) -> CodebaseAnalysis:
+        """Perform complete codebase analysis."""
+        analysis = CodebaseAnalysis(root_path=self.root_path)
+        
+        # Find all relevant files
+        files = self._find_source_files()
+        analysis.total_files = len(files)
+        
+        # Parse each file
+        for file_path in files:
+            self._parse_file(file_path, analysis)
+        
+        # Detect entry points
+        analysis.entry_points = self._detect_entry_points(files)
+        
+        # Analyze execution flows
+        flow_analyzer = FlowAnalyzer(analysis)
+        analysis.execution_flows = flow_analyzer.analyze_flows()
+        
+        # Calculate metrics
+        metrics_analyzer = MetricsAnalyzer(analysis)
+        analysis.total_lines = metrics_analyzer.count_total_lines(files)
+        analysis.languages = metrics_analyzer.detect_languages(files)
+        analysis.complexity_score = metrics_analyzer.calculate_complexity()
+        
+        # Build directory tree
+        analysis.directory_tree = self._build_directory_tree()
+        
+        return analysis
+    
+    def _find_source_files(self) -> List[Path]:
+        """Find all source files in the codebase."""
+        files = []
+        
+        for root, dirs, filenames in os.walk(self.root_path):
+            # Filter out ignored directories
+            dirs[:] = [d for d in dirs if not self._should_ignore(d)]
+            
+            for filename in filenames:
+                file_path = Path(root) / filename
+                if self._is_source_file(file_path) and not self._should_ignore(filename):
+                    files.append(file_path)
+        
+        return files
+    
+    def _is_source_file(self, file_path: Path) -> bool:
+        """Check if file is a source code file."""
+        return file_path.suffix in self.parsers
+    
+    def _should_ignore(self, name: str) -> bool:
+        """Check if file/directory should be ignored."""
+        for pattern in self.ignore_patterns:
+            if pattern.startswith('*'):
+                if name.endswith(pattern[1:]):
+                    return True
+            elif name == pattern or name.startswith(pattern):
+                return True
+        return False
+    
+    def _parse_file(self, file_path: Path, analysis: CodebaseAnalysis):
+        """Parse a single file and add results to analysis."""
+        parser_class = self.parsers.get(file_path.suffix)
+        if not parser_class:
+            return
+        
+        try:
+            parser = parser_class(file_path)
+            
+            # Parse symbols
+            symbols = parser.parse_symbols()
+            analysis.symbols.extend(symbols)
+            
+            # Parse imports
+            imports = parser.parse_imports()
+            analysis.imports.extend(imports)
+            
+            # Parse calls
+            calls = parser.parse_calls()
+            analysis.call_relations.extend(calls)
+            
+            # Parse domain entities
+            entities = parser.parse_domain_entities()
+            analysis.domain_entities.extend(entities)
+            
+        except Exception as e:
+            # Log error but continue processing
+            print(f"Error parsing {file_path}: {e}")
+    
+    def _detect_entry_points(self, files: List[Path]) -> List[Path]:
+        """Detect likely entry points in the codebase."""
+        entry_points = []
+        
+        # Common entry point patterns
+        entry_patterns = [
+            'main.py', 'app.py', 'server.py', 'run.py', 'start.py',
+            'manage.py', '__main__.py', 'wsgi.py', 'asgi.py',
+            'index.js', 'server.js', 'app.js', 'main.js'
+        ]
+        
+        for file_path in files:
+            if file_path.name in entry_patterns:
+                entry_points.append(file_path)
+            elif file_path.name == '__init__.py':
+                # Check if it's a package entry point
+                if self._is_package_entry_point(file_path):
+                    entry_points.append(file_path)
+        
+        return entry_points
+    
+    def _is_package_entry_point(self, init_file: Path) -> bool:
+        """Check if __init__.py file is a package entry point."""
+        try:
+            content = init_file.read_text(encoding='utf-8')
+            # Simple heuristic: contains main execution logic
+            return 'if __name__' in content or 'main(' in content
+        except:
+            return False
+    
+    def _build_directory_tree(self) -> Dict:
+        """Build a directory tree structure."""
+        tree = {}
+        
+        for root, dirs, files in os.walk(self.root_path):
+            # Filter ignored directories
+            dirs[:] = [d for d in dirs if not self._should_ignore(d)]
+            
+            rel_path = Path(root).relative_to(self.root_path)
+            
+            # Build nested structure
+            current = tree
+            for part in rel_path.parts:
+                if part not in current:
+                    current[part] = {}
+                current = current[part]
+            
+            # Add files
+            source_files = [f for f in files 
+                          if self._is_source_file(Path(root) / f) 
+                          and not self._should_ignore(f)]
+            
+            if source_files:
+                current['_files'] = source_files
+        
+        return tree