gitnexus 1.6.4-rc.37 → 1.6.4-rc.38

package/dist/core/ingestion/languages/python/import-target.js

@@ -41,35 +41,76 @@ export function resolvePythonImportTarget(parsedImport, workspaceIndex) {
     const pathLike = parsedImport.targetRaw.replace(/\./g, '/');
     if (pathLike.includes('/')) {
         const [leadingSegment] = pathLike.split('/').filter(Boolean);
-        if (!leadingSegment || !hasRepoCandidate(leadingSegment, ctx.allFilePaths)) {
+        if (!leadingSegment || !hasRepoCandidate(leadingSegment, ctx.allFilePaths, ctx.fromFile)) {
             return null;
         }
     }
-    // Multi-segment absolute resolve: try exact paths first, then suffix
-    // match in nested repos. Using direct `Set.has` + `endsWith` instead of
-    // `suffixResolve`'s shared helper because that helper requires a
-    // pre-built `SuffixIndex` to disambiguate ties — without one it falls
-    // back to an O(files) scan that silently picks the wrong file when
-    // the last segment collides across directories (e.g. `accounts.models`
-    // matching `billing/models.py` when both files exist).
-    return resolveAbsoluteFromFiles(pathLike, ctx.allFilePaths);
+    // Multi-segment absolute resolve: try exact paths first, then ancestor
+    // walk (mirrors the single-segment ancestor walk in
+    // `resolvePythonImportInternal`), then a suffix match in nested repos.
+    // Using direct `Set.has` + `endsWith` instead of `suffixResolve`'s shared
+    // helper because that helper requires a pre-built `SuffixIndex` to
+    // disambiguate ties — without one it falls back to an O(files) scan that
+    // silently picks the wrong file when the last segment collides across
+    // directories (e.g. `accounts.models` matching `billing/models.py` when
+    // both files exist).
+    return resolveAbsoluteFromFiles(pathLike, ctx.allFilePaths, ctx.fromFile);
 }
 /**
  * Resolve `package/sub/module` style paths (already dot-flattened) to a
- * concrete file in `allFilePaths`. Tries the exact path first, then the
- * `__init__.py` variant, then a suffix match for nested layouts.
+ * concrete file in `allFilePaths`. Tries the exact path first, then walks
+ * ancestors of `fromFile` looking for `<ancestor>/<pathLike>.py` (or
+ * `__init__.py`), then falls back to a suffix match for nested layouts.
  * Returns the original (un-normalized) path from the set.
+ *
+ * Precedence order:
+ *  1. Workspace-root direct hit (`<pathLike>.py`, `<pathLike>/__init__.py`).
+ *  2. Closest-ancestor match walking up from the importer's directory.
+ *  3. Suffix fallback (first match).
+ *
+ * Root wins over ancestor by construction — if both `services/sync.py` and
+ * `backend/services/sync.py` exist, `backend/routers/cron.py`'s
+ * `from services.sync import X` resolves to the root file. This mirrors
+ * Python's `sys.path` semantics where the project root is searched first.
+ *
+ * The ancestor walk mirrors the single-segment behavior in
+ * `resolvePythonImportInternal`. For `from services.sync import X` in
+ * `backend/routers/cron.py`, walk up: `backend/routers/services/sync.py` →
+ * `backend/services/sync.py` ✓.
  */
-function resolveAbsoluteFromFiles(pathLike, allFilePaths) {
+function resolveAbsoluteFromFiles(pathLike, allFilePaths, fromFile) {
     const directFile = `${pathLike}.py`;
     const directPkg = `${pathLike}/__init__.py`;
+    // Direct hit at workspace root.
+    if (allFilePaths.has(directFile))
+        return directFile;
+    if (allFilePaths.has(directPkg))
+        return directPkg;
+    // Ancestor walk — match the single-segment resolver's behavior at
+    // multi-segment granularity. Closest match wins. Stop at `i > 0` because
+    // `i === 0` would re-check the workspace-root candidates already covered
+    // by the direct check above.
+    const importerDir = fromFile.replace(/\\/g, '/').split('/').slice(0, -1).join('/');
+    if (importerDir) {
+        const dirParts = importerDir.split('/').filter(Boolean);
+        for (let i = dirParts.length; i > 0; i--) {
+            const ancestor = dirParts.slice(0, i).join('/');
+            const prefix = `${ancestor}/`;
+            const candidateFile = `${prefix}${directFile}`;
+            const candidatePkg = `${prefix}${directPkg}`;
+            if (allFilePaths.has(candidateFile))
+                return candidateFile;
+            if (allFilePaths.has(candidatePkg))
+                return candidatePkg;
+        }
+    }
+    // Existing suffix-match fallback (preserved for monorepo/nested-repo
+    // layouts that don't share a directory ancestor with the importer).
     const suffixFile = `/${directFile}`;
     const suffixPkg = `/${directPkg}`;
     let suffixMatch = null;
     for (const raw of allFilePaths) {
         const f = raw.replace(/\\/g, '/');
-        if (f === directFile || f === directPkg)
-            return raw;
         if (suffixMatch === null && (f.endsWith(suffixFile) || f.endsWith(suffixPkg))) {
             suffixMatch = raw;
         }
@@ -77,23 +118,51 @@ function resolveAbsoluteFromFiles(pathLike, allFilePaths) {
     return suffixMatch;
 }
 /**
- * Does the repo contain a module/package named `leadingSegment` at the top
- * level? Used to guard against false-positive suffix matches on external
- * dotted imports (e.g. `django.apps` matching a local `accounts/apps.py`).
+ * Does the repo contain a module/package named `leadingSegment` somewhere
+ * the importer can plausibly reach?
  *
- * Checks, in order: `<segment>.py` root file, `<segment>/__init__.py`
- * regular package, or any `<segment>/**.py` file (namespace package).
+ * Used to guard against false-positive suffix matches on external dotted
+ * imports (e.g. `django.apps` matching a local `accounts/apps.py`).
+ *
+ * Checks, in order:
+ *  1. `SEGMENT.py` root file or `SEGMENT/__init__.py` regular package.
+ *  2. Any `SEGMENT/...py` file at the workspace root (namespace package).
+ *  3. Any `<importer-ancestor>/SEGMENT/...py` file (nested namespace
+ *     package the importer could reach via an ancestor walk, e.g.
+ *     `backend/services/sync.py` from `backend/routers/cron.py`).
+ *
+ * The nested case is bounded to the importer's own ancestors so a
+ * vendored copy of an external package (e.g. `vendor/django/urls.py`)
+ * does not gate-pass external imports like `from django.urls import path`
+ * issued from `app/main.py`. Files inside the vendored tree itself
+ * (importer under `vendor/django/...`) still resolve correctly because
+ * the ancestor walk includes their own parents.
  */
-function hasRepoCandidate(leadingSegment, allFilePaths) {
+function hasRepoCandidate(leadingSegment, allFilePaths, fromFile) {
     const prefix = `${leadingSegment}/`;
     const rootFile = `${leadingSegment}.py`;
     const initFile = `${leadingSegment}/__init__.py`;
+    // Build importer-ancestor prefixes: for `backend/routers/cron.py`,
+    // produces `["backend/routers/services/", "backend/services/"]` for
+    // segment `services` (closest first, root excluded — covered above).
+    const importerDir = fromFile.replace(/\\/g, '/').split('/').slice(0, -1).join('/');
+    const dirParts = importerDir ? importerDir.split('/').filter(Boolean) : [];
+    const ancestorPrefixes = [];
+    for (let i = dirParts.length; i > 0; i--) {
+        ancestorPrefixes.push(`${dirParts.slice(0, i).join('/')}/${leadingSegment}/`);
+    }
     for (const raw of allFilePaths) {
         const f = raw.replace(/\\/g, '/');
         if (f === rootFile || f === initFile)
             return true;
         if (f.startsWith(prefix) && f.endsWith('.py'))
             return true;
+        if (f.endsWith('.py')) {
+            for (const ap of ancestorPrefixes) {
+                if (f.startsWith(ap))
+                    return true;
+            }
+        }
     }
     return false;
 }

package/package.json

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