java-codebase-rag 0.12.0__py3-none-any.whl → 0.12.2__py3-none-any.whl

java_codebase_rag/ast/brownfield_events.py

@@ -1,58 +0,0 @@
-"""Structured stderr events for brownfield extraction (PR-1 scaffolding; PR-2 wiring).
-
-Each call emits one JSON object on a single line to sys.stderr. MCP stdio servers
-must not use this module from tool handlers — graph build / AST paths only.
-"""
-from __future__ import annotations
-
-import json
-import sys
-from typing import Any
-
-_VALID_SEVERITIES = frozenset({"INFO", "WARN"})
-_VALID_EVENTS = frozenset(
-    {
-        "brownfield-exclusivity-shadowing",
-        "brownfield-method-string-literal",
-    }
-)
-
-
-def emit_structured_brownfield_event(
-    event_id: str,
-    severity_level: str,
-    **fields: Any,
-) -> None:
-    """Emit one JSON line to stderr with keys ``event`` and ``severity`` plus ``**fields``.
-
-    Parameters are named ``event_id`` / ``severity_level`` so ``**fields`` may contain
-    keys ``event`` or ``severity`` without a caller TypeError; those keys never override
-    the canonical record (reserved keys are merged last).
-    """
-    if severity_level not in _VALID_SEVERITIES:
-        raise ValueError(
-            f"severity must be one of {_VALID_SEVERITIES}, got {severity_level!r}"
-        )
-    if event_id not in _VALID_EVENTS:
-        raise ValueError(f"event must be one of {_VALID_EVENTS}, got {event_id!r}")
-    # Fields first so JSON ``event`` / ``severity`` always match event_id / severity_level.
-    payload = {**fields, "event": event_id, "severity": severity_level}
-    print(json.dumps(payload, ensure_ascii=False), file=sys.stderr, flush=True)
-
-
-def emit_brownfield_exclusivity_shadowing(**fields: Any) -> None:
-    """INFO: brownfield HTTP annotation co-present with shadowable framework annotations."""
-    emit_structured_brownfield_event(
-        "brownfield-exclusivity-shadowing",
-        "INFO",
-        **fields,
-    )
-
-
-def emit_brownfield_method_string_literal(**fields: Any) -> None:
-    """WARN: HTTP client/route `method` still a string literal (migration / misuse)."""
-    emit_structured_brownfield_event(
-        "brownfield-method-string-literal",
-        "WARN",
-        **fields,
-    )

java_codebase_rag/ast/chunk_heuristics.py

@@ -1,83 +0,0 @@
-"""Lightweight, query-time hints from chunk text — no AST / re-index required."""
-
-from __future__ import annotations
-
-import re
-from dataclasses import dataclass
-
-
-@dataclass
-class ChunkHints:
-    """Heuristic metadata derived from a chunk's text."""
-
-    primary_type_hint: str | None = None
-    """First top-level ``class`` / ``interface`` / ``enum`` / ``record`` name in the chunk."""
-
-    import_heavy: bool = False
-    """True when most lines are ``import`` statements (low semantic density)."""
-
-
-_JAVA_TYPE = re.compile(
-    r"\b(?:public\s+|private\s+|protected\s+|sealed\s+|final\s+|abstract\s+|static\s+)*"
-    r"(?:class|interface|enum|record)\s+([A-Za-z_][A-Za-z0-9_]*)"
-)
-
-# Kotlin type declarations. Covers ``class`` / ``interface`` / ``object`` /
-# ``enum class`` plus the modifiers Kotlin uses (``internal`` / ``open`` / etc.).
-# ``object`` is the Kotlin-specific kind the Java regex misses; top-level
-# ``fun`` is intentionally NOT a type declaration (no name to pin a type to).
-_KOTLIN_TYPE = re.compile(
-    r"\b(?:public\s+|private\s+|protected\s+|internal\s+|"
-    r"final\s+|open\s+|abstract\s+|sealed\s+|data\s+)*"
-    r"(?:class|interface|object|enum\s+class)\s+([A-Za-z_][A-Za-z0-9_]*)"
-)
-
-
-def analyze_chunk(text: str | None, *, language: str, kind: str) -> ChunkHints:
-    if not text or not text.strip():
-        return ChunkHints()
-
-    lines = text.strip().split("\n")
-    n = len(lines)
-    lang = (language or "").lower()
-    # Kotlin chunks live in the java LanceDB table (``kind == "java"``), so the
-    # ``language`` field — not ``kind`` — is what distinguishes them. Detect
-    # Kotlin first so the Kotlin regex wins for ``object`` / Kotlin modifiers.
-    is_kotlin = lang == "kotlin"
-    is_java = not is_kotlin and (kind == "java" or lang == "java")
-
-    # Both Java and Kotlin use ``import <pkg.Type>`` lines (Java ends the line
-    # with ``;``, Kotlin does not), so the import-density heuristic matches on
-    # the ``import `` prefix only — the trailing-``;`` difference is irrelevant.
-    import_heavy = False
-    if (is_java or is_kotlin) and n >= 3:
-        imp = sum(1 for L in lines if L.lstrip().startswith("import "))
-        import_heavy = imp / n >= 0.55
-
-    primary: str | None = None
-    head = "\n".join(lines[: min(80, n)])
-    if is_kotlin:
-        m = _KOTLIN_TYPE.search(head)
-        if m:
-            primary = m.group(1)
-    elif is_java:
-        m = _JAVA_TYPE.search(head)
-        if m:
-            primary = m.group(1)
-
-    return ChunkHints(
-        primary_type_hint=primary,
-        import_heavy=import_heavy,
-    )
-
-
-def looks_like_code_identifier(query: str) -> bool:
-    """PascalCase type name or SCREAMING_SNAKE constant — good candidates for FTS hybrid."""
-    q = query.strip()
-    if not q or len(q) < 2 or len(q) > 200:
-        return False
-    if re.fullmatch(r"[A-Z][a-zA-Z0-9_]*", q):
-        return True
-    if "_" in q and re.fullmatch(r"[A-Z][A-Z0-9_]*", q):
-        return True
-    return False

java_codebase_rag/ast/language.py

@@ -1,117 +0,0 @@
-"""Language-dispatch seam for AST extraction.
-
-A registry of ``LanguageBackend`` objects keyed by ``language_id``; each backend
-owns the source suffixes it claims (``.java`` always; ``.kt`` when the
-``tree-sitter-kotlin`` grammar imports) and a ``parse`` entry point returning a
-``JavaFileAst`` — the single AST shape shared by both languages (Kotlin reuses
-this surface; it does not introduce a separate type).
-
-Both backends parse into ``JavaFileAst``, so ``FileAst`` remains a direct alias
-for ``JavaFileAst``. The Kotlin backend is registered conditionally on the
-grammar wheel importing (see the ``try``/``except ImportError`` below); a
-minimal or graph-only install with no ``tree-sitter-kotlin`` simply has Java in
-the registry, and ``backend_for`` returns ``None`` for ``.kt``.
-
-Import cycle note: ``ast_java`` defines ``JavaFileAst`` whose ``__post_init__``
-validates against ``KNOWN_LANGUAGE_IDS`` (defined here). To keep the cycle
-one-directional, ``ast_java`` does NOT import this module at top level — it
-imports ``KNOWN_LANGUAGE_IDS`` lazily inside ``__post_init__``. This module
-freely imports from ``ast_java``.
-"""
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Protocol, runtime_checkable
-
-from java_codebase_rag.ast.ast_java import JavaFileAst, parse_java
-
-__all__ = [
-    "LanguageBackend",
-    "JavaBackend",
-    "LANG_BACKENDS",
-    "KNOWN_LANGUAGE_IDS",
-    "backend_for",
-    "FileAst",
-]
-
-
-@runtime_checkable
-class LanguageBackend(Protocol):
-    """A pluggable parser backend for one source language."""
-
-    language_id: str
-    suffixes: tuple[str, ...]
-
-    def parse(
-        self,
-        source: bytes | str,
-        *,
-        filename: str,
-        verbose: bool = False,
-    ) -> JavaFileAst: ...
-
-
-class JavaBackend:
-    """The Java backend — delegates to the existing tree-sitter ``parse_java``."""
-
-    language_id: str = "java"
-    suffixes: tuple[str, ...] = (".java",)
-
-    def parse(
-        self, source: bytes | str, *, filename: str = "", verbose: bool = False
-    ) -> JavaFileAst:
-        return parse_java(source, filename=filename, verbose=verbose)
-
-
-# Registry: language_id -> backend. Kotlin is appended conditionally on the
-# grammar wheel importing (try/except below), so minimal/graph-only installs
-# simply skip `.kt` files instead of crashing at import time.
-LANG_BACKENDS: dict[str, LanguageBackend] = {
-    "java": JavaBackend(),
-}
-
-# Conditional Kotlin registration. The grammar wheel (tree-sitter-kotlin) is an
-# optional dependency on some platforms (Intel-Mac graph-only installs); when it
-# is absent, KotlinBackend stays out of the registry and ``backend_for`` returns
-# ``None`` for ``.kt`` — the file is then skipped by every parse site.
-try:  # pragma: no cover - branch depends on whether the wheel is installed
-    import tree_sitter_kotlin as _ts_kotlin  # noqa: F401
-
-    from java_codebase_rag.ast.ast_kotlin import parse_kotlin as _parse_kotlin
-
-    class KotlinBackend:
-        """The Kotlin backend — delegates to ``parse_kotlin``."""
-
-        language_id: str = "kotlin"
-        suffixes: tuple[str, ...] = (".kt",)
-
-        def parse(
-            self, source: bytes | str, *, filename: str = "", verbose: bool = False
-        ) -> JavaFileAst:
-            return _parse_kotlin(source, filename=filename, verbose=verbose)
-
-    LANG_BACKENDS["kotlin"] = KotlinBackend()
-except ImportError:
-    pass
-
-# Derived from the registry so the two never drift apart.
-KNOWN_LANGUAGE_IDS: frozenset[str] = frozenset(LANG_BACKENDS.keys())
-
-
-def backend_for(path: Path | str) -> LanguageBackend | None:
-    """Return the first backend whose ``suffixes`` contain ``path``'s suffix.
-
-    Suffix matching is case-sensitive against ``Path(path).suffix``. Returns
-    ``None`` when no backend claims the file (e.g. ``.md``), or for a ``.kt``
-    file on an install where the ``tree-sitter-kotlin`` grammar is absent.
-    """
-    suffix = Path(path).suffix
-    for backend in LANG_BACKENDS.values():
-        if suffix in backend.suffixes:
-            return backend
-    return None
-
-
-# Single-language alias. Re-exported so downstream call sites can target the
-# generic name and stay source-stable when a Kotlin AST shape is introduced.
-FileAst = JavaFileAst