gitnexus 1.6.9-rc.15 → 1.6.9-rc.17

package/dist/core/ingestion/languages/typescript/nuxt-auto-imports.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Nuxt v4 auto-import resolution for the TypeScript scope-resolver.
+ *
+ * Nuxt and Nitro both make symbols available project-wide without explicit
+ * import statements. Two sources cover the common cases:
+ *
+ *   1. `.nuxt/imports.d.ts` - client/shared composables generated by Nuxt at
+ *      build time. Only entries whose source is a project-local relative path
+ *      (i.e. NOT a package in node_modules or a Nuxt runtime alias) are
+ *      indexed. These are project utils and composables the developer wrote.
+ *
+ *   2. `server/utils/**` - Nitro auto-imports all exports from this directory
+ *      tree into every `server/api/`, `server/routes/`, and
+ *      `server/middleware/` file. These are not included in `imports.d.ts`
+ *      because they are server-only.
+ *
+ * The two sources are kept in separate maps because their visibility scopes
+ * differ: app/client files do not see `server/utils`, while Nitro server
+ * handlers prefer same-named server utilities over client composables.
+ *
+ * Detection: if `.nuxt/imports.d.ts` is absent the repo is not a Nuxt project
+ * and this module returns null immediately, adding zero overhead to non-Nuxt
+ * analysis runs. The `server/utils` scan is only attempted when the Nuxt
+ * detection succeeds, so it also costs nothing for non-Nuxt repos.
+ *
+ * Limitations:
+ *   - Auto-import edges are still heuristic rather than type-checked. The
+ *     emitter tags them with confidence 0.75.
+ *   - Re-exports with non-matching aliases (e.g. `flatUnwrap as unwrapSlot`
+ *     where `flatUnwrap` is the graph node name) try both the original export
+ *     name and the local alias when looking up the graph node.
+ *   - Only direct exports are indexed; barrel re-exports that chain through
+ *     multiple files are not followed.
+ */
+export type NuxtAutoImportScope = 'client' | 'server';
+/** A single auto-imported symbol and where it lives in the repo. */
+export interface NuxtAutoImportEntry {
+    /** The name used at call sites (the alias when `export { X as Y }` form). */
+    readonly localName: string;
+    /** The original export name in the source file (before `as`). */
+    readonly exportName: string;
+    /** Repo-relative POSIX path to the source file (with extension). */
+    readonly sourceFile: string;
+    /** Which Nuxt/Nitro visibility scope supplied this entry. */
+    readonly scope: NuxtAutoImportScope;
+}
+/**
+ * Aggregated auto-import maps for one Nuxt workspace, keyed by the local
+ * name used in calling code. Client/shared entries come from
+ * `.nuxt/imports.d.ts`; server entries come from `server/utils`.
+ */
+export interface NuxtAutoImportConfig {
+    readonly clientByLocalName: ReadonlyMap<string, NuxtAutoImportEntry>;
+    readonly serverByLocalName: ReadonlyMap<string, NuxtAutoImportEntry>;
+}
+/**
+ * Load the Nuxt auto-import map for `repoRoot`.
+ *
+ * Returns null when:
+ *   - `.nuxt/imports.d.ts` does not exist (non-Nuxt project or pre-build), or
+ *   - the file exists but yields zero project-local entries and `server/utils`
+ *     is absent or empty.
+ *
+ * The `server/utils` scan is only attempted when `.nuxt/imports.d.ts` was
+ * successfully read, confirming this is an initialized Nuxt project. This
+ * avoids partial results from repos that have a `server/utils` directory but
+ * are not Nuxt projects.
+ */
+export declare function loadNuxtAutoImports(repoRoot: string): Promise<NuxtAutoImportConfig | null>;
+export declare function hasNuxtAutoImports(config: NuxtAutoImportConfig): boolean;
+export declare function getNuxtAutoImportEntry(config: NuxtAutoImportConfig, localName: string, callerFile: string): NuxtAutoImportEntry | undefined;
+export declare function isNitroServerRuntimeFile(filePath: string): boolean;

package/dist/core/ingestion/languages/typescript/nuxt-auto-imports.js

@@ -0,0 +1,315 @@
+/**
+ * Nuxt v4 auto-import resolution for the TypeScript scope-resolver.
+ *
+ * Nuxt and Nitro both make symbols available project-wide without explicit
+ * import statements. Two sources cover the common cases:
+ *
+ *   1. `.nuxt/imports.d.ts` - client/shared composables generated by Nuxt at
+ *      build time. Only entries whose source is a project-local relative path
+ *      (i.e. NOT a package in node_modules or a Nuxt runtime alias) are
+ *      indexed. These are project utils and composables the developer wrote.
+ *
+ *   2. `server/utils/**` - Nitro auto-imports all exports from this directory
+ *      tree into every `server/api/`, `server/routes/`, and
+ *      `server/middleware/` file. These are not included in `imports.d.ts`
+ *      because they are server-only.
+ *
+ * The two sources are kept in separate maps because their visibility scopes
+ * differ: app/client files do not see `server/utils`, while Nitro server
+ * handlers prefer same-named server utilities over client composables.
+ *
+ * Detection: if `.nuxt/imports.d.ts` is absent the repo is not a Nuxt project
+ * and this module returns null immediately, adding zero overhead to non-Nuxt
+ * analysis runs. The `server/utils` scan is only attempted when the Nuxt
+ * detection succeeds, so it also costs nothing for non-Nuxt repos.
+ *
+ * Limitations:
+ *   - Auto-import edges are still heuristic rather than type-checked. The
+ *     emitter tags them with confidence 0.75.
+ *   - Re-exports with non-matching aliases (e.g. `flatUnwrap as unwrapSlot`
+ *     where `flatUnwrap` is the graph node name) try both the original export
+ *     name and the local alias when looking up the graph node.
+ *   - Only direct exports are indexed; barrel re-exports that chain through
+ *     multiple files are not followed.
+ */
+import fs from 'fs/promises';
+import path from 'path';
+const FILE_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx'];
+const GENERATED_DIR_NAMES = new Set([
+    '.git',
+    '.nuxt',
+    '.output',
+    '.next',
+    'build',
+    'coverage',
+    'dist',
+    'node_modules',
+]);
+const IMPORTS_DTS_EXPORT_RE = /^export\s*\{([^}]+)\}\s*from\s*['"]([^'"]+)['"]/gm;
+const NITRO_DECLARATION_EXPORT_RE = /^export\s+(?:default\s+)?(?:async\s+)?function\s+([A-Za-z_$][A-Za-z0-9_$]*)|^export\s+(?:default\s+)?class\s+([A-Za-z_$][A-Za-z0-9_$]*)/gm;
+const NITRO_VARIABLE_EXPORT_RE = /^export\s+(?:const|let|var)\s+([^;\n]+)/gm;
+// Matches the binding name at the head of a single declarator (`name`, `name:`, `name =`).
+// A leading `{`/`[` (destructuring) does not match, so destructured exports are skipped.
+const DECLARATOR_NAME_RE = /^\s*([A-Za-z_$][A-Za-z0-9_$]*)/;
+// ---- loader -----------------------------------------------------------------
+/**
+ * Load the Nuxt auto-import map for `repoRoot`.
+ *
+ * Returns null when:
+ *   - `.nuxt/imports.d.ts` does not exist (non-Nuxt project or pre-build), or
+ *   - the file exists but yields zero project-local entries and `server/utils`
+ *     is absent or empty.
+ *
+ * The `server/utils` scan is only attempted when `.nuxt/imports.d.ts` was
+ * successfully read, confirming this is an initialized Nuxt project. This
+ * avoids partial results from repos that have a `server/utils` directory but
+ * are not Nuxt projects.
+ */
+export async function loadNuxtAutoImports(repoRoot) {
+    const clientByLocalName = new Map();
+    const serverByLocalName = new Map();
+    const nuxtInitialized = await collectImportsDts(repoRoot, clientByLocalName);
+    // Only scan server/utils when imports.d.ts was present, confirming this is
+    // an initialized Nuxt project. Without this gate, a non-Nuxt repo with a
+    // server/utils directory would get spurious Nitro auto-import edges.
+    if (nuxtInitialized) {
+        await collectNitroServerUtils(repoRoot, serverByLocalName);
+    }
+    const config = { clientByLocalName, serverByLocalName };
+    return hasNuxtAutoImports(config) ? config : null;
+}
+export function hasNuxtAutoImports(config) {
+    return config.clientByLocalName.size > 0 || config.serverByLocalName.size > 0;
+}
+export function getNuxtAutoImportEntry(config, localName, callerFile) {
+    if (isNitroServerRuntimeFile(callerFile)) {
+        // Nitro auto-imports only `server/utils/**` into the server context; app
+        // `composables/` are Vue-app-only. Server callers therefore resolve the
+        // server map only — no client fallback, which would emit cross-context
+        // CALLS edges Nitro never actually creates.
+        return config.serverByLocalName.get(localName);
+    }
+    return config.clientByLocalName.get(localName);
+}
+/**
+ * Directories whose files run in the Nitro server context and so receive
+ * `server/utils` auto-imports without an explicit import: API routes, server
+ * routes, middleware, plugins, and (Nitro 2.6+) tasks.
+ */
+const NITRO_RUNTIME_DIR_PREFIXES = [
+    'server/api/',
+    'server/routes/',
+    'server/middleware/',
+    'server/plugins/',
+    'server/tasks/',
+];
+export function isNitroServerRuntimeFile(filePath) {
+    const normalized = filePath.replace(/\\/g, '/');
+    return NITRO_RUNTIME_DIR_PREFIXES.some((prefix) => normalized.startsWith(prefix));
+}
+// ---- .nuxt/imports.d.ts -----------------------------------------------------
+/**
+ * Parse `.nuxt/imports.d.ts` and add project-local entries to `byLocalName`.
+ *
+ * The file contains lines of the form:
+ *   export { name1, name2, origName as alias } from 'source'
+ *
+ * Only entries with a source that is a project-local relative path
+ * (starts with `./` or `../` AND does not contain `node_modules`) are
+ * included. Nuxt runtime paths (`#app/...`) and third-party packages are
+ * intentionally skipped because they have no graph nodes in the repo.
+ *
+ * @returns true when `.nuxt/imports.d.ts` was successfully read.
+ */
+async function collectImportsDts(repoRoot, byLocalName) {
+    const importsPath = path.join(repoRoot, '.nuxt', 'imports.d.ts');
+    let content;
+    try {
+        content = await fs.readFile(importsPath, 'utf-8');
+    }
+    catch {
+        return false;
+    }
+    const nuxtDir = path.join(repoRoot, '.nuxt');
+    IMPORTS_DTS_EXPORT_RE.lastIndex = 0;
+    let m;
+    while ((m = IMPORTS_DTS_EXPORT_RE.exec(content)) !== null) {
+        const symbolsRaw = m[1];
+        const source = m[2];
+        if (!isProjectLocalPath(source))
+            continue;
+        // Containment guard: a crafted source (`from '../../../../etc/passwd'`)
+        // passes the relative-path check but escapes the repo. Skip anything that
+        // resolves outside repoRoot before touching the filesystem.
+        const resolvedBase = path.resolve(nuxtDir, source);
+        if (!isWithinRepo(repoRoot, resolvedBase))
+            continue;
+        const resolvedFile = await resolveExtension(resolvedBase);
+        if (resolvedFile === null)
+            continue;
+        const sourceFile = toRepoPosix(repoRoot, resolvedFile);
+        for (const raw of symbolsRaw.split(',')) {
+            const trimmed = raw.trim();
+            if (!trimmed)
+                continue;
+            const asIdx = trimmed.indexOf(' as ');
+            const exportName = asIdx >= 0 ? trimmed.slice(0, asIdx).trim() : trimmed;
+            const localName = asIdx >= 0 ? trimmed.slice(asIdx + 4).trim() : trimmed;
+            if (!localName || !exportName)
+                continue;
+            if (!byLocalName.has(localName)) {
+                byLocalName.set(localName, { localName, exportName, sourceFile, scope: 'client' });
+            }
+        }
+    }
+    return true;
+}
+// ---- server/utils (Nitro auto-imports) --------------------------------------
+/**
+ * Scan `server/utils/**` and register every exported symbol as a Nitro
+ * auto-import. Nitro makes all exports from this directory tree available
+ * without an import statement in server routes and middleware.
+ */
+async function collectNitroServerUtils(repoRoot, byLocalName) {
+    const serverUtilsDir = path.join(repoRoot, 'server', 'utils');
+    if (!(await dirExists(serverUtilsDir)))
+        return;
+    const tsFiles = await collectTsFiles(serverUtilsDir);
+    for (const absPath of tsFiles) {
+        let content;
+        try {
+            content = await fs.readFile(absPath, 'utf-8');
+        }
+        catch {
+            continue;
+        }
+        const sourceFile = toRepoPosix(repoRoot, absPath);
+        for (const name of extractNitroExportNames(content)) {
+            if (!byLocalName.has(name)) {
+                byLocalName.set(name, { localName: name, exportName: name, sourceFile, scope: 'server' });
+            }
+        }
+    }
+}
+// ---- helpers ----------------------------------------------------------------
+function isProjectLocalPath(source) {
+    if (!source.startsWith('./') && !source.startsWith('../'))
+        return false;
+    if (source.includes('node_modules'))
+        return false;
+    return true;
+}
+/** True when `absPath` is `repoRoot` itself or lives beneath it. */
+function isWithinRepo(repoRoot, absPath) {
+    const root = path.resolve(repoRoot);
+    return absPath === root || absPath.startsWith(root + path.sep);
+}
+async function resolveExtension(base) {
+    const directFile = await firstExistingFile([...FILE_EXTENSIONS.map((ext) => base + ext), base]);
+    if (directFile !== null)
+        return directFile;
+    return firstExistingFile(FILE_EXTENSIONS.map((ext) => path.join(base, `index${ext}`)));
+}
+async function firstExistingFile(candidates) {
+    const matches = await Promise.all(candidates.map(async (candidate) => ((await isFile(candidate)) ? candidate : null)));
+    return matches.find((candidate) => candidate !== null) ?? null;
+}
+async function isFile(filePath) {
+    try {
+        const stat = await fs.stat(filePath);
+        return stat.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function toRepoPosix(repoRoot, absPath) {
+    return path.relative(repoRoot, absPath).replace(/\\/g, '/');
+}
+async function dirExists(dirPath) {
+    try {
+        const stat = await fs.stat(dirPath);
+        return stat.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/** Recursively collect supported TypeScript/JavaScript files under a directory. */
+async function collectTsFiles(dir) {
+    const results = [];
+    let entries;
+    try {
+        entries = await fs.readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return results;
+    }
+    for (const entry of entries) {
+        if (entry.isDirectory() && GENERATED_DIR_NAMES.has(entry.name))
+            continue;
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            results.push(...(await collectTsFiles(full)));
+        }
+        else if (entry.isFile() && hasSupportedSourceExtension(entry.name)) {
+            results.push(full);
+        }
+    }
+    return results;
+}
+function hasSupportedSourceExtension(fileName) {
+    return FILE_EXTENSIONS.some((ext) => fileName.endsWith(ext));
+}
+function extractNitroExportNames(content) {
+    const names = new Set();
+    NITRO_DECLARATION_EXPORT_RE.lastIndex = 0;
+    let declaration;
+    while ((declaration = NITRO_DECLARATION_EXPORT_RE.exec(content)) !== null) {
+        const name = declaration[1] ?? declaration[2];
+        if (name)
+            names.add(name);
+    }
+    NITRO_VARIABLE_EXPORT_RE.lastIndex = 0;
+    let variableDeclaration;
+    while ((variableDeclaration = NITRO_VARIABLE_EXPORT_RE.exec(content)) !== null) {
+        // Only the LHS binding name of each top-level declarator is a Nitro export.
+        // Splitting on top-level commas and reading the leading identifier avoids
+        // capturing RHS tokens (arrow params, object keys, operands) as export names,
+        // and tolerates commas inside generic type annotations (`x: Map<a, b> = …`).
+        for (const declarator of splitTopLevelDeclarators(variableDeclaration[1])) {
+            const name = DECLARATOR_NAME_RE.exec(declarator);
+            if (name)
+                names.add(name[1]);
+        }
+    }
+    return [...names];
+}
+/**
+ * Split a `const`/`let`/`var` declarator list on top-level commas, tracking
+ * `()`, `[]`, `{}`, and `<>` nesting so commas inside call args, object/array
+ * literals, and generic type arguments do not split a declarator. Errs toward
+ * under-splitting on pathological RHS (a missed binding name, never a spurious
+ * one) — Nitro only auto-imports real top-level binding names.
+ */
+function splitTopLevelDeclarators(text) {
+    const parts = [];
+    let depth = 0;
+    let start = 0;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (ch === '(' || ch === '[' || ch === '{' || ch === '<') {
+            depth++;
+        }
+        else if (ch === ')' || ch === ']' || ch === '}' || ch === '>') {
+            if (depth > 0)
+                depth--;
+        }
+        else if (ch === ',' && depth === 0) {
+            parts.push(text.slice(start, i));
+            start = i + 1;
+        }
+    }
+    parts.push(text.slice(start));
+    return parts;
+}

package/dist/core/ingestion/languages/typescript/scope-resolver.js

@@ -12,12 +12,24 @@
  * ./query.ts (TYPESCRIPT_SCOPE_QUERY constant).
  */
 import { SupportedLanguages } from '../../../../_shared/index.js';
+import { generateId } from '../../../../lib/utils.js';
 import { buildMro, defaultLinearize } from '../../scope-resolution/passes/mro.js';
 import { populateClassOwnedMembers } from '../../scope-resolution/scope/walkers.js';
+import { simpleKey } from '../../scope-resolution/graph-bridge/node-lookup.js';
 import { typescriptProvider } from '../typescript.js';
 import { loadTsconfigPaths } from '../../language-config.js';
 import { buildSuffixIndex } from '../../import-resolvers/utils.js';
 import { typescriptArityCompatibility, typescriptMergeBindings, resolveTsTarget, } from './index.js';
+import { getNuxtAutoImportEntry, hasNuxtAutoImports, loadNuxtAutoImports, } from './nuxt-auto-imports.js';
+const TYPESCRIPT_TYPE_ONLY_BINDING_TYPES = new Set([
+    'Interface',
+    'Type',
+    'TypeAlias',
+    'Typedef',
+    'Trait',
+    'Annotation',
+    'Decorator',
+]);
 /**
  * Build a `resolveImportTarget` adapter that memoizes the workspace
  * file list, the lower-cased file list, and the per-pass `resolveCache`
@@ -65,11 +77,14 @@ const typescriptScopeResolver = {
     importEdgeReason: 'typescript-scope: import',
     resolveImportTarget: makeTsResolveImportTarget(),
     // Threaded into `resolveImportTarget` so tsconfig path aliases
-    // (`@/services/user`, `~/x`, …) resolve through the same standard
+    // (`@/services/user`, `~/x`, ...) resolve through the same standard
     // resolver branch the legacy DAG uses. One I/O round-trip per
     // workspace pass; the orchestrator awaits this once.
+    // `nuxtAutoImports` is null for non-Nuxt projects (no .nuxt/imports.d.ts),
+    // so this adds zero overhead to ordinary TypeScript repos.
     loadResolutionConfig: async (repoPath) => ({
         tsconfigPaths: await loadTsconfigPaths(repoPath),
+        nuxtAutoImports: await loadNuxtAutoImports(repoPath),
     }),
     // TypeScript declaration merging + LEGB: local > import > wildcard,
     // separated by declaration space (value / type / namespace). The
@@ -95,23 +110,173 @@ const typescriptScopeResolver = {
     fieldFallbackOnMethodLookup: false,
     propagatesReturnTypesAcrossImports: true,
     // TypeScript uses `.values()` / `.keys()` method-call syntax for
-    // collection views — no property-style accessors like C#'s
+    // collection views -- no property-style accessors like C#'s
     // `Dictionary<K,V>.Values`. Leave `unwrapCollectionAccessor`
     // undefined and let the regular member-call branch handle them.
     //
-    // `collapseMemberCallsByCallerTarget` left undefined (= false) —
+    // `collapseMemberCallsByCallerTarget` left undefined (= false) --
     // TypeScript legacy DAG emits one edge per call site, so
     // per-site dedup is the parity target.
     //
-    // `populateNamespaceSiblings` left undefined — TypeScript requires
+    // `populateNamespaceSiblings` left undefined -- TypeScript requires
     // an explicit `import` / namespace augmentation for cross-file
     // visibility; there's no implicit same-namespace sibling rule
     // like C#'s.
     //
-    // `hoistTypeBindingsToModule` — `tsBindingScopeFor` DOES hoist
+    // `hoistTypeBindingsToModule` -- `tsBindingScopeFor` DOES hoist
     // method return-type bindings to the enclosing Module scope
     // (mirrors C#), so enable the walk-up that lets the compound-
     // receiver resolver find them.
     hoistTypeBindingsToModule: true,
+    /**
+     * Emit CALLS edges for Nuxt/Nitro auto-imported symbols that are used
+     * without an explicit import statement.
+     *
+     * Nuxt makes composables and server utils available project-wide via its
+     * auto-import system. Because no `import` statement exists, the standard
+     * scope-resolution passes cannot create call-graph edges for these symbols.
+     * This hook recovers those edges after all normal resolution has run.
+     *
+     * For each TypeScript file the hook:
+     *   1. Builds the set of files already explicitly imported (to avoid
+     *      creating duplicate edges for symbols imported conventionally).
+     *   2. Iterates parsed free-call reference sites and checks each against the
+     *      auto-import map selected for the caller's Nuxt/Nitro scope.
+     *   3. For each hit that is not shadowed by a local binding or explicit
+     *      import, emits a CALLS edge from the file's File node to the target
+     *      function node, and an IMPORTS edge from the caller file to the source
+     *      file (once per pair).
+     *
+     * Confidence is 0.75 (below the 0.9 used for fully resolved edges) to
+     * signal that these edges are heuristic rather than type-checked.
+     */
+    emitPostResolutionEdges(graph, parsedFiles, nodeLookup, indexes, ctx) {
+        const cfg = ctx.resolutionConfig;
+        const autoImports = cfg?.nuxtAutoImports;
+        if (!autoImports || !hasNuxtAutoImports(autoImports))
+            return;
+        // Pre-build a file -> explicit imported local names index so importing one
+        // symbol from a source does not suppress other auto-imported symbols from it.
+        const explicitImportNamesByFile = new Map();
+        for (const [scopeId, edges] of indexes.imports) {
+            const scope = indexes.scopeTree.getScope(scopeId);
+            if (!scope?.filePath)
+                continue;
+            let names = explicitImportNamesByFile.get(scope.filePath);
+            if (!names) {
+                names = new Set();
+                explicitImportNamesByFile.set(scope.filePath, names);
+            }
+            for (const edge of edges) {
+                // Record the local name whether or not the import resolved to a file.
+                // An explicit import of a name — even from an unresolved external
+                // package (`import { useAuto } from '@vueuse/core'`) — is authoritative
+                // shadowing intent and must suppress the auto-import for that name.
+                if (edge.localName)
+                    names.add(edge.localName);
+            }
+        }
+        for (const parsedFile of parsedFiles) {
+            const { filePath } = parsedFile;
+            if (!filePath.endsWith('.ts') && !filePath.endsWith('.tsx'))
+                continue;
+            const fileId = generateId('File', filePath);
+            const explicitImports = explicitImportNamesByFile.get(filePath) ?? new Set();
+            // Track (sourceFile) pairs already handled for this caller to avoid
+            // emitting duplicate IMPORTS edges and duplicate CALLS edges per symbol.
+            const emittedImports = new Set();
+            const emittedCalls = new Set();
+            for (const site of parsedFile.referenceSites) {
+                if (site.kind !== 'call' || site.callForm !== 'free')
+                    continue;
+                const localName = site.name;
+                const entry = getNuxtAutoImportEntry(autoImports, localName, filePath);
+                if (!entry)
+                    continue;
+                const { exportName, sourceFile } = entry;
+                // Skip when the file already binds this name explicitly, when the file
+                // IS the source, or when a lexical same-file binding shadows it.
+                if (explicitImports.has(localName) ||
+                    sourceFile === filePath ||
+                    hasLocalBindingInScopeChain(site.inScope, localName, filePath, indexes)) {
+                    continue;
+                }
+                // Emit one IMPORTS edge per (caller, sourceFile) pair.
+                if (!emittedImports.has(sourceFile)) {
+                    emittedImports.add(sourceFile);
+                    const targetFileId = generateId('File', sourceFile);
+                    if (graph.getNode(targetFileId)) {
+                        graph.addRelationship({
+                            id: generateId('IMPORTS', `${fileId}->nuxt-auto-import->${targetFileId}`),
+                            sourceId: fileId,
+                            targetId: targetFileId,
+                            type: 'IMPORTS',
+                            confidence: 0.75,
+                            reason: 'nuxt-auto-import-file',
+                        });
+                    }
+                }
+                // Emit one CALLS edge per (caller, symbol) pair.
+                const callKey = `${sourceFile}::${localName}`;
+                if (emittedCalls.has(callKey))
+                    continue;
+                emittedCalls.add(callKey);
+                // Look up the graph node by export name first, fall back to local name.
+                // The fallback handles `default as X` where the function is named X.
+                const targetNodeId = nodeLookup.get(simpleKey(sourceFile, exportName)) ??
+                    (exportName !== localName ? nodeLookup.get(simpleKey(sourceFile, localName)) : undefined);
+                if (!targetNodeId || !graph.getNode(targetNodeId))
+                    continue;
+                graph.addRelationship({
+                    id: generateId('CALLS', `${fileId}:nuxt-auto-import:${localName}->${targetNodeId}`),
+                    sourceId: fileId,
+                    targetId: targetNodeId,
+                    type: 'CALLS',
+                    confidence: 0.75,
+                    reason: 'nuxt-auto-import',
+                });
+            }
+        }
+    },
 };
+function occupiesTypeScriptValueSpace(type) {
+    return !TYPESCRIPT_TYPE_ONLY_BINDING_TYPES.has(type);
+}
+function hasLocalBindingInScopeChain(scopeId, name, filePath, indexes) {
+    const visited = new Set();
+    let cursor = scopeId;
+    while (cursor !== null && cursor !== undefined && !visited.has(cursor)) {
+        visited.add(cursor);
+        const scope = indexes.scopeTree.getScope(cursor);
+        if (!scope)
+            return false;
+        const localBindings = scope.bindings.get(name);
+        if (localBindings?.some((binding) => binding.origin === 'local' &&
+            binding.def.filePath === filePath &&
+            occupiesTypeScriptValueSpace(binding.def.type))) {
+            return true;
+        }
+        // Type-annotated function parameters — and other value-space type facts
+        // such as `self` and variable annotations — live in `scope.typeBindings`,
+        // not `scope.bindings`. A parameter named like a composable genuinely
+        // shadows the auto-import, and typeBindings never holds a pure type that
+        // belongs to callable space, so a same-file presence check here cannot
+        // over-suppress a legitimate auto-import.
+        //
+        // Residual (known limitation): this catches parameters whose annotation the
+        // TS scope query records as a type-binding (`p: Named`, generics, unions,
+        // predefined, arrays). Function-typed params (`p: () => void`), untyped
+        // params, destructured locals (`const { x } = …`), and catch-clause vars
+        // are captured by NEITHER map — the scope query emits no `@declaration` /
+        // `@type-binding` for them — so those shadow forms still leak an edge.
+        // Closing that needs shared TS scope-query/extractor changes that alter call
+        // resolution beyond Nuxt, so it is deferred to a follow-up rather than fixed
+        // here.
+        if (scope.filePath === filePath && scope.typeBindings.has(name)) {
+            return true;
+        }
+        cursor = scope.parent;
+    }
+    return false;
+}
 export { typescriptScopeResolver };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.9-rc.15",
+  "version": "1.6.9-rc.17",
   "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",