gitnexus 1.6.2-rc.8 → 1.6.2

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/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.
@@ -125,7 +123,7 @@ export declare const _resolveCallTargetForTesting: (call: Pick<ExtractedCall, "c
  * @param ctx         - Resolution context
  * @param heritageMap - Optional heritage map for MRO-aware ancestor walking
  */
-export declare const resolveMemberCall: (ownerType: string, methodName: string, currentFile: string, ctx: ResolutionContext, heritageMap?: HeritageMap, argCount?: number) => ResolveResult | null;
+export declare const resolveMemberCall: (ownerType: string, methodName: string, currentFile: string, ctx: ResolutionContext, heritageMap?: HeritageMap, argCount?: number, ancestryView?: "instance" | "singleton") => ResolveResult | null;
 /**
  * Resolve a free-function call using `lookupExact` (same-file) + import-scoped
  * resolution via `ctx.resolve()`.