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

java_codebase_rag/ast/chunk_heuristics.py

@@ -22,6 +22,16 @@ _JAVA_TYPE = re.compile(
     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():
@@ -30,16 +40,27 @@ def analyze_chunk(text: str | None, *, language: str, kind: str) -> ChunkHints:
     lines = text.strip().split("\n")
     n = len(lines)
     lang = (language or "").lower()
-    is_java = kind == "java" or lang == "java"
-
+    # 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 and n >= 3:
+    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
-    if is_java:
-        head = "\n".join(lines[: min(80, n)])
+    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)

java_codebase_rag/ast/language.py

@@ -0,0 +1,117 @@
+"""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

java_codebase_rag/cli.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 # Heavy imports (`server`, `pr_analysis`, `path_filtering.LayeredIgnore`,
-# `build_ast_graph`) stay lazy inside handlers so `java-codebase-rag --help` stays fast.
+# `build_ast_graph`) stay lazy inside handlers so `jrag --help` stays fast.
 
 import argparse
 import asyncio
@@ -49,7 +49,7 @@ _INCREMENT_WARNING_LINES = (
     "Lance vector index has been updated incrementally and is current.",
     "",
     "For an up-to-date graph, run:",
-    "    java-codebase-rag reprocess",
+    "    jrag reprocess",
     "",
     "Track progress on LadybugDB incremental rebuild:",
     f"    {LADYBUG_INCREMENTAL_TRACKING_ISSUE_URL}",
@@ -61,14 +61,14 @@ _REFRESH_DEPRECATION = (
 )
 
 _REPROCESS_DRIFT_VECTORS_ONLY = (
-    "java-codebase-rag reprocess: rebuilt vectors only; graph (code_graph.lbug) was NOT rebuilt "
+    "jrag reprocess: rebuilt vectors only; graph (code_graph.lbug) was NOT rebuilt "
     "and may now reflect a stale source snapshot."
 )
 
 
 def _reprocess_drift_graph_only_line(index_dir: Path) -> str:
     return (
-        "java-codebase-rag reprocess: rebuilt graph only; vectors (Lance tables under "
+        "jrag reprocess: rebuilt graph only; vectors (Lance tables under "
         f"{index_dir}) were NOT rebuilt and may now reflect a stale source snapshot."
     )
 
@@ -98,10 +98,10 @@ def _is_graph_preflight_blocker(g: Any) -> bool:
 def _emit_reprocess_selective_tty(*, mode: str) -> None:
     if mode == "vectors":
         print("Rebuilt: vectors")
-        print("Skipped: graph (use `java-codebase-rag reprocess --graph-only` or `reprocess` to refresh)")
+        print("Skipped: graph (use `jrag reprocess --graph-only` or `reprocess` to refresh)")
     else:
         print("Rebuilt: graph")
-        print("Skipped: vectors (use `java-codebase-rag reprocess --vectors-only` or `reprocess` to refresh)")
+        print("Skipped: vectors (use `jrag reprocess --vectors-only` or `reprocess` to refresh)")
 
 
 def _reprocess_success_message(mode: str | None, payload: dict[str, Any]) -> str:
@@ -147,7 +147,7 @@ def _pipeline_header(subcommand: str, cfg: ResolvedOperatorConfig) -> None:
     root = cfg.source_root.resolve()
     idx = cfg.index_dir.resolve()
     print(
-        bold(f"java-codebase-rag {subcommand} {_PIPELINE_SEP} source={root} {_PIPELINE_SEP} index={idx}"),
+        bold(f"jrag {subcommand} {_PIPELINE_SEP} source={root} {_PIPELINE_SEP} index={idx}"),
         file=sys.stderr,
         flush=True,
     )
@@ -159,7 +159,7 @@ def _pipeline_footer(subcommand: str, started: float, exit_code: int) -> None:
     elapsed = time.perf_counter() - started
     marker = styled_check() if exit_code == 0 else styled_cross()
     print(
-        f"{marker} {bold(f'java-codebase-rag {subcommand} {_PIPELINE_SEP} finished in {elapsed:.2f}s')}"
+        f"{marker} {bold(f'jrag {subcommand} {_PIPELINE_SEP} finished in {elapsed:.2f}s')}"
         + (f" (exit={exit_code})" if exit_code != 0 else ""),
         file=sys.stderr,
         flush=True,
@@ -358,8 +358,8 @@ def _cmd_init(args: argparse.Namespace) -> int:
                 "success": False,
                 "message": (
                     "init refused: index paths already exist. "
-                    "Use `java-codebase-rag reprocess` to rebuild in place, "
-                    "or `java-codebase-rag erase --yes` then `init` for a clean slate."
+                    "Use `jrag reprocess` to rebuild in place, "
+                    "or `jrag erase --yes` then `init` for a clean slate."
                 ),
                 "non_empty_paths": paths,
             }
@@ -702,7 +702,7 @@ def _cmd_erase(args: argparse.Namespace) -> int:
     cfg.apply_to_os_environ()
     # Lazy import: build_ast_graph transitively pulls numpy/ladybug/pyarrow/
     # tree_sitter (~54ms), and these filenames are only needed on the erase path.
-    # Keeping it out of the top-level import lets `java-codebase-rag --help` (and
+    # Keeping it out of the top-level import lets `jrag --help` (and
     # every other command) stay fast -- see the lazy-import invariant atop this file.
     from java_codebase_rag.graph.build_ast_graph import BUILDER_OWNED_INDEX_FILES
     builder_paths = [cfg.ladybug_path.parent / name for name in BUILDER_OWNED_INDEX_FILES]
@@ -729,7 +729,7 @@ def _cmd_erase(args: argparse.Namespace) -> int:
     if not args.yes:
         if not sys.stdin.isatty():
             print(
-                "java-codebase-rag erase: non-interactive stdin; pass --yes to confirm.",
+                "jrag erase: non-interactive stdin; pass --yes to confirm.",
                 file=sys.stderr,
             )
             return 2
@@ -740,7 +740,7 @@ def _cmd_erase(args: argparse.Namespace) -> int:
             # (the Windows NUL device is a character device, so isatty() lies).
             # Treat it as a refusal instead of crashing with an EOF traceback.
             print(
-                "java-codebase-rag erase: non-interactive stdin; pass --yes to confirm.",
+                "jrag erase: non-interactive stdin; pass --yes to confirm.",
                 file=sys.stderr,
             )
             return 2
@@ -753,7 +753,7 @@ def _cmd_erase(args: argparse.Namespace) -> int:
         drop = run_cocoindex_drop(env, quiet=bool(args.quiet))
         if drop.returncode == 127:
             print(
-                "java-codebase-rag erase: cocoindex CLI not found next to this Python; "
+                "jrag erase: cocoindex CLI not found next to this Python; "
                 "skipped `cocoindex drop` — cocoindex.db (if any) was not removed by CocoIndex.",
                 file=sys.stderr,
             )
@@ -927,7 +927,7 @@ def _cmd_analyze_pr(args: argparse.Namespace) -> int:
 
 def build_parser() -> argparse.ArgumentParser:
     description = (
-        "java-codebase-rag — graph-native code intelligence for Java microservices.\n\n"
+        "jrag — graph-native code intelligence for Java microservices.\n\n"
         "Lifecycle commands stream subprocess progress to stderr (including relayed child stdout); "
         "--quiet suppresses that stream; stdout remains the machine-readable payload.\n\n"
         "Lifecycle (manage the index):\n"
@@ -942,7 +942,7 @@ def build_parser() -> argparse.ArgumentParser:
         "  unresolved-calls  List or aggregate receiver-failure call sites (not in CALLS).\n\n"
         "Analysis (work with code changes):\n"
         "  analyze-pr      Compute blast-radius + risk score for a unified diff.\n\n"
-        "Run `java-codebase-rag <command> --help` for command-specific options."
+        "Run `jrag <command> --help` for command-specific options."
     )
     parser = argparse.ArgumentParser(
         prog="java-codebase-rag",
@@ -1170,7 +1170,7 @@ def main(argv: list[str] | None = None) -> int:
             return 0
         return int(e.code) if isinstance(e.code, int) else 2
     except argparse.ArgumentError as exc:
-        print(f"java-codebase-rag: {exc}", file=sys.stderr)
+        print(f"jrag: {exc}", file=sys.stderr)
         return 2
     handler = getattr(args, "handler", None)
     if handler is None:

java_codebase_rag/cli_dispatch.py

@@ -0,0 +1,251 @@
+"""Unified ``jrag`` CLI dispatcher (Task 2 of the rename).
+
+The tool exposes two disjoint CLI surfaces that this module unifies behind a
+single ``jrag`` console-script entry point:
+
+* :mod:`java_codebase_rag.cli` — operator / lifecycle verbs (``init``,
+  ``install``, ``update``, ``increment``, ``reprocess``, ``erase``, ``meta``,
+  ``tables``, ``diagnose-ignore``, ``analyze-pr``, ``unresolved-calls``).
+* :mod:`java_codebase_rag.jrag` — agent verbs (``find``, ``search``,
+  ``inspect``, ``callers``, ``callees``, ``hierarchy``, ``watch``, ``status``,
+  … — 32 verbs total).
+
+Both modules already expose a zero-argument ``_console_script_main`` that
+reads ``sys.argv`` itself, performs its own startup (``raise_fd_limit``, UTF-8
+stdio, error handling), and calls ``sys.exit`` (via ``os._exit``). This
+dispatcher does NOT reimplement argparse, fd-limit, or error handling: it picks
+the target module and forwards. Letting the chosen ``_console_script_main`` run
+unwinds as normal, including its ``SystemExit`` / ``os._exit``.
+
+Routing contract
+----------------
+For an invocation ``[argv0, *args]``:
+
+* If any token in ``args`` is a member of :data:`OPERATOR_VERBS`, route to
+  ``cli._console_script_main``.
+* Else if any token is a member of :data:`AGENT_VERBS`, route to
+  ``jrag._console_script_main``.
+* Otherwise fall back to the identity default: the basename of ``argv0``.
+  ``jrag`` → ``jrag._console_script_main``; anything else (including the
+  legacy ``java-codebase-rag`` alias) → ``cli._console_script_main``.
+
+The "first matching verb" rule scans left-to-right and routes by *that* verb's
+set. Operator and agent verb sets are disjoint, so the scan is unambiguous.
+
+Known non-goal: if a global flag's value token happens to equal a verb name
+(e.g. a hypothetical ``--config find``), routing may follow the verb heuristic.
+Acceptable edge case — the alternative (a flag-aware parser) would duplicate
+argparse here, which the design explicitly forbids.
+
+Unified help contract
+---------------------
+For the canonical ``jrag`` identity, a top-level help request (``jrag``,
+``jrag --help``, ``jrag -h`` — i.e. ``-h``/``--help`` appears before any
+recognized verb, or no tokens at all) is served by :func:`_print_unified_help`:
+it prints the agent parser's full help (agent verbs + global flags) and
+appends a clearly labeled "Operator commands" section listing the operator
+verbs with one-line descriptions sourced from :func:`cli.build_parser`'s
+subparser choices. This makes ``jrag --help`` the single discovery surface for
+all 11+32 verbs, satisfying the unification design contract.
+
+The legacy ``java-codebase-rag`` alias does NOT get unified help: it keeps its
+pre-rename behavior (operator-only parser) for backward compatibility, since
+operators with shell scripts that parse ``java-codebase-rag --help`` output
+must not see new verbs appear under that alias.
+
+Before routing, :func:`maybe_warn_legacy_alias` runs once. It is a no-op
+unless the tool was invoked through a legacy alias in an interactive context
+(see :mod:`java_codebase_rag._deprecation`); in tests ``sys.stderr`` is not a
+TTY so it stays silent.
+"""
+from __future__ import annotations
+
+import argparse
+import sys
+from typing import Callable
+
+from java_codebase_rag import cli as _cli_mod
+from java_codebase_rag import jrag as _jrag_mod
+from java_codebase_rag._deprecation import _invoked_program_name
+from java_codebase_rag._deprecation import maybe_warn_legacy_alias
+
+__all__ = [
+    "OPERATOR_VERBS",
+    "AGENT_VERBS",
+    "_console_script_main",
+]
+
+#: Tokens that request top-level help. argparse's default help action accepts
+#: both ``-h`` and ``--help`` (neither parser disables ``add_help``).
+_HELP_TOKENS: frozenset[str] = frozenset({"-h", "--help"})
+
+
+#: Operator / lifecycle verbs. Must match ``cli.build_parser()``'s registered
+#: top-level subcommand choice names (drift-guarded by the test suite).
+#:
+#: Note: the rename design spec lists ``diagnose`` and ``unresolved`` here, but
+#: the parser actually registers ``diagnose-ignore`` and ``unresolved-calls``
+#: (the spec abbreviated the names). The drift-guard test pins the dispatcher
+#: to the parser's truth, so the hyphenated names are what we ship.
+OPERATOR_VERBS: frozenset[str] = frozenset(
+    {
+        "init",
+        "install",
+        "update",
+        "increment",
+        "reprocess",
+        "erase",
+        "meta",
+        "tables",
+        "diagnose-ignore",
+        "analyze-pr",
+        "unresolved-calls",
+    }
+)
+
+#: Agent verbs. Must match ``jrag.build_parser()``'s registered top-level
+#: subcommand choice names (drift-guarded by the test suite).
+AGENT_VERBS: frozenset[str] = frozenset(
+    {
+        "find",
+        "search",
+        "inspect",
+        "callers",
+        "callees",
+        "hierarchy",
+        "implementations",
+        "subclasses",
+        "overrides",
+        "overridden-by",
+        "dependents",
+        "impact",
+        "decompose",
+        "flow",
+        "dependencies",
+        "connection",
+        "outline",
+        "imports",
+        "microservices",
+        "map",
+        "conventions",
+        "overview",
+        "vocab-index",
+        "watch",
+        "status",
+        "http-routes",
+        "http-clients",
+        "producers",
+        "topics",
+        "jobs",
+        "listeners",
+        "entities",
+    }
+)
+
+
+def _is_unified_help_request() -> bool:
+    """True iff argv is a top-level help/no-args request.
+
+    Returns True when ``sys.argv[1:]`` is empty (no-args) OR contains
+    ``-h``/``--help`` as the first recognized token (i.e. before any verb).
+    Returns False as soon as a verb token is seen, so verb-specific help
+    (``jrag install --help``, ``jrag find --help``) still routes to the
+    verb's own parser. Also returns False for non-help requests such as
+    ``jrag --version`` (no help token, no verb — falls through to the
+    identity default).
+    """
+    rest = sys.argv[1:] if len(sys.argv) > 1 else []
+    if not rest:
+        return True
+    for token in rest:
+        if token in OPERATOR_VERBS or token in AGENT_VERBS:
+            return False
+        if token in _HELP_TOKENS:
+            return True
+    return False
+
+
+def _operator_subcommand_helps() -> list[tuple[str, str]]:
+    """Return ``[(verb, one_line_help), ...]`` for operator verbs, parser order.
+
+    Pulls the ``(metavar, help)`` of each ``_ChoicesPseudoAction`` registered
+    on ``cli.build_parser()``'s top-level subparsers action. Parser order
+    (lifecycle flow: ``init``, ``install``, ``update``, ...) is preserved
+    rather than sorting alphabetically.
+    """
+    parser = _cli_mod.build_parser()
+    for action in parser._actions:
+        if isinstance(action, argparse._SubParsersAction):
+            return [(ca.metavar, ca.help or "") for ca in action._choices_actions]
+    return []
+
+
+def _print_unified_help(stream=None) -> None:
+    """Print the canonical ``jrag`` unified help: agent verbs + operator verbs.
+
+    Prints the agent parser's full help (which already lists the 32 agent
+    verbs with one-line descriptions plus the global ``-h``/``--version``
+    options and the descriptive epilog), then appends a clearly labeled
+    "Operator commands (indexing & maintenance)" section listing the 11
+    operator verbs with their one-line descriptions sourced from
+    :func:`cli.build_parser`'s subparser choices.
+
+    Writes to ``stream`` (default ``sys.stdout``) and returns without exiting
+    — the caller (``_console_script_main``) returns to the pip wrapper, which
+    exits 0.
+    """
+    target = stream if stream is not None else sys.stdout
+    agent_parser = _jrag_mod.build_parser()
+    agent_parser.print_help(target)
+    target.write("\n")
+    target.write(
+        "Operator commands (indexing & maintenance; run `jrag <command> --help` "
+        "for details):\n"
+    )
+    for name, help_text in _operator_subcommand_helps():
+        target.write(f"    {name:<20} {help_text}\n")
+
+
+def _choose_target() -> Callable[[], None]:
+    """Pick the ``_console_script_main`` to delegate to.
+
+    Scans ``sys.argv[1:]`` left-to-right for the first token that is a member
+    of ``OPERATOR_VERBS`` or ``AGENT_VERBS``; routes by that set. If no token
+    matches, routes by identity default (``jrag`` basename → jrag; anything
+    else → cli, including the legacy ``java-codebase-rag`` alias).
+    """
+    rest = sys.argv[1:] if len(sys.argv) > 1 else []
+    for token in rest:
+        if token in OPERATOR_VERBS:
+            return _cli_mod._console_script_main
+        if token in AGENT_VERBS:
+            return _jrag_mod._console_script_main
+
+    # No verb token: identity default by argv[0] basename.
+    if _invoked_program_name() == "jrag":
+        return _jrag_mod._console_script_main
+    return _cli_mod._console_script_main
+
+
+def _console_script_main() -> None:
+    """Unified ``jrag`` entry point: warn, maybe serve unified help, delegate.
+
+    For the canonical ``jrag`` identity with a top-level help/no-args request,
+    print the unified help (agent verbs + operator verbs) and return — the pip
+    wrapper then exits 0. This is the discovery surface for all verbs.
+
+    Otherwise: pick the target module and forward. The chosen target's
+    ``_console_script_main`` does its own startup and terminates the process
+    (via ``os._exit``); we let ``SystemExit`` propagate rather than
+    reimplementing startup here.
+    """
+    maybe_warn_legacy_alias()
+    if _invoked_program_name() == "jrag" and _is_unified_help_request():
+        _print_unified_help()
+        return
+    target = _choose_target()
+    target()
+
+
+if __name__ == "__main__":  # pragma: no cover - direct invocation
+    _console_script_main()

java_codebase_rag/config.py

@@ -125,7 +125,7 @@ def maybe_expand_embedding_model_path(
     expanded = os.path.expandvars(os.path.expanduser(value))
     if _UNRESOLVED_VAR_RE.search(expanded):
         print(
-            f"java-codebase-rag: path-shaped model string contains unresolved variable: {expanded}",
+            f"jrag: path-shaped model string contains unresolved variable: {expanded}",
             file=sys.stderr,
         )
     if expanded.startswith(("./", "../")):
@@ -191,7 +191,7 @@ def emit_legacy_env_hints_if_present() -> None:
             continue
         _legacy_hint_seen.add(key)
         print(
-            f"java-codebase-rag: {old} is set but no longer read; use {replacement}.",
+            f"jrag: {old} is set but no longer read; use {replacement}.",
             file=sys.stderr,
         )
 
@@ -208,7 +208,7 @@ def emit_legacy_yaml_hint_if_needed(source_root: Path) -> None:
         if (source_root / name).is_file():
             _legacy_yaml_hint_roots.add(root_s)
             print(
-                "java-codebase-rag: found legacy "
+                "jrag: found legacy "
                 f"{name}; rename to .java-codebase-rag.yml to re-enable config.",
                 file=sys.stderr,
             )
@@ -299,7 +299,7 @@ def _config_dir_from_pointer(anchor: Path) -> Path | None:
         if key not in _stale_pointer_seen:
             _stale_pointer_seen.add(key)
             print(
-                "java-codebase-rag: ignoring stale index pointer "
+                "jrag: ignoring stale index pointer "
                 f"{pointer} -> {raw} (target missing or not a config file).",
                 file=sys.stderr,
             )
@@ -343,7 +343,7 @@ def load_yaml_mapping(source_root: Path) -> dict[str, Any]:
         # tuple restores the graceful-degradation contract while still surfacing the
         # problem on stderr.
         print(
-            f"java-codebase-rag: could not load config {path}: {exc}; ignoring config.",
+            f"jrag: could not load config {path}: {exc}; ignoring config.",
             file=sys.stderr,
         )
         return {}
@@ -713,21 +713,21 @@ def resolve_operator_config(
     # Inline floors/validation (mirror the existing graceful-degradation style).
     if w_debounce < 100:
         print(
-            f"java-codebase-rag: watch.debounce_ms={w_debounce} is below the 100 ms "
+            f"jrag: watch.debounce_ms={w_debounce} is below the 100 ms "
             "floor; falling back to 1500.",
             file=sys.stderr,
         )
         w_debounce, w_debounce_src = 1500, "default"
     if w_backend not in ("auto", "watchdog", "polling"):
         print(
-            f"java-codebase-rag: watch.backend={w_backend!r} is not one of "
+            f"jrag: watch.backend={w_backend!r} is not one of "
             "auto/watchdog/polling; falling back to 'auto'.",
             file=sys.stderr,
         )
         w_backend, w_backend_src = "auto", "default"
     if w_poll < 200:
         print(
-            f"java-codebase-rag: watch.poll_interval_ms={w_poll} is below the 200 ms "
+            f"jrag: watch.poll_interval_ms={w_poll} is below the 200 ms "
             "floor; falling back to 2000.",
             file=sys.stderr,
         )

java_codebase_rag/eval/runner.py

@@ -8,7 +8,7 @@ sentence_transformers) and invokes the operator CLI to build a real index.
 Pipeline (``run_eval``):
 
 1. Build a fresh index into ``cfg.index_dir`` via the operator CLI
-   (``java-codebase-rag init``) as a **subprocess** — the stable operator
+   (``jrag init``) as a **subprocess** — the stable operator
    surface. Reaching into cocoindex/pipeline internals is fragile (process env,
    progress renderers), so the subprocess wins on robustness. A non-zero exit
    surfaces stdout/stderr in the raised ``RuntimeError``.
@@ -159,7 +159,7 @@ class EvalReport:
 
 
 def _build_index_subprocess(*, corpus_dir: str, index_dir: str) -> None:
-    """Build a fresh index via ``java-codebase-rag init``.
+    """Build a fresh index via ``jrag init``.
 
     Raises FileNotFoundError if the corpus is missing, RuntimeError on a
     non-zero CLI exit (surfacing clipped stdout/stderr).
@@ -196,7 +196,7 @@ def _build_index_subprocess(*, corpus_dir: str, index_dir: str) -> None:
     )
     if proc.returncode != 0:
         raise RuntimeError(
-            f"java-codebase-rag init exited {proc.returncode} for corpus {corpus_dir}.\n"
+            f"jrag init exited {proc.returncode} for corpus {corpus_dir}.\n"
             f"--- stdout (clipped 8000) ---\n{proc.stdout[-8000:]}\n"
             f"--- stderr (clipped 8000) ---\n{proc.stderr[-8000:]}"
         )