Add gRPC/GraphQL/tRPC service detection with protobuf Route extraction

Pipeline: gRPC/GraphQL/tRPC client libs in service_patterns, edge emitters
in pass_parallel, __grpc__ Route nodes from .proto service defs in
pass_route_nodes, cross-repo matchers in pass_cross_repo. Also adds MQTT,
NATS, Dapr async patterns.

Protobuf extraction: service as Class, rpc as Function with rpc_name
fallback in func_name_node. Route nodes created by line-range matching
rpc Functions to enclosing service Classes.

Tested: Online Boutique protos produce 16 gRPC Route nodes.

Author: test

internal/cbm/extract_defs.c

@@ -188,7 +188,12 @@ static void extract_elixir_call(CBMExtractCtx *ctx, TSNode node, const CBMLangSp
 
 // Get "name" field from a node
 static TSNode func_name_node(TSNode node) {
-    return ts_node_child_by_field_name(node, TS_FIELD("name"));
+    TSNode name = ts_node_child_by_field_name(node, TS_FIELD("name"));
+    if (ts_node_is_null(name)) {
+        /* Protobuf rpc: name is in rpc_name child, not "name" field */
+        name = cbm_find_child_by_kind(node, "rpc_name");
+    }
+    return name;
 }
 
 // Lua: resolve anonymous function assignment name from parent assignment_statement.
@@ -1820,6 +1825,16 @@ static void extract_class_def(CBMExtractCtx *ctx, TSNode node, const CBMLangSpec
     if (ts_node_is_null(name_node) && ctx->language == CBM_LANG_SWIFT) {
         name_node = cbm_find_child_by_kind(node, "type_identifier");
     }
+    // Protobuf: service_name / message_name / enum_name children
+    if (ts_node_is_null(name_node) && ctx->language == CBM_LANG_PROTOBUF) {
+        name_node = cbm_find_child_by_kind(node, "service_name");
+        if (ts_node_is_null(name_node)) {
+            name_node = cbm_find_child_by_kind(node, "message_name");
+        }
+        if (ts_node_is_null(name_node)) {
+            name_node = cbm_find_child_by_kind(node, "enum_name");
+        }
+    }
     if (ts_node_is_null(name_node)) {
         return;
     }

internal/cbm/lang_specs.c

@@ -627,7 +627,8 @@ static const char *cmake_module_types[] = {"source_file", NULL};
 static const char *cmake_call_types[] = {"normal_command", NULL};
 
 // ==================== PROTOBUF ====================
-static const char *protobuf_class_types[] = {"message", "enum", NULL};
+static const char *protobuf_class_types[] = {"message", "enum", "service", NULL};
+static const char *protobuf_func_types[] = {"rpc", NULL};
 static const char *protobuf_module_types[] = {"source_file", NULL};
 static const char *protobuf_field_types[] = {"field", "map_field", "oneof_field", NULL};
 static const char *protobuf_import_types[] = {"import", NULL};
@@ -983,7 +984,7 @@ static const CBMLangSpec lang_specs[CBM_LANG_COUNT] = {
      empty_types, NULL, NULL},
 
     // CBM_LANG_PROTOBUF
-    {CBM_LANG_PROTOBUF, empty_types, protobuf_class_types, protobuf_field_types,
+    {CBM_LANG_PROTOBUF, protobuf_func_types, protobuf_class_types, protobuf_field_types,
      protobuf_module_types, empty_types, protobuf_import_types, empty_types, empty_types,
      empty_types, empty_types, empty_types, NULL, empty_types, NULL, NULL},
 

internal/cbm/service_patterns.c

@@ -234,6 +234,28 @@ static const lib_pattern_t async_libraries[] = {
     /* Scala */
     {"Alpakka", CBM_SVC_ASYNC, "alpakka"},
 
+    /* MQTT */
+    {"mqtt", CBM_SVC_ASYNC, "mqtt"},
+    {"paho.mqtt", CBM_SVC_ASYNC, "mqtt"},
+    {"MQTTClient", CBM_SVC_ASYNC, "mqtt"},
+    {"mosquitto", CBM_SVC_ASYNC, "mqtt"},
+    {"asyncio_mqtt", CBM_SVC_ASYNC, "mqtt"},
+    {"gmqtt", CBM_SVC_ASYNC, "mqtt"},
+    {"rumqttc", CBM_SVC_ASYNC, "mqtt"},
+
+    /* NATS */
+    {"nats.go", CBM_SVC_ASYNC, "nats"},
+    {"nats-py", CBM_SVC_ASYNC, "nats"},
+    {"nats.ws", CBM_SVC_ASYNC, "nats"},
+    {"nats.java", CBM_SVC_ASYNC, "nats"},
+    {"nats.net", CBM_SVC_ASYNC, "nats"},
+    {"async-nats", CBM_SVC_ASYNC, "nats"},
+    {"nats.rs", CBM_SVC_ASYNC, "nats"},
+
+    /* Dapr pub/sub */
+    {"dapr.clients.grpc", CBM_SVC_ASYNC, "dapr"},
+    {"DaprClient", CBM_SVC_ASYNC, "dapr"},
+
     {NULL, CBM_SVC_NONE, NULL},
 };
 
@@ -351,6 +373,88 @@ static const lib_pattern_t route_reg_libraries[] = {
     {NULL, CBM_SVC_NONE, NULL},
 };
 
+/* gRPC client libraries — protobuf stub invocations */
+static const lib_pattern_t grpc_libraries[] = {
+    /* Go */
+    {"google.golang.org/grpc", CBM_SVC_GRPC, NULL},
+    {"grpc.Dial", CBM_SVC_GRPC, NULL},
+    {"grpc.NewClient", CBM_SVC_GRPC, NULL},
+    {"grpc.DialContext", CBM_SVC_GRPC, NULL},
+
+    /* Python */
+    {"grpc.insecure_channel", CBM_SVC_GRPC, NULL},
+    {"grpc.secure_channel", CBM_SVC_GRPC, NULL},
+    {"grpcio", CBM_SVC_GRPC, NULL},
+    {"grpc.aio", CBM_SVC_GRPC, NULL},
+
+    /* Java/Kotlin */
+    {"io.grpc", CBM_SVC_GRPC, NULL},
+    {"ManagedChannelBuilder", CBM_SVC_GRPC, NULL},
+    {"ManagedChannel", CBM_SVC_GRPC, NULL},
+    {"newBlockingStub", CBM_SVC_GRPC, NULL},
+    {"newFutureStub", CBM_SVC_GRPC, NULL},
+
+    /* C# */
+    {"Grpc.Net.Client", CBM_SVC_GRPC, NULL},
+    {"GrpcChannel", CBM_SVC_GRPC, NULL},
+    {"Grpc.Core", CBM_SVC_GRPC, NULL},
+
+    /* JS/TS */
+    {"@grpc/grpc-js", CBM_SVC_GRPC, NULL},
+    {"grpc-web", CBM_SVC_GRPC, NULL},
+
+    /* Rust */
+    {"tonic", CBM_SVC_GRPC, NULL},
+
+    /* Dart/Flutter */
+    {"package:grpc", CBM_SVC_GRPC, NULL},
+
+    {NULL, CBM_SVC_NONE, NULL},
+};
+
+/* GraphQL client libraries */
+static const lib_pattern_t graphql_libraries[] = {
+    /* JS/TS */
+    {"graphql-request", CBM_SVC_GRAPHQL, NULL},
+    {"@apollo/client", CBM_SVC_GRAPHQL, NULL},
+    {"apollo-client", CBM_SVC_GRAPHQL, NULL},
+    {"urql", CBM_SVC_GRAPHQL, NULL},
+    {"graphql-tag", CBM_SVC_GRAPHQL, NULL},
+
+    /* Python */
+    {"gql", CBM_SVC_GRAPHQL, NULL},
+    {"sgqlc", CBM_SVC_GRAPHQL, NULL},
+    {"graphene", CBM_SVC_GRAPHQL, NULL},
+
+    /* Java */
+    {"graphql-java", CBM_SVC_GRAPHQL, NULL},
+    {"DgsQueryExecutor", CBM_SVC_GRAPHQL, NULL},
+
+    /* Go */
+    {"graphql-go", CBM_SVC_GRAPHQL, NULL},
+    {"gqlgen", CBM_SVC_GRAPHQL, NULL},
+
+    /* Ruby */
+    {"graphql-ruby", CBM_SVC_GRAPHQL, NULL},
+
+    /* Rust */
+    {"async-graphql", CBM_SVC_GRAPHQL, NULL},
+    {"juniper", CBM_SVC_GRAPHQL, NULL},
+
+    {NULL, CBM_SVC_NONE, NULL},
+};
+
+/* tRPC libraries (TypeScript only) */
+static const lib_pattern_t trpc_libraries[] = {
+    {"@trpc/server", CBM_SVC_TRPC, NULL},
+    {"@trpc/client", CBM_SVC_TRPC, NULL},
+    {"@trpc/react-query", CBM_SVC_TRPC, NULL},
+    {"createTRPCRouter", CBM_SVC_TRPC, NULL},
+    {"createTRPCProxyClient", CBM_SVC_TRPC, NULL},
+
+    {NULL, CBM_SVC_NONE, NULL},
+};
+
 /* Method suffix type (used by both route registration and HTTP client tables) */
 typedef struct {
     const char *suffix;
@@ -472,6 +576,21 @@ cbm_svc_kind_t cbm_service_pattern_match(const char *resolved_qn) {
         return p->kind;
     }
 
+    p = match_qn(resolved_qn, grpc_libraries);
+    if (p) {
+        return p->kind;
+    }
+
+    p = match_qn(resolved_qn, graphql_libraries);
+    if (p) {
+        return p->kind;
+    }
+
+    p = match_qn(resolved_qn, trpc_libraries);
+    if (p) {
+        return p->kind;
+    }
+
     return CBM_SVC_NONE;
 }
 

internal/cbm/service_patterns.h

@@ -18,6 +18,9 @@ typedef enum {
     CBM_SVC_ASYNC = 2,     /* Async dispatch (message broker, task queue) */
     CBM_SVC_CONFIG = 3,    /* Config/env accessor */
     CBM_SVC_ROUTE_REG = 4, /* Route registration (router.GET, app.get, Route::post) */
+    CBM_SVC_GRPC = 5,      /* gRPC client call (protobuf stub invocation) */
+    CBM_SVC_GRAPHQL = 6,   /* GraphQL client query/mutation */
+    CBM_SVC_TRPC = 7,      /* tRPC client procedure call */
 } cbm_svc_kind_t;
 
 /* Initialize the pattern lookup tables. Call once at startup. Thread-safe after init. */

src/mcp/mcp.c

@@ -1671,24 +1671,22 @@ static bool aspect_wanted(yyjson_doc *aspects_doc, yyjson_val *aspects_arr, cons
 /* Append cross_repo_links summary to architecture JSON if CROSS_* edges exist. */
 static void append_cross_repo_summary(yyjson_mut_doc *doc, yyjson_mut_val *root,
                                       const cbm_schema_info_t *schema) {
-    int cross_http = 0;
-    int cross_async = 0;
-    int cross_channel = 0;
-    for (int i = 0; i < schema->edge_type_count; i++) {
-        if (strcmp(schema->edge_types[i].type, "CROSS_HTTP_CALLS") == 0) {
-            cross_http = schema->edge_types[i].count;
-        } else if (strcmp(schema->edge_types[i].type, "CROSS_ASYNC_CALLS") == 0) {
-            cross_async = schema->edge_types[i].count;
-        } else if (strcmp(schema->edge_types[i].type, "CROSS_CHANNEL") == 0) {
-            cross_channel = schema->edge_types[i].count;
+    /* Scan edge types for any CROSS_* edges and sum them */
+    int cross_total = 0;
+    yyjson_mut_val *cr = yyjson_mut_obj(doc);
+    static const char *cross_types[] = {"CROSS_HTTP_CALLS",    "CROSS_ASYNC_CALLS",
+                                        "CROSS_CHANNEL",       "CROSS_GRPC_CALLS",
+                                        "CROSS_GRAPHQL_CALLS", "CROSS_TRPC_CALLS"};
+    for (int t = 0; t < (int)(sizeof(cross_types) / sizeof(cross_types[0])); t++) {
+        for (int i = 0; i < schema->edge_type_count; i++) {
+            if (strcmp(schema->edge_types[i].type, cross_types[t]) == 0) {
+                yyjson_mut_obj_add_int(doc, cr, cross_types[t], schema->edge_types[i].count);
+                cross_total += schema->edge_types[i].count;
+                break;
+            }
         }
     }
-    int cross_total = cross_http + cross_async + cross_channel;
     if (cross_total > 0) {
-        yyjson_mut_val *cr = yyjson_mut_obj(doc);
-        yyjson_mut_obj_add_int(doc, cr, "cross_http_calls", cross_http);
-        yyjson_mut_obj_add_int(doc, cr, "cross_async_calls", cross_async);
-        yyjson_mut_obj_add_int(doc, cr, "cross_channel", cross_channel);
         yyjson_mut_obj_add_int(doc, cr, "total", cross_total);
         yyjson_mut_obj_add_val(doc, root, "cross_repo_links", cr);
     }
@@ -2113,7 +2111,8 @@ static char *handle_cross_repo_mode(const char *repo_path, const char *args) {
     free(targets);
     yyjson_doc_free(jdoc);
 
-    int total = result.http_edges + result.async_edges + result.channel_edges;
+    int total = result.http_edges + result.async_edges + result.channel_edges + result.grpc_edges +
+                result.graphql_edges + result.trpc_edges;
     yyjson_mut_doc *doc = yyjson_mut_doc_new(NULL);
     yyjson_mut_val *root = yyjson_mut_obj(doc);
     yyjson_mut_doc_set_root(doc, root);
@@ -2124,6 +2123,9 @@ static char *handle_cross_repo_mode(const char *repo_path, const char *args) {
     yyjson_mut_obj_add_int(doc, root, "cross_http_calls", result.http_edges);
     yyjson_mut_obj_add_int(doc, root, "cross_async_calls", result.async_edges);
     yyjson_mut_obj_add_int(doc, root, "cross_channel", result.channel_edges);
+    yyjson_mut_obj_add_int(doc, root, "cross_grpc_calls", result.grpc_edges);
+    yyjson_mut_obj_add_int(doc, root, "cross_graphql_calls", result.graphql_edges);
+    yyjson_mut_obj_add_int(doc, root, "cross_trpc_calls", result.trpc_edges);
     yyjson_mut_obj_add_int(doc, root, "total_cross_edges", total);
     yyjson_mut_obj_add_real(doc, root, "elapsed_ms", result.elapsed_ms);
 

src/pipeline/pass_cross_repo.c

@@ -109,6 +109,9 @@ static void delete_cross_edges(cbm_store_t *store, const char *project) {
     cbm_store_delete_edges_by_type(store, project, "CROSS_HTTP_CALLS");
     cbm_store_delete_edges_by_type(store, project, "CROSS_ASYNC_CALLS");
     cbm_store_delete_edges_by_type(store, project, "CROSS_CHANNEL");
+    cbm_store_delete_edges_by_type(store, project, "CROSS_GRPC_CALLS");
+    cbm_store_delete_edges_by_type(store, project, "CROSS_GRAPHQL_CALLS");
+    cbm_store_delete_edges_by_type(store, project, "CROSS_TRPC_CALLS");
 }
 
 /* Insert a CROSS_* edge into a store. */
@@ -461,6 +464,90 @@ static int match_channels(cbm_store_t *src_store, const char *src_project, cbm_s
     return count;
 }
 
+/* ── Phase D: Generic route-type matcher (gRPC, GraphQL, tRPC) ──── */
+
+/* Look up a node's qualified_name by id. Returns true if found. */
+static bool lookup_node_qn(struct sqlite3 *db, int64_t node_id, char *out, size_t out_sz) {
+    out[0] = '\0';
+    sqlite3_stmt *st = NULL;
+    if (sqlite3_prepare_v2(db, "SELECT qualified_name FROM nodes WHERE id = ?1", CBM_NOT_FOUND, &st,
+                           NULL) != SQLITE_OK) {
+        return false;
+    }
+    sqlite3_bind_int64(st, SKIP_ONE, node_id);
+    bool found = false;
+    if (sqlite3_step(st) == SQLITE_ROW) {
+        const char *qn = (const char *)sqlite3_column_text(st, 0);
+        if (qn) {
+            snprintf(out, out_sz, "%s", qn);
+            found = true;
+        }
+    }
+    sqlite3_finalize(st);
+    return found;
+}
+
+/* Match edges of a given type against Route nodes with a given QN prefix.
+ * Reuses the same infrastructure as HTTP/async matching. */
+static int match_typed_routes(cbm_store_t *src_store, const char *src_project,
+                              cbm_store_t *tgt_store, const char *tgt_project,
+                              const char *edge_type, const char *svc_key, const char *method_key,
+                              const char *cross_edge_type) {
+    struct sqlite3 *src_db = cbm_store_get_db(src_store);
+    if (!src_db) {
+        return 0;
+    }
+
+    char sql[CBM_SZ_256];
+    snprintf(sql, sizeof(sql),
+             "SELECT e.source_id, e.target_id, e.properties FROM edges e "
+             "WHERE e.project = ?1 AND e.type = '%s'",
+             edge_type);
+
+    sqlite3_stmt *s = NULL;
+    if (sqlite3_prepare_v2(src_db, sql, CBM_NOT_FOUND, &s, NULL) != SQLITE_OK) {
+        return 0;
+    }
+    sqlite3_bind_text(s, SKIP_ONE, src_project, CBM_NOT_FOUND, SQLITE_STATIC);
+
+    int count = 0;
+    while (sqlite3_step(s) == SQLITE_ROW && count < CR_MAX_EDGES) {
+        int64_t caller_id = sqlite3_column_int64(s, 0);
+        int64_t route_id = sqlite3_column_int64(s, SKIP_ONE);
+        const char *props = (const char *)sqlite3_column_text(s, PAIR_LEN);
+
+        char svc_val[CBM_SZ_256] = {0};
+        char meth_val[CBM_SZ_256] = {0};
+        json_str_prop(props, svc_key, svc_val, sizeof(svc_val));
+        json_str_prop(props, method_key, meth_val, sizeof(meth_val));
+        if (!svc_val[0] && !meth_val[0]) {
+            continue;
+        }
+
+        /* Look up the Route QN from the target node (already points to the Route). */
+        char route_qn[CR_QN_BUF] = {0};
+        if (!lookup_node_qn(src_db, route_id, route_qn, sizeof(route_qn))) {
+            continue;
+        }
+
+        char handler_name[CBM_SZ_256] = {0};
+        char handler_file[CBM_SZ_512] = {0};
+        int64_t handler_id =
+            find_route_handler(tgt_store, route_qn, handler_name, sizeof(handler_name),
+                               handler_file, sizeof(handler_file));
+        if (handler_id == 0) {
+            continue;
+        }
+
+        emit_cross_route_bidirectional(src_store, src_project, src_db, caller_id, route_id,
+                                       tgt_store, tgt_project, handler_id, route_qn, handler_name,
+                                       handler_file, svc_val, svc_key, cross_edge_type);
+        count++;
+    }
+    sqlite3_finalize(s);
+    return count;
+}
+
 /* ── Collect target projects ─────────────────────────────────────── */
 
 /* When target_projects = ["*"], scan the cache directory for all .db files. */
@@ -566,6 +653,13 @@ cbm_cross_repo_result_t cbm_cross_repo_match(const char *project, const char **t
         result.http_edges += match_http_routes(src_store, project, tgt_store, tgt);
         result.async_edges += match_async_routes(src_store, project, tgt_store, tgt);
         result.channel_edges += match_channels(src_store, project, tgt_store, tgt);
+        result.grpc_edges += match_typed_routes(src_store, project, tgt_store, tgt, "GRPC_CALLS",
+                                                "service", "method", "CROSS_GRPC_CALLS");
+        result.graphql_edges +=
+            match_typed_routes(src_store, project, tgt_store, tgt, "GRAPHQL_CALLS", "operation",
+                               "operation", "CROSS_GRAPHQL_CALLS");
+        result.trpc_edges += match_typed_routes(src_store, project, tgt_store, tgt, "TRPC_CALLS",
+                                                "procedure", "procedure", "CROSS_TRPC_CALLS");
         result.projects_scanned++;
 
         cbm_store_close(tgt_store);
@@ -582,10 +676,9 @@ cbm_cross_repo_result_t cbm_cross_repo_match(const char *project, const char **t
     result.elapsed_ms = ((double)(t1.tv_sec - t0.tv_sec) * CR_MS_PER_SEC) +
                         ((double)(t1.tv_nsec - t0.tv_nsec) / CR_NS_PER_MS);
 
-    int total = result.http_edges + result.async_edges + result.channel_edges;
-    cbm_log_info("cross_repo.done", "project", project, "http", cr_itoa(result.http_edges), "async",
-                 cr_itoa(result.async_edges), "channel", cr_itoa(result.channel_edges), "total",
-                 cr_itoa(total));
+    int total = result.http_edges + result.async_edges + result.channel_edges + result.grpc_edges +
+                result.graphql_edges + result.trpc_edges;
+    cbm_log_info("cross_repo.done", "project", project, "total", cr_itoa(total));
 
     return result;
 }

src/pipeline/pass_cross_repo.h

@@ -12,6 +12,9 @@ typedef struct {
     int http_edges;    /* CROSS_HTTP_CALLS edges created */
     int async_edges;   /* CROSS_ASYNC_CALLS edges created */
     int channel_edges; /* CROSS_CHANNEL edges created */
+    int grpc_edges;    /* CROSS_GRPC_CALLS edges created */
+    int graphql_edges; /* CROSS_GRAPHQL_CALLS edges created */
+    int trpc_edges;    /* CROSS_TRPC_CALLS edges created */
     int projects_scanned;
     double elapsed_ms;
 } cbm_cross_repo_result_t;