java-codebase-rag 0.9.4__py3-none-any.whl → 0.9.6__py3-none-any.whl

build_ast_graph.py → java_codebase_rag/graph/build_ast_graph.py

@@ -41,7 +41,7 @@ from pathlib import Path
 import ladybug
 import pyarrow as pa
 
-from ast_java import (
+from java_codebase_rag.ast.ast_java import (
     ONTOLOGY_VERSION,
     CallSite,
     JavaFileAst,
@@ -52,10 +52,12 @@ from ast_java import (
     lombok_required_args_annotations,
     parse_java,
 )
-from graph_enrich import (
+from java_codebase_rag.graph.graph_enrich import (
     _load_config_cross_service_resolution,
+    classify_java_file,
     collect_annotation_meta_chain,
     load_brownfield_overrides,
+    load_generated_detection,
     microservice_for_path,
     module_for_path,
     phantom_id,
@@ -65,8 +67,8 @@ from graph_enrich import (
     resolve_routes_for_method,
     symbol_id,
 )
-from path_filtering import LayeredIgnore, iter_java_source_files
-from java_ontology import (
+from java_codebase_rag.graph.path_filtering import LayeredIgnore, iter_java_source_files
+from java_codebase_rag.graph.java_ontology import (
     CLIENT_KIND_FEIGN_METHOD,
     CLIENT_KIND_REST_TEMPLATE,
     VALID_CLIENT_KINDS,
@@ -465,6 +467,8 @@ class GraphTables:
     cross_service_resolution: str = "auto"
     # Populated in _write_nodes (same overrides + meta_chain as Symbol.role).
     type_role_by_node_id: dict[str, str] = field(default_factory=dict)
+    # Populated in pass 1 (classify_java_file) and _load_existing_types for incremental rebuilds.
+    type_generated_by_node_id: dict[str, tuple[bool, str | None]] = field(default_factory=dict)
 
 
 @dataclass
@@ -598,7 +602,7 @@ def _load_existing_types(conn: ladybug.Connection, tables: GraphTables, exclude_
     query = f"""
     MATCH (s:Symbol)
     {where}
-    RETURN s.kind, s.fqn, s.name, s.filename, s.module, s.microservice, s.id, s.role
+    RETURN s.kind, s.fqn, s.name, s.filename, s.module, s.microservice, s.id, s.role, s.generated, s.generated_by
     """
     result = conn.execute(query, params)
     while result.has_next():
@@ -608,6 +612,8 @@ def _load_existing_types(conn: ladybug.Connection, tables: GraphTables, exclude_
         microservice = row[5] if len(row) > 5 else ""
         node_id = row[6] if len(row) > 6 else ""
         role = row[7] if len(row) > 7 else ""
+        generated = row[8] if len(row) > 8 else False
+        generated_by = row[9] if len(row) > 9 else ""
 
         decl = TypeDecl(name, kind, fqn)
         package = fqn[: -(len(name) + 1)] if fqn.endswith("." + name) else ""
@@ -629,6 +635,8 @@ def _load_existing_types(conn: ladybug.Connection, tables: GraphTables, exclude_
         # the default during node staging (issue #352 divergence #2).
         if role:
             tables.type_role_by_node_id[node_id] = role
+        # Seed the persisted generated/generated_by so stubs retain their values
+        tables.type_generated_by_node_id[node_id] = (bool(generated), generated_by)
 
 
 def _load_existing_members(conn: ladybug.Connection, tables: GraphTables, exclude_files: set[str] | None = None) -> None:
@@ -1061,6 +1069,12 @@ def pass1_parse(
             microservice = microservice_for_path(str(p), root)
             asts[rel] = ast
 
+            # Classify the file once (generated or not, and which tool generated it)
+            generated_config = load_generated_detection(str(root))
+            file_generated, file_generated_by = classify_java_file(
+                content, ast, config=generated_config, project_root=root
+            )
+
             # file node
             file_id = symbol_id("file", rel, rel, 0)
             tables.files[rel] = file_id
@@ -1075,6 +1089,12 @@ def pass1_parse(
                     module=module, microservice=microservice, outer_fqn=None,
                 )
 
+            # Seed generated/generated_by for all types in this file (including nested)
+            for t in ast.all_types:
+                if t.fqn in tables.types:
+                    node_id = tables.types[t.fqn].node_id
+                    tables.type_generated_by_node_id[node_id] = (file_generated, file_generated_by)
+
     if verbose:
         elapsed = time.time() - t0
         _emit_graph_progress(
@@ -2906,7 +2926,8 @@ _SCHEMA_NODE = (
     "filename STRING, start_line INT64, end_line INT64, "
     "start_byte INT64, end_byte INT64, "
     "modifiers STRING[], annotations STRING[], capabilities STRING[], "
-    "role STRING, signature STRING, parent_id STRING, resolved BOOLEAN"
+    "role STRING, signature STRING, parent_id STRING, resolved BOOLEAN, "
+    "generated BOOLEAN, generated_by STRING"
     ")"
 )
 
@@ -3088,6 +3109,7 @@ def _node_row(**kwargs) -> dict:
         "start_byte": 0, "end_byte": 0,
         "modifiers": [], "annotations": [], "capabilities": [],
         "role": "OTHER", "signature": "", "parent_id": "", "resolved": True,
+        "generated": False, "generated_by": None,
     }
     base.update(kwargs)
     return base
@@ -3138,7 +3160,8 @@ def _existing_node_ids(conn: ladybug.Connection) -> set[str]:
 _NODE_COLUMNS = [
     "id", "kind", "name", "fqn", "package", "module", "microservice",
     "filename", "start_line", "end_line", "start_byte", "end_byte",
-    "modifiers", "annotations", "capabilities", "role", "signature", "parent_id", "resolved"
+    "modifiers", "annotations", "capabilities", "role", "signature", "parent_id", "resolved",
+    "generated", "generated_by"
 ]
 
 # Type declaration kinds. Tuple (not set) so the rendered SQL `IN` clause is
@@ -3161,7 +3184,8 @@ _SET_SYMBOL_BY_ID = (
     "n.start_byte = $start_byte, n.end_byte = $end_byte, "
     "n.modifiers = $modifiers, n.annotations = $annotations, "
     "n.capabilities = $capabilities, n.role = $role, "
-    "n.signature = $signature, n.parent_id = $parent_id, n.resolved = $resolved"
+    "n.signature = $signature, n.parent_id = $parent_id, n.resolved = $resolved, "
+    "n.generated = $generated, n.generated_by = $generated_by"
 )
 
 # Refresh every mutable Route field on an existing Route node by id. Mirrors the
@@ -3240,6 +3264,9 @@ def _write_nodes_impl(
             overrides=overrides,
             meta_chain=mch,
         )
+        # Read generated/generated_by from pass-1 classification or stub persistence
+        generated, generated_by = tables.type_generated_by_node_id.get(entry.node_id, (False, None))
+
         if entry.loaded_from_db:
             stub_ids.add(entry.node_id)
             # Out-of-scope stub: its annotation-less decl collapses role to the
@@ -3250,6 +3277,7 @@ def _write_nodes_impl(
             # capabilities placeholder never reaches the graph.
             role = tables.type_role_by_node_id.get(entry.node_id, role)
             capabilities = []
+            # For stubs, trust the persisted generated/generated_by (seeded by _load_existing_types)
         else:
             tables.type_role_by_node_id[entry.node_id] = role
         rows.append(_node_row(
@@ -3265,6 +3293,8 @@ def _write_nodes_impl(
             role=role,
             signature="",
             parent_id=tables.types[entry.outer_fqn].node_id if entry.outer_fqn and entry.outer_fqn in tables.types else "",
+            generated=generated,
+            generated_by=generated_by,
         ))
     # members (methods / constructors)
     for m in tables.members:
@@ -3774,7 +3804,7 @@ def incremental_rebuild(
     Returns IncrementalResult with statistics about the rebuild.
     Falls back to full rebuild if:
     - No previous graph exists
-    - Ontology version < 17 (missing source_file on edges)
+    - Ontology version < ONTOLOGY_VERSION (stale schema; rebuild for current columns)
     - Crash marker exists (previous incremental run failed)
     - Dependent expansion exceeds expansion_cap
     """
@@ -3812,9 +3842,9 @@ def incremental_rebuild(
         if meta_result.has_next():
             row = meta_result.get_next()
             version = row[0] if row else 0
-            if version < 17:
+            if version < ONTOLOGY_VERSION:
                 if verbose:
-                    _verbose_stderr_line(f"[increment] ontology version {version} < 17; falling back to full rebuild")
+                    _verbose_stderr_line(f"[increment] ontology version {version} < {ONTOLOGY_VERSION}; falling back to full rebuild")
                 conn.close()
                 db.close()
                 del conn, db
@@ -4208,9 +4238,57 @@ def write_ladybug(
         _write_meta(conn, tables, source_root)
         conn.close()
         db.close()
+
+    # Build vocabulary index (best-effort, failure doesn't fail the graph build)
+    _try_build_vocabulary_index(db_path, source_root, verbose)
     _init_hash_tracker(source_root, db_path)
 
 
+def _try_build_vocabulary_index(db_path: Path, source_root: Path, verbose: bool) -> None:
+    """Build and save the vocabulary index as a sidecar (best-effort).
+
+    This is called after write_ladybug() completes. A build failure must not
+    fail the graph build, so this is wrapped in try/except and logged.
+
+    Args:
+        db_path: Path to the LadybugDB database file
+        source_root: Source repository root
+        verbose: Whether to emit verbose progress
+    """
+    try:
+        from java_codebase_rag.absence.absence_vocab import VocabularyIndex, VOCAB_INDEX_FILENAME
+        from java_codebase_rag.graph.ladybug_queries import LadybugGraph
+
+        t0 = time.time()
+        if verbose:
+            _verbose_stderr_line("[vocab] building vocabulary index")
+
+        # Open graph for reading
+        graph = LadybugGraph.get(str(db_path))
+
+        # Read q from env var set by ResolvedOperatorConfig.subprocess_env()
+        raw_q = os.environ.get("JAVA_CODEBASE_RAG_ABSENCE_NGRAM_Q", "3").strip()
+        try:
+            q = int(raw_q) if raw_q else 3
+        except ValueError:
+            q = 3  # Invalid env value falls back to default
+        # Build index with configured q (or default 3)
+        index = VocabularyIndex.build(graph, q=q)
+
+        # Save to sidecar next to the graph db
+        sidecar_path = Path(db_path).parent / VOCAB_INDEX_FILENAME
+        index.save(sidecar_path, ontology_version=ONTOLOGY_VERSION)
+
+        if verbose:
+            _verbose_stderr_line(f"[vocab] index built with {index.symbol_count} symbols in {time.time() - t0:.2f}s")
+
+    except Exception as e:
+        # Log but don't fail - graph build is the primary concern
+        log.warning(f"Vocabulary index build failed (non-critical): {e}")
+        if verbose:
+            _verbose_stderr_line(f"[vocab] build failed (graph still written): {e}")
+
+
 # ---------- CLI ----------
 
 

graph_enrich.py → java_codebase_rag/graph/graph_enrich.py

@@ -19,12 +19,13 @@ Two location concepts are tracked per file:
 from __future__ import annotations
 
 import hashlib
+import re
 import sys
 from dataclasses import dataclass, field, replace
 from functools import lru_cache
 from pathlib import Path
 from typing import Any, TypeVar
-from ast_java import (
+from java_codebase_rag.ast.ast_java import (
     AnnotationRef,
     JavaFileAst,
     MethodDecl,
@@ -42,7 +43,7 @@ from ast_java import (
     _METHOD_ANN_TO_CAPABILITY,
     _TYPE_ANN_TO_CAPABILITY,
 )
-from java_ontology import (
+from java_codebase_rag.graph.java_ontology import (
     CLIENT_KIND_REST_TEMPLATE,
     VALID_CAPABILITIES,
     VALID_CLIENT_KINDS,
@@ -51,7 +52,7 @@ from java_ontology import (
     VALID_ROUTE_FRAMEWORKS,
     VALID_ROUTE_KINDS,
 )
-from path_filtering import LayeredIgnore, iter_java_source_files
+from java_codebase_rag.graph.path_filtering import LayeredIgnore, iter_java_source_files
 
 __all__ = [
     "AnnotationDecl",
@@ -141,6 +142,87 @@ def _load_config_microservice_roots(project_root_str: str) -> tuple[str, ...]:
     return ()
 
 
+@lru_cache(maxsize=64)
+def load_generated_detection(project_root_str: str | None) -> GeneratedDetectionConfig:
+    """Read `generated_detection` from `.java-codebase-rag.yml` at project_root.
+
+    Cached per project_root to avoid re-reading on every chunk. Returns empty
+    config when section absent or project_root is None. Malformed entries
+    (wrong types, non-string values) are dropped with a stderr warning.
+    """
+    if project_root_str is None:
+        return GeneratedDetectionConfig()
+
+    root = Path(project_root_str)
+    for name in CONFIG_FILENAMES:
+        candidate = root / name
+        if not candidate.is_file():
+            continue
+        try:
+            import yaml  # PyYAML; already a transitive dep of cocoindex
+        except ImportError:
+            return GeneratedDetectionConfig()
+        try:
+            data = yaml.safe_load(candidate.read_text(encoding="utf-8"))
+        except Exception:
+            return GeneratedDetectionConfig()
+        if not isinstance(data, dict):
+            return GeneratedDetectionConfig()
+
+        raw = data.get("generated_detection")
+        if raw is None:
+            return GeneratedDetectionConfig()
+
+        if not isinstance(raw, dict):
+            import sys
+            print("[warn] generated_detection must be a dict; skipping",
+                  file=sys.stderr)
+            return GeneratedDetectionConfig()
+
+        result = GeneratedDetectionConfig()
+
+        # Spec table: (config_key, field_name, type_converter, is_list_type)
+        # is_list_type: True = keep as list, False = convert to set
+        spec_table = [
+            ("header_patterns", "header_patterns", lambda x: x, True),
+            ("annotation_patterns", "annotation_patterns", lambda x: x, True),
+            ("force_fqns", "force_fqns", set, False),
+            ("exclude_fqns", "exclude_fqns", set, False),
+        ]
+
+        for config_key, field_name, type_conv, is_list_type in spec_table:
+            value = raw.get(config_key)
+            if value is not None:
+                if isinstance(value, list):
+                    if is_list_type:
+                        valid = [s for s in value if isinstance(s, str)]
+                    else:
+                        valid = {s for s in value if isinstance(s, str)}
+
+                    if len(valid) != len(value):
+                        import sys
+                        print(f"[warn] generated_detection.{config_key}: "
+                              "non-string entries dropped", file=sys.stderr)
+
+                    # Update result with converted value
+                    kwargs = {field_name: type_conv(valid)}
+                    result = GeneratedDetectionConfig(
+                        header_patterns=kwargs.get("header_patterns", result.header_patterns),
+                        annotation_patterns=kwargs.get("annotation_patterns", result.annotation_patterns),
+                        force_fqns=kwargs.get("force_fqns", result.force_fqns),
+                        exclude_fqns=kwargs.get("exclude_fqns", result.exclude_fqns)
+                    )
+                else:
+                    import sys
+                    print(f"[warn] generated_detection.{config_key}: "
+                          "must be a list; skipping", file=sys.stderr)
+
+        return result
+
+    # No config file found → return empty config
+    return GeneratedDetectionConfig()
+
+
 @lru_cache(maxsize=64)
 def _load_config_cross_service_resolution(project_root_str: str) -> str:
     """Read `cross_service_resolution` from `.java-codebase-rag.yml` at project_root.
@@ -238,6 +320,19 @@ class BrownfieldOverrides:
     fqn_to_async_producer_hint: dict[str, AsyncProducerHint] = field(default_factory=dict)
 
 
+@dataclass(frozen=True)
+class GeneratedDetectionConfig:
+    """Config for generated-source detection.
+
+    Mirrors brownfield override pattern: frozen dataclass with
+    field(default_factory=...) for mutable defaults.
+    """
+    header_patterns: list[str] = field(default_factory=list)
+    annotation_patterns: list[str] = field(default_factory=list)
+    force_fqns: set[str] = field(default_factory=set)
+    exclude_fqns: set[str] = field(default_factory=set)
+
+
 def _meta_builtins() -> frozenset[str]:
     return (
         frozenset(ROLE_ANNOTATIONS)
@@ -1544,6 +1639,156 @@ def microservice_for_path(
     return ""
 
 
+# ---------- generated-source detection ----------
+
+
+# Built-in generator markers (v1 set). Verified against real generator output.
+# Annotation FQNs that mark generated code (any annotation with these FQNs
+# or simple names is considered a marker).
+_GENERATED_ANNOTATION_FQNS = {
+    "javax.annotation.processing.Generated",  # Standard Java (pre-Jakarta)
+    "jakarta.annotation.processing.Generated",  # Jakarta EE
+    "org.immutables.value.Generated",  # Immutables
+    "lombok.Generated",  # Lombok
+    "com.squareup.javapoet.Generated",  # JavaPoet
+}
+
+# Header patterns for generators that emit banners (checked against first 4KB).
+# Patterns are compiled as case-insensitive regexes.
+_GENERATED_HEADER_PATTERNS = {
+    re.compile(r"This file was generated by the OpenAPI Generator", re.IGNORECASE): "openapi",
+    re.compile(r"Generated by the protocol buffer compiler", re.IGNORECASE): "protobuf",
+    re.compile(r"This file was generated by jsonschema2pojo", re.IGNORECASE): "jsonschema2pojo",
+    re.compile(r"generated by wsimport", re.IGNORECASE): "wsimport",  # JAX-WS wsimport
+    re.compile(r"WARNING: DO NOT EDIT.*generated by MapStruct", re.IGNORECASE): "mapstruct",
+}
+
+# @Generated(value="...") patterns that identify the generator family.
+# These are matched against annotation arguments["value"] or arguments["comments"].
+_GENERATED_VALUE_PATTERNS = {
+    re.compile(r"org\.openapitools\.codegen\."): "openapi",
+    re.compile(r"org\.mapstruct\.ap\.MappingProcessor"): "mapstruct",
+    re.compile(r"com\.google\.auto\.value\.processor\.AutoValueProcessor"): "autovalue",
+    re.compile(r"org\.jooq\."): "jooq",
+    re.compile(r"com\.querydsl\."): "querydsl",
+    re.compile(r"org\.immutables\."): "immutables",
+}
+
+
+def _infer_family_from_annotation(annotation: AnnotationRef) -> str | None:
+    """Infer generator family from @Generated annotation arguments.
+
+    Returns lowercased family slug or None if no match.
+    """
+    # Check value/comments arguments for generator identifiers FIRST
+    # (handles javax.annotation.processing.Generated(value="org.mapstruct.ap.MappingProcessor"))
+    value = annotation.arguments.get("value", "")
+    comments = annotation.arguments.get("comments", "")
+
+    for pattern, family in _GENERATED_VALUE_PATTERNS.items():
+        if pattern.search(value) or pattern.search(comments):
+            return family
+
+    # Check annotation FQN for families identifiable by FQN itself
+    if annotation.qualified in _GENERATED_ANNOTATION_FQNS:
+        # Extract family from qualified name if possible
+        if "lombok.Generated" in annotation.qualified:
+            return "lombok"
+        if "immutables" in annotation.qualified:
+            return "immutables"
+        # Generic javax/jakarta or JavaPoet -> unknown family
+        return None
+
+    return None
+
+
+def _check_header_banners(header_text: str) -> str | None:
+    """Check header (first 4KB) for generator banners.
+
+    Args:
+        header_text: Decoded header text (first 4KB of source file).
+
+    Returns family slug if matched, None otherwise.
+    """
+    for pattern, family in _GENERATED_HEADER_PATTERNS.items():
+        if pattern.search(header_text):
+            return family
+
+    return None
+
+
+def classify_java_file(
+    source: bytes,
+    ast: "JavaFileAst",
+    *,
+    config: GeneratedDetectionConfig | None = None,
+    project_root: str | Path | None = None,
+) -> tuple[bool, str | None]:
+    """Classify whether a Java source file is generated.
+
+    Args:
+        source: Raw file bytes (required for header-banner detection).
+        ast: Parsed Java AST (from ast_java.parse_java_ast).
+        config: Optional detection config (defaults to empty config).
+        project_root: Optional project root for loading default config.
+
+    Returns:
+        (generated, generated_by) tuple:
+        - generated: True if file is detected as generated code.
+        - generated_by: Lowercased family slug (openapi, jsonschema2pojo,
+          protobuf, mapstruct, wsimport, querydsl, jooq, immutables,
+          autovalue, lombok) or None if family unknown.
+    """
+    # Load config if not provided
+    if config is None:
+        config = load_generated_detection(
+            str(project_root) if project_root is not None else None
+        )
+
+    # Decode header once for banner detection (first 4KB)
+    HEADER_PREFIX_SIZE = 4096
+    header_prefix = source[:HEADER_PREFIX_SIZE].decode("utf-8", errors="ignore")
+
+    # Collect all type FQNs for config-based checks
+    all_type_fqns = {t.fqn for t in ast.all_types}
+
+    # Priority 1: exclude_fqns (override, wins even with markers)
+    if all_type_fqns & config.exclude_fqns:
+        return False, None
+
+    # Priority 2: force_fqns (forced generated, no markers needed)
+    if all_type_fqns & config.force_fqns:
+        return True, None
+
+    # Priority 3: annotation-based detection
+    for typ in ast.all_types:
+        for ann in typ.annotations:
+            # Check simple name "Generated" first
+            if ann.name == "Generated":
+                family = _infer_family_from_annotation(ann)
+                if family is not None:
+                    return True, family
+                # Generic @Generated without identifiable value
+                return True, None
+
+            # Check configured annotation patterns
+            for pattern in config.annotation_patterns:
+                if re.search(pattern, ann.qualified) or re.search(pattern, ann.name):
+                    return True, None
+
+    # Priority 4: header-banner detection
+    family = _check_header_banners(header_prefix)
+    if family is not None:
+        return True, family
+
+    # Check configured header patterns
+    for pattern in config.header_patterns:
+        if re.search(pattern, header_prefix, re.IGNORECASE):
+            return True, None
+
+    return False, None
+
+
 def detect_microservice_from_path(cwd: Path, source_root: Path) -> str | None:
     """Detect microservice from cwd for query-time auto-scope.
 

graph_types.py → java_codebase_rag/graph/graph_types.py

@@ -10,8 +10,8 @@ from typing import Any, Literal
 
 from pydantic import BaseModel
 
-from ladybug_queries import LadybugGraph
-from mcp_hints import generate_hints
+from java_codebase_rag.graph.ladybug_queries import LadybugGraph
+from java_codebase_rag.mcp.mcp_hints import generate_hints
 
 __all__ = [
     "NodeRef",
@@ -34,6 +34,8 @@ class NodeRef(BaseModel):
     microservice: str | None = None
     module: str | None = None
     role: str | None = None
+    generated: bool | None = None
+    generated_by: str | None = None
 
 
 class StructuredHint(BaseModel):
@@ -126,6 +128,8 @@ def _node_ref_from_row(kind: Literal["symbol", "route", "client", "producer"], r
         microservice=str(row.get("microservice") or "") or None,
         module=str(row.get("module") or "") or None,
         role=role,
+        generated=bool(row.get("generated")) if row.get("generated") is not None else None,
+        generated_by=str(row.get("generated_by")) if row.get("generated_by") else None,
     )
 
 

java_ontology.py → java_codebase_rag/graph/java_ontology.py

@@ -7,7 +7,7 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Literal
 
-from ast_java import (
+from java_codebase_rag.ast.ast_java import (
     ROLE_ANNOTATIONS,
     _INJECTED_TYPES_TO_CAPABILITY,
     _METHOD_ANN_TO_CAPABILITY,

ladybug_queries.py → java_codebase_rag/graph/ladybug_queries.py

@@ -6,7 +6,7 @@ so the MCP server can serialize them without further mapping.
 The Ladybug database is opened read-only and cached per-process. This module is
 intentionally dependency-light: nothing here imports LanceDB or sentence-transformers.
 
-Cypher pitfalls (see also ``AGENTS.md``): avoid ``label(e) IN $list`` in ``WHERE`` for
+Cypher pitfalls (see also ``CLAUDE.md``): avoid ``label(e) IN $list`` in ``WHERE`` for
 relationship-type filters; use OR of ``label(e) = $param`` with bound parameters.
 Typed unions ``-[e:A|B]-`` require every ``RETURN`` column on ``e`` to exist on all
 listed rel types, or the binder may fail.
@@ -24,7 +24,7 @@ from typing import Any, Literal
 
 import ladybug
 
-from ast_java import ONTOLOGY_VERSION as _ONTOLOGY_VERSION
+from java_codebase_rag.ast.ast_java import ONTOLOGY_VERSION as _ONTOLOGY_VERSION
 
 log = logging.getLogger(__name__)
 
@@ -207,7 +207,7 @@ def _symbol_return_for(alias: str) -> str:
         f"{alias}.modifiers AS modifiers, {alias}.annotations AS annotations, "
         f"{alias}.capabilities AS capabilities, "
         f"{alias}.role AS role, {alias}.signature AS signature, "
-        f"{alias}.parent_id AS parent_id, {alias}.resolved AS resolved"
+        f"{alias}.parent_id AS parent_id, {alias}.resolved AS resolved, {alias}.generated AS generated, {alias}.generated_by AS generated_by"
     )
 
 
@@ -296,7 +296,7 @@ def _row_to_symbol(row: dict[str, Any]) -> SymbolHit:
 _SYM_COLS = (
     "id", "kind", "name", "fqn", "package", "module", "microservice",
     "filename", "start_line", "end_line", "start_byte", "end_byte",
-    "modifiers", "annotations", "capabilities", "role", "signature", "parent_id", "resolved",
+    "modifiers", "annotations", "capabilities", "role", "signature", "parent_id", "resolved", "generated", "generated_by",
 )
 
 
@@ -1107,14 +1107,14 @@ class LadybugGraph:
             f"s.{c} AS s_{c}" for c in (
                 "id", "kind", "name", "fqn", "package", "module", "microservice",
                 "filename", "start_line", "end_line", "start_byte", "end_byte",
-                "modifiers", "annotations", "capabilities", "role", "signature", "parent_id", "resolved",
+                "modifiers", "annotations", "capabilities", "role", "signature", "parent_id", "resolved", "generated", "generated_by",
             )
         )
         t_proj = ", ".join(
             f"t.{c} AS t_{c}" for c in (
                 "id", "kind", "name", "fqn", "package", "module", "microservice",
                 "filename", "start_line", "end_line", "start_byte", "end_byte",
-                "modifiers", "annotations", "capabilities", "role", "signature", "parent_id", "resolved",
+                "modifiers", "annotations", "capabilities", "role", "signature", "parent_id", "resolved", "generated", "generated_by",
             )
         )
         q = (