gitnexus 1.6.4-rc.18 → 1.6.4-rc.19

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

@@ -14,6 +14,8 @@ const DEFAULT_MATCHING = {
     bm25_threshold: 0.7,
     embedding_threshold: 0.65,
     max_candidates_per_step: 3,
+    exclude_links_paths: [],
+    exclude_links_param_only_paths: false,
 };
 export function parseGroupConfig(yamlContent) {
     const raw = yaml.load(yamlContent, { schema: yaml.JSON_SCHEMA });

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

@@ -1,4 +1,4 @@
-import type { StoredContract, CrossLink } from './types.js';
+import type { StoredContract, CrossLink, MatchingConfig } from './types.js';
 export interface MatchResult {
     matched: CrossLink[];
     unmatched: StoredContract[];
@@ -8,6 +8,6 @@ export interface WildcardMatchResult {
     remaining: StoredContract[];
 }
 export declare function normalizeContractId(id: string): string;
-export declare function buildProviderIndex(contracts: StoredContract[]): Map<string, StoredContract[]>;
-export declare function runExactMatch(contracts: StoredContract[], providerIndex?: Map<string, StoredContract[]>): MatchResult;
+export declare function buildProviderIndex(contracts: StoredContract[], matchingConfig?: MatchingConfig): Map<string, StoredContract[]>;
+export declare function runExactMatch(contracts: StoredContract[], providerIndex?: Map<string, StoredContract[]>, matchingConfig?: MatchingConfig): MatchResult;
 export declare function runWildcardMatch(unmatched: StoredContract[], providerIndex: Map<string, StoredContract[]>): WildcardMatchResult;

package/dist/core/group/matching.js

@@ -1,6 +1,43 @@
 function isGrpcWildcard(cid) {
     return cid.startsWith('grpc::') && cid.endsWith('/*');
 }
+/**
+ * Detect HTTP contracts that are too generic or infrastructure-level to
+ * produce meaningful cross-repo links. These are still extracted (useful
+ * for documentation / route maps) but excluded from cross-link matching.
+ *
+ * Two categories:
+ * 1. Health-check / readiness endpoints — every service has one, matching
+ *    them produces N×M false links.
+ * 2. Param-only paths — routes like `/{param}` or `/{param}/{param}` that
+ *    collapse to a single catch-all after normalization. These match any
+ *    service with a similar shape, producing false positives.
+ *
+ * Both are configurable via matching.exclude_links_paths and
+ * matching.exclude_links_param_only_paths in group.yaml.
+ */
+function buildNoisyContractFilter(matchingConfig) {
+    const excludePaths = matchingConfig?.exclude_links_paths?.length
+        ? new Set(matchingConfig.exclude_links_paths.map((p) => p.replace(/\/+$/, '')))
+        : new Set();
+    const excludeParamOnly = matchingConfig?.exclude_links_param_only_paths === true;
+    return function isNoisyHttpContract(contractId) {
+        if (!contractId.startsWith('http::'))
+            return false;
+        const parts = contractId.split('::');
+        if (parts.length < 3)
+            return false;
+        const pathPart = parts.slice(2).join('::').replace(/\/+$/, '');
+        if (excludePaths.has(pathPart))
+            return true;
+        if (excludeParamOnly) {
+            const segments = pathPart.split('/').filter(Boolean);
+            if (segments.length > 0 && segments.every((s) => s === '{param}'))
+                return true;
+        }
+        return false;
+    };
+}
 export function normalizeContractId(id) {
     const colonIdx = id.indexOf('::');
     if (colonIdx === -1)
@@ -74,8 +111,9 @@ function findMatchingKeys(contractId, index) {
     }
     return [];
 }
-export function buildProviderIndex(contracts) {
-    const providers = contracts.filter((c) => c.role === 'provider');
+export function buildProviderIndex(contracts, matchingConfig) {
+    const isNoisy = buildNoisyContractFilter(matchingConfig);
+    const providers = contracts.filter((c) => c.role === 'provider' && !isNoisy(c.contractId));
     const index = new Map();
     for (const p of providers) {
         const key = normalizeContractId(p.contractId);
@@ -85,10 +123,10 @@ export function buildProviderIndex(contracts) {
     }
     return index;
 }
-export function runExactMatch(contracts, providerIndex) {
-    const index = providerIndex ?? buildProviderIndex(contracts);
-    // Skip gRPC wildcard consumers — they go to wildcard pass only
-    const consumers = contracts.filter((c) => c.role === 'consumer' && !isGrpcWildcard(c.contractId));
+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));
     const matched = [];
     const matchedConsumerIds = new Set();
     const matchedProviderIds = new Set();
@@ -129,6 +167,8 @@ export function runExactMatch(contracts, providerIndex) {
     const normalUnmatched = contracts.filter((c) => {
         if (isGrpcWildcard(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);
     });

package/dist/core/group/storage.js

@@ -85,6 +85,8 @@ matching:
   bm25_threshold: 0.7
   embedding_threshold: 0.65
   max_candidates_per_step: 3
+  # exclude_links_paths: [/ping, /health, /healthcheck]
+  # exclude_links_param_only_paths: false
 `;
     await fsp.writeFile(path.join(groupDir, 'group.yaml'), template, 'utf-8');
     return groupDir;

package/dist/core/group/sync.js

@@ -168,7 +168,7 @@ export async function syncGroup(config, opts) {
             console.log(`  manifest: ${manifestCrossLinks.length} cross-links from ${config.links.length} declared links`);
         }
     }
-    const { matched, unmatched } = runExactMatch(autoContracts);
+    const { matched, unmatched } = runExactMatch(autoContracts, undefined, config.matching);
     // 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

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

@@ -29,6 +29,24 @@ export interface MatchingConfig {
     bm25_threshold: number;
     embedding_threshold: number;
     max_candidates_per_step: number;
+    /**
+     * HTTP paths to exclude from cross-link matching. Contracts at these paths
+     * are still extracted and visible in the registry, but they don't produce
+     * cross-repo links. Useful for health-check endpoints (`/ping`, `/health`)
+     * that every service exposes and would otherwise create N×M false links.
+     * Trailing slashes are normalized before comparison.
+     * @default []
+     */
+    exclude_links_paths?: string[];
+    /**
+     * When `true`, exclude HTTP routes where every path segment is `{param}`
+     * (e.g. `/{param}`, `/{param}/{param}`) from cross-link matching. Mixed
+     * routes like `/users/{param}` are not affected. These param-only routes
+     * collapse to a single catch-all after normalization and produce false
+     * positives across unrelated services.
+     * @default false
+     */
+    exclude_links_param_only_paths?: boolean;
 }
 export interface SymbolRef {
     filePath: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.4-rc.18",
+  "version": "1.6.4-rc.19",
   "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",