gitnexus 1.6.4-rc.72 → 1.6.4-rc.73

package/dist/core/group/config-parser.js

@@ -1,11 +1,12 @@
 import { createRequire } from 'node:module';
 const _require = createRequire(import.meta.url);
 const yaml = _require('js-yaml');
-const VALID_CONTRACT_TYPES = ['http', 'grpc', 'topic', 'lib', 'custom'];
+const VALID_CONTRACT_TYPES = ['http', 'grpc', 'thrift', 'topic', 'lib', 'custom'];
 const VALID_ROLES = ['provider', 'consumer'];
 const DEFAULT_DETECT = {
     http: true,
     grpc: true,
+    thrift: true,
     topics: true,
     shared_libs: true,
     embedding_fallback: true,

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

@@ -136,7 +136,7 @@ export class ManifestExtractor {
             return null;
         // NOTE: All lookups use EXACT equality on the relevant name field and
         // deterministic ORDER BY before LIMIT 1. Previous versions used CONTAINS
-        // for fuzzy matching (plus an unconditional ".proto" fallback for gRPC)
+        // for fuzzy matching (plus an unconditional IDL file fallback for gRPC)
         // which produced silent false positives: e.g. manifest "/orders" would
         // match "/suborders", and a gRPC manifest entry in a repo with any
         // .proto file would attach to a random proto symbol.
@@ -180,16 +180,20 @@ export class ManifestExtractor {
            ORDER BY n.filePath ASC
            LIMIT 1`, { contract: link.contract });
             }
-            else if (link.type === 'grpc') {
+            else if (link.type === 'grpc' || link.type === 'thrift') {
                 // Contract is "Service/Method" or just "Service" (or package.Service
                 // variants). Prefer matching by method name when present, otherwise
-                // by service name. NO .proto path fallback — that's guaranteed to
-                // return a wrong symbol in any repo with more than one proto file.
+                // by service name. Thrift generated Java classes often use
+                // package.Service in manifests while graph Class/Interface names are
+                // stored as bare Service, so strip the package prefix for thrift
+                // service-name lookups. NO IDL path fallback — that's guaranteed to
+                // return a wrong symbol in any repo with more than one IDL file.
                 // Label filters scope lookups: methods → Function|Method, services
                 // → Class|Interface (no label match = no silent wrong hits on
                 // File/Variable nodes that happen to share the name).
                 const parts = link.contract.split('/');
-                const serviceName = parts[0]?.trim() ?? '';
+                const rawServiceName = parts[0]?.trim() ?? '';
+                const serviceName = link.type === 'thrift' ? (rawServiceName.split('.').pop() ?? '') : rawServiceName;
                 const methodName = parts[1]?.trim() ?? '';
                 if (methodName) {
                     rows = await executor(`MATCH (n:Function|Method) WHERE n.name = $methodName
@@ -290,6 +294,8 @@ export class ManifestExtractor {
             }
             case 'grpc':
                 return `grpc::${contract}`;
+            case 'thrift':
+                return `thrift::${contract}`;
             case 'topic':
                 return `topic::${contract}`;
             case 'lib':

package/dist/core/group/extractors/thrift-extractor.d.ts

@@ -0,0 +1,22 @@
+import type { ContractExtractor, CypherExecutor } from '../contract-extractor.js';
+import type { ExtractedContract, RepoHandle } from '../types.js';
+export interface ThriftServiceInfo {
+    namespace: string;
+    serviceName: string;
+    methods: string[];
+    thriftPath: string;
+}
+export interface ThriftContext {
+    namespacesByThrift: Map<string, string>;
+    servicesByName: Map<string, ThriftServiceInfo[]>;
+}
+export declare function thriftMethodContractId(namespace: string, serviceName: string, methodName: string): string;
+export declare function thriftServiceContractId(namespace: string, serviceName: string): string;
+export declare function buildThriftContext(repoPath: string): Promise<ThriftContext>;
+export declare class ThriftExtractor implements ContractExtractor {
+    type: "thrift";
+    canExtract(_repo: RepoHandle): Promise<boolean>;
+    extract(_dbExecutor: CypherExecutor | null, repoPath: string, _repo: RepoHandle): Promise<ExtractedContract[]>;
+    private detectionToContract;
+    private dedupe;
+}

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

@@ -0,0 +1,274 @@
+import { glob } from 'glob';
+import Parser from 'tree-sitter';
+import { readSafe } from './fs-utils.js';
+import { getPluginForFile, THRIFT_SCAN_GLOB, } from './thrift-patterns/index.js';
+function normalizeThriftPath(rel) {
+    return rel.replace(/\\/g, '/');
+}
+export function thriftMethodContractId(namespace, serviceName, methodName) {
+    const prefix = namespace ? `${namespace}.${serviceName}` : serviceName;
+    return `thrift::${prefix}/${methodName}`;
+}
+export function thriftServiceContractId(namespace, serviceName) {
+    const prefix = namespace ? `${namespace}.${serviceName}` : serviceName;
+    return `thrift::${prefix}/*`;
+}
+/**
+ * Replace Thrift comments and string literals with spaces while preserving
+ * newlines and character offsets. Service block scanning can then count braces
+ * without being confused by examples or comments inside the IDL.
+ */
+function stripThriftCommentsAndStrings(content) {
+    const out = new Array(content.length);
+    let i = 0;
+    while (i < content.length) {
+        const ch = content[i];
+        const next = content[i + 1];
+        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;
+        }
+        if (ch === '#') {
+            out[i] = ' ';
+            i++;
+            while (i < content.length && content[i] !== '\n') {
+                out[i] = content[i] === '\r' ? '\r' : ' ';
+                i++;
+            }
+            continue;
+        }
+        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;
+                }
+                out[i] = content[i] === '\n' || content[i] === '\r' ? content[i] : ' ';
+                i++;
+            }
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            const quote = ch;
+            out[i] = ' ';
+            i++;
+            while (i < content.length) {
+                const c = content[i];
+                if (c === '\\' && i + 1 < content.length) {
+                    out[i] = ' ';
+                    out[i + 1] = ' ';
+                    i += 2;
+                    continue;
+                }
+                if (c === quote) {
+                    out[i] = ' ';
+                    i++;
+                    break;
+                }
+                out[i] = c === '\n' || c === '\r' ? c : ' ';
+                i++;
+            }
+            continue;
+        }
+        out[i] = ch;
+        i++;
+    }
+    return out.join('');
+}
+function extractNamespace(sanitizedContent) {
+    const namespaces = [];
+    const namespaceRe = /^\s*namespace\s+([A-Za-z_*][\w.*-]*)\s+([A-Za-z_][\w.]*)\s*$/gm;
+    let match;
+    while ((match = namespaceRe.exec(sanitizedContent)) !== null) {
+        namespaces.push({ language: match[1], namespace: match[2] });
+    }
+    return (namespaces.find((entry) => entry.language === 'java')?.namespace ??
+        namespaces[0]?.namespace ??
+        '');
+}
+function extractServiceBlocks(sanitizedContent) {
+    const results = [];
+    const headerRe = /service\s+([A-Za-z_]\w*)\s*(?:extends\s+[A-Za-z_][\w.]*)?\s*\{/g;
+    let headerMatch;
+    while ((headerMatch = headerRe.exec(sanitizedContent)) !== null) {
+        const serviceName = headerMatch[1];
+        const bodyStart = headerMatch.index + headerMatch[0].length;
+        let depth = 1;
+        let pos = bodyStart;
+        while (pos < sanitizedContent.length && depth > 0) {
+            const ch = sanitizedContent[pos];
+            if (ch === '{')
+                depth++;
+            else if (ch === '}')
+                depth--;
+            pos++;
+        }
+        if (depth !== 0)
+            continue;
+        results.push({
+            name: serviceName,
+            body: sanitizedContent.slice(bodyStart, pos - 1),
+        });
+    }
+    return results;
+}
+function extractMethods(sanitizedServiceBody) {
+    const methods = [];
+    const methodRe = /(?:^|[;,\n\r])\s*(?:oneway\s+)?[A-Za-z_][\w.]*(?:\s*<[^(){};]*>)?\s+([A-Za-z_]\w*)\s*\(/g;
+    let match;
+    while ((match = methodRe.exec(sanitizedServiceBody)) !== null) {
+        methods.push(match[1]);
+    }
+    return methods;
+}
+function thriftSourceScanSymbolUid(contractId, role, filePath, symbolName) {
+    const contractKey = contractId.startsWith('thrift::')
+        ? contractId.slice('thrift::'.length)
+        : contractId;
+    return ['source-scan::thrift', role, contractKey, normalizeThriftPath(filePath), symbolName].join('::');
+}
+function makeContract(cid, role, filePath, symbolName, confidence, meta) {
+    return {
+        contractId: cid,
+        type: 'thrift',
+        role,
+        symbolUid: thriftSourceScanSymbolUid(cid, role, filePath, symbolName),
+        symbolRef: { filePath: normalizeThriftPath(filePath), name: symbolName },
+        symbolName,
+        confidence,
+        meta: { ...meta, extractionStrategy: 'source_scan' },
+    };
+}
+export async function buildThriftContext(repoPath) {
+    const thriftFiles = await glob('**/*.thrift', {
+        cwd: repoPath,
+        absolute: false,
+        nodir: true,
+        ignore: ['**/node_modules/**', '**/.git/**', '**/vendor/**', '**/dist/**', '**/build/**'],
+    });
+    const namespacesByThrift = new Map();
+    const servicesByName = new Map();
+    for (const rel of thriftFiles) {
+        const thriftPath = normalizeThriftPath(rel);
+        const content = readSafe(repoPath, rel);
+        if (!content)
+            continue;
+        const sanitized = stripThriftCommentsAndStrings(content);
+        const namespace = extractNamespace(sanitized);
+        namespacesByThrift.set(thriftPath, namespace);
+        for (const block of extractServiceBlocks(sanitized)) {
+            const methods = extractMethods(block.body);
+            const info = {
+                namespace,
+                serviceName: block.name,
+                methods,
+                thriftPath,
+            };
+            const existing = servicesByName.get(block.name) ?? [];
+            existing.push(info);
+            servicesByName.set(block.name, existing);
+        }
+    }
+    return { namespacesByThrift, servicesByName };
+}
+export class ThriftExtractor {
+    type = 'thrift';
+    async canExtract(_repo) {
+        return true;
+    }
+    async extract(_dbExecutor, repoPath, _repo) {
+        const out = [];
+        const context = await buildThriftContext(repoPath);
+        for (const infos of context.servicesByName.values()) {
+            for (const info of infos) {
+                for (const methodName of info.methods) {
+                    const symbolName = `${info.serviceName}.${methodName}`;
+                    out.push(makeContract(thriftMethodContractId(info.namespace, info.serviceName, methodName), 'provider', info.thriftPath, symbolName, 0.85, {
+                        namespace: info.namespace,
+                        service: info.serviceName,
+                        method: methodName,
+                        source: 'thrift_idl',
+                    }));
+                }
+            }
+        }
+        const sourceFiles = await glob(THRIFT_SCAN_GLOB, {
+            cwd: repoPath,
+            absolute: false,
+            nodir: true,
+            ignore: ['**/node_modules/**', '**/.git/**', '**/vendor/**', '**/dist/**', '**/build/**'],
+        });
+        const parser = new Parser();
+        for (const rel of sourceFiles) {
+            const plugin = getPluginForFile(rel);
+            if (!plugin)
+                continue;
+            const content = readSafe(repoPath, rel);
+            if (!content)
+                continue;
+            let detections = [];
+            try {
+                parser.setLanguage(plugin.language);
+                const tree = parser.parse(content);
+                detections = plugin.scan(tree);
+            }
+            catch {
+                continue;
+            }
+            for (const detection of detections) {
+                const contract = this.detectionToContract(detection, rel, context);
+                if (contract)
+                    out.push(contract);
+            }
+        }
+        return this.dedupe(out);
+    }
+    detectionToContract(detection, filePath, context) {
+        const candidates = context.servicesByName.get(detection.serviceName) ?? [];
+        if (candidates.length > 1)
+            return null;
+        const info = candidates[0];
+        if (info) {
+            if (!info.methods.includes(detection.methodName))
+                return null;
+            return makeContract(thriftMethodContractId(info.namespace, info.serviceName, detection.methodName), detection.role, filePath, detection.symbolName, detection.confidenceWithIdl, {
+                namespace: info.namespace,
+                service: info.serviceName,
+                method: detection.methodName,
+                source: detection.source,
+            });
+        }
+        if (detection.role !== 'consumer' ||
+            !detection.methodName ||
+            !detection.usesGeneratedServiceMember) {
+            return null;
+        }
+        return makeContract(thriftMethodContractId('', detection.serviceName, detection.methodName), detection.role, filePath, detection.symbolName, detection.confidenceWithoutIdl, {
+            service: detection.serviceName,
+            method: detection.methodName,
+            source: 'java_thrift_consumer_weak',
+        });
+    }
+    dedupe(items) {
+        const byKey = new Map();
+        for (const c of items) {
+            const key = `${c.contractId}|${c.role}|${c.symbolRef.filePath}|${c.symbolName}`;
+            const existing = byKey.get(key);
+            if (!existing || c.confidence > existing.confidence) {
+                byKey.set(key, c);
+            }
+        }
+        return Array.from(byKey.values());
+    }
+}

package/dist/core/group/extractors/thrift-patterns/index.d.ts

@@ -0,0 +1,4 @@
+import type { ThriftLanguagePlugin } from './types.js';
+export type { ThriftDetection, ThriftLanguagePlugin, ThriftRole } from './types.js';
+export declare const THRIFT_SCAN_GLOB = "**/*.java";
+export declare function getPluginForFile(rel: string): ThriftLanguagePlugin | undefined;

package/dist/core/group/extractors/thrift-patterns/index.js

@@ -0,0 +1,10 @@
+import * as path from 'node:path';
+import { JAVA_THRIFT_PLUGIN } from './java.js';
+const REGISTRY = {
+    '.java': JAVA_THRIFT_PLUGIN,
+};
+export const THRIFT_SCAN_GLOB = '**/*.java';
+export function getPluginForFile(rel) {
+    const ext = path.extname(rel).toLowerCase();
+    return REGISTRY[ext];
+}

package/dist/core/group/extractors/thrift-patterns/java.d.ts

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

package/dist/core/group/extractors/thrift-patterns/java.js

@@ -0,0 +1,220 @@
+import Java from 'tree-sitter-java';
+import { compilePatterns, runCompiledPatterns, } from '../tree-sitter-scanner.js';
+const GENERATED_MEMBER_TYPES = new Set(['Iface', 'Client']);
+const SERVICE_TYPE_RE = /^[A-Z][A-Za-z0-9]*(?:Service|Management)$/;
+const VARIABLE_PATTERNS = compilePatterns({
+    name: 'java-thrift-variables',
+    language: Java,
+    patterns: [
+        {
+            meta: {},
+            query: `
+        (field_declaration
+          type: (_) @type
+          declarator: (variable_declarator
+            name: (identifier) @var))
+      `,
+        },
+        {
+            meta: {},
+            query: `
+        (local_variable_declaration
+          type: (_) @type
+          declarator: (variable_declarator
+            name: (identifier) @var))
+      `,
+        },
+        {
+            meta: {},
+            query: `
+        (formal_parameter
+          type: (_) @type
+          name: (identifier) @var)
+      `,
+        },
+    ],
+});
+const CALL_PATTERNS = compilePatterns({
+    name: 'java-thrift-method-calls',
+    language: Java,
+    patterns: [
+        {
+            meta: {},
+            query: `
+        (method_invocation
+          object: (identifier) @receiver
+          name: (identifier) @method)
+      `,
+        },
+        {
+            meta: {},
+            query: `
+        (method_invocation
+          object: (field_access
+            object: (this)
+            field: (identifier) @receiver)
+          name: (identifier) @method)
+      `,
+        },
+    ],
+});
+const PROVIDER_PATTERNS = compilePatterns({
+    name: 'java-thrift-providers',
+    language: Java,
+    patterns: [
+        {
+            meta: {},
+            query: `
+        (class_declaration
+          name: (identifier) @class_name
+          (super_interfaces
+            (type_list
+              (_) @type))
+          body: (class_body) @body) @class
+      `,
+        },
+    ],
+});
+function serviceFromType(typeText) {
+    const segments = typeText.split('.').filter((segment) => segment.length > 0);
+    const last = segments.at(-1);
+    const service = segments.at(-2);
+    if (last && service && GENERATED_MEMBER_TYPES.has(last)) {
+        return { serviceName: service, usesGeneratedServiceMember: true };
+    }
+    return last && SERVICE_TYPE_RE.test(last)
+        ? { serviceName: last, usesGeneratedServiceMember: false }
+        : null;
+}
+function methodNamesInClassBody(body) {
+    const names = [];
+    for (let i = 0; i < body.namedChildCount; i++) {
+        const child = body.namedChild(i);
+        if (!child || child.type !== 'method_declaration')
+            continue;
+        const name = child.childForFieldName('name');
+        if (name?.text)
+            names.push(name.text);
+    }
+    return names;
+}
+function nearestAncestor(node, types) {
+    let current = node;
+    while (current) {
+        if (types.has(current.type))
+            return current;
+        current = current.parent;
+    }
+    return null;
+}
+function bindingScope(varNode) {
+    const declaration = nearestAncestor(varNode, new Set(['field_declaration', 'local_variable_declaration', 'formal_parameter']));
+    if (!declaration)
+        return null;
+    if (declaration.type === 'field_declaration') {
+        const classBody = nearestAncestor(declaration, new Set(['class_body']));
+        if (!classBody)
+            return null;
+        return { scope: classBody, declarationEnd: 0 };
+    }
+    if (declaration.type === 'formal_parameter') {
+        const callable = nearestAncestor(declaration, new Set(['method_declaration', 'constructor_declaration']));
+        if (!callable)
+            return null;
+        return { scope: callable, declarationEnd: 0 };
+    }
+    const block = nearestAncestor(declaration, new Set(['block']));
+    if (!block)
+        return null;
+    return { scope: block, declarationEnd: declaration.endIndex };
+}
+function resolveServiceForReceiver(bindings, receiver, callNode) {
+    const callStart = callNode.startIndex;
+    const candidates = bindings.filter((binding) => binding.name === receiver &&
+        binding.scopeStart <= callStart &&
+        callStart <= binding.scopeEnd &&
+        binding.declarationEnd <= callStart);
+    candidates.sort((a, b) => {
+        if (a.scopeSize !== b.scopeSize)
+            return a.scopeSize - b.scopeSize;
+        return b.declarationEnd - a.declarationEnd;
+    });
+    return candidates[0] ?? null;
+}
+export const JAVA_THRIFT_PLUGIN = {
+    name: 'java-thrift',
+    language: Java,
+    scan(tree) {
+        const out = [];
+        const bindings = [];
+        for (const match of runCompiledPatterns(VARIABLE_PATTERNS, tree)) {
+            const typeNode = match.captures.type;
+            const varNode = match.captures.var;
+            if (!typeNode || !varNode)
+                continue;
+            const service = serviceFromType(typeNode.text);
+            if (!service)
+                continue;
+            const scope = bindingScope(varNode);
+            if (!scope)
+                continue;
+            bindings.push({
+                name: varNode.text,
+                serviceName: service.serviceName,
+                usesGeneratedServiceMember: service.usesGeneratedServiceMember,
+                scopeStart: scope.scope.startIndex,
+                scopeEnd: scope.scope.endIndex,
+                declarationEnd: scope.declarationEnd,
+                scopeSize: scope.scope.endIndex - scope.scope.startIndex,
+            });
+        }
+        for (const match of runCompiledPatterns(CALL_PATTERNS, tree)) {
+            const receiver = match.captures.receiver?.text;
+            const methodName = match.captures.method?.text;
+            const callNode = match.captures.receiver?.parent;
+            if (!receiver || !methodName)
+                continue;
+            if (!callNode)
+                continue;
+            const binding = resolveServiceForReceiver(bindings, receiver, callNode);
+            if (!binding)
+                continue;
+            out.push({
+                role: 'consumer',
+                serviceName: binding.serviceName,
+                methodName,
+                symbolName: `${receiver}.${methodName}`,
+                source: 'java_thrift_consumer',
+                confidenceWithIdl: 0.75,
+                confidenceWithoutIdl: 0.45,
+                usesGeneratedServiceMember: binding.usesGeneratedServiceMember,
+            });
+        }
+        const emittedProviders = new Set();
+        for (const match of runCompiledPatterns(PROVIDER_PATTERNS, tree)) {
+            const typeNode = match.captures.type;
+            const bodyNode = match.captures.body;
+            if (!typeNode || !bodyNode)
+                continue;
+            const service = serviceFromType(typeNode.text);
+            if (!service)
+                continue;
+            for (const methodName of methodNamesInClassBody(bodyNode)) {
+                const key = `${service.serviceName}.${methodName}`;
+                if (emittedProviders.has(key))
+                    continue;
+                emittedProviders.add(key);
+                out.push({
+                    role: 'provider',
+                    serviceName: service.serviceName,
+                    methodName,
+                    symbolName: `${service.serviceName}.${methodName}`,
+                    source: 'java_thrift_provider',
+                    confidenceWithIdl: 0.8,
+                    confidenceWithoutIdl: 0,
+                });
+            }
+        }
+        return out;
+    },
+};

package/dist/core/group/extractors/thrift-patterns/types.d.ts

@@ -0,0 +1,17 @@
+import type Parser from 'tree-sitter';
+export type ThriftRole = 'provider' | 'consumer';
+export interface ThriftDetection {
+    role: ThriftRole;
+    serviceName: string;
+    methodName: string;
+    symbolName: string;
+    source: string;
+    confidenceWithIdl: number;
+    confidenceWithoutIdl: number;
+    usesGeneratedServiceMember?: boolean;
+}
+export interface ThriftLanguagePlugin {
+    name: string;
+    language: unknown;
+    scan(tree: Parser.Tree): ThriftDetection[];
+}

package/dist/core/group/extractors/thrift-patterns/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/group/matching.js

@@ -1,5 +1,5 @@
-function isGrpcWildcard(cid) {
-    return cid.startsWith('grpc::') && cid.endsWith('/*');
+function isServiceWildcard(cid) {
+    return (cid.startsWith('grpc::') || cid.startsWith('thrift::')) && cid.endsWith('/*');
 }
 /**
  * Detect HTTP contracts that are too generic or infrastructure-level to
@@ -55,8 +55,9 @@ export function normalizeContractId(id) {
             }
             return id;
         }
-        case 'grpc': {
-            // Canonical form: `grpc::<lowercased-package-or-service>[/<method>]`.
+        case 'grpc':
+        case 'thrift': {
+            // Canonical form: `<type>::<lowercased-package-or-service>[/<method>]`.
             //
             // The package/service segment is lowercased because gRPC package
             // names are effectively case-insensitive across language bindings
@@ -70,22 +71,23 @@ export function normalizeContractId(id) {
             // as DISTINCT canonical forms: `grpc::userservice` does not match
             // `grpc::userservice/Login`. That's by design — callers that want
             // service-level manifest matching against method-level providers
-            // should use the gRPC wildcard form `grpc::UserService/*` which is
+            // should use the service wildcard form `grpc::UserService/*` or
+            // `thrift::UserService/*` which is
             // handled by runWildcardMatch below.
             const slashIdx = rest.indexOf('/');
             if (slashIdx > 0) {
                 const pkg = rest.substring(0, slashIdx).toLowerCase();
                 const method = rest.substring(slashIdx);
-                return `grpc::${pkg}${method}`;
+                return `${type}::${pkg}${method}`;
             }
             if (slashIdx === 0) {
                 // Malformed "/method" with leading slash — keep as-is so two
                 // equally malformed ids can still match each other.
-                return `grpc::${rest}`;
+                return `${type}::${rest}`;
             }
             // No slash: package/service only. Lowercase to match the package
             // segment produced by the pkg/method branch above.
-            return `grpc::${rest.toLowerCase()}`;
+            return `${type}::${rest.toLowerCase()}`;
         }
         case 'topic':
             return `topic::${rest.trim().toLowerCase()}`;
@@ -109,6 +111,34 @@ function findMatchingKeys(contractId, index) {
         }
         return matches;
     }
+    if (normalized.startsWith('thrift::')) {
+        const rest = normalized.substring('thrift::'.length);
+        const slashIdx = rest.indexOf('/');
+        if (slashIdx > 0) {
+            const service = rest.substring(0, slashIdx);
+            const method = rest.substring(slashIdx + 1);
+            if (!service.includes('.') && method && method !== '*') {
+                const matches = [];
+                for (const key of index.keys()) {
+                    if (!key.startsWith('thrift::') || key.endsWith('/*'))
+                        continue;
+                    const providerRest = key.substring('thrift::'.length);
+                    const providerSlashIdx = providerRest.indexOf('/');
+                    if (providerSlashIdx < 0)
+                        continue;
+                    const providerService = providerRest.substring(0, providerSlashIdx);
+                    const providerMethod = providerRest.substring(providerSlashIdx + 1);
+                    if (providerMethod !== method)
+                        continue;
+                    if (providerService === service || providerService.endsWith('.' + service)) {
+                        matches.push(key);
+                    }
+                }
+                matches.sort();
+                return matches.length === 1 ? matches : [];
+            }
+        }
+    }
     return [];
 }
 export function buildProviderIndex(contracts, matchingConfig) {
@@ -126,7 +156,8 @@ export function buildProviderIndex(contracts, matchingConfig) {
 export function runExactMatch(contracts, providerIndex, matchingConfig) {
     const isNoisy = buildNoisyContractFilter(matchingConfig);
     const index = providerIndex ?? buildProviderIndex(contracts, matchingConfig);
-    const consumers = contracts.filter((c) => c.role === 'consumer' && !isGrpcWildcard(c.contractId) && !isNoisy(c.contractId));
+    // Skip service wildcard consumers — they go to wildcard pass only
+    const consumers = contracts.filter((c) => c.role === 'consumer' && !isServiceWildcard(c.contractId) && !isNoisy(c.contractId));
     const matched = [];
     const matchedConsumerIds = new Set();
     const matchedProviderIds = new Set();
@@ -165,32 +196,40 @@ export function runExactMatch(contracts, providerIndex, matchingConfig) {
     }
     // normalUnmatched: contracts that weren't matched in exact pass
     const normalUnmatched = contracts.filter((c) => {
-        if (isGrpcWildcard(c.contractId))
+        if (isServiceWildcard(c.contractId))
             return false; // excluded from exact, handled separately
         if (isNoisy(c.contractId))
             return false; // excluded from matching — don't surface as unmatched
         const id = `${c.repo}::${c.contractId}`;
         return c.role === 'provider' ? !matchedProviderIds.has(id) : !matchedConsumerIds.has(id);
     });
-    // Re-add gRPC wildcard contracts — they were never in exact matching
-    const grpcWildcards = contracts.filter((c) => isGrpcWildcard(c.contractId));
-    const unmatched = [...normalUnmatched, ...grpcWildcards];
+    // Re-add service wildcard contracts — they were never in exact matching
+    const serviceWildcards = contracts.filter((c) => isServiceWildcard(c.contractId));
+    const unmatched = [...normalUnmatched, ...serviceWildcards];
     return { matched, unmatched };
 }
 export function runWildcardMatch(unmatched, providerIndex) {
-    const wildcardConsumers = unmatched.filter((c) => c.role === 'consumer' && isGrpcWildcard(c.contractId));
+    const wildcardConsumers = unmatched.filter((c) => c.role === 'consumer' && isServiceWildcard(c.contractId));
     const matched = [];
     const matchedConsumerIds = new Set();
     for (const consumer of wildcardConsumers) {
         const normalized = normalizeContractId(consumer.contractId);
+        const typeEnd = normalized.indexOf('::');
+        const consumerType = normalized.slice(0, typeEnd);
         // "grpc::com.example.userservice/*" → "com.example.userservice"
-        // "grpc::userservice/*" → "userservice"
-        const fqService = normalized.slice(normalized.indexOf('::') + 2, -2); // strip "grpc::" and "/*"
+        // "thrift::userservice/*" → "userservice"
+        const fqService = normalized.slice(typeEnd + 2, -2); // strip "<type>::" and "/*"
+        const candidateProviders = [];
+        const matchedProviderServices = new Set();
         for (const [key, providers] of providerIndex) {
-            // Only match against non-wildcard gRPC providers (method-level IDs)
-            if (!key.startsWith('grpc::') || key.endsWith('/*'))
+            // Only match against non-wildcard same-type providers (method-level IDs).
+            const keyTypeEnd = key.indexOf('::');
+            if (keyTypeEnd < 0 || key.endsWith('/*'))
+                continue;
+            const providerType = key.slice(0, keyTypeEnd);
+            if (providerType !== consumerType)
                 continue;
-            const afterPrefix = key.slice(6); // strip "grpc::"
+            const afterPrefix = key.slice(keyTypeEnd + 2); // strip "<type>::"
             const slashIdx = afterPrefix.indexOf('/');
             if (slashIdx < 0)
                 continue;
@@ -200,37 +239,42 @@ export function runWildcardMatch(unmatched, providerIndex) {
                 (!fqService.includes('.') && providerFqService.endsWith('.' + fqService));
             if (!isMatch)
                 continue;
-            for (const provider of providers) {
-                // Skip same-repo same-service (same logic as runExactMatch)
-                if (provider.repo === consumer.repo) {
-                    if (!provider.service || !consumer.service || provider.service === consumer.service) {
-                        continue;
-                    }
+            matchedProviderServices.add(providerFqService);
+            candidateProviders.push(...providers);
+        }
+        if (consumerType === 'thrift' && !fqService.includes('.') && matchedProviderServices.size > 1) {
+            continue;
+        }
+        for (const provider of candidateProviders) {
+            // Skip same-repo same-service (same logic as runExactMatch)
+            if (provider.repo === consumer.repo) {
+                if (!provider.service || !consumer.service || provider.service === consumer.service) {
+                    continue;
                 }
-                matched.push({
-                    from: {
-                        repo: consumer.repo,
-                        service: consumer.service,
-                        symbolUid: consumer.symbolUid,
-                        symbolRef: consumer.symbolRef,
-                    },
-                    to: {
-                        repo: provider.repo,
-                        service: provider.service,
-                        symbolUid: provider.symbolUid,
-                        symbolRef: provider.symbolRef,
-                    },
-                    type: consumer.type,
-                    contractId: consumer.contractId, // consumer's wildcard ID
-                    matchType: 'wildcard',
-                    confidence: Math.min(provider.confidence, consumer.confidence),
-                });
-                matchedConsumerIds.add(`${consumer.repo}::${consumer.contractId}`);
             }
+            matched.push({
+                from: {
+                    repo: consumer.repo,
+                    service: consumer.service,
+                    symbolUid: consumer.symbolUid,
+                    symbolRef: consumer.symbolRef,
+                },
+                to: {
+                    repo: provider.repo,
+                    service: provider.service,
+                    symbolUid: provider.symbolUid,
+                    symbolRef: provider.symbolRef,
+                },
+                type: consumer.type,
+                contractId: consumer.contractId, // consumer's wildcard ID
+                matchType: 'wildcard',
+                confidence: Math.min(provider.confidence, consumer.confidence),
+            });
+            matchedConsumerIds.add(`${consumer.repo}::${consumer.contractId}`);
         }
     }
     const remaining = unmatched.filter((c) => {
-        if (c.role !== 'consumer' || !isGrpcWildcard(c.contractId))
+        if (c.role !== 'consumer' || !isServiceWildcard(c.contractId))
             return true;
         return !matchedConsumerIds.has(`${c.repo}::${c.contractId}`);
     });

package/dist/core/group/sync.js

@@ -5,10 +5,11 @@ import { initLbug, closeLbug, executeParameterized } from '../lbug/pool-adapter.
 import { readRegistry } from '../../storage/repo-manager.js';
 import { HttpRouteExtractor } from './extractors/http-route-extractor.js';
 import { GrpcExtractor } from './extractors/grpc-extractor.js';
+import { ThriftExtractor } from './extractors/thrift-extractor.js';
 import { TopicExtractor } from './extractors/topic-extractor.js';
 import { ManifestExtractor } from './extractors/manifest-extractor.js';
 import { discoverWorkspaceLinks } from './extractors/workspace-extractor.js';
-import { runExactMatch } from './matching.js';
+import { buildProviderIndex, runExactMatch, runWildcardMatch } from './matching.js';
 import { detectServiceBoundaries, assignService } from './service-boundary-detector.js';
 import { writeContractRegistry } from './storage.js';
 export function stableRepoPoolId(entry, allEntries) {
@@ -70,6 +71,7 @@ export async function syncGroup(config, opts) {
         const resolve = opts?.resolveRepoHandle ?? defaultResolveHandle(entries);
         const httpEx = new HttpRouteExtractor();
         const grpcEx = new GrpcExtractor();
+        const thriftEx = new ThriftExtractor();
         const topicEx = new TopicExtractor();
         dbExecutors = new Map();
         const openPoolIds = [];
@@ -108,6 +110,16 @@ export async function syncGroup(config, opts) {
                             });
                         }
                     }
+                    if (config.detect.thrift) {
+                        const extracted = await thriftEx.extract(executor, handle.repoPath, handle);
+                        for (const c of extracted) {
+                            autoContracts.push({
+                                ...c,
+                                repo: groupPath,
+                                service: assignService(c.symbolRef.filePath, boundaries),
+                            });
+                        }
+                    }
                     if (config.detect.topics) {
                         const extracted = await topicEx.extract(executor, handle.repoPath, handle);
                         for (const c of extracted) {
@@ -191,12 +203,14 @@ export async function syncGroup(config, opts) {
             console.log(`  manifest: ${manifestCrossLinks.length} cross-links from ${allLinks.length} links (${config.links.length} declared + ${allLinks.length - config.links.length} discovered)`);
         }
     }
-    const { matched, unmatched } = runExactMatch(autoContracts, undefined, config.matching);
+    const providerIndex = buildProviderIndex(autoContracts, config.matching);
+    const { matched, unmatched } = runExactMatch(autoContracts, providerIndex, config.matching);
+    const wildcard = runWildcardMatch(unmatched, providerIndex);
     // Dedupe cross-links. Manifest contracts participate in runExactMatch, so a
     // manifest-declared link can also emit a matchType:'exact' CrossLink with the
     // same endpoints. Prefer the manifest version — it reflects operator intent
     // and carries matchType:'manifest' which downstream consumers may rely on.
-    const crossLinks = dedupeCrossLinks([...manifestCrossLinks, ...matched]);
+    const crossLinks = dedupeCrossLinks([...manifestCrossLinks, ...matched, ...wildcard.matched]);
     const allContracts = autoContracts;
     const registry = {
         version: 1,
@@ -212,7 +226,7 @@ export async function syncGroup(config, opts) {
     return {
         contracts: allContracts,
         crossLinks,
-        unmatched,
+        unmatched: wildcard.remaining,
         missingRepos,
         repoSnapshots,
     };

package/dist/core/group/types.d.ts

@@ -1,4 +1,4 @@
-export type ContractType = 'http' | 'grpc' | 'topic' | 'lib' | 'custom';
+export type ContractType = 'http' | 'grpc' | 'thrift' | 'topic' | 'lib' | 'custom';
 export type MatchType = 'exact' | 'manifest' | 'wildcard' | 'bm25' | 'embedding';
 export type ContractRole = 'provider' | 'consumer';
 export interface GroupConfig {
@@ -21,6 +21,7 @@ export interface GroupManifestLink {
 export interface DetectConfig {
     http: boolean;
     grpc: boolean;
+    thrift: boolean;
     topics: boolean;
     shared_libs: boolean;
     embedding_fallback: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.4-rc.72",
+  "version": "1.6.4-rc.73",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",