gitnexus 1.6.2-rc.2 → 1.6.2-rc.21

package/dist/core/group/extractors/http-patterns/node.js

@@ -7,6 +7,9 @@ import { compilePatterns, runCompiledPatterns, unquoteLiteral, } from '../tree-s
  *   - Express `router.get(...)` / `app.post(...)` providers
  *   - `fetch(url)` / `fetch(url, { method: 'POST' })` consumers
  *   - `axios.get(url)` / `axios.delete(url)` consumers
+ *   - `axios({ method, url })` object-form consumers
+ *   - jQuery `$.get(url)` / `$.post(url, ...)` shorthand consumers
+ *   - jQuery `$.ajax({ url, method | type })` consumers
  *
  * Because the JavaScript and TypeScript tree-sitter grammars share
  * node type names for every construct we query, pattern sources are
@@ -86,6 +89,45 @@ const AXIOS_SPEC = {
       arguments: (arguments . [(string) (template_string)] @path))
   `,
 };
+// ─── Consumer: jQuery shorthand $.get(url) / $.post(url, ...) ────────
+// `$` is a valid JS identifier, so tree-sitter parses `$.get(...)` as a
+// call_expression whose function is a member_expression on identifier `$`.
+const JQUERY_SHORTHAND_SPEC = {
+    meta: {},
+    query: `
+    (call_expression
+      function: (member_expression
+        object: (identifier) @obj (#eq? @obj "$")
+        property: (property_identifier) @http_method (#match? @http_method "^(get|post)$"))
+      arguments: (arguments . [(string) (template_string)] @path))
+  `,
+};
+// ─── Consumer: jQuery $.ajax({ url, method|type }) ───────────────────
+// The query captures the options object only; key/value pairs are read
+// programmatically via `readStringProp` below, which tolerates any key
+// order and accepts either `method:` or `type:` (jQuery supports both).
+const JQUERY_AJAX_SPEC = {
+    meta: {},
+    query: `
+    (call_expression
+      function: (member_expression
+        object: (identifier) @obj (#eq? @obj "$")
+        property: (property_identifier) @fn (#eq? @fn "ajax"))
+      arguments: (arguments (object) @options))
+  `,
+};
+// ─── Consumer: axios({ method, url }) object form ────────────────────
+// Distinct from AXIOS_SPEC above because the call target is an identifier
+// (`axios`) rather than a member expression (`axios.get`). As with the
+// jQuery ajax form, option keys are resolved programmatically.
+const AXIOS_OBJECT_SPEC = {
+    meta: {},
+    query: `
+    (call_expression
+      function: (identifier) @fn (#eq? @fn "axios")
+      arguments: (arguments (object) @options))
+  `,
+};
 function compileBundle(language, name) {
     const mk = (spec, suffix) => compilePatterns({
         name: `${name}-${suffix}`,
@@ -99,6 +141,9 @@ function compileBundle(language, name) {
         fetchNoOptions: mk(FETCH_NO_OPTIONS_SPEC, 'fetch-no-options'),
         fetchWithOptions: mk(FETCH_WITH_OPTIONS_SPEC, 'fetch-with-options'),
         axios: mk(AXIOS_SPEC, 'axios'),
+        jqueryShorthand: mk(JQUERY_SHORTHAND_SPEC, 'jquery-shorthand'),
+        jqueryAjax: mk(JQUERY_AJAX_SPEC, 'jquery-ajax'),
+        axiosObject: mk(AXIOS_OBJECT_SPEC, 'axios-object'),
     };
 }
 const JAVASCRIPT_BUNDLE = compileBundle(JavaScript, 'javascript-http');
@@ -130,6 +175,32 @@ function joinPath(prefix, sub) {
         return `/${cleanSub}`;
     return `/${cleanPrefix}/${cleanSub}`;
 }
+/**
+ * Walk `pair` children of an `object` literal and return the unquoted
+ * string/template_string value for the first pair whose key matches one
+ * of `keyNames`. Returns null when no matching pair is present or the
+ * value is not a string literal. Used by the jQuery ajax / axios object
+ * consumers to resolve `url` / `method` / `type` keys in any order.
+ */
+function readStringProp(objectNode, keyNames) {
+    for (let i = 0; i < objectNode.namedChildCount; i++) {
+        const pair = objectNode.namedChild(i);
+        if (!pair || pair.type !== 'pair')
+            continue;
+        const keyNode = pair.childForFieldName('key');
+        const valueNode = pair.childForFieldName('value');
+        if (!keyNode || !valueNode)
+            continue;
+        if (!keyNames.includes(keyNode.text))
+            continue;
+        if (valueNode.type !== 'string' && valueNode.type !== 'template_string')
+            continue;
+        const lit = unquoteLiteral(valueNode.text);
+        if (lit !== null)
+            return lit;
+    }
+    return null;
+}
 /**
  * For a standalone `decorator` node (child of class_body / program),
  * find the related `class_declaration` node that it decorates. In
@@ -335,6 +406,65 @@ function scanBundle(bundle, tree) {
             confidence: 0.7,
         });
     }
+    // Consumer: jQuery shorthand $.get(url) / $.post(url, ...)
+    for (const match of runCompiledPatterns(bundle.jqueryShorthand, tree)) {
+        const methodNode = match.captures.http_method;
+        const pathNode = match.captures.path;
+        if (!methodNode || !pathNode)
+            continue;
+        const path = unquoteLiteral(pathNode.text);
+        if (path === null)
+            continue;
+        out.push({
+            role: 'consumer',
+            framework: 'jquery',
+            method: methodNode.text.toUpperCase(),
+            path,
+            name: null,
+            confidence: 0.7,
+        });
+    }
+    // Consumer: jQuery $.ajax({ url, method|type }). jQuery accepts either
+    // `method:` or `type:`; both default to GET when absent.
+    for (const match of runCompiledPatterns(bundle.jqueryAjax, tree)) {
+        const optionsNode = match.captures.options;
+        if (!optionsNode)
+            continue;
+        const path = readStringProp(optionsNode, ['url']);
+        if (path === null)
+            continue;
+        const rawMethod = readStringProp(optionsNode, ['method', 'type']);
+        const method = (rawMethod ?? 'GET').toUpperCase();
+        out.push({
+            role: 'consumer',
+            framework: 'jquery',
+            method,
+            path,
+            name: null,
+            confidence: 0.7,
+        });
+    }
+    // Consumer: axios({ method, url }) object form. Structurally distinct
+    // from axios.<verb>(url) (identifier vs member_expression call), so no
+    // dedup against the member-form loop above is required.
+    for (const match of runCompiledPatterns(bundle.axiosObject, tree)) {
+        const optionsNode = match.captures.options;
+        if (!optionsNode)
+            continue;
+        const path = readStringProp(optionsNode, ['url']);
+        if (path === null)
+            continue;
+        const rawMethod = readStringProp(optionsNode, ['method']);
+        const method = (rawMethod ?? 'GET').toUpperCase();
+        out.push({
+            role: 'consumer',
+            framework: 'axios',
+            method,
+            path,
+            name: null,
+            confidence: 0.7,
+        });
+    }
     return out;
 }
 export const JAVASCRIPT_HTTP_PLUGIN = {

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

@@ -68,14 +68,29 @@ export function manifestSymbolUid(repo, contractId) {
 }
 export class ManifestExtractor {
     async extractFromManifest(links, dbExecutors) {
-        const contracts = [];
-        const crossLinks = [];
-        for (const link of links) {
+        const resolveCache = new Map();
+        const resolveOnce = (repo, link) => {
+            const key = `${repo}\u0000${link.type}\u0000${link.contract}`;
+            let pending = resolveCache.get(key);
+            if (!pending) {
+                pending = this.resolveSymbol(repo, link, dbExecutors);
+                resolveCache.set(key, pending);
+            }
+            return pending;
+        };
+        const perLink = await Promise.all(links.map(async (link) => {
             const contractId = this.buildContractId(link.type, link.contract);
             const providerRepo = link.role === 'provider' ? link.from : link.to;
             const consumerRepo = link.role === 'provider' ? link.to : link.from;
-            const providerSymbol = await this.resolveSymbol(providerRepo, link, dbExecutors);
-            const consumerSymbol = await this.resolveSymbol(consumerRepo, link, dbExecutors);
+            const [providerSymbol, consumerSymbol] = await Promise.all([
+                resolveOnce(providerRepo, link),
+                resolveOnce(consumerRepo, link),
+            ]);
+            return { link, contractId, providerRepo, consumerRepo, providerSymbol, consumerSymbol };
+        }));
+        const contracts = [];
+        const crossLinks = [];
+        for (const { link, contractId, providerRepo, consumerRepo, providerSymbol, consumerSymbol, } of perLink) {
             const providerRef = providerSymbol || { filePath: '', name: link.contract };
             const consumerRef = consumerSymbol || { filePath: '', name: link.contract };
             // When the resolver finds a real graph symbol we keep its uid, otherwise

package/dist/core/group/sync.js

@@ -6,6 +6,7 @@ import { readRegistry } from '../../storage/repo-manager.js';
 import { HttpRouteExtractor } from './extractors/http-route-extractor.js';
 import { GrpcExtractor } from './extractors/grpc-extractor.js';
 import { TopicExtractor } from './extractors/topic-extractor.js';
+import { ManifestExtractor } from './extractors/manifest-extractor.js';
 import { runExactMatch } from './matching.js';
 import { detectServiceBoundaries, assignService } from './service-boundary-detector.js';
 import { writeContractRegistry } from './storage.js';
@@ -34,10 +35,28 @@ function defaultResolveHandle(allEntries) {
         };
     };
 }
+/**
+ * Dedupe cross-links that point from the same consumer endpoint to the same
+ * provider endpoint for the same contract. Preserves first-seen order so the
+ * caller controls precedence (e.g., pass manifest links first).
+ */
+function dedupeCrossLinks(links) {
+    const seen = new Set();
+    const out = [];
+    for (const link of links) {
+        const key = `${link.from.repo}::${link.from.symbolUid}|${link.to.repo}::${link.to.symbolUid}|${link.type}|${link.contractId}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(link);
+    }
+    return out;
+}
 export async function syncGroup(config, opts) {
     const missingRepos = [];
     const repoSnapshots = {};
     let autoContracts = [];
+    let manifestCrossLinks = [];
     let dbExecutors;
     const eo = opts?.extractorOverride;
     if (eo && eo.length === 0) {
@@ -124,8 +143,37 @@ export async function syncGroup(config, opts) {
             }
         }
     }
+    // Process manifest links declared in group.yaml.
+    // ManifestExtractor is fully implemented but was never wired into this
+    // pipeline — config.links were parsed and validated but silently dropped.
+    // Placed after the DB try/finally: resolveSymbol falls back to synthetic
+    // UIDs when dbExecutors is undefined or a pool is closed, so cross-links
+    // are always generated regardless of whether real DB executors are available.
+    if (config.links.length > 0) {
+        // Warn about dangling links that reference repos not declared in config.repos.
+        // They still generate cross-links via synthetic UIDs (determinism is preserved),
+        // but the operator probably meant something that now silently does nothing useful.
+        const knownRepos = new Set(Object.keys(config.repos));
+        for (const link of config.links) {
+            const dangling = [link.from, link.to].filter((r) => !knownRepos.has(r));
+            if (dangling.length > 0) {
+                console.warn(`[group/sync] manifest link ${link.type}:${link.contract} references repos not in config.repos: ${dangling.join(', ')} — cross-links will use synthetic UIDs`);
+            }
+        }
+        const manifestEx = new ManifestExtractor();
+        const manifestResult = await manifestEx.extractFromManifest(config.links, dbExecutors);
+        autoContracts.push(...manifestResult.contracts);
+        manifestCrossLinks = manifestResult.crossLinks;
+        if (opts?.verbose) {
+            console.log(`  manifest: ${manifestCrossLinks.length} cross-links from ${config.links.length} declared links`);
+        }
+    }
     const { matched, unmatched } = runExactMatch(autoContracts);
-    const crossLinks = matched;
+    // 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 allContracts = autoContracts;
     const registry = {
         version: 1,

package/dist/core/ingestion/call-extractors/configs/c-cpp.d.ts

@@ -0,0 +1,3 @@
+import type { CallExtractionConfig } from '../../call-types.js';
+export declare const cCallConfig: CallExtractionConfig;
+export declare const cppCallConfig: CallExtractionConfig;

package/dist/core/ingestion/call-extractors/configs/c-cpp.js

@@ -0,0 +1,8 @@
+// gitnexus/src/core/ingestion/call-extractors/configs/c-cpp.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const cCallConfig = {
+    language: SupportedLanguages.C,
+};
+export const cppCallConfig = {
+    language: SupportedLanguages.CPlusPlus,
+};

package/dist/core/ingestion/call-extractors/configs/csharp.d.ts

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

package/dist/core/ingestion/call-extractors/configs/csharp.js

@@ -0,0 +1,6 @@
+// gitnexus/src/core/ingestion/call-extractors/configs/csharp.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const csharpCallConfig = {
+    language: SupportedLanguages.CSharp,
+    typeAsReceiverHeuristic: true,
+};

package/dist/core/ingestion/call-extractors/configs/dart.d.ts

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

package/dist/core/ingestion/call-extractors/configs/dart.js

@@ -0,0 +1,5 @@
+// gitnexus/src/core/ingestion/call-extractors/configs/dart.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const dartCallConfig = {
+    language: SupportedLanguages.Dart,
+};

package/dist/core/ingestion/call-extractors/configs/go.d.ts

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

package/dist/core/ingestion/call-extractors/configs/go.js

@@ -0,0 +1,5 @@
+// gitnexus/src/core/ingestion/call-extractors/configs/go.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const goCallConfig = {
+    language: SupportedLanguages.Go,
+};

package/dist/core/ingestion/call-extractors/configs/jvm.d.ts

@@ -0,0 +1,3 @@
+import type { CallExtractionConfig } from '../../call-types.js';
+export declare const javaCallConfig: CallExtractionConfig;
+export declare const kotlinCallConfig: CallExtractionConfig;

package/dist/core/ingestion/call-extractors/configs/jvm.js

@@ -0,0 +1,51 @@
+// gitnexus/src/core/ingestion/call-extractors/configs/jvm.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+// ---------------------------------------------------------------------------
+// Java method_reference (::) parsing — absorbs call-sites/java.ts
+// ---------------------------------------------------------------------------
+/**
+ * Parse Java `method_reference` nodes (`expr::method`, `Type::new`,
+ * `this::m`, `super::m`).
+ */
+function parseJavaMethodReference(callNode) {
+    if (callNode.type !== 'method_reference')
+        return null;
+    const recv = callNode.namedChild(0);
+    if (!recv)
+        return null;
+    // Type::new  →  constructor call
+    for (const c of callNode.children) {
+        if (c.type === 'new') {
+            if (recv.type !== 'identifier')
+                return null;
+            return { calledName: recv.text, callForm: 'constructor' };
+        }
+    }
+    // expr::method  →  member call with receiver
+    const rhs = callNode.child(callNode.childCount - 1);
+    if (!rhs || rhs.type !== 'identifier')
+        return null;
+    const methodName = rhs.text;
+    if (recv.type === 'identifier') {
+        return { calledName: methodName, callForm: 'member', receiverName: recv.text };
+    }
+    if (recv.type === 'this') {
+        return { calledName: methodName, callForm: 'member', receiverName: 'this' };
+    }
+    if (recv.type === 'super') {
+        return { calledName: methodName, callForm: 'member', receiverName: 'super' };
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// Configs
+// ---------------------------------------------------------------------------
+export const javaCallConfig = {
+    language: SupportedLanguages.Java,
+    extractLanguageCallSite: parseJavaMethodReference,
+    typeAsReceiverHeuristic: true,
+};
+export const kotlinCallConfig = {
+    language: SupportedLanguages.Kotlin,
+    typeAsReceiverHeuristic: true,
+};

package/dist/core/ingestion/call-extractors/configs/php.d.ts

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

package/dist/core/ingestion/call-extractors/configs/php.js

@@ -0,0 +1,5 @@
+// gitnexus/src/core/ingestion/call-extractors/configs/php.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const phpCallConfig = {
+    language: SupportedLanguages.PHP,
+};

package/dist/core/ingestion/call-extractors/configs/python.d.ts

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

package/dist/core/ingestion/call-extractors/configs/python.js

@@ -0,0 +1,5 @@
+// gitnexus/src/core/ingestion/call-extractors/configs/python.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const pythonCallConfig = {
+    language: SupportedLanguages.Python,
+};

package/dist/core/ingestion/call-extractors/configs/ruby.d.ts

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

package/dist/core/ingestion/call-extractors/configs/ruby.js

@@ -0,0 +1,5 @@
+// gitnexus/src/core/ingestion/call-extractors/configs/ruby.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const rubyCallConfig = {
+    language: SupportedLanguages.Ruby,
+};

package/dist/core/ingestion/call-extractors/configs/rust.d.ts

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

package/dist/core/ingestion/call-extractors/configs/rust.js

@@ -0,0 +1,5 @@
+// gitnexus/src/core/ingestion/call-extractors/configs/rust.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const rustCallConfig = {
+    language: SupportedLanguages.Rust,
+};

package/dist/core/ingestion/call-extractors/configs/swift.d.ts

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

package/dist/core/ingestion/call-extractors/configs/swift.js

@@ -0,0 +1,5 @@
+// gitnexus/src/core/ingestion/call-extractors/configs/swift.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const swiftCallConfig = {
+    language: SupportedLanguages.Swift,
+};

package/dist/core/ingestion/call-extractors/configs/typescript-javascript.d.ts

@@ -0,0 +1,3 @@
+import type { CallExtractionConfig } from '../../call-types.js';
+export declare const typescriptCallConfig: CallExtractionConfig;
+export declare const javascriptCallConfig: CallExtractionConfig;

package/dist/core/ingestion/call-extractors/configs/typescript-javascript.js

@@ -0,0 +1,8 @@
+// gitnexus/src/core/ingestion/call-extractors/configs/typescript-javascript.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const typescriptCallConfig = {
+    language: SupportedLanguages.TypeScript,
+};
+export const javascriptCallConfig = {
+    language: SupportedLanguages.JavaScript,
+};

package/dist/core/ingestion/call-extractors/generic.d.ts

@@ -0,0 +1,5 @@
+import type { CallExtractor, CallExtractionConfig } from '../call-types.js';
+/**
+ * Create a CallExtractor from a declarative config.
+ */
+export declare function createCallExtractor(config: CallExtractionConfig): CallExtractor;

package/dist/core/ingestion/call-extractors/generic.js

@@ -0,0 +1,59 @@
+// gitnexus/src/core/ingestion/call-extractors/generic.ts
+import { inferCallForm, extractReceiverName, extractReceiverNode, extractMixedChain, countCallArguments, } from '../utils/call-analysis.js';
+/**
+ * Create a CallExtractor from a declarative config.
+ */
+export function createCallExtractor(config) {
+    return {
+        language: config.language,
+        extract(callNode, callNameNode) {
+            // ── Path 1: Language-specific call site ──────────────────────────
+            // Non-standard call shapes (e.g. Java `::` method references) are
+            // handled entirely by the config hook.  When it returns a result,
+            // the generic path is skipped — no argCount, no mixed chain.
+            //
+            // Note: `extractLanguageCallSite` is called on every `extract()`
+            // invocation — both `extract(callNode, undefined)` (parse-worker
+            // Path 1) and `extract(callNode, callNameNode)` (Path 2).
+            // Language hooks must therefore be idempotent and cheap (e.g. a
+            // single node-type check).
+            if (config.extractLanguageCallSite) {
+                const seed = config.extractLanguageCallSite(callNode);
+                if (seed) {
+                    return {
+                        ...seed,
+                        ...(config.typeAsReceiverHeuristic ? { typeAsReceiverHeuristic: true } : {}),
+                    };
+                }
+            }
+            // ── Path 2: Generic extraction via @call.name ────────────────────
+            if (!callNameNode)
+                return null;
+            const calledName = callNameNode.text;
+            const callForm = inferCallForm(callNode, callNameNode);
+            let receiverName = callForm === 'member' ? extractReceiverName(callNameNode) : undefined;
+            let receiverMixedChain;
+            // When the receiver is a complex expression (call chain, field chain,
+            // or mixed), extractReceiverName returns undefined.  Walk the receiver
+            // node to build a unified mixed chain for deferred resolution.
+            if (callForm === 'member' && receiverName === undefined) {
+                const receiverNode = extractReceiverNode(callNameNode);
+                if (receiverNode) {
+                    const extracted = extractMixedChain(receiverNode);
+                    if (extracted && extracted.chain.length > 0) {
+                        receiverMixedChain = extracted.chain;
+                        receiverName = extracted.baseReceiverName;
+                    }
+                }
+            }
+            return {
+                calledName,
+                ...(callForm !== undefined ? { callForm } : {}),
+                ...(receiverName !== undefined ? { receiverName } : {}),
+                argCount: countCallArguments(callNode),
+                ...(receiverMixedChain !== undefined ? { receiverMixedChain } : {}),
+                ...(config.typeAsReceiverHeuristic ? { typeAsReceiverHeuristic: true } : {}),
+            };
+        },
+    };
+}

package/dist/core/ingestion/call-processor.d.ts

@@ -1,13 +1,11 @@
 import { KnowledgeGraph } from '../graph/types.js';
 import { ASTCache } from './ast-cache.js';
-import type { SymbolDefinition, SymbolTableReader } from './model/symbol-table.js';
+import type { SymbolDefinition, SymbolTableReader, HeritageMap, ExtractedHeritage } from './model/index.js';
 import type { ResolutionContext } from './model/resolution-context.js';
 import type { TieredCandidates } from './model/resolution-context.js';
 import type { TypeEnvironment } from './type-env.js';
-import type { HeritageMap } from './model/heritage-map.js';
 import type { BindingAccumulator } from './binding-accumulator.js';
 import type { ExtractedCall, ExtractedAssignment, ExtractedRoute, ExtractedFetchCall, FileConstructorBindings } from './workers/parse-worker.js';
-import type { ExtractedHeritage } from './model/heritage-map.js';
 import type { LiteralTypeInferrer } from './type-extractors/types.js';
 import type { SyntaxNode } from './utils/ast-helpers.js';
 /** Per-file resolved type bindings for exported symbols.