code-graph-rag 0.0.484__tar.gz → 0.0.534__tar.gz

{code_graph_rag-0.0.484/code_graph_rag.egg-info → code_graph_rag-0.0.534}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-graph-rag
-Version: 0.0.484
+Version: 0.0.534
 Summary: The ultimate RAG for your monorepo. Query, understand, and edit multi-language codebases with the power of AI and knowledge graphs
 License-Expression: MIT
 Keywords: rag,retrieval-augmented-generation,knowledge-graph,code-analysis,tree-sitter,mcp,mcp-server,llm,graph-database,semantic-search,codebase,memgraph,developer-tools,monorepo
@@ -76,7 +76,25 @@ Dynamic: license-file
 
 # Code-Graph-RAG
 
-A graph-based RAG system that parses multi-language codebases with Tree-sitter, builds knowledge graphs in Memgraph, and enables natural language querying, editing, and optimisation.
+Code-Graph-RAG parses a multi-language codebase with Tree-sitter, builds a knowledge graph of its structure in Memgraph, and lets you query, edit, and optimise that code in plain English. It works across a monorepo of mixed languages under one unified graph schema.
+
+## What It Does
+
+Point it at a repository and it reads every source file, extracts functions, classes, methods, and modules along with the relationships between them, and stores the result as an interconnected graph. Once the graph exists you can:
+
+- Ask questions about the codebase in natural language and get answers grounded in the real structure.
+- Retrieve the actual source of any function, class, or method by name or by intent.
+- Edit code through the agent with AST-based surgical patching and a diff preview before anything changes.
+- Search and rewrite code structurally by AST pattern with ast-grep, instead of text or regex.
+- Trace data flow through assignments, calls, and I/O sinks via `FLOWS_TO` taint edges.
+- Optimise code against language best practices or your own coding standards.
+- Find dead code by walking call and reference edges from entry points.
+- Group several repositories into a named workspace and query them as one graph.
+- Trace calls between microservices: route decorators become endpoint templates, and HTTP client URLs resolve to the handlers that serve them, linking services across project boundaries.
+
+## Supported Languages
+
+Python, TypeScript, TSX, JavaScript, Rust, Go, Java, C, C++, C#, PHP, Lua, and Dart are fully supported. Scala is in development, and Ruby has structural support (modules, functions, classes, and imports) through the pluggable ast-grep tier, which requires the `ast-grep` extra (`pip install 'code-graph-rag[ast-grep]'`).
 
 ## Install
 
@@ -154,18 +172,31 @@ cgr dead-code --format json --fail-on-found     # CI-friendly report
 Results are candidates for review, not a guaranteed delete list. See the
 [Dead Code Detection guide](https://docs.code-graph-rag.com/guide/dead-code/).
 
-**Run as an MCP server (for Claude Code):**
+**Group repositories into a workspace and query them together:**
 
 ```bash
-cgr mcp-server
+cgr workspace create my-platform
+cgr workspace add-repo my-platform ./service-a
+cgr workspace add-repo my-platform ./service-b
+cgr start --workspace my-platform
 ```
 
-**Check your setup:**
+**Inspect the graph and the stack:**
 
 ```bash
-cgr doctor
+cgr stats                                  # node and relationship counts
+cgr status                                 # stack state and last sync per project
+cgr doctor                                 # check dependencies and configuration
 ```
 
+## MCP Server
+
+Run `cgr mcp-server` to serve the tools over stdio or HTTP for Claude Code and other MCP clients. The MCP surface registers:
+
+- **Ask and retrieve:** `ask_agent`, `query_code_graph`, `get_code_snippet`, and `semantic_search` (needs the `semantic` extra)
+- **Structural editing:** `surgical_replace_code`, plus `structural_search` and `structural_replace` (need the `ast-grep` extra)
+- **Files and projects:** `read_file`, `write_file`, `list_directory`, `list_projects`, `index_repository`, `update_repository`, `delete_project`, `wipe_database`
+
 ## Python SDK
 
 The `cgr` package provides short imports for programmatic use.

{code_graph_rag-0.0.484 → code_graph_rag-0.0.534}/PYPI_README.md

@@ -1,6 +1,24 @@
 # Code-Graph-RAG
 
-A graph-based RAG system that parses multi-language codebases with Tree-sitter, builds knowledge graphs in Memgraph, and enables natural language querying, editing, and optimisation.
+Code-Graph-RAG parses a multi-language codebase with Tree-sitter, builds a knowledge graph of its structure in Memgraph, and lets you query, edit, and optimise that code in plain English. It works across a monorepo of mixed languages under one unified graph schema.
+
+## What It Does
+
+Point it at a repository and it reads every source file, extracts functions, classes, methods, and modules along with the relationships between them, and stores the result as an interconnected graph. Once the graph exists you can:
+
+- Ask questions about the codebase in natural language and get answers grounded in the real structure.
+- Retrieve the actual source of any function, class, or method by name or by intent.
+- Edit code through the agent with AST-based surgical patching and a diff preview before anything changes.
+- Search and rewrite code structurally by AST pattern with ast-grep, instead of text or regex.
+- Trace data flow through assignments, calls, and I/O sinks via `FLOWS_TO` taint edges.
+- Optimise code against language best practices or your own coding standards.
+- Find dead code by walking call and reference edges from entry points.
+- Group several repositories into a named workspace and query them as one graph.
+- Trace calls between microservices: route decorators become endpoint templates, and HTTP client URLs resolve to the handlers that serve them, linking services across project boundaries.
+
+## Supported Languages
+
+Python, TypeScript, TSX, JavaScript, Rust, Go, Java, C, C++, C#, PHP, Lua, and Dart are fully supported. Scala is in development, and Ruby has structural support (modules, functions, classes, and imports) through the pluggable ast-grep tier, which requires the `ast-grep` extra (`pip install 'code-graph-rag[ast-grep]'`).
 
 ## Install
 
@@ -78,18 +96,31 @@ cgr dead-code --format json --fail-on-found     # CI-friendly report
 Results are candidates for review, not a guaranteed delete list. See the
 [Dead Code Detection guide](https://docs.code-graph-rag.com/guide/dead-code/).
 
-**Run as an MCP server (for Claude Code):**
+**Group repositories into a workspace and query them together:**
 
 ```bash
-cgr mcp-server
+cgr workspace create my-platform
+cgr workspace add-repo my-platform ./service-a
+cgr workspace add-repo my-platform ./service-b
+cgr start --workspace my-platform
 ```
 
-**Check your setup:**
+**Inspect the graph and the stack:**
 
 ```bash
-cgr doctor
+cgr stats                                  # node and relationship counts
+cgr status                                 # stack state and last sync per project
+cgr doctor                                 # check dependencies and configuration
 ```
 
+## MCP Server
+
+Run `cgr mcp-server` to serve the tools over stdio or HTTP for Claude Code and other MCP clients. The MCP surface registers:
+
+- **Ask and retrieve:** `ask_agent`, `query_code_graph`, `get_code_snippet`, and `semantic_search` (needs the `semantic` extra)
+- **Structural editing:** `surgical_replace_code`, plus `structural_search` and `structural_replace` (need the `ast-grep` extra)
+- **Files and projects:** `read_file`, `write_file`, `list_directory`, `list_projects`, `index_repository`, `update_repository`, `delete_project`, `wipe_database`
+
 ## Python SDK
 
 The `cgr` package provides short imports for programmatic use.

{code_graph_rag-0.0.484 → code_graph_rag-0.0.534/code_graph_rag.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-graph-rag
-Version: 0.0.484
+Version: 0.0.534
 Summary: The ultimate RAG for your monorepo. Query, understand, and edit multi-language codebases with the power of AI and knowledge graphs
 License-Expression: MIT
 Keywords: rag,retrieval-augmented-generation,knowledge-graph,code-analysis,tree-sitter,mcp,mcp-server,llm,graph-database,semantic-search,codebase,memgraph,developer-tools,monorepo
@@ -76,7 +76,25 @@ Dynamic: license-file
 
 # Code-Graph-RAG
 
-A graph-based RAG system that parses multi-language codebases with Tree-sitter, builds knowledge graphs in Memgraph, and enables natural language querying, editing, and optimisation.
+Code-Graph-RAG parses a multi-language codebase with Tree-sitter, builds a knowledge graph of its structure in Memgraph, and lets you query, edit, and optimise that code in plain English. It works across a monorepo of mixed languages under one unified graph schema.
+
+## What It Does
+
+Point it at a repository and it reads every source file, extracts functions, classes, methods, and modules along with the relationships between them, and stores the result as an interconnected graph. Once the graph exists you can:
+
+- Ask questions about the codebase in natural language and get answers grounded in the real structure.
+- Retrieve the actual source of any function, class, or method by name or by intent.
+- Edit code through the agent with AST-based surgical patching and a diff preview before anything changes.
+- Search and rewrite code structurally by AST pattern with ast-grep, instead of text or regex.
+- Trace data flow through assignments, calls, and I/O sinks via `FLOWS_TO` taint edges.
+- Optimise code against language best practices or your own coding standards.
+- Find dead code by walking call and reference edges from entry points.
+- Group several repositories into a named workspace and query them as one graph.
+- Trace calls between microservices: route decorators become endpoint templates, and HTTP client URLs resolve to the handlers that serve them, linking services across project boundaries.
+
+## Supported Languages
+
+Python, TypeScript, TSX, JavaScript, Rust, Go, Java, C, C++, C#, PHP, Lua, and Dart are fully supported. Scala is in development, and Ruby has structural support (modules, functions, classes, and imports) through the pluggable ast-grep tier, which requires the `ast-grep` extra (`pip install 'code-graph-rag[ast-grep]'`).
 
 ## Install
 
@@ -154,18 +172,31 @@ cgr dead-code --format json --fail-on-found     # CI-friendly report
 Results are candidates for review, not a guaranteed delete list. See the
 [Dead Code Detection guide](https://docs.code-graph-rag.com/guide/dead-code/).
 
-**Run as an MCP server (for Claude Code):**
+**Group repositories into a workspace and query them together:**
 
 ```bash
-cgr mcp-server
+cgr workspace create my-platform
+cgr workspace add-repo my-platform ./service-a
+cgr workspace add-repo my-platform ./service-b
+cgr start --workspace my-platform
 ```
 
-**Check your setup:**
+**Inspect the graph and the stack:**
 
 ```bash
-cgr doctor
+cgr stats                                  # node and relationship counts
+cgr status                                 # stack state and last sync per project
+cgr doctor                                 # check dependencies and configuration
 ```
 
+## MCP Server
+
+Run `cgr mcp-server` to serve the tools over stdio or HTTP for Claude Code and other MCP clients. The MCP surface registers:
+
+- **Ask and retrieve:** `ask_agent`, `query_code_graph`, `get_code_snippet`, and `semantic_search` (needs the `semantic` extra)
+- **Structural editing:** `surgical_replace_code`, plus `structural_search` and `structural_replace` (need the `ast-grep` extra)
+- **Files and projects:** `read_file`, `write_file`, `list_directory`, `list_projects`, `index_repository`, `update_repository`, `delete_project`, `wipe_database`
+
 ## Python SDK
 
 The `cgr` package provides short imports for programmatic use.

{code_graph_rag-0.0.484 → code_graph_rag-0.0.534}/code_graph_rag.egg-info/SOURCES.txt

@@ -124,8 +124,11 @@ codebase_rag/parsers/__init__.py
 codebase_rag/parsers/ast_grep_tier.py
 codebase_rag/parsers/call_processor.py
 codebase_rag/parsers/call_resolver.py
+codebase_rag/parsers/contract_linking.py
+codebase_rag/parsers/contracts.py
 codebase_rag/parsers/definition_processor.py
 codebase_rag/parsers/dependency_parser.py
+codebase_rag/parsers/dispatch_registry.py
 codebase_rag/parsers/endpoint_prefixes.py
 codebase_rag/parsers/endpoint_routes.py
 codebase_rag/parsers/endpoints.py
@@ -134,6 +137,7 @@ codebase_rag/parsers/factory.py
 codebase_rag/parsers/function_ingest.py
 codebase_rag/parsers/import_processor.py
 codebase_rag/parsers/python_source_roots.py
+codebase_rag/parsers/rpc_exposure.py
 codebase_rag/parsers/stdlib_extractor.py
 codebase_rag/parsers/structure_processor.py
 codebase_rag/parsers/type_inference.py
@@ -200,6 +204,7 @@ codebase_rag/parsers/java/utils.py
 codebase_rag/parsers/java/variable_analyzer.py
 codebase_rag/parsers/js_ts/__init__.py
 codebase_rag/parsers/js_ts/ingest.py
+codebase_rag/parsers/js_ts/module_paths.py
 codebase_rag/parsers/js_ts/module_system.py
 codebase_rag/parsers/js_ts/type_inference.py
 codebase_rag/parsers/js_ts/utils.py

{code_graph_rag-0.0.484 → code_graph_rag-0.0.534}/codebase_rag/constants/ast_go.py

@@ -1,9 +1,13 @@
 # Go tree-sitter node types.
 
+TS_GO_PACKAGE_CLAUSE = "package_clause"
+TS_GO_PACKAGE_IDENTIFIER = "package_identifier"
 TS_GO_TYPE_DECLARATION = "type_declaration"
 TS_GO_TYPE_SPEC = "type_spec"
 TS_GO_TYPE_ALIAS = "type_alias"
 TS_GO_STRUCT_TYPE = "struct_type"
+TS_GO_METHOD_ELEM = "method_elem"
+TS_GO_BLOCK = "block"
 TS_GO_SELECTOR_EXPRESSION = "selector_expression"
 TS_GO_TYPE_ASSERTION_EXPRESSION = "type_assertion_expression"
 # A Go source file ending in `_test.go` is compiled only under `go test`; its

{code_graph_rag-0.0.484 → code_graph_rag-0.0.534}/codebase_rag/constants/ast_js.py

@@ -77,11 +77,18 @@ TS_ARRAY = "array"
 # name; arrows nested under a const-bound object still take the object's name.
 JS_CALL_RESULT_VALUE_TYPES = frozenset({TS_CALL_EXPRESSION, TS_NEW_EXPRESSION})
 TS_FUNCTION_EXPRESSION = "function_expression"
+# The `get` accessor keyword prefixing a getter `method_definition`
+# (`get thing() {...}`); its presence marks the method as a property whose
+# reads are member accesses, not invocations.
+TS_GET_ACCESSOR_KEYWORD = "get"
 TS_ARROW_FUNCTION = "arrow_function"
 TS_REQUIRED_PARAMETER = "required_parameter"
 TS_OPTIONAL_PARAMETER = "optional_parameter"
 TS_ASSIGNMENT_PATTERN = "assignment_pattern"
 TS_JS_ASSIGNMENT_EXPRESSION = "assignment_expression"
+# A class field holding a value (`log = noop`); `name` is the property, `value`
+# is the initializer. Used to reference a NAMED function a field binds.
+TS_PUBLIC_FIELD_DEFINITION = "public_field_definition"
 # `x += v` and friends: reads the old value AND writes the new one.
 TS_JS_AUGMENTED_ASSIGNMENT_EXPRESSION = "augmented_assignment_expression"
 # `x++` / `--x`: also a read-then-write; the operand is the `argument` field.
@@ -93,6 +100,16 @@ TS_MODULE = "module"
 TS_CLASS_BODY = "class_body"
 
 TS_PROPERTY_IDENTIFIER = "property_identifier"
+# `[expr]` as an object-literal / class-member key.
+TS_JS_COMPUTED_PROPERTY_NAME = "computed_property_name"
+# The `(a, b = 1, ...rest)` parameter list of a function.
+TS_JS_FORMAL_PARAMETERS = "formal_parameters"
+# A class field in the JS grammar (`[k] = v` in a class body); TS spells it
+# public_field_definition. Its key sits in the `property` field.
+TS_JS_FIELD_DEFINITION = "field_definition"
+# The Symbol global: `Symbol('x')` / `Symbol.for('x')` mint the unique keys
+# that symbol-keyed member dispatch (issue #989) indexes.
+JS_SYMBOL_GLOBAL = "Symbol"
 
 # JS prototype property keywords
 JS_PROTOTYPE_KEYWORD = "prototype"
@@ -134,14 +151,14 @@ JS_PROTOTYPE_METHOD_QUERY = """
       object: (identifier) @constructor_name
       property: (property_identifier) @prototype_keyword (#eq? @prototype_keyword "prototype"))
     property: (property_identifier) @method_name)
-  right: (function_expression) @method_function)
+  right: [(function_expression) (generator_function)] @method_function)
 """
 
 # JS object method query
 JS_OBJECT_METHOD_QUERY = """
 (pair
   key: (property_identifier) @method_name
-  value: (function_expression) @method_function)
+  value: [(function_expression) (generator_function)] @method_function)
 """
 
 # JS method definition query
@@ -170,7 +187,7 @@ JS_ASSIGNMENT_ARROW_QUERY = """
 JS_ASSIGNMENT_FUNCTION_QUERY = """
 (assignment_expression
   (member_expression) @member_expr
-  (function_expression) @function_expr)
+  [(function_expression) (generator_function)] @function_expr)
 """
 
 # JS/TS control-flow node types + fields for the path-sensitive taint walk
@@ -187,17 +204,36 @@ TS_JS_SWITCH_DEFAULT = "switch_default"
 # `c ? a : b` (shared name with the Java grammar); C++ spells it
 # conditional_expression.
 TS_JS_TERNARY_EXPRESSION = "ternary_expression"
+# tree-sitter-javascript parses `await (X)()` as a CALL to an identifier
+# spelled `await` with X as its argument (the TS grammar does not); climbs
+# treat that call as the transparent await it denotes.
+JS_AWAIT_IDENTIFIER = "await"
 # Short-circuit operators whose result IS one of the operands, so a
 # bind through them unions both operands' taints.
 JS_SHORT_CIRCUIT_OPERATORS: frozenset[str] = frozenset({"||", "??", "&&"})
+# The computed-name leaf prefix of a well-known-symbol class member
+# (`[Symbol.iterator]`, `[Symbol.toStringTag]`) as the definition pass
+# registers it; user symbol keys register without the `Symbol.` path.
+JS_WELL_KNOWN_SYMBOL_NAME_PREFIX = "[Symbol."
+JS_COMPUTED_NAME_SUFFIX = "]"
+JS_WELL_KNOWN_SYMBOL_BRACKET_PREFIX = "[Symbol["
+# `&&` alone among them cannot yield its LEFT operand as a function value.
+JS_OPERATOR_LOGICAL_AND = "&&"
 TS_JS_ELSE_CLAUSE = "else_clause"
 TS_JS_WHILE_STATEMENT = "while_statement"
 TS_JS_FOR_STATEMENT = "for_statement"
 TS_JS_FOR_IN_STATEMENT = "for_in_statement"
 TS_JS_TRY_STATEMENT = "try_statement"
 TS_JS_CATCH_CLAUSE = "catch_clause"
+# `(a, b)`: the comma operator; its value is the LAST operand.
+TS_JS_SEQUENCE_EXPRESSION = "sequence_expression"
+TS_JS_SWITCH_BODY = "switch_body"
+# `for (var x of xs)` hoists x to the function; only this `kind` widens the
+# loop binding's scope past the for statement itself.
+TS_JS_VAR_KIND = "var"
 TS_JS_FINALLY_CLAUSE = "finally_clause"
 FIELD_ALTERNATIVE = "alternative"
+FIELD_CONSEQUENCE = "consequence"
 FIELD_HANDLER = "handler"
 FIELD_FINALIZER = "finalizer"
 # The C-style `for (init; cond; increment)` update clause, which runs AFTER the
@@ -205,18 +241,25 @@ FIELD_FINALIZER = "finalizer"
 FIELD_INCREMENT = "increment"
 
 # JS/TS module system node types
+TS_TYPE_ANNOTATION = "type_annotation"
+TS_IMPORT_ALIAS = "import_alias"
+TS_JS_WITH_STATEMENT = "with_statement"
+TS_CLASS_STATIC_BLOCK = "class_static_block"
 TS_OBJECT_PATTERN = "object_pattern"
 TS_ARRAY_PATTERN = "array_pattern"
 TS_REST_PATTERN = "rest_pattern"
 TS_SHORTHAND_PROPERTY_IDENTIFIER_PATTERN = "shorthand_property_identifier_pattern"
 TS_SHORTHAND_PROPERTY_IDENTIFIER = "shorthand_property_identifier"
 TS_PAIR_PATTERN = "pair_pattern"
+# `{ a = dflt }` in a destructuring pattern: `left` binds, `right` is a READ.
+TS_OBJECT_ASSIGNMENT_PATTERN = "object_assignment_pattern"
 # `process.env.X` is a member_expression; `process.env['X']` a subscript, used
 # to detect environment-variable reads (issue #714 process.env follow-up).
 TS_SUBSCRIPT_EXPRESSION = "subscript_expression"
 TS_FIELD_INDEX = "index"
 TS_FUNCTION_DECLARATION = "function_declaration"
 TS_GENERATOR_FUNCTION_DECLARATION = "generator_function_declaration"
+TS_GENERATOR_FUNCTION = "generator_function"
 
 # Tree-sitter field names for module system
 FIELD_FUNCTION = "function"
@@ -255,6 +298,17 @@ JS_COMMONJS_EXPORTS_FUNCTION_QUERY = """
 """
 
 # JS/TS CommonJS module.exports query
+# The DIRECT form `module.exports = function (...) {...}` / arrow: the whole
+# module IS one function (fastify's generated error-serializer). Two-level
+# member on the left, unlike the three-level named-property form below.
+JS_COMMONJS_DIRECT_EXPORT_QUERY = """
+(assignment_expression
+  left: (member_expression
+    object: (identifier) @module_obj
+    property: (property_identifier) @exports_prop)
+  right: [(function_expression) (arrow_function) (call_expression)] @export_function)
+"""
+
 JS_COMMONJS_MODULE_EXPORTS_QUERY = """
 (assignment_expression
   left: (member_expression

{code_graph_rag-0.0.484 → code_graph_rag-0.0.534}/codebase_rag/constants/ast_nodes.py

@@ -51,11 +51,18 @@ IMPORT_NODES_INCLUDE = ("preproc_include",)
 JS_TS_FUNCTION_NODES = (
     "function_declaration",
     "generator_function_declaration",
+    # The generator EXPRESSION (`const g = function* () {}`) is a function
+    # value like function_expression; omitting it left such nodes
+    # unregistered and unreferencable (issue #994).
+    "generator_function",
     "function_expression",
     "arrow_function",
     "method_definition",
 )
-JS_TS_CLASS_NODES = ("class_declaration", "class")
+# The anonymous class-expression node type (`const X = class {...}`); the named
+# form is `class_declaration`.
+TS_CLASS_EXPRESSION = "class"
+JS_TS_CLASS_NODES = ("class_declaration", TS_CLASS_EXPRESSION)
 JS_TS_IMPORT_NODES = (
     "import_statement",
     "lexical_declaration",
@@ -83,6 +90,10 @@ FIELD_RETURN_TYPE = "return_type"
 FIELD_CONSTRUCTOR = "constructor"
 FIELD_DECLARATOR = "declarator"
 FIELD_PARAMETERS = "parameters"
+# A JS/TS arrow with a single bare-identifier parameter (`x => ...`) carries it
+# in the singular `parameter` field, with no formal_parameters wrapper.
+FIELD_PARAMETER = "parameter"
+FIELD_KIND = "kind"
 FIELD_RECEIVER = "receiver"
 FIELD_TYPE = "type"
 # The wrapped function/class inside a Python decorated_definition node.
@@ -162,6 +173,16 @@ TS_STRING = "string"
 # JS/TS string literals hold their text in a string_fragment child (like
 # Python's string_content), used for I/O target extraction.
 TS_STRING_FRAGMENT = "string_fragment"
+# The node type for an escaped char, spelled the same in every grammar we load
+# but placed differently, so check the shape before reusing this anywhere new:
+# JS/TS, Go, Rust, C/C++, C# and Java make it a SIBLING that splits the
+# surrounding content into separate fragments, and a reader joining content
+# children alone drops it and fuses the fragments either side (issue #944);
+# Python and Lua nest it inside their content node, which needs no handling;
+# Dart and Scala expose the escape as the only named child, with the plain
+# text in hidden tokens, so a content-plus-escape join would return the escape
+# ALONE (neither has an io_access descriptor today).
+TS_ESCAPE_SEQUENCE = "escape_sequence"
 # Modern Node builtin imports carry a node: scheme (`import fs from 'node:fs'`);
 # stripped when checking whether an imported name is the builtin module.
 NODE_BUILTIN_PREFIX = "node:"

{code_graph_rag-0.0.484 → code_graph_rag-0.0.534}/codebase_rag/constants/ast_python.py

@@ -5,6 +5,7 @@ TS_PY_IDENTIFIER = "identifier"
 TS_PY_TYPED_PARAMETER = "typed_parameter"
 TS_PY_TYPED_DEFAULT_PARAMETER = "typed_default_parameter"
 TS_PY_ATTRIBUTE = "attribute"
+TS_PY_FIELD_ATTRIBUTE = "attribute"
 TS_PY_CALL = "call"
 TS_PY_LIST = "list"
 TS_PY_DICTIONARY = "dictionary"

{code_graph_rag-0.0.484 → code_graph_rag-0.0.534}/codebase_rag/constants/ast_rust.py

@@ -20,6 +20,8 @@ TS_RS_ENUM_ITEM = "enum_item"
 TS_RS_TRAIT_ITEM = "trait_item"
 TS_RS_TYPE_ITEM = "type_item"
 TS_RS_FUNCTION_ITEM = "function_item"
+TS_RS_CONST_ITEM = "const_item"
+TS_RS_STATIC_ITEM = "static_item"
 TS_RS_IMPL_ITEM = "impl_item"
 TS_RS_FUNCTION_SIGNATURE_ITEM = "function_signature_item"
 TS_RS_CLOSURE_EXPRESSION = "closure_expression"
@@ -35,6 +37,12 @@ TS_RS_BLOCK_COMMENT = "block_comment"
 RS_COMMENT_TYPES = (TS_RS_LINE_COMMENT, TS_RS_BLOCK_COMMENT)
 TS_RS_ATTRIBUTE_ITEM = "attribute_item"
 TS_RS_INNER_ATTRIBUTE_ITEM = "inner_attribute_item"
+# The `#[cfg(test)]` gate in whitespace-normalised form: attributes are
+# token streams, so extracted text is compared after dropping ALL
+# whitespace (`#[cfg( test )]` names the same gate). Recorded on a mod
+# declaration's TARGET module and read by dead-code test detection
+# (issue #1010).
+RS_CFG_TEST_ATTRIBUTE = "#[cfg(test)]"
 
 # Rust I/O direct-sink walk node types (issue #714). call_expression keeps a
 # `function` field (a scoped_identifier like `std::fs::write`), so call_name works
@@ -170,3 +178,16 @@ RS_ENCODING_UTF8 = "utf8"
 RS_WILDCARD_PREFIX = "*"
 
 RS_FIELD_ARGUMENT = "argument"
+
+# Cargo target layout (issue #1007 crate-root discovery). Auto-target
+# directories root every .rs file directly inside them; explicit target
+# `path` overrides in the manifest sections below root the named file
+# wherever it sits. Entry stems never root themselves as file targets.
+RS_AUTO_TARGET_DIRS = frozenset({"examples", "tests", "benches"})
+RS_BIN_DIR = "bin"
+RS_BUILD_STEM = "build"
+RS_ENTRY_STEMS = frozenset({"lib", "main", "mod"})
+RS_MANIFEST_TARGET_SECTIONS = ("bin", "lib", "example", "test", "bench")
+RS_MANIFEST_PATH_KEY = "path"
+RS_MANIFEST_PACKAGE_KEY = "package"
+RS_MANIFEST_BUILD_KEY = "build"

{code_graph_rag-0.0.484 → code_graph_rag-0.0.534}/codebase_rag/constants/core.py

@@ -90,9 +90,11 @@ TEXT_UNKNOWN = "unknown"
 TMP_EXTENSION = ".tmp"
 
 MOD_RS = "mod.rs"
+LIB_RS = "lib.rs"
+MAIN_RS = "main.rs"
 SEPARATOR_DOUBLE_COLON = "::"
 SEPARATOR_PROTOTYPE = ".prototype."
-RUST_CRATE_PREFIX = "crate::"
+RUST_CRATE_KEYWORD = "crate"
 BUILTIN_PREFIX = "builtin"
 IIFE_FUNC_PREFIX = "iife_func_"
 IIFE_ARROW_PREFIX = "iife_arrow_"

{code_graph_rag-0.0.484 → code_graph_rag-0.0.534}/codebase_rag/constants/deadcode_roots.py

@@ -67,6 +67,24 @@ GO_ROOT_FUNCTION_NAMES: frozenset[str] = frozenset({"init", "main"})
 # call site -- a reachability root (gated by .rs).
 RUST_ROOT_FUNCTION_NAMES: frozenset[str] = frozenset({"main"})
 
+# Rust test attributes: the harness invokes these functions with no call site.
+# Bare names match exactly; scoped runner variants (#[tokio::test],
+# #[async_std::test]) match by the ::test suffix. Gated by .rs (issue #1008).
+RUST_TEST_ATTRIBUTE_NAMES: frozenset[str] = frozenset({"test", "bench"})
+RUST_TEST_ATTRIBUTE_SUFFIX = "::test"
+
+# The `#[cfg(test)] mod tests` convention: a real MODULE node named
+# `tests` or `test` in a .rs file marks inline test code (issue #1008).
+# This is deliberately WIDER than TEST_PATH_PATTERNS (whose /tests/ and
+# /test/ entries match directory segments only, never a src/test.rs file
+# or an inline mod): the name is a proxy for the `#[cfg(test)]` gate the
+# graph does not yet record. Measured across a 972-crate corpus, 4155
+# such modules are cfg-gated test code and 41 are ungated, of which two
+# ship as production API (aws-lc-rs `pub mod test`, alacritty's terminal
+# test helpers), both test-support by nature; that residual silencing is
+# accepted until issue #1010 replaces the name proxy with cfg awareness.
+RUST_TEST_MODULE_SEGMENTS: frozenset[str] = frozenset({"tests", "test"})
+
 # Rust trait-impl methods the language/std dispatches implicitly (Display::fmt
 # via format!, PartialEq::eq via ==, Iterator::next via for, operator traits,
 # Drop::drop, serde, ...), never through an explicit call the graph can see.
@@ -210,6 +228,96 @@ TEST_PATH_PATTERNS: tuple[str, ...] = (
     "__tests__",
 )
 
+# NestJS component decorators that mark a CLASS as instantiated and driven by
+# the DI container / framework, never by a first-party `new` the graph can see:
+# `@Injectable` (providers/services), `@Controller`, `@Module`, `@Catch`
+# (exception filters), `@Resolver` (GraphQL), `@WebSocketGateway`. Such a class's
+# constructor is invoked by the container and its framework-contract methods by
+# Nest, so both are reachability roots (gated by a JS/TS extension). Names are the
+# lowercased, argument-stripped form _norm_decorator produces.
+NEST_ROOT_CLASS_DECORATORS: frozenset[str] = frozenset(
+    {
+        "injectable",
+        "controller",
+        "module",
+        "catch",
+        "resolver",
+        "websocketgateway",
+    }
+)
+
+# NestJS async-options factory interfaces follow the `XxxOptionsFactory` naming
+# convention (`TypeOrmOptionsFactory`, `MongooseOptionsFactory`,
+# `GqlOptionsFactory`, ...). A class that `implements` one has its factory method
+# invoked by Nest, so its methods are roots. Matched on the interface leaf name
+# so only these framework contracts root (an unrelated third-party interface
+# does not), gated to an EXTERNAL interface (outside the project prefix).
+NEST_OPTIONS_FACTORY_SUFFIX = "OptionsFactory"
+
+# NestJS methods invoked by the framework through a lifecycle or interface
+# contract, never by a named call the graph can see: lifecycle hooks
+# (`onModuleInit`, `onApplicationBootstrap`, ...) and the single-method
+# interface contracts (`NestMiddleware.use`, `NestInterceptor.intercept`,
+# `NestModule.configure`, `CanActivate.canActivate`, `ExceptionFilter.catch`,
+# `PipeTransform.transform`). Rooted only on a method of a NestJS component
+# class (a NEST_ROOT_CLASS_DECORATORS decorator), so a same-named ordinary
+# method (`use`, `transform`) on a plain class is NOT force-rooted.
+NEST_FRAMEWORK_METHOD_NAMES: frozenset[str] = frozenset(
+    {
+        "onModuleInit",
+        "onModuleDestroy",
+        "onApplicationBootstrap",
+        "onApplicationShutdown",
+        "beforeApplicationShutdown",
+        "configure",
+        "use",
+        "intercept",
+        "canActivate",
+        "catch",
+        "transform",
+    }
+)
+
+# React component base classes: a class that `extends` one of these is a class
+# component whose lifecycle methods React drives at runtime. Matched on the base
+# interface/class leaf name (`React.Component`, `PureComponent`, and the rarely
+# spelled-out `React.PureComponent`), so the INHERITS target's last segment
+# identifies it regardless of the import alias.
+REACT_COMPONENT_BASE_NAMES: frozenset[str] = frozenset({"Component", "PureComponent"})
+
+# The module namespace React's `Component`/`PureComponent` base lives in
+# (`react.Component`, `React.Component`). The base's namespace must equal this
+# EXACTLY (lowercased), so a look-alike (`preact.Component`, `notreact.Component`,
+# Ember/Glimmer's `@glimmer/component.Component`) is not mistaken for React.
+REACT_NAMESPACE_TOKEN = "react"
+
+# React class-component lifecycle methods the runtime invokes (mount/update/
+# unmount/render/error), plus the constructor React calls when it instantiates
+# the component. Never called by a first-party call the graph can see, so they
+# are reachability roots on a React component class (gated by INHERITS to a
+# REACT_COMPONENT_BASE_NAMES base and a JS/TS extension); the methods and
+# callbacks they reach via `this.` then expand from them.
+REACT_LIFECYCLE_METHOD_NAMES: frozenset[str] = frozenset(
+    {
+        "render",
+        "constructor",
+        "componentDidMount",
+        "componentDidUpdate",
+        "componentWillUnmount",
+        "shouldComponentUpdate",
+        "getSnapshotBeforeUpdate",
+        "componentDidCatch",
+        "getDerivedStateFromProps",
+        "getDerivedStateFromError",
+        "componentWillMount",
+        "componentWillReceiveProps",
+        "componentWillUpdate",
+        "UNSAFE_componentWillMount",
+        "UNSAFE_componentWillReceiveProps",
+        "UNSAFE_componentWillUpdate",
+    }
+)
+
 # Python Enum protocol hooks: the enum machinery invokes these sunder
 # METHODS by NAME (_generate_next_value_ on auto(), _missing_ on a failed
 # value lookup), never through a call the graph can see -- runtime roots

{code_graph_rag-0.0.484 → code_graph_rag-0.0.534}/codebase_rag/constants/deps.py

@@ -45,6 +45,8 @@ DEP_FILE_GOMOD = "go.mod"
 # the module's packages; a same-line comment (incl. `// Deprecated:`) may
 # trail it.
 GO_KEYWORD_MODULE = "module"
+GO_KEYWORD_PACKAGE = "package"
+GO_PACKAGE_MAIN = "main"
 GO_MOD_COMMENT_PREFIX = "//"
 DEP_FILE_GEMFILE = "gemfile"
 DEP_FILE_COMPOSER = "composer.json"