java-codebase-rag 0.5.3__py3-none-any.whl → 0.6.1__py3-none-any.whl

java_codebase_rag/lance_optimize.py

@@ -0,0 +1,148 @@
+"""Serialized post-flow LanceDB optimize with commit-conflict retry.
+
+cocoindex 1.0.7 schedules ``table.optimize()`` (a LanceDB **Rewrite**/compaction
+transaction) as a *background* ``asyncio`` task that races concurrent
+``table.delete()`` (**Delete**) transactions emitted by later mutation batches.
+LanceDB does not allow a Rewrite to commit concurrently with a Delete
+(upstream lancedb#1504 — "We do not support concurrent deletes right now"),
+which surfaces as a flood of::
+
+    RuntimeError: lance error: Retryable commit conflict for version N: \
+This Rewrite transaction was preempted by concurrent transaction Delete ...
+
+To eliminate the race, the flow (``java_index_flow_lancedb.py``) disables the
+in-flight background optimize entirely by raising
+``num_transactions_before_optimize`` to a value that is effectively never
+reached. This module then performs a *single*, serialized optimize after the
+flow returns (exit 0 → no concurrent writers), retrying the rare residual
+commit conflict that two internal compaction passes can still produce.
+"""
+from __future__ import annotations
+
+import asyncio
+import sys
+from pathlib import Path
+
+# Single source of truth for the three Lance table names created by the flow.
+# Keep in sync with ``search_lancedb.TABLES`` (the values there mirror these).
+LANCE_TABLE_NAMES: tuple[str, ...] = (
+    "javacodeindex_java_code",
+    "sqlschemaindex_sql_schema",
+    "yamlconfigindex_yaml_config",
+)
+
+# Commit conflicts are transient; a handful of exponential-backoff retries is
+# enough because, post-flow, there are no concurrent writers — only successive
+# optimize/compaction passes within this single serialized call can still
+# transiently preempt one another.
+_MAX_ATTEMPTS = 6
+_BASE_BACKOFF_S = 0.1
+
+# Substrings identifying the retryable Lance commit-conflict error. LanceDB
+# wraps the underlying lance error text into the raised ``RuntimeError`` str,
+# so a substring match is the robust detector (no dedicated exception type).
+_RETRYABLE_MARKERS = (
+    "Retryable commit conflict",
+    "preempted by concurrent transaction",
+)
+
+
+def _is_retryable(exc: BaseException) -> bool:
+    text = str(exc)
+    return any(marker in text for marker in _RETRYABLE_MARKERS)
+
+
+async def _list_table_names(db: object) -> set[str]:
+    """Existing table names across LanceDB API variants (``list_tables`` ≥ ``table_names``)."""
+    if hasattr(db, "list_tables"):
+        response = await db.list_tables()
+        return set(getattr(response, "tables", response))
+    return set(await db.table_names())
+
+
+async def optimize_lance_tables(index_dir: Path, *, quiet: bool = False) -> dict[str, str]:
+    """Optimize all known Lance tables under *index_dir*, serially, with retry.
+
+    Runs ``table.optimize()`` for each name in :data:`LANCE_TABLE_NAMES` that
+    exists in the DB. Retryable commit conflicts are retried with exponential
+    backoff; any other exception (or an exhausted retry budget) is captured
+    per-table in the returned dict and logged to **stderr** — never stdout,
+    since this is callable from stdio-MCP / JSON-stdout contexts.
+
+    Args:
+        index_dir: directory holding the Lance tables (the flow's LanceDB URI).
+        quiet: when True, suppress the per-table success/skip info lines on
+            stderr (errors are always logged).
+
+    Returns:
+        Mapping of table name → status. Values are ``"ok"``, ``"skipped"``
+        (table absent — e.g. a repo with no SQL/YAML), or ``"error: <text>"``.
+    """
+    # Lazy import: the flow imports this module for LANCE_TABLE_NAMES and must
+    # not pay the lancedb import cost at flow-definition time.
+    import lancedb
+
+    results: dict[str, str] = {}
+    db = await lancedb.connect_async(str(index_dir))
+    try:
+        try:
+            existing = await _list_table_names(db)
+        except Exception as exc:
+            print(
+                f"java-codebase-rag: optimize: failed to list tables in "
+                f"{index_dir}: {exc}",
+                file=sys.stderr,
+            )
+            return {name: f"error: list failed: {exc}" for name in LANCE_TABLE_NAMES}
+
+        for name in LANCE_TABLE_NAMES:
+            if name not in existing:
+                results[name] = "skipped"
+                if not quiet:
+                    print(
+                        f"java-codebase-rag: optimize: {name} absent, skipped",
+                        file=sys.stderr,
+                    )
+                continue
+            try:
+                table = await db.open_table(name)
+            except Exception as exc:
+                results[name] = f"error: open failed: {exc}"
+                print(
+                    f"java-codebase-rag: optimize: {name} open failed: {exc}",
+                    file=sys.stderr,
+                )
+                continue
+
+            last_exc: BaseException | None = None
+            for attempt in range(_MAX_ATTEMPTS):
+                try:
+                    await table.optimize()
+                    last_exc = None
+                    break
+                except Exception as exc:
+                    last_exc = exc
+                    if _is_retryable(exc) and attempt < _MAX_ATTEMPTS - 1:
+                        await asyncio.sleep(_BASE_BACKOFF_S * (2**attempt))
+                        continue
+                    # Non-retryable, or retries exhausted: stop the loop and
+                    # surface below — do not swallow silently.
+                    break
+
+            if last_exc is None:
+                results[name] = "ok"
+                if not quiet:
+                    print(
+                        f"java-codebase-rag: optimize: {name} ok",
+                        file=sys.stderr,
+                    )
+            else:
+                results[name] = f"error: {last_exc}"
+                print(
+                    f"java-codebase-rag: optimize: {name} failed: {last_exc}",
+                    file=sys.stderr,
+                )
+    finally:
+        # ``AsyncConnection.close`` is a *sync* method in lancedb 0.30.x.
+        db.close()
+    return results

java_codebase_rag/pipeline.py

@@ -1,6 +1,7 @@
 """Subprocess helpers for cocoindex + graph builder (no heavy ML imports at import time)."""
 from __future__ import annotations
 
+import asyncio
 import os
 import shutil
 import subprocess
@@ -11,6 +12,7 @@ from pathlib import Path
 
 from java_codebase_rag.cli_format import Spinner, is_noise_line, stderr_is_tty
 from java_codebase_rag.cli_progress import emit_vectors_finish, emit_vectors_start
+from java_codebase_rag.config import cocoindex_subprocess_env_defaults
 
 COCOINDEX_TARGET = "java_index_flow_lancedb.py:JavaCodeIndexLance"
 
@@ -110,6 +112,57 @@ def run_cocoindex_update(
     quiet: bool,
     verbose: bool = True,
     lance_project_root: Path | None = None,
+) -> subprocess.CompletedProcess[str]:
+    result = _run_cocoindex_update_impl(
+        env,
+        full_reprocess=full_reprocess,
+        quiet=quiet,
+        verbose=verbose,
+        lance_project_root=lance_project_root,
+    )
+    # After cocoindex returns exit 0 there are no concurrent writers, so this
+    # is the safe window to compact the Lance tables. The flow disabled its
+    # in-flight background optimize (see java_index_flow_lancedb.py), making
+    # this serialized pass the sole optimizer. Optimize failure does not flip
+    # the cocoindex CompletedProcess (a successful index is still usable, just
+    # not compacted); the outcome is logged to stderr only.
+    if result.returncode == 0:
+        _maybe_run_serialized_optimize(env, quiet=quiet)
+    return result
+
+
+def _maybe_run_serialized_optimize(env: dict[str, str], *, quiet: bool) -> None:
+    """Resolve the index dir from *env* and run the serialized Lance optimize.
+
+    The flow's lifespan reads ``JAVA_CODEBASE_RAG_INDEX_DIR`` (set by the CLI /
+    config.subprocess_env), so it is guaranteed present when cocoindex ran.
+    If it is somehow absent we skip optimize with a stderr warning rather than
+    crash — a successful index is still searchable un-compacted.
+    """
+    idx_raw = env.get("JAVA_CODEBASE_RAG_INDEX_DIR", "").strip()
+    if not idx_raw:
+        print(
+            "java-codebase-rag: optimize skipped — JAVA_CODEBASE_RAG_INDEX_DIR "
+            "not set in subprocess env",
+            file=sys.stderr,
+        )
+        return
+    try:
+        from java_codebase_rag.lance_optimize import optimize_lance_tables
+
+        asyncio.run(optimize_lance_tables(Path(idx_raw), quiet=quiet))
+    except Exception as exc:
+        # Never crash the CLI on an optimize failure — surface on stderr only.
+        print(f"java-codebase-rag: optimize failed: {exc}", file=sys.stderr)
+
+
+def _run_cocoindex_update_impl(
+    env: dict[str, str],
+    *,
+    full_reprocess: bool,
+    quiet: bool,
+    verbose: bool = True,
+    lance_project_root: Path | None = None,
 ) -> subprocess.CompletedProcess[str]:
     exe = cocoindex_bin()
     if not exe.is_file():
@@ -128,10 +181,11 @@ def run_cocoindex_update(
             stdout="",
             stderr=f"java_index_flow_lancedb.py not found under {bd}",
         )
-    # Set CocoIndex concurrency limits to prevent "too many open files" error
-    # See: https://github.com/HumanBean17/java-codebase-rag/issues/293
+    # Cap CocoIndex concurrency to avoid EMFILE ("too many open files") under
+    # default OS fd limits. See: https://github.com/HumanBean17/java-codebase-rag/issues/306
     env = env.copy()
-    env.setdefault("COCOINDEX_SOURCE_MAX_INFLIGHT_ROWS", "256")
+    for _k, _v in cocoindex_subprocess_env_defaults().items():
+        env.setdefault(_k, _v)
     cmd: list[str] = [str(exe), "update", COCOINDEX_TARGET]
     if full_reprocess:
         cmd.extend(["--full-reprocess", "-f"])
@@ -201,7 +255,7 @@ def run_cocoindex_drop(env: dict[str, str], *, quiet: bool) -> subprocess.Comple
 def run_build_ast_graph(
     *,
     source_root: Path,
-    kuzu_path: Path,
+    ladybug_path: Path,
     verbose: bool,
     quiet: bool = False,
     env: dict[str, str] | None = None,
@@ -219,8 +273,8 @@ def run_build_ast_graph(
         str(builder),
         "--source-root",
         str(source_root),
-        "--kuzu-path",
-        str(kuzu_path),
+        "--ladybug-path",
+        str(ladybug_path),
     ]
     # Three-tier: --quiet (silent) / default (filtered progress) / --verbose (raw).
     # Default passes --verbose so the builder emits per-pass progress lines,
@@ -254,7 +308,7 @@ def run_build_ast_graph(
 def run_incremental_graph(
     *,
     source_root: Path,
-    kuzu_path: Path,
+    ladybug_path: Path,
     verbose: bool,
     quiet: bool = False,
     env: dict[str, str] | None = None,
@@ -273,8 +327,8 @@ def run_incremental_graph(
         str(builder),
         "--source-root",
         str(source_root),
-        "--kuzu-path",
-        str(kuzu_path),
+        "--ladybug-path",
+        str(ladybug_path),
         "--incremental",
     ]
     # Three-tier: --quiet (silent) / default (filtered progress) / --verbose (raw).

{java_codebase_rag-0.5.3.dist-info → java_codebase_rag-0.6.1.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: java-codebase-rag
-Version: 0.5.3
+Version: 0.6.1
 Summary: MCP server for semantic + structural search over Java codebases
 Author: HumanBean17
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/HumanBean17/java-codebase-rag
 Project-URL: Repository, https://github.com/HumanBean17/java-codebase-rag
 Project-URL: Issues, https://github.com/HumanBean17/java-codebase-rag/issues
-Keywords: mcp,java,rag,code-search,graph,lancedb,kuzu
+Keywords: mcp,java,rag,code-search,graph,lancedb,ladybug
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3
@@ -19,7 +19,7 @@ Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: cocoindex[lancedb]<2,>=1.0.0a43
-Requires-Dist: kuzu<0.12,>=0.11.3
+Requires-Dist: ladybug<0.18,>=0.17.1
 Requires-Dist: lancedb<0.31,>=0.25.3
 Requires-Dist: mcp<2,>=1.27.0
 Requires-Dist: numpy<2.5,>=1.26.4
@@ -35,6 +35,7 @@ Requires-Dist: unidiff<1,>=0.7.3
 Provides-Extra: dev
 Requires-Dist: pytest>=7; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.21; extra == "dev"
+Requires-Dist: pytest-xdist>=3; extra == "dev"
 Requires-Dist: ruff>=0.4; extra == "dev"
 Dynamic: license-file
 
@@ -103,7 +104,7 @@ java-codebase-rag install
 java-codebase-rag install --non-interactive --agent claude-code
 ```
 
-After `pip install --upgrade java-codebase-rag`, run `java-codebase-rag update` to refresh shipped artifacts.
+After `pip install --upgrade java-codebase-rag`, run `java-codebase-rag update` to refresh shipped artifacts and catch up the index (Lance + graph).
 
 ### Manual registration
 
@@ -235,7 +236,7 @@ Run `java-codebase-rag --help` to list grouped subcommands. Operator playbook wi
 | Group | Subcommand | What it does |
 |---|---|---|
 | Setup | `install` | Interactive setup wizard: config, MCP registration, skill/agent deployment, indexing. |
-| Setup | `update` | Refresh shipped artifacts (skill, agent, MCP entry) after pip upgrade. |
+| Setup | `update` | Refresh shipped artifacts (skill, agent, MCP entry) + incremental Lance/graph catch-up after pip upgrade. |
 | Lifecycle | `init` | First-time index. Refuses if artifacts already exist. |
 | Lifecycle | `increment` | CocoIndex catch-up + incremental Kuzu update. `--vectors-only` for Lance only. |
 | Lifecycle | `reprocess` | Full Lance + Kuzu rebuild. `--vectors-only` / `--graph-only` for a single phase. |

java_codebase_rag-0.6.1.dist-info/RECORD

@@ -0,0 +1,36 @@
+ast_java.py,sha256=NQgZzstbsMq-PdowoD6r_ixJKxEEFzTP9xUzqDpiXeU,99661
+brownfield_events.py,sha256=yxXkKDgMb3VPtaiakGzncHM_EGnda8xIue6w90yYp8s,2055
+build_ast_graph.py,sha256=OKigswkUmWwUAKXXRNH4zplw2VonIdWUWzVjC-t5roo,152893
+chunk_heuristics.py,sha256=aQk2NOKxzUdqoUAJUO3G3LE0MN_bYZWNLQ0tkmj5uts,1813
+graph_enrich.py,sha256=POT4LwSkTsrjUmP67bsm2UezUam70cunuPDYDh-v1Bs,63332
+index_common.py,sha256=HT6FKHFJ084eFvd3fR1j8z8gf4eWoPHVW8GXLpw464I,285
+java_index_flow_lancedb.py,sha256=MH9iTNF6HDHDTt5Jn7TOVE5hQ4WUPNt7PlQoh1tuh9o,13212
+java_index_v1_common.py,sha256=nF1KrSqboF_RRvWerG9knRRFmWwsrG_CvhgnsoZ8KqA,1154
+java_ontology.py,sha256=71bCLDNvMy0SpZPzSR5apJ0qJXNd6y5ggkLdBEw_PFo,16682
+kuzu_queries.py,sha256=9bQzrU311AOw_BcUp_KSGiZgPVSaLSU7y63XfcT_vqI,90137
+ladybug_queries.py,sha256=912j9VAYDjcU4ReVorWQ6R4DZl0tteKic-Pqu0jyBS0,90837
+mcp_hints.py,sha256=3swh05LSiWur3tm3-yssndBsLxIxFhy501kBtJI8jJ0,42509
+mcp_v2.py,sha256=o94GJI7j6dLJDIA3R_1ZiQhjzQfMAEW3etdeZYnHOUc,80637
+path_filtering.py,sha256=-oX16SYLWYwX9pcV1fu3vbVTIhY1GzFflT7J1E2tqPY,17122
+pr_analysis.py,sha256=3-5L8_G5XupdJsl9RN73Lq-ejPoK11B3m_VzAx2fGG8,18413
+search_lancedb.py,sha256=scG6HBUrsgIeSWFrGcLcGdhWv1qODOx4JOBMAlLDY_E,36793
+server.py,sha256=Js3XDpV7ThAtj352StH6QdhHutf1D5qUkbR-8k3jO8g,31303
+java_codebase_rag/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+java_codebase_rag/_fdlimit.py,sha256=WroFdfSNbcriKok6q8znTf74dqlznxea_1Fd5bHl_3o,1930
+java_codebase_rag/cli.py,sha256=a5IFLWAsh77mfLv1Z9OdpvLaYvj4i0KR3_kLtL-ans8,34156
+java_codebase_rag/cli_format.py,sha256=arU7P9W6Fvm7X_wzR1wJ8EfyxK1rDP_ESEhdA0ub4Mo,2579
+java_codebase_rag/cli_progress.py,sha256=9jCqEagYOXs32SYVA31_sOCrONvYy7cl1CrdBD2Pg44,3168
+java_codebase_rag/config.py,sha256=Gn3LgxkTOtAvsL-3U2Xn7atOIhyOT2aGmY8SBBTLoQg,16975
+java_codebase_rag/installer.py,sha256=DlBuVVWbHXgcjaQkuXUeT9fNdmk7XZefVT3zzw47k18,45965
+java_codebase_rag/lance_optimize.py,sha256=MzACYlgwxmkJCK64qQLyIAdizSq5BARqaMYSZONlc1I,6069
+java_codebase_rag/pipeline.py,sha256=UcgluFAW9Ghnas8u40x45bVic0mQv6rjzcliDKsnYJI,11936
+java_codebase_rag/install_data/agents/explorer-rag-enhanced.md,sha256=APl9d-No12qZNZLjU7mwNRwxHIgnT3ZtQZiD4clWlyU,14413
+java_codebase_rag/install_data/skills/explore-codebase/SKILL.md,sha256=pIM-Xdwq_fXkhhBJCdb-fA2nes5c_mMPcdUXb7Adyxo,12040
+java_codebase_rag-0.6.1.dist-info/licenses/LICENSE,sha256=gxvtiHtuviR_q8ZAjWw-QTcF3DyPzg6ZY-lQrr8OPpw,1068
+user_rag/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+user_rag/cli.py,sha256=TVcyfzwvmdYXJW6KrEYTKMHm7z2JSXMmz2uB-8kkjxY,5604
+java_codebase_rag-0.6.1.dist-info/METADATA,sha256=aPiLbGD8xE-P3B_RI9gx7VuqrTd-VUriZ--ZPYNK02I,16934
+java_codebase_rag-0.6.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+java_codebase_rag-0.6.1.dist-info/entry_points.txt,sha256=mVVQJa0n73OWfhHXYCDoPRrWin_LJhH2Rn0CkJ2iax4,101
+java_codebase_rag-0.6.1.dist-info/top_level.txt,sha256=syQgi8XPBwY2ws_NZ1uRCxTf_s41NpshwEHNdcdnk3A,245
+java_codebase_rag-0.6.1.dist-info/RECORD,,

{java_codebase_rag-0.5.3.dist-info → java_codebase_rag-0.6.1.dist-info}/top_level.txt

@@ -8,7 +8,7 @@ java_codebase_rag
 java_index_flow_lancedb
 java_index_v1_common
 java_ontology
-kuzu_queries
+ladybug_queries
 mcp_hints
 mcp_v2
 path_filtering

java_index_flow_lancedb.py

@@ -4,7 +4,7 @@ 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_INDEX_DIR — Lance tables + LadybugDB + 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)
 
@@ -36,6 +36,7 @@ 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_codebase_rag.lance_optimize import LANCE_TABLE_NAMES
 from java_index_v1_common import (
     JAVA_CHUNK,
     SBERT_MODEL,
@@ -68,6 +69,20 @@ else:
 
 splitter = RecursiveSplitter()
 
+# cocoindex 1.0.7 schedules ``table.optimize()`` (a LanceDB Rewrite/compaction
+# transaction) as a *background* asyncio task after every
+# ``num_transactions_before_optimize`` mutation batches (default 50). That
+# background Rewrite races the concurrent ``table.delete()`` (Delete)
+# transactions emitted by later batches, and LanceDB does not allow a Rewrite
+# to commit concurrently with a Delete (upstream lancedb#1504), which floods
+# stderr with "Retryable commit conflict ... preempted by concurrent
+# transaction Delete". Setting this effectively to infinity disables the
+# in-flight background optimize; the serialized post-flow optimize in
+# ``lance_optimize.optimize_lance_tables`` then compacts the table with no
+# concurrent writers. ``optimize()`` is pure maintenance (compact/prune/index);
+# upsert/delete correctness via merge_insert does not depend on it.
+_NUM_TXN_BEFORE_OPTIMIZE = 10**12
+
 
 @dataclass
 class JavaLanceChunk:
@@ -317,8 +332,9 @@ async def app_main() -> None:
     )
     java_table = await lancedb.mount_table_target(
         LANCE_DB,
-        "javacodeindex_java_code",
+        LANCE_TABLE_NAMES[0],
         java_schema,
+        num_transactions_before_optimize=_NUM_TXN_BEFORE_OPTIMIZE,
     )
 
     sql_schema = await lancedb.TableSchema.from_class(
@@ -327,8 +343,9 @@ async def app_main() -> None:
     )
     sql_table = await lancedb.mount_table_target(
         LANCE_DB,
-        "sqlschemaindex_sql_schema",
+        LANCE_TABLE_NAMES[1],
         sql_schema,
+        num_transactions_before_optimize=_NUM_TXN_BEFORE_OPTIMIZE,
     )
 
     yaml_schema = await lancedb.TableSchema.from_class(
@@ -337,8 +354,9 @@ async def app_main() -> None:
     )
     yaml_table = await lancedb.mount_table_target(
         LANCE_DB,
-        "yamlconfigindex_yaml_config",
+        LANCE_TABLE_NAMES[2],
         yaml_schema,
+        num_transactions_before_optimize=_NUM_TXN_BEFORE_OPTIMIZE,
     )
 
     project_root = coco.use_context(PROJECT_ROOT)

java_ontology.py

@@ -15,7 +15,10 @@ from ast_java import (
     _TYPE_ANN_TO_CAPABILITY,
 )
 
-# Roles: Spring stereotype values plus DTO from `infer_role_for_type`.
+# Roles assignable by indexing: Spring stereotype values plus DTO. ``OTHER`` is the
+# built-in inference fallback (ast_java.infer_role when nothing matches) and is
+# deliberately excluded here — it is a read-side value (the mcp_v2 ``Role`` enum
+# includes it) but not a role a user may set via @CodebaseRole / role_overrides.
 VALID_ROLES: frozenset[str] = frozenset((*ROLE_ANNOTATIONS.values(), "DTO"))
 
 VALID_CAPABILITIES: frozenset[str] = frozenset(
@@ -141,7 +144,7 @@ Cardinality = Literal["many_to_many", "many_to_one", "one_to_many", "one_to_one"
 @dataclass(frozen=True)
 class EdgeAttr:
     name: str
-    kuzu_type: str
+    graph_type: str
     purpose: str