java-codebase-rag 0.1.0__py3-none-any.whl

java_codebase_rag-0.1.0.dist-info/RECORD

@@ -0,0 +1,27 @@
+ast_java.py,sha256=QIldCwZVFlJUu3BwBjjoHYAhu5Eas4dxMaAb3MSBWDg,98174
+brownfield_events.py,sha256=yxXkKDgMb3VPtaiakGzncHM_EGnda8xIue6w90yYp8s,2055
+build_ast_graph.py,sha256=jF3EzHxZUWOYfghI0RQHZskKmYOzBzi8eFebqlq4kNg,118019
+chunk_heuristics.py,sha256=aQk2NOKxzUdqoUAJUO3G3LE0MN_bYZWNLQ0tkmj5uts,1813
+graph_enrich.py,sha256=2-njD2alm7FFpLn217ZG3f3ln-zqbdtGwTghOpd44oo,62021
+index_common.py,sha256=HT6FKHFJ084eFvd3fR1j8z8gf4eWoPHVW8GXLpw464I,285
+java_index_flow_lancedb.py,sha256=LMmfMSdE2d-ujxuJ2-hss7BhkrUMxHNyZuqsiGITuAI,12057
+java_index_v1_common.py,sha256=nF1KrSqboF_RRvWerG9knRRFmWwsrG_CvhgnsoZ8KqA,1154
+java_ontology.py,sha256=nM-oY8_91rmUudv9hAss1AMus9BFY9s5tTpAWjlCz00,16424
+kuzu_queries.py,sha256=9bQzrU311AOw_BcUp_KSGiZgPVSaLSU7y63XfcT_vqI,90137
+mcp_hints.py,sha256=myzwhmXCtHzUcEjM8PbrCpxyEo1WfMEXJ5i6O-Syb7k,31686
+mcp_v2.py,sha256=939iHxEAxCRrvXIKJLOrpF_KMm0JLBkojFpMKeOnQIQ,76837
+path_filtering.py,sha256=-oX16SYLWYwX9pcV1fu3vbVTIhY1GzFflT7J1E2tqPY,17122
+pr_analysis.py,sha256=Zaq90xYgMgrReV3vCGcFhOkK61gIRMAAIgs7ev-rJG4,18410
+search_lancedb.py,sha256=-XgtpbJ_3zDLiZ_vGKXjaLpl7RlvgyzUb7oAGoWkXO0,36754
+server.py,sha256=lAsO3c8DMPsrB8tY7q9F9jbieqeDBI4vLnYcIJScHzk,25705
+java_codebase_rag/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+java_codebase_rag/cli.py,sha256=hCjlmAXkS80noTX_bxm6BMiLIYEz_P5xfrw9C7LvkBE,27678
+java_codebase_rag/cli_progress.py,sha256=Vtio3RqJ3LkRoNpxrv8iGbEiX4klkTlJX-mR4l6oeBM,1586
+java_codebase_rag/config.py,sha256=h07zJrV8QoLv9hIhJZ2JgUI0Rh6uPBZUiPkGDEmTg_w,11687
+java_codebase_rag/pipeline.py,sha256=QyKNCrBsjdFU71N9Xygti-DdtMQQsrZ8aySisux46lI,5311
+java_codebase_rag-0.1.0.dist-info/licenses/LICENSE,sha256=gxvtiHtuviR_q8ZAjWw-QTcF3DyPzg6ZY-lQrr8OPpw,1068
+java_codebase_rag-0.1.0.dist-info/METADATA,sha256=cR732vM6PVtmldy-CwOuailN5-fwMMJQ4Bi3mE5IcKo,51720
+java_codebase_rag-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+java_codebase_rag-0.1.0.dist-info/entry_points.txt,sha256=mVVQJa0n73OWfhHXYCDoPRrWin_LJhH2Rn0CkJ2iax4,101
+java_codebase_rag-0.1.0.dist-info/top_level.txt,sha256=5aIYoMkvJvvfXvf4iHn2OeSIM7PZXP-0j94eNESnwMw,242
+java_codebase_rag-0.1.0.dist-info/RECORD,,

java_codebase_rag-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

java_codebase_rag-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+java-codebase-rag = java_codebase_rag.cli:main
+java-codebase-rag-mcp = server:main

java_codebase_rag-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 HumanBean17
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

java_codebase_rag-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,17 @@
+ast_java
+brownfield_events
+build_ast_graph
+chunk_heuristics
+graph_enrich
+index_common
+java_codebase_rag
+java_index_flow_lancedb
+java_index_v1_common
+java_ontology
+kuzu_queries
+mcp_hints
+mcp_v2
+path_filtering
+pr_analysis
+search_lancedb
+server

java_index_flow_lancedb.py

@@ -0,0 +1,398 @@
+"""
+CocoIndex 1.0 app: index Java, Flyway SQL, and YAML into LanceDB.
+
+LanceDB requires a single primary key per table; each chunk gets a UUID `id`.
+
+Environment:
+  JAVA_CODEBASE_RAG_INDEX_DIR — Lance tables + Kuzu + cocoindex state (default: ./.java-codebase-rag)
+  JAVA_CODEBASE_RAG_SOURCE_ROOT — Java repo root for indexing (optional; else cocoindex cwd)
+  SBERT_MODEL / SBERT_DEVICE — embedding (optional; YAML also supported via java-codebase-rag CLI)
+
+Dependencies:
+  pip install "cocoindex[lancedb]" sentence-transformers
+
+Usage:
+  cocoindex update java_index_flow_lancedb.py:JavaCodeIndexLance --full-reprocess
+"""
+from __future__ import annotations
+
+import inspect
+import os
+import uuid
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Annotated, Any
+
+import cocoindex as coco
+import numpy as np
+import numpy.typing as npt
+import pyarrow as pa
+from cocoindex.connectors import lancedb, localfs
+from cocoindex.connectors.lancedb import LanceType
+from cocoindex.ops.sentence_transformers import SentenceTransformerEmbedder
+from cocoindex.ops.text import RecursiveSplitter, detect_code_language
+from cocoindex.resources.file import PatternFilePathMatcher
+
+from java_codebase_rag.config import resolved_sbert_model_for_process_env
+from java_index_v1_common import (
+    JAVA_CHUNK,
+    SBERT_MODEL,
+    SQL_CHUNK,
+    YAML_CHUNK,
+    chunk_key_range,
+    position_to_json,
+)
+from path_filtering import LayeredIgnore
+from ast_java import ONTOLOGY_VERSION, parse_java
+from graph_enrich import enrich_chunk
+
+# Older cocoindex (e.g. 1.0.0a43) uses ``tracked=False``; newer releases renamed
+# the flag to ``detect_change`` (default False) and reject ``tracked``.
+_ck_params = inspect.signature(coco.ContextKey.__init__).parameters
+if "detect_change" in _ck_params:
+    PROJECT_ROOT = coco.ContextKey[Path]("java_lance_project_root")
+    LANCE_DB = coco.ContextKey("java_lance_async_conn")
+    EMBEDDER = coco.ContextKey[SentenceTransformerEmbedder]("java_lance_embedder")
+elif "tracked" in _ck_params:
+    PROJECT_ROOT = coco.ContextKey[Path]("java_lance_project_root", tracked=False)
+    LANCE_DB = coco.ContextKey("java_lance_async_conn", tracked=False)
+    EMBEDDER = coco.ContextKey[SentenceTransformerEmbedder](
+        "java_lance_embedder", tracked=False
+    )
+else:
+    PROJECT_ROOT = coco.ContextKey[Path]("java_lance_project_root")
+    LANCE_DB = coco.ContextKey("java_lance_async_conn")
+    EMBEDDER = coco.ContextKey[SentenceTransformerEmbedder]("java_lance_embedder")
+
+splitter = RecursiveSplitter()
+
+
+@dataclass
+class JavaLanceChunk:
+    id: str
+    filename: str
+    language: str
+    text: str
+    range_start: int
+    range_end: int
+    start: dict[str, Any]
+    end: dict[str, Any]
+    embedding: Annotated[npt.NDArray[np.float32], EMBEDDER]
+    package: str
+    module: str
+    microservice: str
+    primary_type_fqn: str
+    primary_type_kind: str
+    role: str
+    # Native PyArrow lists: without the LanceType override CocoIndex would JSON-encode
+    # `list[str]` into a STRING column, which caller code then iterates character-by-character.
+    capabilities: Annotated[list[str], LanceType(pa.list_(pa.string()))]
+    annotations_on_type: Annotated[list[str], LanceType(pa.list_(pa.string()))]
+    symbols: Annotated[list[str], LanceType(pa.list_(pa.string()))]
+    ontology_version: int
+
+
+@dataclass
+class SqlLanceChunk:
+    id: str
+    filename: str
+    text: str
+    range_start: int
+    range_end: int
+    start: dict[str, Any]
+    end: dict[str, Any]
+    embedding: Annotated[npt.NDArray[np.float32], EMBEDDER]
+
+
+@dataclass
+class YamlLanceChunk:
+    id: str
+    filename: str
+    text: str
+    range_start: int
+    range_end: int
+    start: dict[str, Any]
+    end: dict[str, Any]
+    embedding: Annotated[npt.NDArray[np.float32], EMBEDDER]
+
+
+@coco.lifespan
+async def coco_lifespan(builder: coco.EnvironmentBuilder) -> AsyncIterator[None]:
+    idx_raw = os.environ.get("JAVA_CODEBASE_RAG_INDEX_DIR", "").strip()
+    if idx_raw and not idx_raw.startswith(("s3://", "gs://", "az://")):
+        index_dir = Path(idx_raw).expanduser().resolve()
+    else:
+        index_dir = (Path(".").resolve() / ".java-codebase-rag").resolve()
+    index_dir.mkdir(parents=True, exist_ok=True)
+    builder.settings.db_path = index_dir / "cocoindex.db"
+
+    env_root = os.environ.get("JAVA_CODEBASE_RAG_SOURCE_ROOT", "").strip()
+    if env_root:
+        root = Path(env_root).expanduser().resolve()
+    else:
+        root = Path(".").resolve()
+    builder.provide(PROJECT_ROOT, root)
+
+    embedder = SentenceTransformerEmbedder(
+        resolved_sbert_model_for_process_env(SBERT_MODEL),
+        device=os.environ.get("SBERT_DEVICE") or None,
+        trust_remote_code=True,
+    )
+    builder.provide(EMBEDDER, embedder)
+
+    uri = str(index_dir)
+
+    @asynccontextmanager
+    async def _lance_cm() -> AsyncIterator[Any]:
+        conn = await lancedb.connect_async(uri)
+        try:
+            yield conn
+        finally:
+            conn.close()
+
+    await builder.provide_async_with(LANCE_DB, _lance_cm())
+    yield
+
+
+@coco.fn(memo=True)
+async def process_java_file(
+    file: localfs.File,
+    table: lancedb.TableTarget[JavaLanceChunk],
+) -> None:
+    embedder = coco.use_context(EMBEDDER)
+    project_root = coco.use_context(PROJECT_ROOT)
+    if LayeredIgnore(project_root).is_ignored((project_root / file.file_path.path).resolve())[0]:
+        return
+    try:
+        content = await file.read_text()
+    except UnicodeDecodeError:
+        return
+    if not content.strip():
+        return
+
+    language = detect_code_language(filename=file.file_path.path.name) or "text"
+    cs, mn, ov = JAVA_CHUNK
+    chunks = splitter.split(
+        content,
+        cs,
+        min_chunk_size=mn,
+        chunk_overlap=ov,
+        language=language,
+    )
+    rel = file.file_path.path.as_posix()
+    content_bytes = content.encode("utf-8", errors="replace")
+    ast = parse_java(content_bytes)
+
+    for ch in chunks:
+        rs, re = chunk_key_range(ch)
+        enrich = enrich_chunk(
+            ast,
+            chunk_start_byte=ch.start.byte_offset,
+            chunk_end_byte=ch.end.byte_offset,
+            file_path=rel,
+            project_root=project_root,
+        )
+        emb = await embedder.embed(ch.text)
+        table.declare_row(
+            row=JavaLanceChunk(
+                id=str(uuid.uuid4()),
+                filename=rel,
+                language=language,
+                text=ch.text,
+                range_start=rs,
+                range_end=re,
+                start=position_to_json(ch.start),
+                end=position_to_json(ch.end),
+                embedding=emb,
+                package=enrich.package,
+                module=enrich.module,
+                microservice=enrich.microservice,
+                primary_type_fqn=enrich.primary_type_fqn,
+                primary_type_kind=enrich.primary_type_kind,
+                role=enrich.role,
+                capabilities=list(enrich.capabilities),
+                annotations_on_type=enrich.annotations_on_type,
+                symbols=enrich.symbols,
+                ontology_version=ONTOLOGY_VERSION,
+            )
+        )
+
+
+@coco.fn(memo=True)
+async def process_sql_file(
+    file: localfs.File,
+    table: lancedb.TableTarget[SqlLanceChunk],
+) -> None:
+    embedder = coco.use_context(EMBEDDER)
+    project_root = coco.use_context(PROJECT_ROOT)
+    if LayeredIgnore(project_root).is_ignored((project_root / file.file_path.path).resolve())[0]:
+        return
+    try:
+        content = await file.read_text()
+    except UnicodeDecodeError:
+        return
+    if not content.strip():
+        return
+
+    language = "sql"
+    cs, mn, ov = SQL_CHUNK
+    chunks = splitter.split(
+        content,
+        cs,
+        min_chunk_size=mn,
+        chunk_overlap=ov,
+        language=language,
+    )
+    rel = file.file_path.path.as_posix()
+
+    for ch in chunks:
+        rs, re = chunk_key_range(ch)
+        emb = await embedder.embed(ch.text)
+        table.declare_row(
+            row=SqlLanceChunk(
+                id=str(uuid.uuid4()),
+                filename=rel,
+                text=ch.text,
+                range_start=rs,
+                range_end=re,
+                start=position_to_json(ch.start),
+                end=position_to_json(ch.end),
+                embedding=emb,
+            )
+        )
+
+
+@coco.fn(memo=True)
+async def process_yaml_file(
+    file: localfs.File,
+    table: lancedb.TableTarget[YamlLanceChunk],
+) -> None:
+    embedder = coco.use_context(EMBEDDER)
+    project_root = coco.use_context(PROJECT_ROOT)
+    if LayeredIgnore(project_root).is_ignored((project_root / file.file_path.path).resolve())[0]:
+        return
+    try:
+        content = await file.read_text()
+    except UnicodeDecodeError:
+        return
+    if not content.strip():
+        return
+
+    ext = file.file_path.path.suffix.lower()
+    language = "yaml" if ext in (".yml", ".yaml") else "text"
+    cs, mn, ov = YAML_CHUNK
+    chunks = splitter.split(
+        content,
+        cs,
+        min_chunk_size=mn,
+        chunk_overlap=ov,
+        language=language,
+    )
+    rel = file.file_path.path.as_posix()
+
+    for ch in chunks:
+        rs, re = chunk_key_range(ch)
+        emb = await embedder.embed(ch.text)
+        table.declare_row(
+            row=YamlLanceChunk(
+                id=str(uuid.uuid4()),
+                filename=rel,
+                text=ch.text,
+                range_start=rs,
+                range_end=re,
+                start=position_to_json(ch.start),
+                end=position_to_json(ch.end),
+                embedding=emb,
+            )
+        )
+
+
+@coco.fn
+async def app_main() -> None:
+    java_schema = await lancedb.TableSchema.from_class(
+        JavaLanceChunk,
+        primary_key=["id"],
+    )
+    java_table = await lancedb.mount_table_target(
+        LANCE_DB,
+        "javacodeindex_java_code",
+        java_schema,
+    )
+
+    sql_schema = await lancedb.TableSchema.from_class(
+        SqlLanceChunk,
+        primary_key=["id"],
+    )
+    sql_table = await lancedb.mount_table_target(
+        LANCE_DB,
+        "sqlschemaindex_sql_schema",
+        sql_schema,
+    )
+
+    yaml_schema = await lancedb.TableSchema.from_class(
+        YamlLanceChunk,
+        primary_key=["id"],
+    )
+    yaml_table = await lancedb.mount_table_target(
+        LANCE_DB,
+        "yamlconfigindex_yaml_config",
+        yaml_schema,
+    )
+
+    project_root = coco.use_context(PROJECT_ROOT)
+    _ignore = LayeredIgnore(project_root)
+    _walk_excludes = _ignore.cocoindex_excluded_patterns()
+    java_files = localfs.walk_dir(
+        PROJECT_ROOT,
+        recursive=True,
+        path_matcher=PatternFilePathMatcher(
+            included_patterns=["**/*.java"],
+            excluded_patterns=_walk_excludes,
+        ),
+    )
+    sql_files = localfs.walk_dir(
+        PROJECT_ROOT,
+        recursive=True,
+        path_matcher=PatternFilePathMatcher(
+            included_patterns=["**/src/main/resources/db/migration/*.sql"],
+            excluded_patterns=_walk_excludes,
+        ),
+    )
+    yaml_files = localfs.walk_dir(
+        PROJECT_ROOT,
+        recursive=True,
+        path_matcher=PatternFilePathMatcher(
+            included_patterns=[
+                "**/src/main/resources/application*.yml",
+                "**/src/main/resources/application*.yaml",
+            ],
+            excluded_patterns=_walk_excludes,
+        ),
+    )
+
+    await coco.mount_each(
+        coco.component_subpath(coco.Symbol("java_files")),
+        process_java_file,
+        java_files.items(),
+        java_table,
+    )
+    await coco.mount_each(
+        coco.component_subpath(coco.Symbol("sql_files")),
+        process_sql_file,
+        sql_files.items(),
+        sql_table,
+    )
+    await coco.mount_each(
+        coco.component_subpath(coco.Symbol("yaml_files")),
+        process_yaml_file,
+        yaml_files.items(),
+        yaml_table,
+    )
+
+
+app = coco.App(
+    coco.AppConfig(name="JavaCodeIndexLance"),
+    app_main,
+)

java_index_v1_common.py

@@ -0,0 +1,33 @@
+"""Shared helpers for Java/SQL/YAML CocoIndex 1.0 apps (no ContextKeys here)."""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+
+from cocoindex.resources.chunk import Chunk, TextPosition
+
+# Hub id or absolute path to a local model dir (config.json + weights). Override with env SBERT_MODEL.
+_DEFAULT_HUB = "sentence-transformers/all-MiniLM-L6-v2"
+SBERT_MODEL = os.path.expandvars(os.path.expanduser(os.environ.get("SBERT_MODEL", _DEFAULT_HUB)))
+
+# Larger window + overlap so chunks carry more behavioural context (method bodies
+# rarely split mid-statement, fewer "orphan" import-only hits at chunk edges).
+# Requires re-index to apply.
+JAVA_CHUNK = (1500, 350, 220)
+SQL_CHUNK = (800, 100, 80)
+YAML_CHUNK = (600, 100, 60)
+
+
+def position_to_json(pos: TextPosition) -> dict[str, Any]:
+    return {
+        "byte_offset": pos.byte_offset,
+        "char_offset": pos.char_offset,
+        "line": pos.line,
+        "column": pos.column,
+    }
+
+
+def chunk_key_range(chunk: Chunk) -> tuple[int, int]:
+    """Byte range for stable primary keys (start inclusive, end exclusive)."""
+    return chunk.start.byte_offset, chunk.end.byte_offset