<!-- Generated by codeindex (detailed) at 2026-03-12T15:49:23.076210 -->

# codeindex

## Overview

- **Files**: 86
- **Symbols**: 547

## Files

### __init__.py
_codeindex - AI-native code indexing tool for large codebases

Usage:
    codeindex scan <path>     # Scan a directory and generate README_AI.md
    co_

### adaptive_config.py
_Adaptive symbols configuration.

This module defines the configuration structure for adaptive symbol extraction,
which allows dynamically adjusting th_

**class** `class AdaptiveSymbolsConfig`
> Configuration for adaptive symbol extraction.

    Adaptive symbol extraction adjusts the number of 

### adaptive_selector.py
_Adaptive symbol selector for dynamic symbol limit calculation.

This module implements the core algorithm for adaptive symbol extraction,
which adjust_

**class** `class AdaptiveSymbolSelector`
> Selects appropriate symbol limit based on file size.

    This selector implements a tiered approach

**Methods:**
- `def calculate_limit(self, file_lines: int, total_symbols: int) -> int`
- `def _determine_size_category(self, lines: int) -> str`
- `def _apply_constraints(self, limit: int, total_symbols: int) -> int`

### ai_helper.py
_AI enhancement helper functions (Epic 4 Story 4.1).

This module provides reusable functions for AI enhancement operations,
eliminating code duplicati_

**Functions:**
- `def aggregate_parse_results(
    parse_results: list[ParseResult],
    path: Path,
) -> ParseResult`

### cli.py
_CLI entry point for codeindex.

This module serves as the main entry point for the codeindex CLI tool.
It imports and registers commands from speciali_

**Functions:**
- `def main()`

### cli_common.py
_Common utilities for CLI modules.

This module provides shared resources used across all CLI command modules,
such as the Rich console instance for fo_

### cli_config.py
_CLI commands for configuration and project status.

This module provides commands for initializing configuration files,
checking indexing status, and _

**Functions:**
- `def _print_post_init_message()`
- `def init(force: bool, yes: bool, quiet: bool, help_config: bool)`
- `def status(root: Path)`
- `def list_dirs(root: Path)`

### cli_config_commands.py
_CLI commands for configuration help and explanation (Epic 15 Story 15.3).

This module provides commands for:
- Explaining individual configuration pa_

**Functions:**
- `def config()`
- `def explain(parameter: str)`

### cli_docs.py
_Documentation CLI commands for codeindex._

**Functions:**
- `def docs()`
- `def show_ai_guide()`

### cli_hooks.py
_Git Hooks management module for codeindex.

Epic 6, P3.1: Automate Git Hooks installation and management.

This module provides:
- HookManager: Manage_

**class** `class HookStatus(Enum)`
> Status of a Git hook.

**class** `class HookManager`
> Manage Git hooks for codeindex.

**Methods:**
- `def _find_git_repo(self) -> Path`
- `def install_hook(
        self, hook_name: str, backup: bool = True, force: bool = False
    ) -> bool`
- `def uninstall_hook(
        self, hook_name: str, restore_backup: bool = True
    ) -> bool`
- `def list_all_hooks(self) -> dict[str, HookStatus]`

**Functions:**
- `def generate_hook_script(
    hook_name: str, config: Optional[dict] = None
) -> str`
- `def _generate_pre_commit_script(config: dict) -> str`
- `def _generate_post_commit_script(config: dict) -> str`
- `def _generate_pre_push_script(config: dict) -> str`
- `def backup_existing_hook(hook_path: Path) -> Path`
- `def detect_existing_hooks(hooks_dir: Path) -> list[str]`
- `def install_hook(hook_name: str, repo_path: Optional[Path] = None) -> bool`
- `def uninstall_hook(hook_name: str, repo_path: Optional[Path] = None) -> bool`
- `def run_post_commit_hook() -> int`

_... and 5 more symbols_

### cli_parse.py
_CLI parse command - Parse a single source file and output JSON.

Epic 12, Story 12.1: Single File Parse Command
This module provides the 'parse' comma_

**Functions:**
- `def parse(file_path: str)`

### cli_scan.py
_CLI commands for scanning directories and generating README files.

This module provides the core scanning functionality, including single directory
s_

**Functions:**
- `def _validate_scan_args(fallback: bool, dry_run: bool, ai: bool, quiet: bool) -> None`
- `def _validate_and_resolve_path(path: Path, output: str) -> Path`
- `def _load_and_prepare_config(
    ai: bool,
    parallel: int | None,
    docstring_mode: str | None,
) -> tuple[Config, DocstringProcessor | None]`
- `def _scan_and_parse_directory(
    path: Path, config: Config, quiet: bool, output: str
) -> list | None`
- `def _output_scan_json(parse_results: list) -> None`
- `def _generate_structural_readme(
    path: Path,
    parse_results: list,
    config: Config,
    docstring_processor: DocstringProcessor | None,
    quiet: bool,
    show_cost: bool,
) -> None`
- `def _generate_ai_readme(
    path: Path,
    parse_results: list,
    config: Config,
    dry_run: bool,
    quiet: bool,
    timeout: int,
) -> None`
- `def _validate_scanall_args(fallback: bool, quiet: bool) -> None`
- `def _load_scanall_config(
    root: Path,
    output: str,
    parallel: int | None,
    docstring_mode: str | None,
) -> tuple[Config, DocstringProcessor | None]`
- `def _output_scanall_json(root: Path, config: Config) -> None`
- `def _build_and_print_tree(root: Path, config: Config, quiet: bool) -> DirectoryTree`
- `def _process_directories_parallel(
    dirs: list[Path],
    tree: DirectoryTree,
    config: Config,
    docstring_processor: DocstringProcessor | None,
    quiet: bool,
    show_cost: bool,
    ai: bool = False,
    timeout: int = 120,
) -> None`
- `def _enrich_directories_with_ai(
    dirs: list[Path],
    tree: DirectoryTree,
    config: Config,
    quiet: bool,
    timeout: int,
) -> None`
- `def _process_directory_with_smartwriter(
    dir_path: Path,
    tree: DirectoryTree,
    config: Config,
    docstring_processor=None,
) -> tuple[Path, bool, str, int]`
- `def scan(
    path: Path,
    ai: bool,
    dry_run: bool,
    fallback: bool,
    quiet: bool,
    timeout: int,
    parallel: int | None,
    docstring_mode: str | None,
    show_cost: bool,
    output: str,
)`

_... and 1 more symbols_

### cli_symbols.py
_CLI commands for symbol indexing and dependency analysis.

This module provides commands for generating project-wide indices
and analyzing code depend_

**Functions:**
- `def extract_module_purpose(
    dir_path: Path,
    config: Config,
    output_file: str = "README_AI.md"
) -> str`
- `def index(root: Path, output: str)`
- `def symbols(root: Path, output: str, quiet: bool)`
- `def affected(since: str, until: str, as_json: bool)`

### cli_tech_debt.py
_CLI commands for technical debt analysis.

This module provides the tech-debt command for analyzing technical debt
in a directory, including file size_

**Functions:**
- `def _find_source_files(
    path: Path, recursive: bool, languages: list[str] | None = None
) -> list[Path]`
- `def _analyze_files(
    files: list[Path],
    detector: TechDebtDetector,
    reporter: TechDebtReporter,
    show_progress: bool,
) -> list[dict]`
- `def _get_file_type(file_path: Path) -> str`
- `def _create_scorer(parse_result, file_type: str) -> SymbolImportanceScorer`
- `def _analyze_single_file(
    file_path: Path,
    parse_result,
    detector: TechDebtDetector,
    reporter: TechDebtReporter,
    test_smell_detector,
) -> list[dict]`
- `def _collect_test_smells(file_path: Path, parse_result, test_smell_detector) -> list[dict]`
- `def _handle_parse_error(file_path: Path, error: str, show_progress: bool)`
- `def _handle_analysis_error(file_path: Path, error: Exception, show_progress: bool)`
- `def _format_and_output(
    report: TechDebtReport,
    format: str,
    output: Path | None,
    quiet: bool,
    test_smells: list[dict] | None = None,
    target_path: Path | None = None,
) -> None`
- `def tech_debt(path: Path, format: str, output: Path | None, recursive: bool, quiet: bool)`

### config.py
_Configuration management for codeindex._

**class** `class SymbolsConfig`
> Configuration for symbol extraction.

**class** `class GroupingConfig`
> Configuration for file grouping.

**class** `class SemanticConfig`
> Configuration for semantic extraction.

**class** `class IndexingConfig`
> Configuration for smart indexing.

**class** `class IncrementalConfig`
> Configuration for incremental updates.

**class** `class DocstringConfig`
> Configuration for docstring extraction (Epic 9).

    Supports AI-powered docstring extraction and n

**class** `class PostCommitConfig`
> Configuration for post-commit Git hook.

    Modes:
    - auto: Smart detection (≤2 dirs = sync, >2 

**class** `class HooksConfig`
> Configuration for Git hooks (Story 6).

**class** `class Config`
> Configuration for codeindex.

### config_help.py
_Configuration help documentation for codeindex (Epic 15 Story 15.3).

This module provides comprehensive help documentation for all .codeindex.yaml
co_

**Functions:**
- `def show_full_config_help() -> None`
- `def _show_param_section(param_name: str) -> None`
- `def explain_parameter(
    param_name: str, current_value: Optional[any] = None, cpu_count: Optional[int] = None
) -> int`

### directory_tree.py
_Directory tree structure for hierarchical indexing._

**class** `class DirectoryNode`
> A node in the directory tree.

**class** `class DirectoryTree`
> Pre-scanned directory tree for determining index levels.

    This enables two-pass indexing:
    1.

**Methods:**
- `def _build_tree(self)`
- `def _scan_directory_structure(self)`
- `def _add_intermediate_directories(self)`
- `def _establish_relationships(self)`
- `def print_tree(self, max_depth: int = 3)`

### docstring_processor.py
_Docstring Processor - AI-powered documentation extraction.

Story 9.1: Docstring Processor Core

This module provides AI-powered docstring extraction _

**class** `class DocstringProcessor`
> AI-powered docstring extraction and normalization.

    Uses external AI CLI (Claude, GPT-4, etc.) t

**Methods:**
- `def process_file(
        self, file_path: Path, symbols: list[Symbol]
    ) -> dict[str, str]`
- `def _should_process(self, docstring: str) -> bool`
- `def _should_use_ai(self, docstring: str) -> bool`
- `def _contains_non_ascii(self, text: str) -> bool`
- `def _process_simple(self, symbols: list[Symbol]) -> dict[str, str]`
- `def _process_with_ai(
        self,
        file_path: Path,
        symbols_to_process: list[Symbol],
        all_symbols: list[Symbol],
    ) -> dict[str, str]`
- `def _generate_prompt(self, file_path: Path, symbols: list[Symbol]) -> str`
- `def _call_ai(self, prompt: str) -> str`
- `def _parse_ai_response(self, response: str) -> dict[str, str]`
- `def _fallback_extract(self, docstring: str) -> str`

### enricher.py
_AI enrichment module for generating one-line module descriptions.

Epic 25: Instead of AI generating entire README_AI.md files, AI only
produces a sho_

**Functions:**
- `def extract_symbol_summary(parse_results: list[ParseResult]) -> str`
- `def extract_summary_from_readme(readme_path: Path) -> str`
- `def build_enrich_prompt(
    dir_name: str,
    symbol_summary: str,
    parent_name: str = "",
) -> str`
- `def inject_blockquote(readme_path: Path, description: str) -> None`
- `def should_enrich(level: str) -> bool`

### errors.py
_Error codes and structures for JSON output.

Story 4: Structured error handling for machine-readable errors._

**class** `class ErrorCode(str, Enum)`
> Error codes for command-level errors.

**class** `class ErrorInfo`
> Structured error information for JSON output.

**Methods:**
- `def to_dict(self) -> dict`

**Functions:**
- `def create_error_response(
    error: ErrorInfo,
    results: Optional[list] = None,
) -> dict`

### __init__.py
_Framework-specific route extractors.

This package contains route extractors for different frameworks.
Each extractor implements the RouteExtractor in_

### spring.py
_Spring Framework route extractor.

Extracts REST routes from Spring controllers using annotations.

Spring routing via annotations:
- Controller: @Res_

**class** `class SpringRouteExtractor`
> Route extractor for Spring Framework.

    Extracts REST API routes from Spring controllers by analy

**Methods:**
- `def extract_routes(self, result: ParseResult) -> list[RouteInfo]`
- `def _get_mapping_info(self, annotation_name: str) -> tuple[str, str] | None`
- `def _extract_path_from_annotation(self, arguments: dict | str) -> str`
- `def _build_path(self, prefix: str, path: str) -> str`

### thinkphp.py
_ThinkPHP route extractor.

Extracts routes from ThinkPHP framework controllers using convention-based routing.

ThinkPHP routing convention:
- URL: /m_

**class** `class ThinkPHPRouteExtractor(RouteExtractor)`
> Route extractor for ThinkPHP framework.

    ThinkPHP uses convention-based routing where:
    - Con

**Methods:**
- `def can_extract(self, context: ExtractionContext) -> bool`
- `def extract_routes(self, context: ExtractionContext) -> list[RouteInfo]`
- `def _extract_description(self, symbol) -> str`

### file_classifier.py
_Unified file size classification system (Epic 4 Story 4.2).

This module provides a unified approach to file size classification,
replacing hard-coded_

**class** `class FileSizeCategory(Enum)`
> File size categories for classification.

**class** `class FileSizeAnalysis`
> Result of file size analysis.

    Attributes:
        category: File size category (enum)
        f

**class** `class FileSizeClassifier`
> Unified file size classifier for all modules.

    This classifier provides consistent file size det

**Methods:**
- `def classify(self, parse_result: ParseResult) -> FileSizeAnalysis`
- `def is_super_large(self, parse_result: ParseResult) -> bool`
- `def is_large(self, parse_result: ParseResult) -> bool`

### framework_detect.py
_Framework detection and pattern extraction for PHP projects._

**class** `class RouteInfo`
> Information about a route.

**class** `class ModelInfo`
> Information about a model.

**class** `class FrameworkInfo`
> Detected framework information.

**Functions:**
- `def detect_framework(root: Path) -> FrameworkType`
- `def extract_thinkphp_routes(
    parse_results: list[ParseResult],
    module_name: str,
) -> list[RouteInfo]`
- `def extract_thinkphp_models(
    parse_results: list[ParseResult],
) -> list[ModelInfo]`
- `def analyze_thinkphp_project(
    root: Path,
    parse_results_by_dir: dict[Path, list[ParseResult]],
) -> FrameworkInfo`
- `def format_framework_info(info: FrameworkInfo, max_routes: int = 20) -> str`

### hierarchical.py
_Bottom-up hierarchical processing for codeindex._

**class** `class DirectoryInfo`
> Information about a directory in the hierarchy.

**Functions:**
- `def build_directory_hierarchy(
    directories: List[Path],
) -> Tuple[Dict[Path, DirectoryInfo], List[Path]]`
- `def create_processing_batches(
    dir_info: Dict[Path, DirectoryInfo], max_workers: int
) -> List[List[Path]]`
- `def process_directory_batch(
    batch: List[Path],
    config: Config,
    use_fallback: bool = False,
    quiet: bool = False,
    timeout: int = 120,
    root_path: Path = None,
) -> Dict[Path, bool]`
- `def process_normal(
    path: Path,
    config: Config,
    use_fallback: bool,
    quiet: bool,
    timeout: int,
    root_path: Path = None,
) -> bool`
- `def process_with_children(
    path: Path, config: Config, use_fallback: bool, quiet: bool, timeout: int
) -> bool`
- `def scan_directories_hierarchical(
    root: Path,
    config: Config,
    max_workers: int = 8,
    use_fallback: bool = True,
    quiet: bool = False,
    timeout: int = 120
) -> bool`
- `def _handle_no_directories(quiet: bool)`
- `def _build_and_populate_hierarchy(directories: List[Path], config: Config, quiet: bool)`
- `def _create_and_report_batches(dir_info_map: dict, max_workers: int, quiet: bool) -> tuple[list, int]`
- `def _process_all_batches(
    batches: list,
    dir_info_map: dict,
    config: Config,
    use_fallback: bool,
    quiet: bool,
    timeout: int,
    root: Path
) -> int`
- `def generate_enhanced_fallback_readme(
    dir_path: Path,
    parse_results: list,
    child_readmes: List[Path],
    output_file: str = "README_AI.md"
)`

### hooks.py
_Post-install hook for automatic CLAUDE.md updates.

Epic #25, Story #26: Implement post-install hook that updates
~/.claude/CLAUDE.md with latest code_

**Functions:**
- `def _extract_version_from_file(file_path: Path) -> Optional[str]`
- `def _inject_core_guide(file_path: Path, version: str) -> bool`
- `def _is_ci_environment() -> bool`
- `def post_install_update_guide() -> None`

### incremental.py
_Incremental update logic for codeindex.

This module analyzes git changes and determines which directories
need README_AI.md updates based on configur_

**class** `class UpdateLevel(Enum)`
> Update decision levels.

**class** `class FileChange`
> Represents a changed file.

**class** `class ChangeAnalysis`
> Analysis result of git changes.

**Methods:**
- `def to_dict(self) -> dict`

**Functions:**
- `def run_git_command(args: list[str], cwd: Path | None = None) -> str`
- `def filter_code_files(
    changes: list[FileChange],
    languages: list[str],
) -> list[FileChange]`
- `def analyze_changes(
    config: Config,
    since: str = "HEAD~1",
    until: str = "HEAD",
    cwd: Path | None = None,
) -> ChangeAnalysis`
- `def should_update_project_index(analysis: ChangeAnalysis, config: Config) -> bool`

### init_wizard.py
_Interactive Setup Wizard for codeindex (Epic 15 Story 15.1).

This module provides an intelligent, interactive setup wizard that:
- Auto-detects proje_

**class** `class WizardResult`
> Result of running the interactive wizard.

**Functions:**
- `def check_parser_installed(language: str) -> bool`
- `def detect_languages(project_dir: Path, max_scan_files: int = 1000) -> List[str]`
- `def detect_frameworks(project_dir: Path, languages: List[str]) -> List[str]`
- `def infer_include_patterns(project_dir: Path) -> List[str]`
- `def infer_exclude_patterns(project_dir: Path) -> List[str]`
- `def calculate_parallel_workers(file_count: int, cpu_count: Optional[int] = None) -> int`
- `def calculate_batch_size(file_count: int) -> int`
- `def count_files(project_dir: Path, patterns: List[str]) -> int`
- `def inject_claude_md(project_dir: Path) -> Path`
- `def has_claude_md_injection(project_dir: Path) -> bool`
- `def run_interactive_wizard(project_dir: Path) -> WizardResult`
- `def generate_config_yaml(result: WizardResult, project_dir: Path) -> str`
- `def create_codeindex_md(project_dir: Path) -> Path`

### invoker.py
_AI CLI invoker - calls external AI CLI tools._

**class** `class InvokeResult`
> Result of invoking AI CLI.

**Functions:**
- `def clean_ai_output(output: str) -> str`
- `def validate_markdown_output(output: str) -> bool`
- `def format_prompt(
    dir_path: Path,
    files_info: str,
    symbols_info: str,
    imports_info: str,
) -> str`
- `def invoke_ai_cli(
    command_template: str,
    prompt: str,
    timeout: int = 120,
    dry_run: bool = False,
) -> InvokeResult`
- `def invoke_ai_cli_stdin(
    command: str,
    prompt: str,
    timeout: int = 120,
    dry_run: bool = False,
) -> InvokeResult`

### objc_association.py
_Objective-C header/implementation file association utilities (Story 3.2).

This module provides utilities to associate .h and .m files for the same cl_

**class** `class ObjCFilePair`
> Represents an associated .h/.m file pair.

    Attributes:
        class_name: Name of the Objective

**Functions:**
- `def find_objc_pairs(directory: Path) -> list[ObjCFilePair]`
- `def parse_objc_pair(
    header_file: Path | None = None,
    implementation_file: Path | None = None,
) -> ObjCFilePair`
- `def merge_objc_results(pair: ObjCFilePair) -> ParseResult`
- `def calculate_association_accuracy(pairs: list[ObjCFilePair]) -> float`

### parallel.py
_Parallel processing utilities for codeindex._

**class** `class BatchResult`
> Result of processing a batch of files.

**Functions:**
- `def parse_files_parallel(
    files: List[Path],
    config: Config,
    quiet: bool = False
) -> list[ParseResult]`
- `def scan_directories_parallel(
    directories: List[Path],
    config: Config,
    quiet: bool = False
) -> List[Path]`

### parser.py
_Multi-language AST parser using tree-sitter.

Epic 13: Parser Modularization - Phase 3
This module serves as the unified entry point for all language _

**class** `class CallType(Enum)`
> Call type enumeration (Epic 11).

    Distinguishes between different types of function/method calls

**class** `class Call`
> Function/method call relationship (Epic 11).

    Represents caller → callee relationships for knowl

**class** `class Symbol`
> Represents a code symbol (class, function, etc.).

**class** `class Import`
> Represents an import statement (extended for LoomGraph).

    Attributes:
        module: Module nam

**class** `class Inheritance`
> Class inheritance information for knowledge graph construction.

    Represents parent-child relatio

**class** `class Annotation`
> Represents a code annotation/decorator (e.g., Java @RestController).

    Story 7.1.2.1: Annotation 

**class** `class ParseResult`
> Result of parsing a file (extended for LoomGraph).

    Attributes:
        path: File path
        

**Methods:**
- `def to_dict(self) -> dict`
- `def to_dict(self) -> dict`
- `def to_dict(self) -> dict`
- `def to_dict(self) -> dict`
- `def to_dict(self) -> dict`
- `def to_dict(self) -> dict`

**Functions:**
- `def _get_parser(language: str) -> Parser | None`
- `def parse_file(path: Path, language: str | None = None) -> ParseResult`

_... and 2 more symbols_

### __init__.py
_Language-specific parser modules.

This package contains modular parsers for different programming languages.
Each language has its own parser module _

### base.py
_Base class for language parsers.

This module defines the abstract interface that all language-specific parsers must implement.
It provides a consiste_

**class** `class BaseLanguageParser(ABC)`
> Abstract base class for language-specific parsers.

    All language parsers (Python, PHP, Java, etc

**Methods:**
- `def parse(self, path: Path)`

### __init__.py
_Java language parser.

This module provides the JavaParser class that implements Java-specific
symbol extraction, import resolution, inheritance extra_

**class** `class JavaParser(BaseLanguageParser)`
> Java language parser.

    Extracts symbols, imports, calls, and inheritances from Java source code.

**Methods:**
- `def extract_symbols(self, tree: Tree, source_bytes: bytes) -> list`
- `def extract_imports(self, tree: Tree, source_bytes: bytes) -> list`
- `def extract_calls(
        self, tree: Tree, source_bytes: bytes, symbols: list, imports: list
    ) -> list`
- `def extract_inheritances(self, tree: Tree, source_bytes: bytes) -> list`
- `def parse(self, path: Path)`

**Functions:**
- `def is_java_file(path: str) -> bool`
- `def parse_java_file(file_path: str, content: str)`

### calls.py
_Call extraction for Java parser.

This module provides functions to extract method calls, constructor calls,
and call relationships from Java source c_

**Functions:**
- `def extract_calls(
    tree: Tree,
    source_bytes: bytes,
    symbols: list,
    imports: list[Import],
    namespace: str = "",
    import_map: dict[str, str] | None = None
) -> list[Call]`
- `def _parse_method_call(
    node: Node,
    source_bytes: bytes,
    caller: str,
    import_map: dict[str, str],
    static_import_map: dict[str, str],
    namespace: str,
    parent_map: dict[str, str]
) -> Optional[Call]`
- `def _parse_constructor_call(
    node: Node,
    source_bytes: bytes,
    caller: str,
    import_map: dict[str, str],
    namespace: str
) -> Optional[Call]`
- `def _extract_calls_recursive(
    node: Node,
    source_bytes: bytes,
    caller: str,
    import_map: dict[str, str],
    static_import_map: dict[str, str],
    namespace: str,
    parent_map: dict[str, str]
) -> list[Call]`
- `def _extract_calls_from_tree(
    tree: Tree,
    source_bytes: bytes,
    inheritances: list[Inheritance],
    namespace: str,
    import_map: dict[str, str]
) -> list[Call]`

### imports.py
_Import extraction for Java parser.

This module provides functions to extract import statements and build import
mappings from Java source code using _

**Functions:**
- `def extract_imports(tree: Tree, source_bytes: bytes) -> list[Import]`
- `def build_import_map(root: Node, source_bytes: bytes) -> dict[str, str]`
- `def build_static_import_map(root: Node, source_bytes: bytes) -> dict[str, str]`
- `def resolve_static_import(
    method_name: str,
    static_import_map: dict[str, str]
) -> str | None`
- `def _parse_java_import(node: Node, source_bytes: bytes) -> Import | None`

### inheritance.py
_Inheritance extraction for Java parser.

This module provides functions to extract class and interface inheritance
relationships from Java source code_

**Functions:**
- `def extract_inheritances(
    tree: Tree,
    source_bytes: bytes,
    namespace: str = "",
    import_map: dict[str, str] | None = None
) -> list[Inheritance]`
- `def extract_package(tree: Tree, source_bytes: bytes) -> str`

### symbols.py
_Symbol extraction for Java parser.

This module provides functions to extract symbols (classes, interfaces, enums,
records, methods, fields, construct_

**Functions:**
- `def extract_symbols(
    tree: Tree,
    source_bytes: bytes,
    namespace: str = "",
    import_map: Optional[dict[str, str]] = None,
    inheritances: Optional[list[Inheritance]] = None
) -> list[Symbol]`
- `def extract_module_docstring(tree: Tree, source_bytes: bytes) -> str`
- `def _strip_generic_type(type_name: str) -> str`
- `def _extract_package_namespace(class_full_name: str) -> str`
- `def _resolve_java_type(
    short_name: str,
    namespace: str,
    import_map: dict[str, str]
) -> str`
- `def _extract_java_modifiers(node: Node, source_bytes: bytes) -> list[str]`
- `def _build_java_signature(modifiers: list[str], *parts: str) -> str`
- `def _extract_java_annotations(node: Node, source_bytes: bytes) -> list[Annotation]`
- `def _parse_annotation_arguments(arg_list_node: Node, source_bytes: bytes) -> dict[str, str]`
- `def _find_child_by_type(node: Node, type_name: str) -> Node | None`
- `def _extract_java_docstring(node: Node, source_bytes: bytes) -> str`
- `def _parse_java_method(node: Node, source_bytes: bytes, class_name: str = "") -> Symbol`
- `def _parse_java_constructor(node: Node, source_bytes: bytes, class_name: str) -> Symbol`
- `def _parse_java_field(node: Node, source_bytes: bytes, class_name: str = "") -> list[Symbol]`
- `def _extract_java_inheritances(
    node: Node,
    source_bytes: bytes,
    child_name: str,
    package_namespace: str,
    import_map: dict[str, str]
) -> list[Inheritance]`

_... and 5 more symbols_

### java_parser.py
_Java language parser (backward compatibility shim).

DEPRECATED: This module exists for backward compatibility only.
New code should import from codei_

### __init__.py
_Objective-C language parser.

This module provides the ObjCParser class that implements Objective-C-specific
symbol extraction, import resolution, inh_

**class** `class ObjCParser(BaseLanguageParser)`
> Objective-C language parser.

    Extracts symbols, imports, calls, and inheritances from Objective-

**Methods:**
- `def _preprocess_source(self, source_bytes: bytes) -> bytes`
- `def parse(self, path: Path)`
- `def extract_symbols(self, tree: Tree, source_bytes: bytes) -> list`
- `def extract_imports(self, tree: Tree, source_bytes: bytes) -> list`
- `def extract_calls(
        self, tree: Tree, source_bytes: bytes, symbols: list, imports: list
    ) -> list`
- `def extract_inheritances(self, tree: Tree, source_bytes: bytes) -> list`

### calls.py
_Call extraction for Objective-C parser.

This module provides functions to extract function/method calls from Objective-C code.

Note: Call graph extr_

**Functions:**
- `def extract_calls(
    tree: Tree, source_bytes: bytes, symbols: list, imports: list
) -> list`

### imports.py
_Import extraction for Objective-C parser.

This module provides functions to extract import statements from Objective-C:
- #import "LocalFile.h" (loca_

**Functions:**
- `def extract_imports(tree: Tree, source_bytes: bytes) -> list`
- `def _extract_import(node, source_bytes: bytes) -> Import | None`

### inheritance.py
_Inheritance extraction for Objective-C parser.

This module provides functions to extract inheritance relationships:
- Class inheritance (superclass)
_

**Functions:**
- `def extract_inheritances(tree: Tree, source_bytes: bytes) -> list`
- `def _extract_interface_inheritance(node, source_bytes: bytes) -> list[Inheritance]`
- `def _extract_protocol_inheritance(node, source_bytes: bytes) -> list[Inheritance]`

### symbols.py
_Symbol extraction for Objective-C parser.

This module provides functions to extract symbols from Objective-C source code:
- @interface declarations (_

**Functions:**
- `def extract_symbols(tree: Tree, source_bytes: bytes) -> list`
- `def _extract_interface(node, source_bytes: bytes) -> list[Symbol]`
- `def _extract_implementation(node, source_bytes: bytes) -> list[Symbol]`
- `def _extract_protocol(node, source_bytes: bytes) -> list[Symbol]`
- `def _extract_declarations(
    decl_list_node, source_bytes: bytes, class_name: str
) -> list[Symbol]`
- `def _extract_method(
    node, source_bytes: bytes, class_name: str
) -> Symbol | None`
- `def _extract_property(
    node, source_bytes: bytes, class_name: str
) -> Symbol | None`
- `def _build_interface_signature(
    node, source_bytes: bytes, class_name: str
) -> str`
- `def _build_method_signature(
    node, source_bytes: bytes, is_class_method: bool
) -> str`

### __init__.py
_PHP language parser.

This module provides the PhpParser class that implements PHP-specific
symbol extraction, import resolution, inheritance extracti_

**class** `class PhpParser(BaseLanguageParser)`
> PHP language parser.

    Extracts symbols, imports, calls, and inheritances from PHP source code.
 

**Methods:**
- `def extract_symbols(self, tree: Tree, source_bytes: bytes) -> list`
- `def extract_imports(self, tree: Tree, source_bytes: bytes) -> list`
- `def extract_calls(
        self, tree: Tree, source_bytes: bytes, symbols: list, imports: list
    ) -> list`
- `def extract_inheritances(self, tree: Tree, source_bytes: bytes) -> list`
- `def parse(self, path)`
- `def _parse_namespace(self, node, source_bytes: bytes) -> str`

### calls.py
_Call extraction for PHP parser.

This module provides functions to extract function/method call relationships
from PHP source code using tree-sitter._

**Functions:**
- `def extract_calls(
    tree: Tree, source_bytes: bytes, symbols: list, imports: list
) -> list`
- `def _parse_namespace(node, source_bytes: bytes) -> str`
- `def _parse_use_for_map(node, source_bytes: bytes) -> list[Import]`
- `def _extract_class_inheritances(
    node,
    source_bytes: bytes,
    namespace: str,
    use_map: dict[str, str],
    inheritances: list
) -> None`
- `def _extract_calls_from_tree(
    tree,
    source_bytes: bytes,
    imports: list[Import],
    inheritances: list,
    namespace: str,
    use_map: dict[str, str]
) -> list[Call]`
- `def _extract_calls_from_node(
    node: Node,
    source_bytes: bytes,
    caller: str,
    use_map: dict[str, str],
    namespace: str,
    parent_map: dict[str, str],
    current_class: str
) -> list[Call]`
- `def _parse_function_call(
    node: Node,
    source_bytes: bytes,
    caller: str,
    use_map: dict[str, str],
    namespace: str
) -> Optional[Call]`
- `def _parse_member_call(
    node: Node,
    source_bytes: bytes,
    caller: str,
    use_map: dict[str, str],
    namespace: str,
    current_class: str
) -> Optional[Call]`
- `def _parse_scoped_call(
    node: Node,
    source_bytes: bytes,
    caller: str,
    use_map: dict[str, str],
    namespace: str,
    parent_map: dict[str, str],
    current_class: str
) -> Optional[Call]`
- `def _parse_object_creation(
    node: Node,
    source_bytes: bytes,
    caller: str,
    use_map: dict[str, str],
    namespace: str
) -> Optional[Call]`

### imports.py
_Import extraction for PHP parser.

This module provides functions to extract import/use statements and
require/include statements from PHP source code_

**Functions:**
- `def extract_imports(tree: Tree, source_bytes: bytes) -> list`
- `def _parse_use(node, source_bytes: bytes) -> list[Import]`
- `def _parse_include(node, source_bytes: bytes) -> Import | None`

### inheritance.py
_Inheritance extraction for PHP parser.

This module provides functions to extract class inheritance relationships
(extends and implements) from PHP so_

**Functions:**
- `def extract_inheritances(tree: Tree, source_bytes: bytes) -> list`
- `def _parse_namespace(node, source_bytes: bytes) -> str`
- `def _parse_use_for_map(node, source_bytes: bytes) -> list[Import]`
- `def _parse_class_inheritances(
    node,
    source_bytes: bytes,
    namespace: str,
    use_map: dict[str, str],
    inheritances: list[Inheritance]
) -> None`

### symbols.py
_Symbol extraction for PHP parser.

This module provides functions to extract symbols (classes, functions, methods, properties)
from PHP source code us_

**Functions:**
- `def extract_symbols(tree: Tree, source_bytes: bytes) -> list`
- `def _extract_docstring(node, source_bytes: bytes) -> str`
- `def _parse_phpdoc_text(text: str) -> str`
- `def _parse_function(node, source_bytes: bytes, class_name: str = "") -> Symbol`
- `def _parse_method(node, source_bytes: bytes, class_name: str) -> Symbol`
- `def _parse_property(node, source_bytes: bytes, class_name: str) -> Symbol`
- `def _parse_class(
    node,
    source_bytes: bytes,
    namespace: str = "",
    use_map: dict[str, str] | None = None,
    inheritances: list[Inheritance] | None = None
) -> list[Symbol]`
- `def _parse_namespace(node, source_bytes: bytes) -> str`
- `def _parse_use(node, source_bytes: bytes) -> list`

### __init__.py
_Python language parser.

This module provides the PythonParser class that implements Python-specific
symbol extraction, import resolution, and call re_

**class** `class PythonParser(BaseLanguageParser)`
> Python language parser.

    Extracts symbols (classes, functions, methods), imports, inheritances,


**Methods:**
- `def extract_symbols(self, tree: Tree, source_bytes: bytes) -> list`
- `def extract_imports(self, tree: Tree, source_bytes: bytes) -> list`
- `def extract_calls(
        self, tree: Tree, source_bytes: bytes, symbols: list, imports: list
    ) -> list`
- `def extract_inheritances(self, tree: Tree, source_bytes: bytes) -> list`
- `def parse(self, path: Path)`

### calls.py
_Call relationship extraction for Python parser.

This module provides functions to extract function/method call relationships
from Python source code _

**Functions:**
- `def extract_calls(
    tree: Tree, source_bytes: bytes, symbols: list, imports: list, inheritances: list
) -> list`
- `def _build_alias_map(imports: list[Import]) -> dict[str, str]`
- `def _resolve_alias(callee: str, alias_map: dict[str, str]) -> str`
- `def _determine_python_call_type(func_node: Node, source_bytes: bytes) -> CallType`
- `def _extract_call_name(func_node: Node, source_bytes: bytes) -> str`
- `def _parse_python_call(
    node: Node,
    source_bytes: bytes,
    caller: str,
    alias_map: dict[str, str],
    parent_map: dict[str, str],
) -> Optional[Call]`
- `def _extract_python_calls(
    node: Node,
    source_bytes: bytes,
    context: str,
    alias_map: dict[str, str],
    parent_map: dict[str, str],
) -> list[Call]`
- `def _is_simple_decorator(decorator_node: Node) -> bool`
- `def _extract_decorator_name(decorator_node: Node, source_bytes: bytes) -> str`
- `def _extract_decorator_calls(
    node: Node, source_bytes: bytes, context: str
) -> list[Call]`
- `def _extract_python_calls_from_tree(
    tree: Tree,
    source_bytes: bytes,
    imports: list[Import],
    inheritances: list[Inheritance],
) -> list[Call]`

### imports.py
_Import extraction for Python parser.

This module provides functions to extract import statements from Python source code
using tree-sitter._

**Functions:**
- `def extract_imports(tree: Tree, source_bytes: bytes) -> list`
- `def _parse_import(node: Node, source_bytes: bytes) -> list[Import]`

### inheritance.py
_Inheritance extraction for Python parser.

This module provides functions to extract class inheritance relationships
from Python source code using tre_

**Functions:**
- `def extract_inheritances(tree: Tree, source_bytes: bytes) -> list`
- `def _extract_class_inheritances(
    node: Node,
    source_bytes: bytes,
    parent_class: str,
    inheritances: list[Inheritance],
) -> None`

### symbols.py
_Symbol extraction for Python parser.

This module provides functions to extract symbols (classes, functions, methods)
from Python source code using tr_

**Functions:**
- `def extract_symbols(tree: Tree, source_bytes: bytes) -> list`
- `def extract_module_docstring(tree: Tree, source_bytes: bytes) -> str`
- `def _extract_docstring(node: Node, source_bytes: bytes) -> str`
- `def _parse_function(
    node: Node,
    source_bytes: bytes,
    class_name: str = "",
    decorators: list[str] | None = None,
) -> Symbol`
- `def _parse_class(
    node: Node,
    source_bytes: bytes,
    parent_class: str = "",
    inheritances: list[Inheritance] | None = None,
) -> list[Symbol]`

### __init__.py
_Swift language parser.

This module provides the SwiftParser class that implements Swift-specific
symbol extraction, import resolution, and inheritanc_

**class** `class SwiftParser(BaseLanguageParser)`
> Swift language parser.

    Extracts symbols (classes, structs, enums, protocols, functions, methods

**Methods:**
- `def extract_symbols(self, tree: Tree, source_bytes: bytes) -> list`
- `def extract_imports(self, tree: Tree, source_bytes: bytes) -> list`
- `def extract_calls(
        self, tree: Tree, source_bytes: bytes, symbols: list, imports: list
    ) -> list`
- `def extract_inheritances(self, tree: Tree, source_bytes: bytes) -> list`

### calls.py
_Call extraction for Swift parser.

This module provides functions to extract call relationships from Swift source code.

TODO: Phase 3 implementation _

**Functions:**
- `def extract_calls(
    tree: Tree, source_bytes: bytes, symbols: list, imports: list
) -> list`

### imports.py
_Import extraction for Swift parser.

This module provides functions to extract import statements from Swift source code._

**Functions:**
- `def extract_imports(tree: Tree, source_bytes: bytes) -> list`

### inheritance.py
_Inheritance extraction for Swift parser.

This module provides functions to extract inheritance relationships from Swift
source code, including class _

**Functions:**
- `def extract_inheritances(tree: Tree, source_bytes: bytes) -> list`
- `def _extract_type_inheritances(node: Node, source_bytes: bytes) -> list`
- `def _extract_parent_type_from_specifier(node: Node, source_bytes: bytes) -> str | None`
- `def _extract_extension_inheritances(node: Node, source_bytes: bytes) -> list`
- `def _extract_parent_types(node: Node, source_bytes: bytes) -> list[str]`

### symbols.py
_Symbol extraction for Swift parser.

This module provides functions to extract symbols (classes, structs, enums,
protocols, functions, methods, proper_

**Functions:**
- `def extract_symbols(tree: Tree, source_bytes: bytes) -> list`
- `def _build_docstring_map(node: Node, source_bytes: bytes) -> dict[int, str]`
- `def _is_doc_comment(comment_text: str) -> bool`
- `def _clean_docstring(comment_text: str) -> str`
- `def _extract_generic_parameters(node: Node) -> str`
- `def _extract_access_modifier(node: Node) -> str`
- `def _extract_class(node: Node, source_bytes: bytes, docstring: str = "") -> list[Symbol]`
- `def _extract_struct(node: Node, source_bytes: bytes, docstring: str = "") -> list[Symbol]`
- `def _extract_enum(node: Node, source_bytes: bytes, docstring: str = "") -> list[Symbol]`
- `def _extract_protocol(node: Node, source_bytes: bytes, docstring: str = "") -> list[Symbol]`
- `def _extract_extension(
    node: Node, source_bytes: bytes, docstring: str = ""
) -> list[Symbol]`
- `def _extract_function(
    node: Node, source_bytes: bytes, docstring: str = ""
) -> Symbol | None`
- `def _extract_class_methods(
    class_name: str, body_node: Node, source_bytes: bytes
) -> list[Symbol]`
- `def _extract_property(
    class_name: str, node: Node, source_bytes: bytes
) -> Symbol | None`
- `def _find_property_name(node: Node) -> str | None`

_... and 2 more symbols_

### __init__.py
_TypeScript/JavaScript language parser.

This module provides parsing for TypeScript (.ts), TSX (.tsx),
JavaScript (.js), and JSX (.jsx) files using tr_

**class** `class TypeScriptParser(BaseLanguageParser)`
> TypeScript/JavaScript language parser.

    Handles .ts, .tsx, .js, .jsx files using the appropriate

**Methods:**
- `def extract_symbols(self, tree: Tree, source_bytes: bytes) -> list`
- `def extract_imports(self, tree: Tree, source_bytes: bytes) -> list`
- `def extract_calls(
        self, tree: Tree, source_bytes: bytes, symbols: list, imports: list
    ) -> list`
- `def extract_inheritances(self, tree: Tree, source_bytes: bytes) -> list`
- `def parse(self, path: Path)`

**Functions:**
- `def is_typescript_file(path: str) -> bool`

### calls.py
_Call extraction for TypeScript/JavaScript parser.

This module provides functions to extract function and method call relationships
from TypeScript/Ja_

**Functions:**
- `def extract_calls(
    tree: Tree, source_bytes: bytes, symbols: list, imports: list
) -> list`
- `def _extract_calls_from_node(
    node: Node, source_bytes: bytes, caller: str, calls: list[Call]
)`
- `def _parse_call_expression(
    node: Node, source_bytes: bytes, caller: str
) -> Call | None`
- `def _parse_new_expression(
    node: Node, source_bytes: bytes, caller: str
) -> Call | None`

### imports.py
_Import extraction for TypeScript/JavaScript parser.

This module provides functions to extract import/export statements
from TypeScript/JavaScript sou_

**Functions:**
- `def extract_imports(tree: Tree, source_bytes: bytes) -> list`
- `def _parse_import_statement(
    node: Node, source_bytes: bytes
) -> list[Import]`
- `def _parse_export_as_import(
    node: Node, source_bytes: bytes
) -> list[Import]`
- `def _parse_require(
    node: Node, source_bytes: bytes
) -> Import | None`
- `def _extract_string_content(node: Node, source_bytes: bytes) -> str`

### inheritance.py
_Inheritance extraction for TypeScript/JavaScript parser.

This module provides functions to extract class and interface inheritance
relationships from_

**Functions:**
- `def extract_inheritances(tree: Tree, source_bytes: bytes) -> list`
- `def _extract_inheritances_from_node(
    node: Node, source_bytes: bytes, inheritances: list[Inheritance]
)`
- `def _parse_class_heritage(
    node: Node, source_bytes: bytes
) -> tuple[str, list[str]]`
- `def _strip_generic_type(type_name: str) -> str`

### symbols.py
_Symbol extraction for TypeScript/JavaScript parser.

This module provides functions to extract symbols (classes, functions, methods,
interfaces, enums_

**Functions:**
- `def extract_symbols(tree: Tree, source_bytes: bytes) -> list`
- `def extract_module_docstring(tree: Tree, source_bytes: bytes) -> str`
- `def _extract_node_symbols(
    node: Node, source_bytes: bytes, class_name: str = ""
) -> list[Symbol]`
- `def _parse_function_declaration(
    node: Node, source_bytes: bytes
) -> Symbol | None`
- `def _parse_class_declaration(
    node: Node, source_bytes: bytes, abstract: bool = False
) -> list[Symbol]`
- `def _parse_class_heritage(
    node: Node, source_bytes: bytes
) -> tuple[str, list[str]]`
- `def _parse_class_body(
    node: Node, source_bytes: bytes, class_name: str
) -> list[Symbol]`
- `def _parse_method_definition(
    node: Node, source_bytes: bytes, class_name: str
) -> Symbol | None`
- `def _parse_field_definition(
    node: Node, source_bytes: bytes, class_name: str
) -> Symbol | None`
- `def _parse_interface_declaration(
    node: Node, source_bytes: bytes
) -> Symbol | None`
- `def _parse_enum_declaration(
    node: Node, source_bytes: bytes
) -> Symbol | None`
- `def _parse_type_alias(
    node: Node, source_bytes: bytes
) -> Symbol | None`
- `def _parse_lexical_declaration(
    node: Node, source_bytes: bytes
) -> list[Symbol]`
- `def _parse_variable_declarator(
    node: Node, source_bytes: bytes, decl_keyword: str
) -> Symbol | None`
- `def _parse_namespace(
    node: Node, source_bytes: bytes
) -> Symbol | None`

_... and 2 more symbols_

### utils.py
_Utility functions for language parsers.

This module contains helper functions that are shared across multiple language parsers._

**Functions:**
- `def count_arguments(args_node: Node) -> Optional[int]`

### route_extractor.py
_Route extraction framework for multi-framework support.

This module provides the abstract base class for route extractors and
the extraction context _

**class** `class ExtractionContext`
> Context for route extraction.

    Provides all necessary information for a route extractor to analy

**class** `class RouteExtractor(ABC)`
> Abstract base class for framework-specific route extractors.

    Each framework (ThinkPHP, Laravel,

### route_registry.py
_Route extractor registry for framework-agnostic route extraction.

This module provides a registry to store and retrieve route extractors
for differen_

**class** `class RouteExtractorRegistry`
> Registry for route extractors.

    Stores and manages route extractors for different frameworks.
  

**Methods:**
- `def register(self, extractor: RouteExtractor) -> None`
- `def has_extractor(self, framework: str) -> bool`
- `def list_frameworks(self) -> list[str]`

### scanner.py
_Directory scanner for codeindex._

**class** `class ScanResult`
> Result of scanning a directory.

**Functions:**
- `def is_pass_through(dir_path: Path, config: Config) -> bool`
- `def should_exclude(path: Path, exclude_patterns: list[str], base_path: Path) -> bool`
- `def scan_directory(
    path: Path,
    config: Config,
    base_path: Path | None = None,
    recursive: bool = True
) -> ScanResult`
- `def find_all_directories(root: Path, config: Config) -> list[Path]`

### semantic_extractor.py
_Business Semantic Extractor

Story 4.4: Extract business semantics from directory structure
Task 4.4.5: KISS Universal Description Generator

This mod_

**class** `class DirectoryContext`
> Context information about a directory

    Used to collect information for semantic extraction.

**class** `class BusinessSemantic`
> Business semantic information

    Extracted description of what a directory does.

**class** `class SimpleDescriptionGenerator`
> Universal description generator: zero assumptions, zero semantic understanding

    Only extracts ob

**class** `class SemanticExtractor`
> Extract business semantics from directory context

    Supports two modes:
    - Heuristic mode: KIS

**Methods:**
- `def generate(self, context: DirectoryContext) -> str`
- `def _extract_path_context(self, path: str) -> str`
- `def _analyze_symbol_pattern(self, symbols: List[str]) -> str`
- `def _pluralize(self, suffix: str) -> str`
- `def _extract_entity_names(self, symbols: List[str]) -> List[str]`
- `def extract_directory_semantic(
        self,
        context: DirectoryContext
    ) -> BusinessSemantic`
- `def _heuristic_extract(self, context: DirectoryContext) -> BusinessSemantic`
- `def _ai_extract(self, context: DirectoryContext) -> BusinessSemantic`
- `def _build_ai_prompt(self, context: DirectoryContext) -> str`
- `def _parse_ai_response(self, response: str) -> BusinessSemantic`

### skill_helpers.py
_Skill helpers for codeindex-update-guide.

Epic #25, Story #27: Provides helper functions for the
/codeindex-update-guide skill to analyze projects, g_

**Functions:**
- `def detect_project_languages(project_path: Path) -> list[str]`
- `def detect_codeindex_config(project_path: Path) -> Optional[dict]`
- `def detect_loomgraph_integration(project_path: Path) -> bool`
- `def generate_version_diff(old_version: str, new_version: str) -> str`
- `def generate_language_table_diff(old_languages: list[str], new_languages: list[str]) -> str`
- `def generate_suggestions(profile: dict, current_version: str) -> list[str]`
- `def apply_updates(
    file_path: Path,
    updates: list[dict],
    select_all: bool = False,
    selected_indices: Optional[list[int]] = None,
) -> bool`
- `def create_backup(file_path: Path) -> Optional[Path]`
- `def rollback_from_backup(file_path: Path, backup_path: Path) -> bool`

### smart_writer.py
_Smart README writer — backward-compatibility shim.

All implementation has moved to the writers/ package.
This module re-exports the public API so exi_

### symbol_index.py
_Global symbol index generator for PROJECT_SYMBOLS.md._

**class** `class SymbolEntry`
> A symbol entry in the global index.

**class** `class GlobalSymbolIndex`
> Generates a global symbol index (PROJECT_SYMBOLS.md) for a project.

    Collects all classes, funct

**Methods:**
- `def collect_symbols(self, quiet: bool = False) -> dict`
- `def generate_index(self, output_file: str = "PROJECT_SYMBOLS.md") -> Path`
- `def _group_by_type(self) -> dict[str, list[SymbolEntry]]`

### symbol_scorer.py
_Symbol importance scoring system.

This module provides functionality to score symbols based on their importance,
helping to prioritize which symbols _

**class** `class ScoringContext`
> Scoring context for symbols.

    Attributes:
        framework: The framework being used (e.g., 'th

**class** `class SymbolImportanceScorer`
> Score symbols by importance for inclusion in documentation.

    This scorer evaluates symbols acros

**Methods:**
- `def _score_visibility(self, symbol: Symbol) -> float`
- `def _score_semantics(self, symbol: Symbol) -> float`
- `def _score_documentation(self, symbol: Symbol) -> float`
- `def _score_complexity(self, symbol: Symbol) -> float`
- `def _score_naming_pattern(self, symbol: Symbol) -> float`
- `def score(self, symbol: Symbol) -> float`

### tech_debt.py
_Technical debt detection for code analysis.

This module provides tools to detect and analyze technical debt in codebases,
including file size issues,_

**class** `class DebtSeverity(IntEnum)`
> Severity levels for technical debt issues.

    Lower values indicate higher severity (CRITICAL is m

**class** `class DebtIssue`
> Represents a technical debt issue detected in code.

    Attributes:
        severity: The severity 

**class** `class DebtAnalysisResult`
> Result of analyzing a file for technical debt.

    Attributes:
        issues: List of detected tec

**class** `class SymbolOverloadAnalysis`
> Analysis result of symbol overload detection.

    Attributes:
        total_symbols: Total number o

**class** `class FileReport`
> Report for a single file's technical debt analysis.

    Attributes:
        

---
_Content truncated due to size limit. See individual module README files for details._
