gitnexus 1.6.0 → 1.6.2-rc.1

package/dist/core/group/extractors/grpc-extractor.js

@@ -1,19 +1,29 @@
-import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { glob } from 'glob';
-function readSafe(repoPath, rel) {
-    const abs = path.resolve(repoPath, rel);
-    const base = path.resolve(repoPath);
-    const relToBase = path.relative(base, abs);
-    if (relToBase.startsWith('..') || path.isAbsolute(relToBase))
-        return null;
-    try {
-        return fs.readFileSync(abs, 'utf-8');
-    }
-    catch {
-        return null;
-    }
-}
+import Parser from 'tree-sitter';
+import { readSafe } from './fs-utils.js';
+import { GRPC_SCAN_GLOB, getPluginForFile, hasProtoPlugin, } from './grpc-patterns/index.js';
+/**
+ * Language-agnostic orchestrator for gRPC (provider + consumer) contract
+ * extraction.
+ *
+ * Two parts:
+ *
+ * 1. **`.proto` parsing** — tree-sitter when `tree-sitter-proto` is
+ *    installed (optionalDependency vendored in `vendor/tree-sitter-proto/`),
+ *    via the `.proto` entry in `grpc-patterns/` and `hasProtoPlugin`.
+ *    When the grammar isn't available (platform incompatibility, native
+ *    build failure) the orchestrator falls back to the in-process
+ *    string-sanitizing parser defined below (`stripProtoCommentsAndStrings`
+ *    + `extractServiceBlocks`). The fallback preserves offsets so any
+ *    downstream regex scans run against a sanitized copy without
+ *    affecting line numbers of the original.
+ *
+ * 2. **Source-scan providers / consumers** — delegated to per-language
+ *    plugins in `./grpc-patterns/`. The orchestrator imports NO
+ *    tree-sitter grammars or query strings — each plugin owns its own.
+ */
+// ─── .proto fallback parser (used only when tree-sitter-proto is absent) ───
 function contractId(pkg, service, method) {
     const prefix = pkg ? `${pkg}.${service}` : service;
     return `grpc::${prefix}/${method}`;
@@ -21,18 +31,103 @@ function contractId(pkg, service, method) {
 function serviceOnlyContractId(serviceName) {
     return `grpc::${serviceName}/*`;
 }
+/**
+ * Replace all .proto comments and string literals with spaces, preserving the
+ * original length and character offsets of the input. This lets downstream
+ * regex / brace-depth parsers run on a "sanitized" copy without having to
+ * understand proto syntax, while any RegExp.exec/index-based lookups that
+ * were already positional against `content` continue to work against the
+ * original string.
+ *
+ * Supported comment forms: `// line comment`, `/* block comment * /`.
+ * Supported strings: double-quoted ("…") and single-quoted ('…') with `\`
+ * escape handling. Raw/unterminated strings are not supported — we stop
+ * on a line break for line-style comments and on EOF for unterminated
+ * strings/blocks, which matches how most real proto files parse.
+ */
+function stripProtoCommentsAndStrings(content) {
+    const out = new Array(content.length);
+    let i = 0;
+    while (i < content.length) {
+        const ch = content[i];
+        const next = content[i + 1];
+        // Line comment: // ... \n
+        if (ch === '/' && next === '/') {
+            out[i] = ' ';
+            out[i + 1] = ' ';
+            i += 2;
+            while (i < content.length && content[i] !== '\n') {
+                out[i] = content[i] === '\r' ? '\r' : ' ';
+                i++;
+            }
+            continue;
+        }
+        // Block comment: /* ... */
+        if (ch === '/' && next === '*') {
+            out[i] = ' ';
+            out[i + 1] = ' ';
+            i += 2;
+            while (i < content.length) {
+                if (content[i] === '*' && content[i + 1] === '/') {
+                    out[i] = ' ';
+                    out[i + 1] = ' ';
+                    i += 2;
+                    break;
+                }
+                // Preserve newlines so line numbers stay stable for downstream code.
+                out[i] = content[i] === '\n' || content[i] === '\r' ? content[i] : ' ';
+                i++;
+            }
+            continue;
+        }
+        // String literal: "..." or '...'
+        if (ch === '"' || ch === "'") {
+            const quote = ch;
+            out[i] = ' '; // replace opening quote
+            i++;
+            while (i < content.length) {
+                const c = content[i];
+                if (c === '\\' && i + 1 < content.length) {
+                    // Skip escaped pair (e.g. \" \n \\)
+                    out[i] = ' ';
+                    out[i + 1] = ' ';
+                    i += 2;
+                    continue;
+                }
+                if (c === quote) {
+                    out[i] = ' ';
+                    i++;
+                    break;
+                }
+                // Preserve newlines; proto technically disallows unescaped newlines
+                // inside strings, but real files occasionally have them.
+                out[i] = c === '\n' || c === '\r' ? c : ' ';
+                i++;
+            }
+            continue;
+        }
+        out[i] = ch;
+        i++;
+    }
+    return out.join('');
+}
 function extractServiceBlocks(content) {
     const results = [];
-    // v1: brace-depth only — braces inside comments or string literals are not filtered (see spec Fix 2)
+    // Sanitize comments and string literals so braces inside them don't
+    // throw off the depth counter. The sanitized copy has the same length
+    // and offsets as the original, so we use it ONLY to scan for service
+    // headers and braces; the service body we return is sliced from the
+    // ORIGINAL content to preserve exact source text for downstream use.
+    const sanitized = stripProtoCommentsAndStrings(content);
     const headerRe = /service\s+(\w+)\s*\{/g;
     let headerMatch;
-    while ((headerMatch = headerRe.exec(content)) !== null) {
+    while ((headerMatch = headerRe.exec(sanitized)) !== null) {
         const serviceName = headerMatch[1];
         const bodyStart = headerMatch.index + headerMatch[0].length;
         let depth = 1;
         let pos = bodyStart;
-        while (pos < content.length && depth > 0) {
-            const ch = content[pos];
+        while (pos < sanitized.length && depth > 0) {
+            const ch = sanitized[pos];
             if (ch === '{')
                 depth++;
             else if (ch === '}')
@@ -60,6 +155,145 @@ function makeContract(cid, role, filePath, symbolName, confidence, meta) {
         meta: { ...meta, extractionStrategy: 'source_scan' },
     };
 }
+function normalizeProtoPath(rel) {
+    return rel.replace(/\\/g, '/');
+}
+function extractProtoImports(content) {
+    const imports = [];
+    const re = /^\s*import\s+"([^"]+)"\s*;/gm;
+    let match;
+    while ((match = re.exec(content)) !== null) {
+        imports.push(match[1]);
+    }
+    return imports;
+}
+function longestSharedSegmentRun(aPath, bPath) {
+    const a = aPath.split('/').filter(Boolean);
+    const b = bPath.split('/').filter(Boolean);
+    let best = 0;
+    for (let i = 0; i < a.length; i++) {
+        for (let j = 0; j < b.length; j++) {
+            let run = 0;
+            while (a[i + run] && b[j + run] && a[i + run] === b[j + run]) {
+                run++;
+            }
+            if (run > best)
+                best = run;
+        }
+    }
+    return best;
+}
+async function buildProtoContext(repoPath) {
+    const servicesByName = new Map();
+    const protoFiles = await glob('**/*.proto', {
+        cwd: repoPath,
+        absolute: false,
+        nodir: true,
+        ignore: ['**/node_modules/**', '**/.git/**', '**/vendor/**'],
+    });
+    const contents = new Map();
+    for (const rel of protoFiles) {
+        const content = readSafe(repoPath, rel);
+        if (!content)
+            continue;
+        contents.set(normalizeProtoPath(rel), content);
+    }
+    const packagesByProto = new Map();
+    const resolvePackage = (protoPath, seen = new Set()) => {
+        if (packagesByProto.has(protoPath))
+            return packagesByProto.get(protoPath) ?? '';
+        if (seen.has(protoPath))
+            return '';
+        const content = contents.get(protoPath);
+        if (!content)
+            return '';
+        seen.add(protoPath);
+        const pkgMatch = content.match(/^\s*package\s+([\w.]+)\s*;/m);
+        if (pkgMatch?.[1]) {
+            packagesByProto.set(protoPath, pkgMatch[1]);
+            return pkgMatch[1];
+        }
+        for (const importPath of extractProtoImports(content)) {
+            const normalizedImport = normalizeProtoPath(importPath);
+            const candidates = [
+                normalizeProtoPath(path.posix.normalize(path.posix.join(path.posix.dirname(protoPath), normalizedImport))),
+                normalizedImport,
+            ];
+            for (const candidate of candidates) {
+                if (!contents.has(candidate))
+                    continue;
+                const inheritedPackage = resolvePackage(candidate, seen);
+                if (inheritedPackage) {
+                    packagesByProto.set(protoPath, inheritedPackage);
+                    return inheritedPackage;
+                }
+            }
+        }
+        packagesByProto.set(protoPath, '');
+        return '';
+    };
+    for (const rel of protoFiles) {
+        const normalizedRel = normalizeProtoPath(rel);
+        const content = contents.get(normalizedRel);
+        if (!content)
+            continue;
+        const pkg = resolvePackage(normalizedRel);
+        const serviceBlocks = extractServiceBlocks(content);
+        for (const block of serviceBlocks) {
+            const rpcRe = /rpc\s+(\w+)\s*\(/g;
+            const methods = [];
+            let m;
+            while ((m = rpcRe.exec(block.body)) !== null) {
+                methods.push(m[1]);
+            }
+            const info = {
+                package: pkg,
+                serviceName: block.name,
+                methods,
+                protoPath: normalizedRel,
+            };
+            const existing = servicesByName.get(block.name) ?? [];
+            existing.push(info);
+            servicesByName.set(block.name, existing);
+        }
+    }
+    return { packagesByProto, servicesByName };
+}
+export async function buildProtoMap(repoPath) {
+    const { servicesByName } = await buildProtoContext(repoPath);
+    return servicesByName;
+}
+export function resolveProtoConflict(serviceName, sourceFilePath, candidates) {
+    if (candidates.length === 0)
+        return null;
+    if (candidates.length === 1)
+        return candidates[0];
+    const sourceDir = normalizeProtoPath(path.dirname(sourceFilePath));
+    const scored = candidates.map((c) => {
+        const protoDir = normalizeProtoPath(path.dirname(c.protoPath));
+        return { candidate: c, score: longestSharedSegmentRun(sourceDir, protoDir) };
+    });
+    let maxScore = -1;
+    for (const s of scored) {
+        if (s.score > maxScore)
+            maxScore = s.score;
+    }
+    const winners = scored.filter((s) => s.score === maxScore);
+    // Path heuristic cannot uniquely identify a winner — refuse to guess.
+    // Ties (including all-zero ties) would otherwise silently merge unrelated
+    // services under a fabricated package-qualified contract id.
+    if (winners.length !== 1) {
+        const paths = candidates.map((c) => c.protoPath).join(', ');
+        console.warn(`[grpc-extractor] Ambiguous proto resolution for service "${serviceName}" from ${sourceFilePath}: ${winners.length} candidates tied at score ${maxScore} among [${paths}] — skipping canonical contract`);
+        return null;
+    }
+    return winners[0].candidate;
+}
+export function serviceContractId(pkg, serviceName) {
+    const prefix = pkg ? `${pkg}.${serviceName}` : serviceName;
+    return `grpc::${prefix}/*`;
+}
+// ─── Orchestrator ────────────────────────────────────────────────────
 export class GrpcExtractor {
     type = 'grpc';
     async canExtract(_repo) {
@@ -67,198 +301,101 @@ export class GrpcExtractor {
     }
     async extract(_dbExecutor, repoPath, _repo) {
         const out = [];
-        // Proto files — definitive provider source
-        const protoFiles = await glob('**/*.proto', {
-            cwd: repoPath,
-            ignore: ['**/node_modules/**', '**/.git/**', '**/vendor/**'],
-            nodir: true,
-        });
-        for (const rel of protoFiles) {
-            const content = readSafe(repoPath, rel);
-            if (content)
-                out.push(...this.parseProtoFile(content, rel));
+        const protoContext = await buildProtoContext(repoPath);
+        const protoMap = protoContext.servicesByName;
+        // ─── Proto files — definitive provider source ─────────────────
+        // When tree-sitter-proto is available, .proto files are handled by
+        // the plugin loop below (they're in GRPC_SCAN_GLOB). Otherwise
+        // emit provider contracts directly from the proto map that
+        // `buildProtoContext` already built — no second glob / parse pass.
+        if (!hasProtoPlugin) {
+            for (const infos of protoMap.values()) {
+                for (const info of infos) {
+                    for (const methodName of info.methods) {
+                        const cid = contractId(info.package, info.serviceName, methodName);
+                        out.push(makeContract(cid, 'provider', info.protoPath, `${info.serviceName}.${methodName}`, 0.85, {
+                            package: info.package,
+                            service: info.serviceName,
+                            method: methodName,
+                            source: 'proto',
+                        }));
+                    }
+                }
+            }
         }
-        // Source files — server/client detection
-        const sourceFiles = await glob('**/*.{go,java,py,ts,tsx,js,jsx}', {
+        // ─── Source files (+ .proto when plugin available) ────────────
+        const sourceFiles = await glob(GRPC_SCAN_GLOB, {
             cwd: repoPath,
             ignore: ['**/node_modules/**', '**/.git/**', '**/vendor/**', '**/dist/**', '**/build/**'],
             nodir: true,
         });
+        const parser = new Parser();
         for (const rel of sourceFiles) {
+            const plugin = getPluginForFile(rel);
+            if (!plugin)
+                continue;
             const content = readSafe(repoPath, rel);
             if (!content)
                 continue;
-            const ext = path.extname(rel).toLowerCase();
-            if (ext === '.go') {
-                out.push(...this.scanGoProviders(content, rel));
-                out.push(...this.scanGoConsumers(content, rel));
-            }
-            else if (ext === '.java') {
-                out.push(...this.scanJavaProviders(content, rel));
-                out.push(...this.scanJavaConsumers(content, rel));
+            let detections = [];
+            try {
+                parser.setLanguage(plugin.language);
+                const tree = parser.parse(content);
+                detections = plugin.scan(tree);
             }
-            else if (ext === '.py') {
-                out.push(...this.scanPythonProviders(content, rel));
-                out.push(...this.scanPythonConsumers(content, rel));
+            catch {
+                continue;
             }
-            else if (['.ts', '.tsx', '.js', '.jsx'].includes(ext)) {
-                out.push(...this.scanTsProviders(content, rel));
+            for (const d of detections) {
+                const contract = this.detectionToContract(d, rel, protoMap);
+                if (contract)
+                    out.push(contract);
             }
         }
         return this.dedupe(out);
     }
-    parseProtoFile(content, filePath) {
-        const out = [];
-        const pkgMatch = content.match(/^package\s+([\w.]+)\s*;/m);
-        const pkg = pkgMatch ? pkgMatch[1] : '';
-        for (const { name: serviceName, body } of extractServiceBlocks(content)) {
-            const rpcRe = /rpc\s+(\w+)\s*\(/g;
-            let rpcMatch;
-            while ((rpcMatch = rpcRe.exec(body)) !== null) {
-                const methodName = rpcMatch[1];
-                const cid = contractId(pkg, serviceName, methodName);
-                out.push(makeContract(cid, 'provider', filePath, `${serviceName}.${methodName}`, 0.85, {
-                    package: pkg,
-                    service: serviceName,
-                    method: methodName,
-                    source: 'proto',
-                }));
-            }
-        }
-        return out;
-    }
-    scanGoProviders(content, filePath) {
-        const out = [];
-        // pb.RegisterXxxServer(
-        const registerRe = /\w+\.Register(\w+)Server\s*\(/g;
-        let m;
-        while ((m = registerRe.exec(content)) !== null) {
-            const serviceName = m[1];
-            out.push(makeContract(serviceOnlyContractId(serviceName), 'provider', filePath, `Register${serviceName}Server`, 0.8, { service: serviceName, source: 'go_register' }));
-        }
-        // pb.UnimplementedXxxServer
-        const unimplRe = /\w+\.Unimplemented(\w+)Server\b/g;
-        while ((m = unimplRe.exec(content)) !== null) {
-            const serviceName = m[1];
-            out.push(makeContract(serviceOnlyContractId(serviceName), 'provider', filePath, `Unimplemented${serviceName}Server`, 0.8, { service: serviceName, source: 'go_unimplemented' }));
-        }
-        return out;
-    }
-    scanGoConsumers(content, filePath) {
-        const out = [];
-        const re = /\w+\.New(\w+)Client\s*\(/g;
-        let m;
-        while ((m = re.exec(content)) !== null) {
-            const serviceName = m[1];
-            out.push(makeContract(serviceOnlyContractId(serviceName), 'consumer', filePath, `New${serviceName}Client`, 0.7, { service: serviceName, source: 'go_client' }));
-        }
-        return out;
-    }
-    scanJavaProviders(content, filePath) {
-        const out = [];
-        // @GrpcService
-        if (content.includes('@GrpcService')) {
-            const implBaseRe = /extends\s+(\w+)Grpc\.(\w+)ImplBase/;
-            const m = content.match(implBaseRe);
-            if (m) {
-                out.push(makeContract(serviceOnlyContractId(m[1]), 'provider', filePath, m[2], 0.8, {
-                    service: m[1],
-                    source: 'java_grpc_service',
-                }));
-            }
-            else {
-                // Try extracting service name from class name
-                const classRe = /class\s+(\w*?)(?:Grpc)?(?:Service)?\s+extends\s+(\w+)(?:Grpc\.(\w+))?ImplBase/;
-                const cm = content.match(classRe);
-                if (cm) {
-                    const svcName = cm[2].replace(/Grpc$/, '');
-                    out.push(makeContract(serviceOnlyContractId(svcName), 'provider', filePath, cm[1], 0.8, {
-                        service: svcName,
-                        source: 'java_grpc_service',
-                    }));
-                }
-            }
-        }
-        // extends XxxImplBase (without @GrpcService)
-        if (!content.includes('@GrpcService')) {
-            const implRe = /extends\s+(\w+?)(?:Grpc\.(\w+))?ImplBase/;
-            const m = content.match(implRe);
-            if (m) {
-                const svcName = m[2] || m[1].replace(/Grpc$/, '');
-                out.push(makeContract(serviceOnlyContractId(svcName), 'provider', filePath, svcName, 0.8, {
-                    service: svcName,
-                    source: 'java_impl_base',
-                }));
-            }
-        }
-        return out;
-    }
-    scanJavaConsumers(content, filePath) {
-        const out = [];
-        // XxxGrpc.newBlockingStub( or XxxGrpc.newStub(
-        const re = /(\w+)Grpc\.new(?:Blocking)?Stub\s*\(/g;
-        let m;
-        while ((m = re.exec(content)) !== null) {
-            const serviceName = m[1];
-            out.push(makeContract(serviceOnlyContractId(serviceName), 'consumer', filePath, `${serviceName}Stub`, 0.7, { service: serviceName, source: 'java_stub' }));
-        }
-        return out;
-    }
-    scanPythonProviders(content, filePath) {
-        const out = [];
-        // add_XxxServicer_to_server(
-        const re = /add_(\w+?)Servicer_to_server\s*\(/g;
-        let m;
-        while ((m = re.exec(content)) !== null) {
-            const serviceName = m[1];
-            out.push(makeContract(serviceOnlyContractId(serviceName), 'provider', filePath, `add_${serviceName}Servicer_to_server`, 0.8, { service: serviceName, source: 'python_servicer' }));
-        }
-        return out;
-    }
-    scanPythonConsumers(content, filePath) {
-        const out = [];
-        // XxxStub(
-        const re = /(\w+)Stub\s*\(/g;
-        let m;
-        while ((m = re.exec(content)) !== null) {
-            const name = m[1];
-            // Filter out common false positives
-            if (['Mock', 'Test', 'Fake', 'Stub'].includes(name))
-                continue;
-            out.push(makeContract(serviceOnlyContractId(name), 'consumer', filePath, `${name}Stub`, 0.7, {
-                service: name,
-                source: 'python_stub',
-            }));
-        }
-        return out;
-    }
-    scanTsProviders(content, filePath) {
-        const out = [];
-        // @GrpcMethod('ServiceName', 'MethodName')
-        const re = /@GrpcMethod\s*\(\s*['"](\w+)['"]\s*,\s*['"](\w+)['"]\s*\)/g;
-        let m;
-        while ((m = re.exec(content)) !== null) {
-            const serviceName = m[1];
-            const methodName = m[2];
-            const cid = contractId('', serviceName, methodName);
-            out.push(makeContract(cid, 'provider', filePath, `${serviceName}.${methodName}`, 0.8, {
-                service: serviceName,
-                method: methodName,
-                source: 'ts_grpc_method',
-            }));
-        }
-        return out;
+    /**
+     * Convert a plugin `GrpcDetection` into a concrete `ExtractedContract`
+     * by resolving the short service name against the proto map, building
+     * either a service-level (`grpc::pkg.Svc/*`) or method-level
+     * (`grpc::pkg.Svc/Method`) contract id, and selecting confidence
+     * based on whether the proto map had an entry.
+     */
+    detectionToContract(d, filePath, protoMap) {
+        const candidates = protoMap.get(d.serviceName) ?? [];
+        const proto = resolveProtoConflict(d.serviceName, filePath, candidates);
+        // If there were proto candidates but resolution was ambiguous, skip
+        // contract emission rather than fabricating a package-qualified id from
+        // an arbitrary candidate. resolveProtoConflict already warned.
+        if (candidates.length > 0 && proto === null)
+            return null;
+        const pkg = proto?.package ?? '';
+        const cid = d.methodName
+            ? contractId(pkg, d.serviceName, d.methodName)
+            : proto
+                ? serviceContractId(pkg, d.serviceName)
+                : serviceOnlyContractId(d.serviceName);
+        const confidence = proto ? d.confidenceWithProto : d.confidenceWithoutProto;
+        const meta = {
+            service: d.serviceName,
+            source: d.source,
+        };
+        if (d.methodName)
+            meta.method = d.methodName;
+        return makeContract(cid, d.role, filePath, d.symbolName, confidence, meta);
     }
     dedupe(items) {
-        const seen = new Set();
-        const out = [];
+        const byKey = new Map();
         for (const c of items) {
             const k = `${c.contractId}|${c.role}|${c.symbolRef.filePath}`;
-            if (seen.has(k))
-                continue;
-            seen.add(k);
-            out.push(c);
+            const existing = byKey.get(k);
+            if (!existing ||
+                c.confidence > existing.confidence ||
+                (c.confidence === existing.confidence &&
+                    String(c.meta.source) < String(existing.meta.source))) {
+                byKey.set(k, c);
+            }
         }
-        return out;
+        return Array.from(byKey.values());
     }
 }

package/dist/core/group/extractors/grpc-patterns/go.d.ts

@@ -0,0 +1,2 @@
+import type { GrpcLanguagePlugin } from './types.js';
+export declare const GO_GRPC_PLUGIN: GrpcLanguagePlugin;

package/dist/core/group/extractors/grpc-patterns/go.js

@@ -0,0 +1,97 @@
+import Go from 'tree-sitter-go';
+import { compilePatterns, runCompiledPatterns, } from '../tree-sitter-scanner.js';
+/**
+ * Go gRPC plugin. Detects:
+ *   - Provider: `pb.RegisterXxxServer(...)` calls
+ *   - Provider: `pb.UnimplementedXxxServer` embedded in a struct
+ *   - Consumer: `pb.NewXxxClient(conn)` calls
+ */
+const REGISTER_RE = /^Register(\w+)Server$/;
+const UNIMPLEMENTED_RE = /^Unimplemented(\w+)Server$/;
+const NEW_CLIENT_RE = /^New(\w+)Client$/;
+// Any `xxx.<fn>(...)` call — plugin filters the field identifier text.
+const SELECTOR_CALL_PATTERNS = compilePatterns({
+    name: 'go-grpc-selector-call',
+    language: Go,
+    patterns: [
+        {
+            meta: {},
+            query: `
+        (call_expression
+          function: (selector_expression
+            field: (field_identifier) @fn))
+      `,
+        },
+    ],
+});
+// Any `qualified_type` used as a struct field — for `pb.UnimplementedXxxServer`.
+const STRUCT_EMBEDDING_PATTERNS = compilePatterns({
+    name: 'go-grpc-struct-embedding',
+    language: Go,
+    patterns: [
+        {
+            meta: {},
+            query: `
+        (struct_type
+          (field_declaration_list
+            (field_declaration
+              type: (qualified_type
+                name: (type_identifier) @field_type))))
+      `,
+        },
+    ],
+});
+export const GO_GRPC_PLUGIN = {
+    name: 'go-grpc',
+    language: Go,
+    scan(tree) {
+        const out = [];
+        for (const match of runCompiledPatterns(SELECTOR_CALL_PATTERNS, tree)) {
+            const fnNode = match.captures.fn;
+            if (!fnNode)
+                continue;
+            const fnText = fnNode.text;
+            const registerMatch = REGISTER_RE.exec(fnText);
+            if (registerMatch) {
+                out.push({
+                    role: 'provider',
+                    serviceName: registerMatch[1],
+                    symbolName: fnText,
+                    source: 'go_register',
+                    confidenceWithProto: 0.8,
+                    confidenceWithoutProto: 0.65,
+                });
+                continue;
+            }
+            const newClientMatch = NEW_CLIENT_RE.exec(fnText);
+            if (newClientMatch) {
+                out.push({
+                    role: 'consumer',
+                    serviceName: newClientMatch[1],
+                    symbolName: fnText,
+                    source: 'go_client',
+                    confidenceWithProto: 0.75,
+                    confidenceWithoutProto: 0.55,
+                });
+                continue;
+            }
+        }
+        for (const match of runCompiledPatterns(STRUCT_EMBEDDING_PATTERNS, tree)) {
+            const fieldNode = match.captures.field_type;
+            if (!fieldNode)
+                continue;
+            const unimpl = UNIMPLEMENTED_RE.exec(fieldNode.text);
+            if (!unimpl)
+                continue;
+            out.push({
+                role: 'provider',
+                serviceName: unimpl[1],
+                symbolName: fieldNode.text,
+                source: 'go_unimplemented',
+                confidenceWithProto: 0.8,
+                confidenceWithoutProto: 0.65,
+            });
+        }
+        return out;
+    },
+};