alivirgo/major-ai-skills/tree-sitter-scope-extractor

┌─────────────────────────────────────────────────────────────┐
│                 Code Context Ingestion Scope                │
│                                                             │
│  Full-File Ingestion (800 Lines / 6,500 Tokens):            │
│  • Lines 1-40: Imports & Global DB Pools                    │
│  • Lines 41-130: `createOrder`, `cancelOrder`, `listOrders` │
│  • Lines 131-180: `processOrder` <-- THE ONLY TARGET!       │
│  • Lines 181-800: 12 other unrelated accounting routines    │
│  ↳ 6,500 tokens billed, attention diluted across 800 lines  │
│                                                             │
│  Tree-Sitter Enclosing Scope (60 Lines / 420 Tokens):       │
│  • Lines 1-12: Top-level module imports (Module Contract)   │
│  • Lines 131-180: Complete `processOrder` AST block         │
│  ↳ 420 clean tokens (93.5% Cut!), 100% AST integrity!       │
└─────────────────────────────────────────────────────────────┘

┌───────────────────────────────────────────────────────────────────────────┐
│ 1. PARSE FILE VIA TREE-SITTER: Build Concrete Syntax Tree (2ms in C/Rust) │
│ 2. LOCATE TARGET LINE IN TREE: Find AST node spanning target line number  │
│ 3. WALK UP TO ENCLOSING SCOPE: Extract `function_declaration` node + imports│
└───────────────────────────────────────────────────────────────────────────┘

from pathlib import Path
from typing import Optional, Tuple
import tree_sitter_languages # Provides universal pre-compiled tree-sitter parsers
def extract_enclosing_ast_scope(
    file_path: Path,
    target_line: int,
    language: str = "typescript"
) -> str:
    """Extracts top-level imports and the enclosing function AST scope for target_line."""
    code_bytes = file_path.read_bytes()
    lines = code_bytes.decode("utf-8").splitlines()
    
    parser = tree_sitter_languages.get_parser(language)
    tree = parser.parse(code_bytes)
    root_node = tree.root_node
    # 1. Extract Top-Level Imports (Lines 1..N)
    import_lines = []
    for child in root_node.children:
        if "import" in child.type or "use" in child.type:
            start_row = child.start_point[0]
            end_row = child.end_point[0]
            import_lines.extend(lines[start_row:end_row + 1])
    # 2. Locate AST Node Spanning target_line (0-indexed)
    target_row = target_line - 1
    
    def find_enclosing_scope(node) -> Optional[Tuple[int, int]]:
        for child in node.children:
            if child.start_point[0] <= target_row <= child.end_point[0]:
                # If child is a function / class / method declaration, capture range
                if child.type in [
                    "function_declaration", "method_definition", 
                    "arrow_function", "class_declaration", "function_definition"
                ]:
                    return (child.start_point[0], child.end_point[0])
                # Recurse deeper into block
                deeper = find_enclosing_scope(child)
                if deeper:
                    return deeper
        return None
    scope_range = find_enclosing_scope(root_node)
    
    # 3. Assemble Output Payload
    if scope_range:
        start, end = scope_range
        scope_text = "\n".join(lines[start:end + 1])
        imports_text = "\n".join(import_lines)
        return (
            f"// --- [MODULE IMPORTS] ---\n{imports_text}\n\n"
            f"// --- [ENCLOSING AST SCOPE: Lines {start+1}-{end+1}] ---\n{scope_text}"
        )
        
    # Fallback: Return window +/- 25 lines
    start = max(0, target_row - 25)
    end = min(len(lines), target_row + 25)
    return "\n".join(lines[start:end])