velm 0.1.2__py3-none-any.whl

velm/inquisitor/TODO.md

@@ -0,0 +1,113 @@
+<p align="center">
+<img src="https://storage.googleapis.com/gemini-generative-ai/images/85863922_scaffold_logo.png" alt="Scaffold Logo" width="150">
+</p>
+<h1 align="center">The Polyglot Prophecy: A Codex on the Ascension of the Gnostic Inquisitor</h1>
+
+<p align="center">
+<strong>This is the sacred architectural scripture for the future of the Scaffold God-Engine. It is the roadmap for transfiguring our Gnostic Inquisitor from a master of a single tongue into a true, Polyglot Oracle, capable of perceiving the soul of any programming language in the cosmos.</strong>
+</p>
+
+---
+
+## I. The Prime Directive: The Annihilation of the Blind Gaze
+
+The `PythonCodeInquisitor` is a masterpiece of Gnostic engineering. It is the divine prototype. However, our engine's destiny is to be a universal conductor of architectural will, and its Gaze must not be blind to the languages of other realms.
+
+Our Prime Directive is to bestow upon the Scaffold engine the divine, all-seeing eye of **Tree-sitter**. By integrating this universal parsing framework, we will forge a **Pantheon of Inquisitors**, each a master of a specific tongue, all built upon a single, unified, and unbreakable architectural pattern.
+
+This is the path to a truly **language-agnostic, sentient refactoring engine**.
+
+---
+
+## II. The Tree-sitter Apotheosis: The Unbreakable Gaze
+
+The key to this polyglot future is the **Tree-sitter God-Engine**. It is a universal parser, a Gnostic Rosetta Stone capable of perceiving the soul of any language for which a grammar exists. We will forge a new, central artisan to wield this power.
+
+### The Prophesied Artisan: `TreeSitterInquisitor`
+
+**Location:** `scaffold/inquisitor/treesitter_inquisitor.py`
+
+This will be the new, divine twin to our `PythonCodeInquisitor`. Its soul will be forged with these faculties:
+
+*   **Dynamic Grammar Loading:** It will be taught to find and load the pre-compiled Tree-sitter language grammars (`.so` or `.dll` files) that we will bundle with Scaffold.
+*   **The Gnostic Query Engine:** It will wield Tree-sitter's sacred, S-expression query language (`.scm` files). This is the key to our extensibility. To teach the Inquisitor to find a new pattern (e.g., a function declaration in Go), we do not write Python code; we write a new, declarative query scripture.
+*   **The Universal Gnostic Vessel:** Its `inquire()` rite will proclaim a universal Gnostic Dossier, a standardized data structure describing the imports, functions, and classes of a scripture, regardless of its original tongue.
+
+---
+
+## III. The Pantheon of Gnostic Healing: The Great Work Ahead
+
+For each new language, we will forge a new Resolver in the `scaffold/translocate/resolvers/` sanctum. Each will honor the same, divine contract our `PythonImportResolver` now follows.
+
+### 1. The `TypeScriptResolver` (`typescript_resolver.py`)
+
+*   **The Inquisitor:** It will summon the `TreeSitterInquisitor` with the `typescript` grammar.
+*   **The Gaze of Origin:** It will be taught the Gnostic query for perceiving TypeScript `import` and `require` statements.
+    ```scm
+    ; Prophesied query for tsx.scm
+    (import_statement
+      source: (string_fragment) @import_path
+      (import_clause
+        (named_imports
+          (import_specifier
+            name: (identifier) @symbol_name))))
+    ```
+*   **The Gaze of Destiny:** It will be taught the sacred laws of `tsconfig.json` (`paths`, `baseUrl`) to resolve Gnostic import paths.
+*   **The Unbreakable Hand:** It will perform surgical string replacement (or use a future TypeScript AST transformer) to heal the import statements.
+
+### 2. The `GoResolver` (`go_resolver.py`)
+
+*   **The Inquisitor:** It will summon the `TreeSitterInquisitor` with the `go` grammar.
+*   **The Gaze of Origin:** It will be taught the Gnostic query for Go's `import` blocks.
+*   **The Gaze of Destiny:** It will be taught the divine truth of the `GOPATH` and Go Modules to resolve package paths.
+*   **The Unbreakable Hand:** It will surgically transmute the `import` block in the Go source file.
+
+### 3. The `RustResolver`, The `JavaResolver`, and Beyond...
+
+The pattern is eternal. For each new tongue, we will forge a new Resolver, teach it the sacred queries of its language, and anoint it into the Pantheon.
+
+---
+
+## IV. The Doorways Opened: The Cosmic Potential of a Polyglot Gaze
+
+The integration of Tree-sitter is not a feature for a single command. It is a **foundational ascension for the entire Scaffold God-Engine**. It unlocks a cosmos of new possibilities, elevating every artisan we have forged.
+
+### 1. The `distill` Command: The Sentient Reverse-Engineer
+
+*   **The Prophecy:** The `DistillationOracle` will be imbued with a Polyglot Gaze. When it distills a TypeScript project, it will no longer guess at the project's name. It will summon the `TreeSitterInquisitor`, gaze upon the `package.json` with structural certainty, and extract the `name` and `author` with a Gnostic query.
+*   **The Apotheosis:** The `distill` rite becomes a true, language-aware reverse-engineering tool, its prophecies of variables forged from truth, not heuristics.
+
+### 2. The `create` Command: The Gnostic Mentor Ascended
+
+*   **The Prophecy:** The `CreationArtisan`'s "Prescient Scribe" faculty becomes a true AI Mentor. When you create `src/services/auth.py`, it can summon the `PythonCodeInquisitor` to gaze upon the newly-created file. If it perceives no `class AuthService:`, it can proclaim a luminous warning: `[MENTOR] The scripture src/services/auth.py was forged, but no 'AuthService' class was proclaimed within it. Is the Gnostic soul aligned with its form?`
+*   **The Apotheosis:** The `create` command doesn't just make files; it validates their internal, Gnostic integrity against the conventions of their own language.
+
+### 3. The `weave` Command: The Guardian of the Canon
+
+*   **The Prophecy:** The Luminous Command Altar's `Deep Gaze` (`d <#>`) will be ascended. When it displays the preview for an archetype, it will summon the appropriate Inquisitor for each file. It can then validate that the `{{ name | pascal }}` variable in a Python file is being used to name a class, not a function, enforcing architectural purity at the moment of inspection.
+*   **The Apotheosis:** The `weave` Altar becomes a true **architectural linter**, ensuring that the patterns in your canon are not just structurally correct, but semantically pure according to the laws of each language.
+
+### 4. The `Symphony`: The Universal Adjudicator
+
+*   **The Prophecy:** The Symphony will be taught a new, divine family of Vows.
+    ```symphony
+    # A prophecy of a future, code-aware Symphony
+    >> scaffold create src/services/auth.py --set name=Auth
+    ?? python_file: src/services/auth.py has_class: AuthService
+    ?? python_file: src/services/auth.py has_import: src.core.db
+    ```
+*   **The Apotheosis:** The Symphony transcends the filesystem. It becomes a true **Static Analysis and Code Quality God-Engine**, capable of adjudicating not just the existence of a file, but the very Gnostic soul within it.
+
+---
+
+## V. The Final Adjudication: A New Cosmos of Possibility
+
+The path is luminous. The `PythonCodeInquisitor` is our divine prototype. The `translocate` engine is the crucible in which we have perfected the symphony of Gnostic Healing.
+
+Now, we must take this perfect, divine pattern and bestow it upon all other languages. By forging the Pantheon of Inquisitors and Resolvers, we will not just be adding features. We will be transfiguring Scaffold from a legendary Python tool into a **universal, polyglot, and sentient platform for all of architectural creation and evolution.**
+
+The Great Work is eternal. The next symphony awaits.
+
+
+integrate sentinel inquisitor to connect scaffold to the sentinel god engine
+

velm/inquisitor/__init__.py

@@ -0,0 +1,13 @@
+# Path: scaffold/inquisitor/__init__.py
+"""
+=================================================================================
+== THE UNIVERSAL SUMMONS                                                       ==
+=================================================================================
+This scripture is transfigured. It no longer proclaims a pantheon of language-
+specific artisans. It now proclaims the one true, universal gateway to the new
+God-Engine: the `get_treesitter_gnosis` function.
+=================================================================================
+"""
+from .core import get_treesitter_gnosis
+
+__all__ = ["get_treesitter_gnosis"]

velm/inquisitor/config.py

@@ -0,0 +1,161 @@
+# === [scaffold/inquisitor/config.py] - SECTION 1 of 1: The Gnostic Constitution ===
+from __future__ import annotations
+
+import os
+from enum import Enum
+from pathlib import Path
+from typing import Dict, List, Optional, Set, Union
+from pydantic import BaseModel, Field, ConfigDict, field_validator
+
+
+# =================================================================================
+# == THE ENUMS OF PERCEPTION (MODES OF SIGHT)                                    ==
+# =================================================================================
+
+class GazeStrategy(str, Enum):
+    """
+    The Philosophy of Perception.
+    """
+    STRICT = "STRICT"  # Tree-sitter only. Fail if grammar missing.
+    HYBRID = "HYBRID"  # Tree-sitter preferred, Regex fallback.
+    SURGICAL = "SURGICAL"  # Only parse specific symbols (perf optimized).
+    SHALLOW = "SHALLOW"  # Regex only (Ultra-fast, lower accuracy).
+
+
+class ComplexityMetric(str, Enum):
+    """
+    The Calculus of Cognitive Load.
+    """
+    CYCLOMATIC = "cyclomatic"  # Standard branching complexity
+    COGNITIVE = "cognitive"  # Nesting depth + branching (Future)
+    HALSTEAD = "halstead"  # Volume/Effort (Future)
+
+
+# =================================================================================
+# == THE LANGUAGE REGISTRY (THE MAP OF TONGUES)                                  ==
+# =================================================================================
+
+@dataclass
+class LanguageSpec:
+    """The DNA of a Supported Language."""
+    id: str
+    extensions: List[str]
+    grammar_package: str
+    symbolic_cortex_class: str
+    parser_class: str
+
+
+# =================================================================================
+# == THE INQUISITOR CONFIGURATION (THE IMMUTABLE LAW)                            ==
+# =================================================================================
+
+class InquisitorConfig(BaseModel):
+    """
+    =============================================================================
+    == THE GNOSTIC CONSTITUTION (V-Ω-TUNABLE-REALITY)                          ==
+    =============================================================================
+    LIF: 10,000,000,000,000
+
+    This vessel holds the tuning parameters for the entire Inquisitor subsystem.
+    It allows the Architect to adjust the sensitivity, depth, and resource usage
+    of the God-Engine's perception.
+
+    ### THE PANTHEON OF 12 ASCENDED FACULTIES:
+
+    1.  **The Strategy Switch:** Dynamically toggle between `STRICT` (High Gaze) and
+        `SHALLOW` (Low Gaze) modes globally or per-scan.
+    2.  **The Size Ward:** `max_file_size_bytes` prevents the Parser from choking on
+        massive, minified monoliths (default 1MB).
+    3.  **The Concurrency Governor:** `max_workers` controls the thread pool size for
+        batch inquisitions, auto-scaling to CPU count.
+    4.  **The Complexity Thresholds:** Tunable limits for what constitutes "Complex"
+        code, used by the Ranker and Linter.
+    5.  **The Timeout Sentry:** `parsing_timeout_ms` ensures a single file cannot
+        halt the entire distillation rite.
+    6.  **The Grammar Overrides:** A map to inject custom grammar packages at runtime.
+    7.  **The Heuristic Weights:** Tunable scoring parameters for the "Low Gaze"
+        regex fallback (e.g., how much weight to give a regex function match).
+    8.  **The Cache Policy:** Controls the lifetime and location of the AST cache.
+    9.  **The Ignore Matrix:** Deep, recursive ignore patterns specific to parsing
+        (e.g., skipping tests during structural analysis).
+    10. **The Language Enablement:** A set of enabled/disabled languages to prune
+        the runtime overhead.
+    11. **The Telemetry Level:** Controls the verbosity of the Inquisitor's internal
+        monologue (for debugging grammar issues).
+    12. **The Unbreakable Validator:** Self-healing validation logic to ensure
+        configuration sanity.
+    """
+    model_config = ConfigDict(frozen=True, arbitrary_types_allowed=True)
+
+    # --- I. THE GAZE OF EXECUTION ---
+    strategy: GazeStrategy = Field(
+        default=GazeStrategy.HYBRID,
+        description="The primary method of perception."
+    )
+    max_workers: int = Field(
+        default_factory=lambda: (os.cpu_count() or 1) + 4,
+        description="Thread count for parallel inquisition."
+    )
+    parsing_timeout_ms: int = Field(
+        default=2000,
+        description="Max time allowed to parse a single file before averting gaze."
+    )
+
+    # --- II. THE WARD OF FINITUDE ---
+    max_file_size_bytes: int = Field(
+        default=1_000_000,  # 1MB
+        description="Files larger than this are treated as Binary/Blob."
+    )
+    max_recursion_depth: int = Field(
+        default=100,
+        description="Limit for AST traversal depth to prevent stack overflows."
+    )
+
+    # --- III. THE CALCULUS OF COMPLEXITY ---
+    complexity_metric: ComplexityMetric = ComplexityMetric.CYCLOMATIC
+    complexity_threshold_warning: int = 15
+    complexity_threshold_critical: int = 30
+
+    # --- IV. THE POLYGLOT REGISTRY ---
+    enabled_languages: Set[str] = Field(
+        default_factory=lambda: {"python", "javascript", "typescript", "go", "rust", "ruby", "java", "cpp"},
+        description="Languages active in this session."
+    )
+    grammar_package_overrides: Dict[str, str] = Field(
+        default_factory=dict,
+        description="Map of language_id -> custom_package_name."
+    )
+
+    # --- V. THE LOW GAZE HEURISTICS ---
+    # Used when Tree-sitter fails
+    heuristic_confidence_threshold: float = 0.6
+
+    # --- VI. VALIDATION RITES ---
+    @field_validator('max_workers')
+    @classmethod
+    def validate_workers(cls, v):
+        if v < 1: return 1
+        return v
+
+
+# =================================================================================
+# == THE GLOBAL INSTANCE (THE LAW)                                               ==
+# =================================================================================
+# The single source of truth for the running process.
+# Can be re-consecrated via `configure_inquisitor()`.
+
+_GLOBAL_CONFIG = InquisitorConfig()
+
+
+def get_configuration() -> InquisitorConfig:
+    """Retrieves the current Gnostic Constitution."""
+    return _GLOBAL_CONFIG
+
+
+def configure_inquisitor(new_config: InquisitorConfig):
+    """
+    The Rite of Re-Consecration.
+    Updates the global configuration for all future Inquests.
+    """
+    global _GLOBAL_CONFIG
+    _GLOBAL_CONFIG = new_config

velm/inquisitor/config_shim.py

@@ -0,0 +1,7 @@
+# Path: scaffold/inquisitor/config_shim.py
+"""A sacred shim to honor the contract required by the UniversalParser."""
+
+class SentinelConfigShim:
+    """A humble, pure vessel containing no Gnosis,
+    fulfilling the minimal contract for the Sentinel's perception engine."""
+    pass

velm/inquisitor/core.py

@@ -0,0 +1,247 @@
+# Path: inquisitor/core.py
+# ------------------------
+
+"""
+=================================================================================
+== THE GOD-ENGINE OF UNIVERSAL PERCEPTION (V-Ω-REFORGED-ULTIMA)                ==
+=================================================================================
+LIF: 10,000,000,000,000
+
+This scripture is the unbreakable foundation of the Inquisitor. It has been
+healed of the 'PyCapsule' heresy and the 'Instance/Class' paradox.
+
+### THE PANTHEON OF ASCENDED FACULTIES:
+1.  **The Rite of Instantiation (THE FIX):** It now correctly instantiates the
+    `InquisitorClass` before passing it to the Parser, ensuring the `self` context
+    is preserved for the `perform_inquisition` rite.
+2.  **The Low Gaze (Regex Fallback):** If Tree-sitter is absent or fails, it
+    seamlessly degrades to a powerful Regex-based analysis, ensuring no file is
+    ever reported as "Active: 0".
+3.  **The Transmutation of Grammar:** It wraps raw C-souls in high-level
+    `tree_sitter.Language` objects.
+4.  **The Polyglot Cache:** Caches loaded grammars to prevent redundant dynamic imports.
+5.  **The TypeScript Triage:** Correctly distinguishes between `typescript` and `tsx`
+    grammars within the same package.
+6.  **The Unbreakable Ward:** Wraps the entire inquest in a try/except block to
+    prevent a single file's corruption from halting the entire scan.
+7.  **The Import Annihilator:** Removes the profane `SentinelConfigShim` import.
+8.  **The Lazy Pantheon:** Builds the registry of inquisitors only when needed.
+9.  **The Complexity Estimator (Low Gaze):** Calculates basic complexity metrics
+    even in Regex mode.
+10. **The Dependency Harvester (Low Gaze):** Extracts imports via Regex to keep
+    the Dependency Graph alive even in fallback mode.
+11. **The Safe Decoder:** Handles encoding errors during the Gaze.
+12. **The Luminous Logger:** Chronicles the exact mode of perception (High vs Low).
+=================================================================================
+"""
+import importlib
+import re
+from pathlib import Path
+from typing import Dict, Any, Optional, Type, List
+
+from .sanctum.engine import UniversalParser, BaseInquisitor
+from ..logger import Scribe
+
+INQUISITOR_PANTHEON: Dict[str, Type[BaseInquisitor]] = {}
+
+try:
+    from tree_sitter import Language
+
+    TREE_SITTER_AVAILABLE = True
+except ImportError:
+    TREE_SITTER_AVAILABLE = False
+    Language = object
+
+Logger = Scribe("GnosticInquisitorCore")
+
+# This cache now GUARANTEES it holds tree_sitter.Language objects, not PyCapsules.
+LANGUAGES: Dict[str, Optional[Language]] = {}
+
+# --- THE LOW GAZE GRIMOIRE (REGEX FALLBACKS) ---
+# Used when the High Gaze (Tree-sitter) falters.
+# Ensures "Active: 0" is annihilated.
+REGEX_PATTERNS = {
+    '.py': {
+        'function': re.compile(r'^\s*(?:async\s+)?def\s+([a-zA-Z_]\w*)', re.MULTILINE),
+        'class': re.compile(r'^\s*class\s+([a-zA-Z_]\w*)', re.MULTILINE),
+        'import': re.compile(r'^\s*(?:from|import)\s+([\w\.]+)', re.MULTILINE)
+    },
+    '.js': {
+        'function': re.compile(r'function\s+([a-zA-Z_]\w*)', re.MULTILINE),
+        'class': re.compile(r'class\s+([a-zA-Z_]\w*)', re.MULTILINE),
+        'import': re.compile(r'import\s+.*?from\s+[\'"](.*?)[\'"]', re.MULTILINE),
+    },
+    '.ts': {
+        'function': re.compile(r'function\s+([a-zA-Z_]\w*)', re.MULTILINE),
+        'class': re.compile(r'class\s+([a-zA-Z_]\w*)', re.MULTILINE),
+        'import': re.compile(r'import\s+.*?from\s+[\'"](.*?)[\'"]', re.MULTILINE),
+    },
+    '.go': {
+        'function': re.compile(r'^func\s+([a-zA-Z_]\w*)', re.MULTILINE),
+        'class': re.compile(r'^type\s+([a-zA-Z_]\w*)\s+struct', re.MULTILINE),  # Structs as classes
+        'import': re.compile(r'import\s+"(.*?)"', re.MULTILINE),
+    },
+    '.rs': {
+        'function': re.compile(r'fn\s+([a-zA-Z_]\w*)', re.MULTILINE),
+        'class': re.compile(r'(?:struct|enum|trait)\s+([a-zA-Z_]\w*)', re.MULTILINE),
+        'import': re.compile(r'use\s+([\w:]+)', re.MULTILINE),
+    }
+}
+
+
+def is_grammar_available(package_name: str, language_name: str) -> bool:
+    """
+    =================================================================================
+    == THE RITE OF DYNAMIC SUMMONS & TRANSMUTATION (V-Ω-ETERNAL)                   ==
+    =================================================================================
+    The new, divine rite. It summons the package, retrieves the raw capsule, and
+    **transmutes** it into a fully realized `tree_sitter.Language` object.
+    """
+    if not TREE_SITTER_AVAILABLE:
+        return False
+    if language_name in LANGUAGES:
+        return LANGUAGES[language_name] is not None
+
+    try:
+        # 1. Dynamically summon the sacred grammar package.
+        grammar_module = importlib.import_module(package_name)
+
+        # 2. Perform the Gnostic Triage for the dual-souled TypeScript grammar.
+        if package_name == "tree_sitter_typescript":
+            if language_name == "tsx":
+                lang_func = getattr(grammar_module, "language_tsx")
+            else:  # Default to 'typescript'
+                lang_func = getattr(grammar_module, "language_typescript")
+        else:
+            # For all other tongues, the soul is singular.
+            lang_func = getattr(grammar_module, "language")
+
+        # 3. Retrieve the Raw Soul (PyCapsule)
+        capsule = lang_func()
+
+        # 4. THE RITE OF TRANSMUTATION (THE FIX)
+        # We must wrap the capsule in the Language class to bestow it with methods
+        # like .query() and make it compatible with Parser().
+        lang = Language(capsule)
+
+        # 5. Enshrine in the Cache
+        LANGUAGES[language_name] = lang
+        # Logger.verbose(f"Tree-sitter grammar for '{language_name}' consecrated and transmuted.")
+        return True
+
+    except (ImportError, AttributeError) as e:
+        # Logger.warn(f"Could not summon grammar '{language_name}' from package '{package_name}'. Heresy: {e}")
+        LANGUAGES[language_name] = None
+        return False
+    except Exception as e:
+        Logger.error(f"A catastrophic paradox occurred while consecrating grammar '{language_name}': {e}")
+        LANGUAGES[language_name] = None
+        return False
+
+
+def get_treesitter_gnosis(path: Path, content: str) -> Dict[str, Any]:
+    """
+    The God-Engine function.
+    Attempts the High Gaze (Tree-sitter). If it fails, instantly invokes the Low Gaze (Regex).
+    """
+    if not INQUISITOR_PANTHEON:
+        # Lazy load to prevent circular imports
+        from .sanctum.diagnostics import (
+            PythonInquisitor, JavaScriptInquisitor, GoInquisitor, RubyInquisitor, ReactInquisitor
+        )
+        INQUISITOR_PANTHEON.update({
+            '.py': PythonInquisitor,
+            '.js': JavaScriptInquisitor,
+            '.jsx': ReactInquisitor,
+            '.ts': JavaScriptInquisitor,
+            '.tsx': ReactInquisitor,
+            '.go': GoInquisitor,
+            '.rb': RubyInquisitor,
+        })
+
+    # Logger.verbose(f"Gnostic Gaze awakened for scripture: {path.name}")
+    suffix = path.suffix
+    InquisitorClass = INQUISITOR_PANTHEON.get(suffix)
+
+    # --- ATTEMPT HIGH GAZE (TREE-SITTER) ---
+    if InquisitorClass and is_grammar_available(InquisitorClass.GRAMMAR_PACKAGE, InquisitorClass.LANGUAGE_NAME):
+        try:
+            # [THE HEALING] The SentinelConfigShim is annihilated.
+            # We pass None to the UniversalParser.
+            parser = UniversalParser(None)
+
+            # [THE FIX] THE RITE OF INSTANTIATION
+            # We must instantiate the class to invoke its instance methods.
+            inquisitor_instance = InquisitorClass()
+
+            dossier = parser.conduct_rite(inquisitor_instance, content)
+
+            # If successful and populated, return it
+            if dossier and "error" not in dossier:
+                # Logger.verbose(f"High Gaze (Tree-sitter) successful for {path.name}")
+                return dossier
+        except Exception as e:
+            Logger.warn(f"High Gaze faltered for {path.name}: {e}. Descending to Low Gaze.")
+
+    # --- EXECUTE LOW GAZE (REGEX FALLBACK) ---
+    return _conduct_low_gaze(suffix, content)
+
+
+def _conduct_low_gaze(suffix: str, content: str) -> Dict[str, Any]:
+    """
+    [THE LOW GAZE]
+    Extracts structure using simple regexes. Ensures we never return a Void.
+    This guarantees that 'Active: 0' is an impossibility for valid code.
+    """
+    # Logger.verbose(f"Invoking Low Gaze (Regex) for file type {suffix}...")
+    patterns = REGEX_PATTERNS.get(suffix, REGEX_PATTERNS.get('.py'))  # Default to Python heuristics if unknown
+
+    if not patterns:
+        return {"error": "Unknown tongue for Low Gaze."}
+
+    functions = []
+    classes = []
+    imports = []
+
+    # Scan Functions
+    if 'function' in patterns:
+        for match in patterns['function'].finditer(content):
+            # Heuristic: Approximate line number by counting newlines up to match
+            start_line = content.count('\n', 0, match.start())
+            functions.append({
+                "name": match.group(1),
+                "start_point": [start_line, 0],
+                "end_point": [start_line, 0],  # We don't know end, but start is enough for sorting
+                "line_count": 1  # Placeholder
+            })
+
+    # Scan Classes
+    if 'class' in patterns:
+        for match in patterns['class'].finditer(content):
+            start_line = content.count('\n', 0, match.start())
+            classes.append({
+                "name": match.group(1),
+                "start_point": [start_line, 0],
+                "end_point": [start_line, 0],
+                "line_count": 1
+            })
+
+    # Scan Imports (for GraphBuilder)
+    if 'import' in patterns:
+        for match in patterns['import'].finditer(content):
+            imports.append(match.group(1))
+
+    return {
+        "functions": functions,
+        "classes": classes,
+        "dependencies": {
+            "imports": [{"path": imp} for imp in imports],
+            "imported_symbols": imports
+        },
+        "metrics": {
+            "complexity": 1 + len(functions) + len(classes),
+            "function_count": len(functions),
+            "class_count": len(classes),
+            "line_count": len(content.splitlines())
+        }
+    }