Schema properties, DATA_FLOWS, YAML nested extraction, trace_path tool

- Serialize return_type, parent_class, base_classes on definition nodes
- DATA_FLOWS edges link callers through Route nodes to handlers
- YAML nested field extraction with dotted key paths (key_path property)
- Rename trace_call_path → trace_path with mode parameter:
  calls (default), data_flow, cross_service
- Backward compatible: trace_call_path alias still accepted
- Updated CLI help text and all tests

Author: DeusData

internal/cbm/cbm.h

@@ -173,6 +173,7 @@ typedef enum {
 typedef struct {
     const char *value;             // the string literal content
     const char *enclosing_func_qn; // QN of enclosing function
+    const char *key_path;          // dotted key path from YAML/JSON nesting (NULL if flat)
     CBMStringRefKind kind;         // URL, CONFIG
 } CBMStringRef;
 

internal/cbm/extract_unified.c

@@ -248,6 +248,116 @@ static void handle_string_refs(CBMExtractCtx *ctx, TSNode node, const WalkState
     cbm_stringref_push(&ctx->result->string_refs, ctx->arena, ref);
 }
 
+// --- YAML nested field extraction (D2) ---
+
+/* Recursively walk YAML block_mapping_pair nodes, building dotted key paths.
+ * Emits string_refs with key_path for leaf values that are URLs or config values.
+ * Example: body.operational_info.post_url → "https://..." */
+static void walk_yaml_mapping(CBMExtractCtx *ctx, TSNode node, const char *prefix) {
+    uint32_t nc = ts_node_named_child_count(node);
+    for (uint32_t i = 0; i < nc; i++) {
+        TSNode child = ts_node_named_child(node, i);
+        const char *ck = ts_node_type(child);
+
+        if (strcmp(ck, "block_mapping_pair") != 0) {
+            continue;
+        }
+
+        /* Get key */
+        TSNode key = ts_node_child_by_field_name(child, "key", 3);
+        if (ts_node_is_null(key)) {
+            continue;
+        }
+        char *key_text = cbm_node_text(ctx->arena, key, ctx->source);
+        if (!key_text || !key_text[0]) {
+            continue;
+        }
+
+        /* Build dotted path */
+        const char *path =
+            prefix ? cbm_arena_sprintf(ctx->arena, "%s.%s", prefix, key_text) : key_text;
+
+        /* Get value node */
+        TSNode val = ts_node_child_by_field_name(child, "value", 5);
+        if (ts_node_is_null(val)) {
+            continue;
+        }
+        const char *vk = ts_node_type(val);
+
+        /* If value is a nested mapping (block_node → block_mapping), recurse */
+        if (strcmp(vk, "block_node") == 0 || strcmp(vk, "block_mapping") == 0) {
+            /* Walk children for nested block_mapping */
+            uint32_t vnc = ts_node_named_child_count(val);
+            for (uint32_t vi = 0; vi < vnc; vi++) {
+                TSNode vc = ts_node_named_child(val, vi);
+                const char *vctype = ts_node_type(vc);
+                if (strcmp(vctype, "block_mapping") == 0 ||
+                    strcmp(vctype, "block_mapping_pair") == 0) {
+                    walk_yaml_mapping(ctx, vc, path);
+                }
+            }
+            continue;
+        }
+
+        /* Leaf value: extract and classify */
+        char *val_text = cbm_node_text(ctx->arena, val, ctx->source);
+        if (!val_text || !val_text[0]) {
+            continue;
+        }
+
+        /* Strip quotes */
+        int vlen = (int)strlen(val_text);
+        const char *content = val_text;
+        if (vlen >= 2 && (val_text[0] == '"' || val_text[0] == '\'')) {
+            content = val_text + 1;
+            vlen -= 2;
+            if (vlen <= 0) {
+                continue;
+            }
+        }
+
+        int kind_val = cbm_classify_string(content, vlen);
+        if (kind_val < 0) {
+            continue;
+        }
+
+        char *stored = cbm_arena_strndup(ctx->arena, content, (size_t)vlen);
+        if (!stored) {
+            continue;
+        }
+
+        CBMStringRef ref = {
+            .value = stored,
+            .enclosing_func_qn = ctx->module_qn,
+            .key_path = path,
+            .kind = (CBMStringRefKind)kind_val,
+        };
+        cbm_stringref_push(&ctx->result->string_refs, ctx->arena, ref);
+    }
+}
+
+/* Handle YAML files: walk top-level block_mapping recursively */
+static void handle_yaml_nested(CBMExtractCtx *ctx, TSNode node) {
+    if (ctx->language != CBM_LANG_YAML) {
+        return;
+    }
+    const char *kind = ts_node_type(node);
+    if (strcmp(kind, "block_mapping") != 0) {
+        return;
+    }
+    /* Only process root-level block_mapping (depth 0 or 1) */
+    TSNode parent = ts_node_parent(node);
+    if (ts_node_is_null(parent)) {
+        walk_yaml_mapping(ctx, node, NULL);
+    } else {
+        const char *pk = ts_node_type(parent);
+        if (strcmp(pk, "stream") == 0 || strcmp(pk, "document") == 0 ||
+            strcmp(pk, "block_node") == 0) {
+            walk_yaml_mapping(ctx, node, NULL);
+        }
+    }
+}
+
 // --- Main unified cursor walk ---
 
 void cbm_extract_unified(CBMExtractCtx *ctx) {
@@ -281,6 +391,7 @@ void cbm_extract_unified(CBMExtractCtx *ctx) {
         handle_env_accesses(ctx, node, spec, &state);
         handle_type_assigns(ctx, node, spec, &state);
         handle_string_refs(ctx, node, &state);
+        handle_yaml_nested(ctx, node);
 
         // 4. Push scope markers for boundary nodes
         if (spec->function_node_types && cbm_kind_in_set(node, spec->function_node_types)) {

src/cli/cli.c

@@ -346,7 +346,7 @@ static const char skill_tracing_content[] =
     "description: Call chain and dependency expert. ALWAYS invoke this skill when the user "
     "asks who calls a function, what a function calls, needs impact analysis, or traces "
     "dependencies. Do not grep for function names directly — use codebase-memory-mcp "
-    "trace_call_path first.\n"
+    "trace_path first.\n"
     "---\n"
     "\n"
     "# Call Tracing & Impact Analysis\n"
@@ -355,7 +355,7 @@ static const char skill_tracing_content[] =
     "\n"
     "## Workflow\n"
     "1. `search_graph(name_pattern=\".*FuncName.*\")` — find exact function name\n"
-    "2. `trace_call_path(function_name=\"FuncName\", direction=\"both\")` — trace callers + "
+    "2. `trace_path(function_name=\"FuncName\", direction=\"both\")` — trace callers + "
     "callees\n"
     "3. `detect_changes` — find what changed and assess risk_labels\n"
     "\n"
@@ -402,7 +402,7 @@ static const char skill_reference_content[] =
     "- `search_graph` — find nodes by pattern\n"
     "- `search_code` — text search in source\n"
     "- `query_graph` — Cypher query language\n"
-    "- `trace_call_path` — call chain traversal\n"
+    "- `trace_path` — call chain traversal\n"
     "- `get_code_snippet` — read function source\n"
     "- `get_graph_schema` — node/edge type catalog\n"
     "- `get_architecture` — high-level summary\n"
@@ -429,7 +429,7 @@ static const char codex_instructions_content[] =
     "Use the MCP tools to explore and understand the code:\n"
     "\n"
     "- `search_graph` — find functions, classes, routes by pattern\n"
-    "- `trace_call_path` — trace who calls a function or what it calls\n"
+    "- `trace_path` — trace who calls a function or what it calls\n"
     "- `get_code_snippet` — read function source code\n"
     "- `query_graph` — run Cypher queries for complex patterns\n"
     "- `get_architecture` — high-level project summary\n"
@@ -963,7 +963,7 @@ static const char agent_instructions_content[] =
     "\n"
     "## Priority Order\n"
     "1. `search_graph` — find functions, classes, routes, variables by pattern\n"
-    "2. `trace_call_path` — trace who calls a function or what it calls\n"
+    "2. `trace_path` — trace who calls a function or what it calls\n"
     "3. `get_code_snippet` — read specific function/class source code\n"
     "4. `query_graph` — run Cypher queries for complex patterns\n"
     "5. `get_architecture` — high-level project summary\n"
@@ -975,7 +975,7 @@ static const char agent_instructions_content[] =
     "\n"
     "## Examples\n"
     "- Find a handler: `search_graph(name_pattern=\".*OrderHandler.*\")`\n"
-    "- Who calls it: `trace_call_path(function_name=\"OrderHandler\", direction=\"inbound\")`\n"
+    "- Who calls it: `trace_path(function_name=\"OrderHandler\", direction=\"inbound\")`\n"
     "- Read source: `get_code_snippet(qualified_name=\"pkg/orders.OrderHandler\")`\n";
 
 const char *cbm_get_agent_instructions(void) {
@@ -1558,7 +1558,7 @@ static void cbm_install_hook_gate_script(const char *home) {
                "fi\n"
                "touch \"$GATE\"\n"
                "echo 'BLOCKED: For code discovery, use codebase-memory-mcp tools first: "
-               "search_graph(name_pattern) to find functions/classes, trace_call_path() for "
+               "search_graph(name_pattern) to find functions/classes, trace_path() for "
                "call chains, get_code_snippet(qualified_name) to read source. If the graph "
                "is not indexed yet, call index_repository first. Fall back to Grep/Glob/Read "
                "only for text content search. If you need Grep, retry.' >&2\n"
@@ -1574,8 +1574,8 @@ static void cbm_install_hook_gate_script(const char *home) {
 }
 
 #define GEMINI_HOOK_MATCHER "google_search|read_file|grep_search"
-#define GEMINI_HOOK_COMMAND                                                    \
-    "echo 'Reminder: prefer codebase-memory-mcp search_graph/trace_call_path/" \
+#define GEMINI_HOOK_COMMAND                                               \
+    "echo 'Reminder: prefer codebase-memory-mcp search_graph/trace_path/" \
     "get_code_snippet over grep/file search for code discovery.' >&2"
 
 int cbm_upsert_gemini_hooks(const char *settings_path) {

src/main.c

@@ -148,7 +148,7 @@ static void print_help(void) {
     printf("  --port=N     Set UI port (default 9749, persisted)\n");
     printf("\nSupported agents (auto-detected):\n");
     printf("  Claude Code, Codex CLI, Gemini CLI, Zed, OpenCode, Antigravity, Aider, KiloCode\n");
-    printf("\nTools: index_repository, search_graph, query_graph, trace_call_path,\n");
+    printf("\nTools: index_repository, search_graph, query_graph, trace_path,\n");
     printf("  get_code_snippet, get_graph_schema, get_architecture, search_code,\n");
     printf("  list_projects, delete_project, index_status, detect_changes,\n");
     printf("  manage_adr, ingest_traces\n");

src/mcp/mcp.c

@@ -253,14 +253,19 @@ static const tool_def_t TOOLS[] = {
      "\"Optional row limit. Default: unlimited (100k "
      "ceiling)\"}},\"required\":[\"query\",\"project\"]}"},
 
-    {"trace_call_path",
-     "Trace function call paths — who calls a function and what it calls. Use INSTEAD OF grep when "
-     "finding callers, dependencies, or impact analysis.",
+    {"trace_path",
+     "Trace paths through the code graph. Modes: calls (callers/callees), data_flow (value "
+     "propagation with args at each hop), cross_service (through HTTP/async Route nodes). "
+     "Use INSTEAD OF grep for callers, dependencies, impact analysis, or data flow tracing.",
      "{\"type\":\"object\",\"properties\":{\"function_name\":{\"type\":\"string\"},\"project\":{"
      "\"type\":\"string\"},\"direction\":{\"type\":\"string\",\"enum\":[\"inbound\",\"outbound\","
-     "\"both\"],\"default\":\"both\"},\"depth\":{\"type\":\"integer\",\"default\":3},\"edge_"
-     "types\":{\"type\":\"array\",\"items\":{\"type\":\"string\"}}},\"required\":[\"function_"
-     "name\",\"project\"]}"},
+     "\"both\"],\"default\":\"both\"},\"depth\":{\"type\":\"integer\",\"default\":3},\"mode\":{"
+     "\"type\":\"string\",\"enum\":[\"calls\",\"data_flow\",\"cross_service\"],\"default\":"
+     "\"calls\",\"description\":\"calls: follow CALLS edges. data_flow: follow CALLS+DATA_FLOWS "
+     "with arg expressions. cross_service: follow HTTP_CALLS+ASYNC_CALLS+DATA_FLOWS through "
+     "Routes.\"},\"parameter_name\":{\"type\":\"string\",\"description\":\"For data_flow mode: "
+     "scope trace to a specific parameter name\"},\"edge_types\":{\"type\":\"array\",\"items\":{"
+     "\"type\":\"string\"}}},\"required\":[\"function_name\",\"project\"]}"},
 
     {"get_code_snippet",
      "Read source code for a function/class/symbol. IMPORTANT: First call search_graph to find the "
@@ -1223,11 +1228,15 @@ static char *handle_trace_call_path(cbm_mcp_server_t *srv, const char *args) {
     char *project = cbm_mcp_get_string_arg(args, "project");
     cbm_store_t *store = resolve_store(srv, project);
     char *direction = cbm_mcp_get_string_arg(args, "direction");
+    char *mode = cbm_mcp_get_string_arg(args, "mode");
+    char *param_name = cbm_mcp_get_string_arg(args, "parameter_name");
     int depth = cbm_mcp_get_int_arg(args, "depth", 3);
 
     if (!func_name) {
         free(project);
         free(direction);
+        free(mode);
+        free(param_name);
         return cbm_mcp_text_result("function_name is required", true);
     }
     if (!store) {
@@ -1237,6 +1246,8 @@ static char *handle_trace_call_path(cbm_mcp_server_t *srv, const char *args) {
         free(func_name);
         free(project);
         free(direction);
+        free(mode);
+        free(param_name);
         return _res;
     }
 
@@ -1245,6 +1256,8 @@ static char *handle_trace_call_path(cbm_mcp_server_t *srv, const char *args) {
         free(func_name);
         free(project);
         free(direction);
+        free(mode);
+        free(param_name);
         return not_indexed;
     }
 
@@ -1261,6 +1274,8 @@ static char *handle_trace_call_path(cbm_mcp_server_t *srv, const char *args) {
         free(func_name);
         free(project);
         free(direction);
+        free(mode);
+        free(param_name);
         cbm_store_free_nodes(nodes, 0);
         return cbm_mcp_text_result("{\"error\":\"function not found\"}", true);
     }
@@ -1271,9 +1286,55 @@ static char *handle_trace_call_path(cbm_mcp_server_t *srv, const char *args) {
 
     yyjson_mut_obj_add_str(doc, root, "function", func_name);
     yyjson_mut_obj_add_str(doc, root, "direction", direction);
+    if (mode) {
+        yyjson_mut_obj_add_str(doc, root, "mode", mode);
+    }
+
+    /* Edge types: explicit > mode-based > default */
+    static const char *mode_calls[] = {"CALLS"};
+    static const char *mode_data_flow[] = {"CALLS", "DATA_FLOWS"};
+    static const char *mode_cross_svc[] = {"HTTP_CALLS", "ASYNC_CALLS", "DATA_FLOWS", "CALLS"};
+
+    const char *edge_types[16];
+    int edge_type_count = 0;
+
+    /* Try parsing explicit edge_types array from args */
+    yyjson_doc *et_doc = yyjson_read(args, strlen(args), 0);
+    if (et_doc) {
+        yyjson_val *et_arr = yyjson_obj_get(yyjson_doc_get_root(et_doc), "edge_types");
+        if (et_arr && yyjson_is_arr(et_arr)) {
+            size_t idx2;
+            size_t max2;
+            yyjson_val *val2;
+            yyjson_arr_foreach(et_arr, idx2, max2, val2) {
+                if (yyjson_is_str(val2) && edge_type_count < 16) {
+                    edge_types[edge_type_count++] = yyjson_get_str(val2);
+                }
+            }
+        }
+    }
 
-    const char *edge_types[] = {"CALLS"};
-    int edge_type_count = 1;
+    yyjson_doc *et_doc_keep = et_doc;
+    if (edge_type_count == 0) {
+        /* Select defaults by mode */
+        const char **defaults = mode_calls;
+        int n_defaults = 1;
+        if (mode && strcmp(mode, "data_flow") == 0) {
+            defaults = mode_data_flow;
+            n_defaults = 2;
+        } else if (mode && strcmp(mode, "cross_service") == 0) {
+            defaults = mode_cross_svc;
+            n_defaults = 4;
+        }
+        for (int i = 0; i < n_defaults; i++) {
+            edge_types[i] = defaults[i];
+        }
+        edge_type_count = n_defaults;
+        if (et_doc_keep) {
+            yyjson_doc_free(et_doc_keep);
+            et_doc_keep = NULL;
+        }
+    }
 
     /* Run BFS for each requested direction.
      * IMPORTANT: yyjson_mut_obj_add_str borrows pointers — we must keep
@@ -1338,6 +1399,11 @@ static char *handle_trace_call_path(cbm_mcp_server_t *srv, const char *args) {
     free(func_name);
     free(project);
     free(direction);
+    free(mode);
+    free(param_name);
+    if (et_doc_keep) {
+        yyjson_doc_free(et_doc_keep);
+    }
 
     char *result = cbm_mcp_text_result(json, false);
     free(json);
@@ -2698,7 +2764,7 @@ char *cbm_mcp_handle_tool(cbm_mcp_server_t *srv, const char *tool_name, const ch
     if (strcmp(tool_name, "delete_project") == 0) {
         return handle_delete_project(srv, args_json);
     }
-    if (strcmp(tool_name, "trace_call_path") == 0) {
+    if (strcmp(tool_name, "trace_path") == 0 || strcmp(tool_name, "trace_call_path") == 0) {
         return handle_trace_call_path(srv, args_json);
     }
     if (strcmp(tool_name, "get_architecture") == 0) {

src/pipeline/pass_definitions.c

@@ -182,7 +182,10 @@ static void build_def_props(char *buf, size_t bufsize, const CBMDefinition *def)
     size_t pos = (size_t)n;
     append_json_string(buf, bufsize, &pos, "docstring", def->docstring);
     append_json_string(buf, bufsize, &pos, "signature", def->signature);
+    append_json_string(buf, bufsize, &pos, "return_type", def->return_type);
+    append_json_string(buf, bufsize, &pos, "parent_class", def->parent_class);
     append_json_str_array(buf, bufsize, &pos, "decorators", def->decorators);
+    append_json_str_array(buf, bufsize, &pos, "base_classes", def->base_classes);
     append_json_str_array(buf, bufsize, &pos, "param_names", def->param_names);
     append_json_str_array(buf, bufsize, &pos, "param_types", def->param_types);
 

src/pipeline/pass_parallel.c

@@ -193,7 +193,10 @@ static void build_def_props(char *buf, size_t bufsize, const CBMDefinition *def)
     size_t pos = (size_t)n;
     append_json_string(buf, bufsize, &pos, "docstring", def->docstring);
     append_json_string(buf, bufsize, &pos, "signature", def->signature);
+    append_json_string(buf, bufsize, &pos, "return_type", def->return_type);
+    append_json_string(buf, bufsize, &pos, "parent_class", def->parent_class);
     append_json_str_array(buf, bufsize, &pos, "decorators", def->decorators);
+    append_json_str_array(buf, bufsize, &pos, "base_classes", def->base_classes);
     append_json_str_array(buf, bufsize, &pos, "param_names", def->param_names);
     append_json_str_array(buf, bufsize, &pos, "param_types", def->param_types);
     if (pos < bufsize - 1) {