java-codebase-rag 0.11.2__py3-none-any.whl → 0.12.1__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,62 +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_]*)"
-)
-
-
-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()
-    is_java = kind == "java" or lang == "java"
-
-    import_heavy = False
-    if is_java 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
-    if is_java:
-        head = "\n".join(lines[: min(80, n)])
-        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