gitnexus 1.6.10-rc.87 → 1.6.10-rc.89

package/dist/core/ingestion/languages/python/captures.d.ts

@@ -8,10 +8,9 @@
  *   1. **Per-name import statements** — `import a, b` and
  *      `from m import x, y` decompose to one match per imported name
  *      (see `import-decomposer.ts`).
- *   2. **Receiver type bindings** — each `function_definition` inside a
- *      class body emits a `@type-binding.self` (or `@type-binding.cls`
- *      for `@classmethod`) capture so Pass-4 attaches the implicit
- *      receiver (see `receiver-binding.ts`).
+ *   2. **Receiver type bindings** — methods emit an implicit `self` / `cls`
+ *      binding, and `__init__` assignments from annotated parameters emit
+ *      class-scoped instance-field bindings (see `receiver-binding.ts`).
  *
  * Pure given the input source text. No I/O, no globals consulted.
  */

package/dist/core/ingestion/languages/python/captures.js

@@ -8,17 +8,16 @@
  *   1. **Per-name import statements** — `import a, b` and
  *      `from m import x, y` decompose to one match per imported name
  *      (see `import-decomposer.ts`).
- *   2. **Receiver type bindings** — each `function_definition` inside a
- *      class body emits a `@type-binding.self` (or `@type-binding.cls`
- *      for `@classmethod`) capture so Pass-4 attaches the implicit
- *      receiver (see `receiver-binding.ts`).
+ *   2. **Receiver type bindings** — methods emit an implicit `self` / `cls`
+ *      binding, and `__init__` assignments from annotated parameters emit
+ *      class-scoped instance-field bindings (see `receiver-binding.ts`).
  *
  * Pure given the input source text. No I/O, no globals consulted.
  */
 import { nodeToCapture, syntheticCapture, walkNamedTree, } from '../../utils/ast-helpers.js';
 import { splitImportStatement } from './import-decomposer.js';
 import { getPythonParser, getPythonScopeQuery } from './query.js';
-import { synthesizeReceiverTypeBinding } from './receiver-binding.js';
+import { synthesizeConstructorFieldTypeBindings, synthesizeReceiverTypeBinding, } from './receiver-binding.js';
 import { synthesizeDependsReferences } from './depends-references.js';
 import { computePythonArityMetadata } from './arity-metadata.js';
 import { recordCacheHit, recordCacheMiss } from './cache-stats.js';
@@ -122,6 +121,7 @@ export function emitPythonScopeCaptures(sourceText, _filePath, cachedTree) {
                 const synth = synthesizeReceiverTypeBinding(fnNode);
                 if (synth !== null)
                     out.push(synth);
+                out.push(...synthesizeConstructorFieldTypeBindings(fnNode));
                 for (const depRef of synthesizeDependsReferences(fnNode))
                     out.push(depRef);
             }

package/dist/core/ingestion/languages/python/interpret.js

@@ -118,6 +118,10 @@ export function interpretPythonTypeBinding(captures) {
     // `Registry.lookup` Step 2 treats them identically.
     else if (captures['@type-binding.cls'] !== undefined)
         source = 'self';
+    else if (captures['@type-binding.instance-field'] !== undefined) {
+        source =
+            captures['@type-binding.parameter'] !== undefined ? 'parameter-annotation' : 'annotation';
+    }
     else if (captures['@type-binding.constructor'] !== undefined)
         source = 'constructor-inferred';
     else if (captures['@type-binding.annotation'] !== undefined)

package/dist/core/ingestion/languages/python/receiver-binding.d.ts

@@ -1,6 +1,6 @@
 /**
- * Synthesize `@type-binding.self` / `@type-binding.cls` captures for
- * methods.
+ * Synthesize implicit receiver and constructor-assigned field type bindings
+ * for methods.
  *
  * Tree-sitter can't easily express "the first parameter of a function
  * defined directly inside a class body" via a single static query.
@@ -19,3 +19,16 @@ import { type SyntaxNode } from '../../utils/ast-helpers.js';
  * 'function_definition'`.
  */
 export declare function synthesizeReceiverTypeBinding(fnNode: SyntaxNode): CaptureMatch | null;
+/**
+ * Synthesize class-scope field bindings for the common Python constructor
+ * injection pattern:
+ *
+ *   def __init__(self, service: Service):
+ *       self.service = service
+ *
+ * An explicit field annotation (`self.service: Service = ...`) is also
+ * accepted and takes precedence over a parameter annotation. Deliberately do
+ * not infer from arbitrary unannotated RHS expressions: the receiver resolver
+ * needs a declared type, not a name-only guess.
+ */
+export declare function synthesizeConstructorFieldTypeBindings(fnNode: SyntaxNode): CaptureMatch[];

package/dist/core/ingestion/languages/python/receiver-binding.js

@@ -1,6 +1,6 @@
 /**
- * Synthesize `@type-binding.self` / `@type-binding.cls` captures for
- * methods.
+ * Synthesize implicit receiver and constructor-assigned field type bindings
+ * for methods.
  *
  * Tree-sitter can't easily express "the first parameter of a function
  * defined directly inside a class body" via a single static query.
@@ -114,3 +114,97 @@ export function synthesizeReceiverTypeBinding(fnNode) {
         '@type-binding.type': syntheticCapture('@type-binding.type', first, className),
     };
 }
+/**
+ * Synthesize class-scope field bindings for the common Python constructor
+ * injection pattern:
+ *
+ *   def __init__(self, service: Service):
+ *       self.service = service
+ *
+ * An explicit field annotation (`self.service: Service = ...`) is also
+ * accepted and takes precedence over a parameter annotation. Deliberately do
+ * not infer from arbitrary unannotated RHS expressions: the receiver resolver
+ * needs a declared type, not a name-only guess.
+ */
+export function synthesizeConstructorFieldTypeBindings(fnNode) {
+    if (fnNode.childForFieldName('name')?.text !== '__init__')
+        return [];
+    if (findEnclosingClassDefinition(fnNode) === null)
+        return [];
+    if (hasDecorator(fnNode, 'staticmethod') || hasDecorator(fnNode, 'classmethod'))
+        return [];
+    const receiver = synthesizeReceiverTypeBinding(fnNode);
+    const receiverName = receiver?.['@type-binding.self']?.text;
+    if (receiverName === undefined)
+        return [];
+    const parameters = fnNode.childForFieldName('parameters');
+    const body = fnNode.childForFieldName('body');
+    if (parameters === null || body === null)
+        return [];
+    const parameterTypes = new Map();
+    for (let i = 0; i < parameters.namedChildCount; i++) {
+        const parameter = parameters.namedChild(i);
+        if (parameter === null)
+            continue;
+        const name = firstParameterName(parameter);
+        const annotation = parameter.childForFieldName('type');
+        if (name !== null && annotation !== null)
+            parameterTypes.set(name, annotation.text);
+    }
+    const candidates = new Map();
+    const stack = [body];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (node !== body &&
+            (node.type === 'function_definition' ||
+                node.type === 'lambda' ||
+                node.type === 'class_definition' ||
+                node.type === 'if_statement' ||
+                node.type === 'for_statement' ||
+                node.type === 'while_statement' ||
+                node.type === 'try_statement' ||
+                node.type === 'match_statement')) {
+            continue;
+        }
+        if (node.type === 'assignment') {
+            const left = node.childForFieldName('left');
+            const right = node.childForFieldName('right');
+            if (left?.type === 'attribute') {
+                const object = left.childForFieldName('object');
+                const field = left.childForFieldName('attribute');
+                if (object?.type === 'identifier' && object.text === receiverName && field !== null) {
+                    const explicitType = node.childForFieldName('type');
+                    const parameterType = right?.type === 'identifier' ? parameterTypes.get(right.text) : undefined;
+                    const typeName = explicitType?.text ?? parameterType;
+                    if (typeName !== undefined) {
+                        const explicit = explicitType !== null;
+                        const existing = candidates.get(field.text);
+                        if (existing === undefined || explicit || !existing.explicit) {
+                            candidates.set(field.text, {
+                                explicit,
+                                match: {
+                                    '@type-binding.name': syntheticCapture('@type-binding.name', field, field.text),
+                                    '@type-binding.type': syntheticCapture('@type-binding.type', explicitType ?? right ?? field, typeName),
+                                    ...(explicit
+                                        ? {}
+                                        : {
+                                            '@type-binding.parameter': syntheticCapture('@type-binding.parameter', right ?? field, '1'),
+                                        }),
+                                    '@type-binding.instance-field': syntheticCapture('@type-binding.instance-field', node, '1'),
+                                },
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        // Push in reverse so the LIFO walk visits source order. That keeps Map
+        // insertion order (and therefore emitted capture order) deterministic.
+        for (let i = node.namedChildCount - 1; i >= 0; i--) {
+            const child = node.namedChild(i);
+            if (child !== null)
+                stack.push(child);
+        }
+    }
+    return [...candidates.values()].map(({ match }) => match);
+}

package/dist/core/ingestion/languages/python/simple-hooks.d.ts

@@ -9,11 +9,11 @@ import type { CaptureMatch, NodeLabel, ParsedImport, Scope, ScopeId, ScopeTree,
 import type { SyntaxNode } from 'tree-sitter';
 export declare function pythonFunctionDefinitionLabel(functionNode: SyntaxNode, defaultLabel: NodeLabel): NodeLabel;
 /** Python has no block scope, so the central extractor's "innermost
- *  enclosing scope" default is already correct: `for x in …` creates
- *  `x` in the enclosing function/module scope (because we never emit a
- *  `@scope.block` for the for-loop body), comprehension variables stay
- *  in their expression context, etc. Returns `null` to delegate. */
-export declare function pythonBindingScopeFor(_decl: CaptureMatch, _innermost: Scope, _tree: ScopeTree): ScopeId | null;
+ *  enclosing scope" default is already correct for ordinary bindings.
+ *  Constructor-injected instance fields are the exception: their marker is
+ *  anchored inside `__init__`, but compound receiver resolution needs the
+ *  field type on the enclosing Class scope. */
+export declare function pythonBindingScopeFor(decl: CaptureMatch, innermost: Scope, tree: ScopeTree): ScopeId | null;
 /** Function-local `from x import Y` should attach the binding to the
  *  function scope, not the module. Class-body imports (rare but legal —
  *  `class A: import x` makes `x` a class attribute) attach to the class.

package/dist/core/ingestion/languages/python/simple-hooks.js

@@ -15,11 +15,21 @@ export function pythonFunctionDefinitionLabel(functionNode, defaultLabel) {
 }
 // ─── bindingScopeFor ──────────────────────────────────────────────────────
 /** Python has no block scope, so the central extractor's "innermost
- *  enclosing scope" default is already correct: `for x in …` creates
- *  `x` in the enclosing function/module scope (because we never emit a
- *  `@scope.block` for the for-loop body), comprehension variables stay
- *  in their expression context, etc. Returns `null` to delegate. */
-export function pythonBindingScopeFor(_decl, _innermost, _tree) {
+ *  enclosing scope" default is already correct for ordinary bindings.
+ *  Constructor-injected instance fields are the exception: their marker is
+ *  anchored inside `__init__`, but compound receiver resolution needs the
+ *  field type on the enclosing Class scope. */
+export function pythonBindingScopeFor(decl, innermost, tree) {
+    if (decl['@type-binding.instance-field'] !== undefined) {
+        let current = innermost;
+        while (current !== undefined) {
+            if (current.kind === 'Class')
+                return current.id;
+            if (current.parent === null)
+                break;
+            current = tree.getScope(current.parent);
+        }
+    }
     return null;
 }
 // ─── importOwningScope ────────────────────────────────────────────────────

package/dist/core/ingestion/scope-extractor.js

@@ -770,13 +770,15 @@ function followChainedRef(start, draftById) {
  * name in the same scope. Higher number wins; ties keep the later match
  * (last-write-wins preserves historical order within a tier).
  *
- * Rationale: explicit annotations always beat inferred ones because they
- * reflect user intent. `self`/`cls` are treated as strongly as annotations
- * because they are language-required receiver types.
+ * Rationale: explicit variable and field annotations always beat bindings
+ * derived from parameter annotations or inference because they reflect the
+ * most specific user intent. `self`/`cls` are treated as strongly as other
+ * declared types because they are language-required receiver types.
  */
 function typeBindingStrength(source) {
     switch (source) {
         case 'annotation':
+            return 3;
         case 'parameter-annotation':
         case 'return-annotation':
         case 'self':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.10-rc.87",
+  "version": "1.6.10-rc.89",
   "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",
@@ -56,7 +56,7 @@
     "version": "node scripts/sync-plugin-manifests.mjs"
   },
   "dependencies": {
-    "@ladybugdb/core": "^0.18.0",
+    "@ladybugdb/core": "^0.18.3",
     "@modelcontextprotocol/sdk": "^1.0.0",
     "@scarf/scarf": "^1.4.0",
     "busboy": "^1.6.0",