shannon-codebase-insight 0.4.0__py3-none-any.whl

shannon_codebase_insight-0.4.0.dist-info/METADATA

@@ -0,0 +1,209 @@
+Metadata-Version: 2.4
+Name: shannon-codebase-insight
+Version: 0.4.0
+Summary: Multi-signal codebase quality analyzer using mathematical primitives
+Author: Naman Agarwal
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/namanagarwal/shannon-insight
+Project-URL: Documentation, https://github.com/namanagarwal/shannon-insight#readme
+Project-URL: Repository, https://github.com/namanagarwal/shannon-insight
+Project-URL: Bug Tracker, https://github.com/namanagarwal/shannon-insight/issues
+Keywords: code-quality,static-analysis,codebase-analysis,metrics,entropy,mathematics
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Environment :: Console
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.22.0
+Requires-Dist: scikit-learn>=1.0.0
+Requires-Dist: scipy>=1.7.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: pydantic-settings>=2.0.0
+Requires-Dist: diskcache>=5.6.0
+Requires-Dist: typer>=0.9.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: build>=0.10.0; extra == "dev"
+Requires-Dist: twine>=4.0.0; extra == "dev"
+Dynamic: license-file
+
+# Shannon Insight
+
+[![CI](https://github.com/namanagarwal/shannon-insight/actions/workflows/ci.yml/badge.svg)](https://github.com/namanagarwal/shannon-insight/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/shannon-insight)](https://pypi.org/project/shannon-insight/)
+[![Python](https://img.shields.io/pypi/pyversions/shannon-insight)](https://pypi.org/project/shannon-insight/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+Multi-signal codebase quality analyzer using information-theoretic primitives. Named after Claude Shannon, father of information theory.
+
+## Quick Start
+
+```bash
+pip install shannon-insight
+shannon-insight /path/to/codebase
+shannon-insight . --format json | jq .
+```
+
+## What It Does
+
+Shannon Insight scans your codebase and computes **5 orthogonal quality primitives** per file, then fuses them with consistency-weighted scoring to surface files that need attention:
+
+| Primitive | What it measures | High means |
+|-----------|-----------------|------------|
+| **Structural Entropy** | AST node type distribution | Chaotic organization |
+| **Network Centrality** | PageRank on dependency graph | Critical hub |
+| **Churn Volatility** | File modification recency | Recently changed / unstable |
+| **Semantic Coherence** | Import/export focus | Low: too many unrelated concerns |
+| **Cognitive Load** | Functions x complexity x nesting | Overloaded file |
+
+## Output Formats
+
+```bash
+# Rich terminal output (default) with summary dashboard
+shannon-insight .
+
+# Machine-readable JSON
+shannon-insight . --format json
+
+# Pipe-friendly CSV
+shannon-insight . --format csv
+
+# Just file paths (one per line)
+shannon-insight . --format quiet
+
+# Deep-dive on a specific file
+shannon-insight . --explain complex.go
+
+# Export to file
+shannon-insight . --output report.json
+```
+
+## CI Integration
+
+Use `--fail-above` to gate CI pipelines on code quality:
+
+```bash
+# Fail if any file scores above 2.0
+shannon-insight . --format quiet --fail-above 2.0
+```
+
+Example GitHub Actions step:
+
+```yaml
+- name: Code quality gate
+  run: shannon-insight . --fail-above 2.0 --format quiet
+```
+
+## Configuration
+
+Create `shannon-insight.toml` in your project root:
+
+```toml
+z_score_threshold = 1.5
+fusion_weights = [0.2, 0.25, 0.2, 0.15, 0.2]
+exclude_patterns = ["*_test.go", "vendor/*", "node_modules/*"]
+max_file_size_mb = 10.0
+enable_cache = true
+```
+
+Or use environment variables with `SHANNON_` prefix:
+
+```bash
+export SHANNON_Z_SCORE_THRESHOLD=2.0
+export SHANNON_ENABLE_CACHE=false
+```
+
+## CLI Options
+
+```
+Options:
+  PATH                      Path to codebase directory [default: .]
+  -l, --language TEXT       Language (auto, python, go, typescript, react, javascript)
+  -t, --top INTEGER         Number of top files to display [1-1000]
+  -o, --output FILE         Export JSON report to file
+  -f, --format TEXT         Output format: rich, json, csv, quiet
+  -e, --explain TEXT        Deep-dive on matching file(s)
+  --fail-above FLOAT        CI gate: exit 1 if max score exceeds threshold
+  --threshold FLOAT         Z-score threshold for anomaly detection
+  -c, --config FILE         TOML configuration file
+  -v, --verbose             Enable DEBUG logging
+  -q, --quiet               Suppress all but ERROR logging
+  --no-cache                Disable caching
+  --clear-cache             Clear cache before running
+  -w, --workers INTEGER     Parallel workers [1-32]
+  --version                 Show version and exit
+
+Commands:
+  cache-info    Show cache statistics
+  cache-clear   Clear analysis cache
+```
+
+## Supported Languages
+
+- **Python** - `.py` files
+- **Go** - `.go` files
+- **TypeScript/React** - `.ts`, `.tsx` files
+- **JavaScript** - `.js`, `.jsx` files (uses TypeScript scanner)
+
+Language is auto-detected by default. Override with `--language`.
+
+## How It Works
+
+```
+CodebaseAnalyzer
+  Layer 1: Scanning       - Language-specific file parsing
+  Layer 2: Extraction     - Compute 5 orthogonal primitives per file
+  Layer 3: Detection      - Z-score normalization + anomaly thresholding
+  Layer 4: Fusion         - Consistency-weighted signal combination
+  Layer 5: Recommendations - Root cause attribution + actionable advice
+```
+
+Signal fusion uses coefficient of variation to penalize inconsistent signals:
+
+```
+consistency = 1 / (1 + CV)
+final_score = consistency * |weighted_average|
+```
+
+See [docs/MATHEMATICAL_FOUNDATION.md](docs/MATHEMATICAL_FOUNDATION.md) for the full mathematical framework.
+
+## Development
+
+```bash
+git clone https://github.com/namanagarwal/shannon-insight.git
+cd shannon-insight
+python -m venv .venv && source .venv/bin/activate
+pip install -e ".[dev]"
+
+make test          # Run tests with coverage
+make lint          # Run ruff linter
+make format        # Format with ruff
+make type-check    # Run mypy
+make all           # Format + lint + type-check + test
+```
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+
+## License
+
+MIT License - see [LICENSE](LICENSE)
+
+## Credits
+
+Created by Naman Agarwal. Inspired by Claude Shannon's information theory, PageRank (Page & Brin), and cyclomatic complexity (McCabe).

shannon_codebase_insight-0.4.0.dist-info/RECORD

@@ -0,0 +1,37 @@
+shannon_codebase_insight-0.4.0.dist-info/licenses/LICENSE,sha256=PVdI9e_PoIiAyouwB69rVtOD0WEGAFn-G5z84L4YXko,1070
+shannon_insight/__init__.py,sha256=cVuT2YFKbs2ouJ_Dhd9IZlaHQSxcECrSssiN1MH2IkE,703
+shannon_insight/cache.py,sha256=GxbG0GiqqKpCSwlolwBonx19UqcPK6m9-37oHSfRxm4,5858
+shannon_insight/cli.py,sha256=msSzObpLKb3yOzLW5afPc04TwNzxbSi-_uI2WX5QGi4,10058
+shannon_insight/config.py,sha256=WPnUJ-iuM1Uh2Hy1OMauedIaW2hOIf76o43zwLcaxVQ,7140
+shannon_insight/core.py,sha256=pX5pNXNUZ4sWNGuHN6fFyreN2YDw9zzsJBIuWBCPKVc,20728
+shannon_insight/file_ops.py,sha256=P4F-mpEYCRO-tyfOtJNXcyCk9gVgnJ1ovEZm50Z8ETU,5831
+shannon_insight/logging_config.py,sha256=qG6f2VyDeMtE8VCoRFOjPeAbC11fVJXKMpxicwyk0zg,2389
+shannon_insight/models.py,sha256=hNd5qmHcVtd7y4DN1vsN0lKHZi91alQ44ikXkicpBoQ,959
+shannon_insight/py.typed,sha256=g4nn5g02a75-ZjbL9uICetnLeAGCH1GCSLgvU_YxCAQ,79
+shannon_insight/security.py,sha256=6bLkjc1Af_rvaGwHJrKGicyfr4Mpmo3ylozsvub4h6E,8053
+shannon_insight/analyzers/__init__.py,sha256=M5c7yP_EQ8UGPgvndHdyzaQBwyPGa7swOeNBlr3I9o0,272
+shannon_insight/analyzers/base.py,sha256=OPhneFHU0uYG7wE6X3BtKAsHbxzUfauZss2sNBPrY4k,5996
+shannon_insight/analyzers/go_analyzer.py,sha256=SJ2hWtx9Tn80M7NLUo5OGJyjTTP_NXibwf8MJfn4Nvk,6161
+shannon_insight/analyzers/python_analyzer.py,sha256=7IIjAbZOUaktprQjONE5HY5c9WF_nHLI_3Qp4rrPdJI,6616
+shannon_insight/analyzers/typescript_analyzer.py,sha256=C4SZxBFD2Edj727ge1WnJu5Jeavla6DjDRRg2V0Ci28,6576
+shannon_insight/exceptions/__init__.py,sha256=sxPsbQZHsXEEgeMZNEyM6NAuGYiNQXpHRB_Mu3jW9rM,666
+shannon_insight/exceptions/analysis.py,sha256=hmJkELAWmVltbXFNLH9h9JyBTEtDWYqdnarz8rbY1t0,2583
+shannon_insight/exceptions/base.py,sha256=9A53D2OZX_2Dc93UqWyzIu3V3M7eb_MqM-No5YHywWw,575
+shannon_insight/exceptions/config.py,sha256=Vo-k7Fg8Zk6sL7_6RgXuIdjF6bK9EMsHT1AdGvmR0ME,1431
+shannon_insight/math/__init__.py,sha256=eGYJRFh-QF_w7DK5QsqORoaK5K5Gh97EydSo-slfDjw,331
+shannon_insight/math/entropy.py,sha256=_V4tNyPB3mRB1fbm9L3ub0LfMPdl8rhmwBJjER1V72g,3947
+shannon_insight/math/fusion.py,sha256=NCvhk1RdRyM2RwAUr2Mhv24QSPcrcWoNgmbZuK1lPY0,3616
+shannon_insight/math/graph.py,sha256=2649DhTtsodmQiPsU5piYcT8AU0uKSpMtl1NOpWyPec,6800
+shannon_insight/math/robust.py,sha256=xMtRmK--WZH0xlMU6WuSqB2FsFF72gY4cMvR8pegaSM,3157
+shannon_insight/math/statistics.py,sha256=hnfUwoQ8iD1eUm_DwA59CuoyzcXC6fm2qqjOmQRQW40,4297
+shannon_insight/primitives/__init__.py,sha256=rgCX9YpgvCYM2mvQYkxKgeWnLnrrGCK7f-E1OvVSzRE,335
+shannon_insight/primitives/detector.py,sha256=GeSb_opcKdm8E7KBYjK3trl0NI8MaVVLN5ISwZgWWNc,11679
+shannon_insight/primitives/extractor.py,sha256=7zcOWTwC91mevyQfSc6UhCXynEUp2tTyjZi-dU0-Bhs,10285
+shannon_insight/primitives/fusion.py,sha256=axDi5WWK4UWmd-MPA5BAy_X1PHoIET49MBboGUXn0fA,11895
+shannon_insight/primitives/recommendations.py,sha256=fe-tQiYwPmSoLh75Bu7_poM0TAKpibxbuDnd_rntYSk,6221
+shannon_insight/utils/__init__.py,sha256=UOdKOJkQ6Nleq5cb4QELuSNb4mJZOp7Zuym1cg4rWnE,24
+shannon_codebase_insight-0.4.0.dist-info/METADATA,sha256=JX1ink0O5xSaciFj2kttsB6vAkCtiRAxTHd4Ildhk9M,6955
+shannon_codebase_insight-0.4.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+shannon_codebase_insight-0.4.0.dist-info/entry_points.txt,sha256=WMKvN0qPS7nAUTGhAR8f9Or_3VfwJDLn3NjFPoy3DhE,284
+shannon_codebase_insight-0.4.0.dist-info/top_level.txt,sha256=to3Vz1EmonG4LYEKYtTbqI7gqdH9_fHgEKbYdMUyDp4,16
+shannon_codebase_insight-0.4.0.dist-info/RECORD,,

shannon_codebase_insight-0.4.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

shannon_codebase_insight-0.4.0.dist-info/entry_points.txt

@@ -0,0 +1,7 @@
+[console_scripts]
+shannon-insight = shannon_insight.cli:app
+
+[shannon_insight.languages]
+go = shannon_insight.analyzers.go_analyzer:GoScanner
+python = shannon_insight.analyzers.python_analyzer:PythonScanner
+typescript = shannon_insight.analyzers.typescript_analyzer:TypeScriptScanner

shannon_codebase_insight-0.4.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Naman Agarwal
+
+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.

shannon_codebase_insight-0.4.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+shannon_insight

shannon_insight/__init__.py

@@ -0,0 +1,25 @@
+"""
+Shannon Insight - Multi-Signal Codebase Quality Analyzer
+
+A mathematical approach to code quality analysis using five orthogonal primitives:
+1. Structural Entropy - Disorder in code organization
+2. Network Centrality - Importance in dependency graph
+3. Churn Volatility - Instability of change patterns
+4. Semantic Coherence - Conceptual focus
+5. Cognitive Load - Mental effort to understand
+
+Named after Claude Shannon, father of information theory.
+"""
+
+__version__ = "0.4.0"
+__author__ = "Naman Agarwal"
+
+from .core import CodebaseAnalyzer
+from .models import FileMetrics, AnomalyReport, Primitives
+
+__all__ = [
+    "CodebaseAnalyzer",
+    "Primitives",
+    "FileMetrics",
+    "AnomalyReport",
+]

shannon_insight/analyzers/__init__.py

@@ -0,0 +1,8 @@
+"""Language-specific analyzers"""
+
+from .base import BaseScanner
+from .go_analyzer import GoScanner
+from .typescript_analyzer import TypeScriptScanner
+from .python_analyzer import PythonScanner
+
+__all__ = ["BaseScanner", "GoScanner", "TypeScriptScanner", "PythonScanner"]

shannon_insight/analyzers/base.py

@@ -0,0 +1,215 @@
+"""Base scanner class for language-agnostic functionality"""
+
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import List, Optional
+
+from ..models import FileMetrics
+from ..config import AnalysisSettings, default_settings
+from ..logging_config import get_logger
+from ..exceptions import FileAccessError, ParsingError
+from ..file_ops import should_skip_file
+
+logger = get_logger(__name__)
+
+
+class BaseScanner(ABC):
+    """Abstract base class for language-specific scanners"""
+
+    def __init__(
+        self,
+        root_dir: str,
+        extensions: List[str],
+        settings: Optional[AnalysisSettings] = None
+    ):
+        """
+        Initialize scanner.
+
+        Args:
+            root_dir: Root directory to scan
+            extensions: File extensions to include (e.g., ['.go', '.py'])
+            settings: Analysis settings
+        """
+        self.root_dir = Path(root_dir)
+        self.extensions = extensions
+        self.settings = settings or default_settings
+        logger.debug(f"Initialized {self.__class__.__name__} for {self.root_dir}")
+
+    def scan(self) -> List[FileMetrics]:
+        """
+        Scan all source files and extract metrics.
+
+        Returns:
+            List of file metrics for analyzed files
+        """
+        files = []
+        files_scanned = 0
+        files_skipped = 0
+        files_errored = 0
+
+        for ext in self.extensions:
+            for filepath in self.root_dir.rglob(f"*{ext}"):
+                # Check file count limit
+                if files_scanned >= self.settings.max_files:
+                    logger.warning(f"Reached max files limit ({self.settings.max_files})")
+                    break
+
+                # Skip based on custom logic
+                if self._should_skip(filepath):
+                    files_skipped += 1
+                    logger.debug(f"Skipped (custom): {filepath}")
+                    continue
+
+                # Skip based on exclusion patterns
+                if should_skip_file(filepath, self.settings.exclude_patterns):
+                    files_skipped += 1
+                    logger.debug(f"Skipped (pattern): {filepath}")
+                    continue
+
+                # Check file size
+                try:
+                    size = filepath.stat().st_size
+                    if size > self.settings.max_file_size_bytes:
+                        files_skipped += 1
+                        logger.debug(f"Skipped (size): {filepath} ({size} bytes)")
+                        continue
+                except OSError as e:
+                    files_errored += 1
+                    logger.warning(f"Cannot stat {filepath}: {e}")
+                    continue
+
+                # Analyze file
+                try:
+                    metrics = self._analyze_file(filepath)
+                    files.append(metrics)
+                    files_scanned += 1
+                    logger.debug(f"Analyzed: {filepath}")
+                except FileAccessError as e:
+                    files_errored += 1
+                    logger.warning(f"Access error for {filepath}: {e.reason}")
+                except ParsingError as e:
+                    files_errored += 1
+                    logger.warning(f"Parse error for {filepath}: {e.reason}")
+                except Exception as e:
+                    files_errored += 1
+                    logger.error(f"Unexpected error analyzing {filepath}: {e}")
+
+        logger.info(f"Scan complete: {files_scanned} analyzed, {files_skipped} skipped, {files_errored} errors")
+        return files
+
+    @abstractmethod
+    def _should_skip(self, filepath: Path) -> bool:
+        """
+        Determine if file should be skipped (e.g., tests, vendor).
+
+        Args:
+            filepath: File to check
+
+        Returns:
+            True if file should be skipped
+        """
+        pass
+
+    @abstractmethod
+    def _analyze_file(self, filepath: Path) -> FileMetrics:
+        """
+        Extract all metrics from a single file.
+
+        Args:
+            filepath: File to analyze
+
+        Returns:
+            File metrics
+
+        Raises:
+            FileAccessError: If file cannot be read
+            ParsingError: If file cannot be parsed
+        """
+        pass
+
+    @abstractmethod
+    def _count_tokens(self, content: str) -> int:
+        """
+        Count tokens in source code.
+
+        Args:
+            content: File content
+
+        Returns:
+            Token count
+        """
+        pass
+
+    @abstractmethod
+    def _extract_imports(self, content: str) -> List[str]:
+        """
+        Extract import statements.
+
+        Args:
+            content: File content
+
+        Returns:
+            List of import paths/names
+        """
+        pass
+
+    @abstractmethod
+    def _extract_exports(self, content: str) -> List[str]:
+        """
+        Extract exported identifiers.
+
+        Args:
+            content: File content
+
+        Returns:
+            List of exported names
+        """
+        pass
+
+    @abstractmethod
+    def _count_functions(self, content: str) -> int:
+        """
+        Count function declarations.
+
+        Args:
+            content: File content
+
+        Returns:
+            Function count
+        """
+        pass
+
+    @abstractmethod
+    def _estimate_complexity(self, content: str) -> float:
+        """
+        Estimate cyclomatic complexity.
+
+        Args:
+            content: File content
+
+        Returns:
+            Complexity score
+        """
+        pass
+
+    def _max_nesting_depth(self, content: str) -> int:
+        """
+        Calculate maximum nesting depth (language-agnostic).
+
+        Args:
+            content: File content
+
+        Returns:
+            Maximum nesting depth
+        """
+        max_depth = 0
+        current_depth = 0
+
+        for char in content:
+            if char == "{":
+                current_depth += 1
+                max_depth = max(max_depth, current_depth)
+            elif char == "}":
+                current_depth -= 1
+
+        return max_depth

shannon_insight/analyzers/go_analyzer.py

@@ -0,0 +1,150 @@
+"""Go language analyzer"""
+
+import re
+from pathlib import Path
+from collections import Counter
+from typing import List, Optional
+
+from .base import BaseScanner
+from ..models import FileMetrics
+from ..config import AnalysisSettings
+from ..exceptions import FileAccessError
+from ..logging_config import get_logger
+
+logger = get_logger(__name__)
+
+
+class GoScanner(BaseScanner):
+    """Scanner optimized for Go codebases"""
+
+    def __init__(self, root_dir: str, settings: Optional[AnalysisSettings] = None):
+        super().__init__(root_dir, extensions=[".go"], settings=settings)
+
+    def _should_skip(self, filepath: Path) -> bool:
+        """Skip test files, vendor, venv, and other non-project directories"""
+        path_str = str(filepath)
+        skip_dirs = ("vendor", "venv", ".venv", "__pycache__", ".git", ".tox", ".mypy_cache")
+        return "_test.go" in path_str or any(d in path_str for d in skip_dirs)
+
+    def _analyze_file(self, filepath: Path) -> FileMetrics:
+        """Extract all metrics from a Go file"""
+        try:
+            with open(filepath, "r", encoding="utf-8", errors="replace") as f:
+                content = f.read()
+        except OSError as e:
+            raise FileAccessError(filepath, f"Cannot read file: {e}")
+        except Exception as e:
+            raise FileAccessError(filepath, f"Unexpected error: {e}")
+
+        lines = content.split("\n")
+
+        return FileMetrics(
+            path=str(filepath.relative_to(self.root_dir)),
+            lines=len(lines),
+            tokens=self._count_tokens(content),
+            imports=self._extract_imports(content),
+            exports=self._extract_exports(content),
+            functions=self._count_functions(content),
+            interfaces=self._count_interfaces(content),
+            structs=self._count_structs(content),
+            complexity_score=self._estimate_complexity(content),
+            nesting_depth=self._max_nesting_depth(content),
+            ast_node_types=self._extract_ast_node_types(content),
+            last_modified=filepath.stat().st_mtime,
+        )
+
+    def _count_tokens(self, content: str) -> int:
+        """Approximate token count for Go"""
+        # Remove comments and strings
+        content = re.sub(r"//.*", "", content)
+        content = re.sub(r"/\*.*?\*/", "", content, flags=re.DOTALL)
+        content = re.sub(r"`[^`]*`", "", content)
+        content = re.sub(r'"[^"]*"', "", content)
+
+        # Split on whitespace and common operators
+        tokens = re.findall(r"\w+|[{}()\[\];,.]", content)
+        return len(tokens)
+
+    def _extract_imports(self, content: str) -> List[str]:
+        """Extract Go import statements"""
+        imports = []
+
+        # Match: import "github.com/..."
+        for match in re.finditer(r'import\s+"([^"]+)"', content):
+            imports.append(match.group(1))
+
+        # Match grouped imports: import (\n  "foo"\n  "bar"\n)
+        for match in re.finditer(r"import\s*\([^)]+\)", content, re.DOTALL):
+            group = match.group(0)
+            for imp in re.findall(r'"([^"]+)"', group):
+                imports.append(imp)
+
+        return imports
+
+    def _extract_exports(self, content: str) -> List[str]:
+        """Extract exported identifiers (capitalized names in Go)"""
+        exports = []
+
+        # Exported functions: func ExportedName(...)
+        exports.extend(re.findall(r"^func\s+([A-Z]\w*)\s*\(", content, re.MULTILINE))
+
+        # Exported types: type ExportedName ...
+        exports.extend(re.findall(r"^type\s+([A-Z]\w*)\s+", content, re.MULTILINE))
+
+        # Exported constants: const ExportedName
+        exports.extend(
+            re.findall(r"^const\s+([A-Z]\w*)\s*[=\n]", content, re.MULTILINE)
+        )
+
+        # Exported variables: var ExportedName
+        exports.extend(re.findall(r"^var\s+([A-Z]\w*)\s*[=\n]", content, re.MULTILINE))
+
+        return exports
+
+    def _count_functions(self, content: str) -> int:
+        """Count function declarations (including methods with receivers)"""
+        return len(re.findall(r"\bfunc\s+\w+\s*\(", content))
+
+    def _count_interfaces(self, content: str) -> int:
+        """Count interface declarations"""
+        return len(re.findall(r"\btype\s+\w+\s+interface\s*\{", content))
+
+    def _count_structs(self, content: str) -> int:
+        """Count struct declarations"""
+        return len(re.findall(r"\btype\s+\w+\s+struct\s*\{", content))
+
+    def _estimate_complexity(self, content: str) -> float:
+        """Estimate cyclomatic complexity for Go"""
+        # Count decision points: if, else, case, for, range, select, &&, ||
+        complexity = 1  # Base complexity
+
+        complexity += len(re.findall(r"\bif\s+", content))
+        complexity += len(re.findall(r"\belse\b", content))
+        complexity += len(re.findall(r"\bcase\s+", content))
+        complexity += len(re.findall(r"\bfor\s+", content))
+        complexity += len(re.findall(r"\brange\s+", content))
+        complexity += len(re.findall(r"\bselect\s*\{", content))
+        complexity += len(re.findall(r"&&", content))
+        complexity += len(re.findall(r"\|\|", content))
+
+        return complexity
+
+    def _extract_ast_node_types(self, content: str) -> Counter:
+        """Extract distribution of AST node types for Go"""
+        node_types = Counter()
+
+        # Go-specific node types
+        node_types["function"] = self._count_functions(content)
+        node_types["struct"] = self._count_structs(content)
+        node_types["interface"] = self._count_interfaces(content)
+        node_types["import"] = len(self._extract_imports(content))
+        node_types["export"] = len(self._extract_exports(content))
+        node_types["if"] = len(re.findall(r"\bif\s+", content))
+        node_types["for"] = len(re.findall(r"\bfor\s+", content))
+        node_types["range"] = len(re.findall(r"\brange\s+", content))
+        node_types["return"] = len(re.findall(r"\breturn\b", content))
+        node_types["defer"] = len(re.findall(r"\bdefer\b", content))
+        node_types["go"] = len(re.findall(r"\bgo\s+\w+\s*\(", content))
+        node_types["chan"] = len(re.findall(r"\bchan\s+\w+", content))
+
+        return node_types