gitnexus 1.6.6-rc.2 → 1.6.6-rc.21

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

@@ -0,0 +1,53 @@
+/**
+ * Import-target resolver for JavaScript.
+ *
+ * Delegates to the TypeScript `resolveTsTarget` standard-strategy resolver
+ * with `language: SupportedLanguages.JavaScript` so the resolver tries
+ * `.js` / `.jsx` extensions in addition to (or instead of) `.ts` / `.tsx`.
+ *
+ * The `TsResolveContext.language` flag already exists in `import-target.ts`
+ * and the resolver (`resolveImportPath`) already branches on it — this
+ * adapter just wires the right value in.
+ *
+ * CJS `require()` calls reference the same module-path strings as ESM
+ * `import` statements, so the resolver handles them uniformly without any
+ * CJS-specific logic here.
+ *
+ * No `tsconfig.json` path-alias support (JavaScript projects don't use
+ * `tsconfig.json` compilerOptions.paths in general). Projects that DO use
+ * tsconfig-based aliases alongside JavaScript can still resolve via the
+ * standard extension-suffix fallback; the alias branch is a no-op when
+ * `tsconfigPaths` is null.
+ */
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { resolveTsTarget } from '../typescript/import-target.js';
+/**
+ * Build a memoized `resolveImportTarget` adapter for JavaScript.
+ * Caches the derived arrays and per-pass resolve cache across
+ * `resolveImportTarget` calls within a single workspace pass.
+ */
+export function makeJsResolveImportTarget() {
+    let cached = null;
+    return (targetRaw, fromFile, allFilePaths) => {
+        if (cached === null || cached.key !== allFilePaths) {
+            const allFileList = Array.from(allFilePaths);
+            cached = {
+                key: allFilePaths,
+                allFilePaths: new Set(allFilePaths),
+                allFileList,
+                normalizedFileList: allFileList.map((f) => f.toLowerCase()),
+                resolveCache: new Map(),
+            };
+        }
+        const ws = {
+            fromFile,
+            language: SupportedLanguages.JavaScript,
+            allFilePaths: cached.allFilePaths,
+            allFileList: cached.allFileList,
+            normalizedFileList: cached.normalizedFileList,
+            resolveCache: cached.resolveCache,
+            tsconfigPaths: null,
+        };
+        return resolveTsTarget(targetRaw, ws);
+    };
+}

package/dist/core/ingestion/languages/javascript/index.d.ts

@@ -0,0 +1,48 @@
+/**
+ * JavaScript scope-resolution hooks (RFC #909 Ring 3, issue #928).
+ *
+ * Public API barrel. Consumers should import from this file rather
+ * than the individual modules.
+ *
+ * Module layout (each file is a single concern):
+ *
+ *   - `query.ts`          — JS scope query string + lazy parser/query
+ *                           singletons (`getJsParser`, `getJsScopeQuery`)
+ *   - `captures.ts`       — `emitJsScopeCaptures` — runs the JS scope query,
+ *                           synthesizes CJS require() imports and JSDoc-
+ *                           derived type bindings, delegates arity synthesis
+ *                           and destructuring/instanceof passes to shared
+ *                           or TypeScript utilities
+ *   - `interpret.ts`      — `interpretJsImport` / `interpretJsTypeBinding`
+ *                           (delegate to TypeScript interpreters — same
+ *                           capture-marker vocabulary)
+ *   - `simple-hooks.ts`   — `jsBindingScopeFor` (var hoisting),
+ *                           `jsImportOwningScope`, `jsReceiverBinding`
+ *                           (all delegate to TypeScript counterparts)
+ *   - `merge-bindings.ts` — `jsMergeBindings` (LEGB via typescriptMergeBindings)
+ *   - `arity.ts`          — `jsArityCompatibility` (delegates to TS function)
+ *   - `import-target.ts`  — `makeJsResolveImportTarget` (memoized adapter)
+ *   - `scope-resolver.ts` — `javascriptScopeResolver` wiring object
+ *
+ * ## Known limitations
+ *
+ *   1. **JSDoc coverage** — `@param {T} name`, `@returns {T}` / `@return {T}`,
+ *      and `@type {T}` on variable declarations are synthesized. `@typedef`
+ *      is not yet synthesized (tracked in #1646).
+ *   2. **CJS chained destructuring** — `const { X: { Y } } = require(...)`
+ *      (nested destructuring) emits only the outer `X` binding; `Y` is not
+ *      resolved.
+ *   3. **Dynamic require** — `require(computedPath)` is skipped (non-literal
+ *      argument — cannot statically resolve the target).
+ *   4. **`module.exports` / `exports.X`** — CJS export forms are not yet
+ *      modeled as re-exports. The finalize algorithm treats the exporting
+ *      module as a namespace; importers that do `const X = require('./m')`
+ *      bind the module namespace, and member-call resolution walks the
+ *      class graph from there.
+ */
+export { emitJsScopeCaptures } from './captures.js';
+export { interpretJsImport, interpretJsTypeBinding } from './interpret.js';
+export { jsMergeBindings } from './merge-bindings.js';
+export { jsArityCompatibility } from './arity.js';
+export { makeJsResolveImportTarget } from './import-target.js';
+export { jsBindingScopeFor, jsImportOwningScope, jsReceiverBinding } from './simple-hooks.js';

package/dist/core/ingestion/languages/javascript/index.js

@@ -0,0 +1,48 @@
+/**
+ * JavaScript scope-resolution hooks (RFC #909 Ring 3, issue #928).
+ *
+ * Public API barrel. Consumers should import from this file rather
+ * than the individual modules.
+ *
+ * Module layout (each file is a single concern):
+ *
+ *   - `query.ts`          — JS scope query string + lazy parser/query
+ *                           singletons (`getJsParser`, `getJsScopeQuery`)
+ *   - `captures.ts`       — `emitJsScopeCaptures` — runs the JS scope query,
+ *                           synthesizes CJS require() imports and JSDoc-
+ *                           derived type bindings, delegates arity synthesis
+ *                           and destructuring/instanceof passes to shared
+ *                           or TypeScript utilities
+ *   - `interpret.ts`      — `interpretJsImport` / `interpretJsTypeBinding`
+ *                           (delegate to TypeScript interpreters — same
+ *                           capture-marker vocabulary)
+ *   - `simple-hooks.ts`   — `jsBindingScopeFor` (var hoisting),
+ *                           `jsImportOwningScope`, `jsReceiverBinding`
+ *                           (all delegate to TypeScript counterparts)
+ *   - `merge-bindings.ts` — `jsMergeBindings` (LEGB via typescriptMergeBindings)
+ *   - `arity.ts`          — `jsArityCompatibility` (delegates to TS function)
+ *   - `import-target.ts`  — `makeJsResolveImportTarget` (memoized adapter)
+ *   - `scope-resolver.ts` — `javascriptScopeResolver` wiring object
+ *
+ * ## Known limitations
+ *
+ *   1. **JSDoc coverage** — `@param {T} name`, `@returns {T}` / `@return {T}`,
+ *      and `@type {T}` on variable declarations are synthesized. `@typedef`
+ *      is not yet synthesized (tracked in #1646).
+ *   2. **CJS chained destructuring** — `const { X: { Y } } = require(...)`
+ *      (nested destructuring) emits only the outer `X` binding; `Y` is not
+ *      resolved.
+ *   3. **Dynamic require** — `require(computedPath)` is skipped (non-literal
+ *      argument — cannot statically resolve the target).
+ *   4. **`module.exports` / `exports.X`** — CJS export forms are not yet
+ *      modeled as re-exports. The finalize algorithm treats the exporting
+ *      module as a namespace; importers that do `const X = require('./m')`
+ *      bind the module namespace, and member-call resolution walks the
+ *      class graph from there.
+ */
+export { emitJsScopeCaptures } from './captures.js';
+export { interpretJsImport, interpretJsTypeBinding } from './interpret.js';
+export { jsMergeBindings } from './merge-bindings.js';
+export { jsArityCompatibility } from './arity.js';
+export { makeJsResolveImportTarget } from './import-target.js';
+export { jsBindingScopeFor, jsImportOwningScope, jsReceiverBinding } from './simple-hooks.js';

package/dist/core/ingestion/languages/javascript/interpret.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Capture-match → semantic-shape interpreters for JavaScript.
+ *
+ * `interpretJsImport` delegates to `interpretTsImport` for all cases
+ * because `emitJsScopeCaptures` synthesizes the same
+ * `@import.kind/name/alias/source` markers for both ESM and CJS imports.
+ *
+ * The `@import.kind` values emitted for CJS by `captures.ts`:
+ *
+ *   - `'named'`       : `const { X } = require('./m')`     → named import
+ *   - `'named-alias'` : `const { X: Y } = require('./m')` → aliased import
+ *   - `'namespace'`   : `const X = require('./m')`         → namespace import
+ *   - `'side-effect'` : `require('./m')` bare expression   → side-effect
+ *
+ * These match the kinds `interpretTsImport` already handles for ESM
+ * (`import { X }`, `import { X as Y }`, `import * as X`, `import './m'`),
+ * so no new branch is needed here.
+ *
+ * `interpretJsTypeBinding` handles the JS-only `@type-binding.class-field`
+ * tag before delegating to `interpretTsTypeBinding`.  The class-field tag
+ * is emitted by `synthesizeConstructorFieldBindings` and should produce
+ * `source = 'annotation'` — the same strength as an explicit type
+ * annotation. Remapping it to `@type-binding.annotation` achieves this
+ * without adding a JS-specific branch to the shared TS interpreter
+ * (DoD.md §2.2).
+ */
+import type { CaptureMatch, ParsedImport, ParsedTypeBinding } from '../../../../_shared/index.js';
+export declare function interpretJsImport(captures: CaptureMatch): ParsedImport | null;
+export declare function interpretJsTypeBinding(captures: CaptureMatch): ParsedTypeBinding | null;

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

@@ -0,0 +1,41 @@
+/**
+ * Capture-match → semantic-shape interpreters for JavaScript.
+ *
+ * `interpretJsImport` delegates to `interpretTsImport` for all cases
+ * because `emitJsScopeCaptures` synthesizes the same
+ * `@import.kind/name/alias/source` markers for both ESM and CJS imports.
+ *
+ * The `@import.kind` values emitted for CJS by `captures.ts`:
+ *
+ *   - `'named'`       : `const { X } = require('./m')`     → named import
+ *   - `'named-alias'` : `const { X: Y } = require('./m')` → aliased import
+ *   - `'namespace'`   : `const X = require('./m')`         → namespace import
+ *   - `'side-effect'` : `require('./m')` bare expression   → side-effect
+ *
+ * These match the kinds `interpretTsImport` already handles for ESM
+ * (`import { X }`, `import { X as Y }`, `import * as X`, `import './m'`),
+ * so no new branch is needed here.
+ *
+ * `interpretJsTypeBinding` handles the JS-only `@type-binding.class-field`
+ * tag before delegating to `interpretTsTypeBinding`.  The class-field tag
+ * is emitted by `synthesizeConstructorFieldBindings` and should produce
+ * `source = 'annotation'` — the same strength as an explicit type
+ * annotation. Remapping it to `@type-binding.annotation` achieves this
+ * without adding a JS-specific branch to the shared TS interpreter
+ * (DoD.md §2.2).
+ */
+import { interpretTsImport, interpretTsTypeBinding } from '../typescript/interpret.js';
+export function interpretJsImport(captures) {
+    return interpretTsImport(captures);
+}
+export function interpretJsTypeBinding(captures) {
+    // @type-binding.class-field is a JS-only tag emitted by
+    // synthesizeConstructorFieldBindings. Remap it to the standard
+    // @type-binding.annotation tag so interpretTsTypeBinding assigns
+    // source = 'annotation' without a JS-specific branch in shared code.
+    if (captures['@type-binding.class-field'] !== undefined) {
+        const { '@type-binding.class-field': classField, ...rest } = captures;
+        return interpretTsTypeBinding({ ...rest, '@type-binding.annotation': classField });
+    }
+    return interpretTsTypeBinding(captures);
+}

package/dist/core/ingestion/languages/javascript/merge-bindings.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Binding-merge precedence for JavaScript.
+ *
+ * JavaScript has no TypeScript declaration-merging (no `interface + class`
+ * coexisting in the same scope, no `namespace + class` dual-space declarations).
+ * However, `typescriptMergeBindings` handles these by falling back to
+ * `['value']` for any `NodeLabel` not explicitly mapped to multiple spaces —
+ * which is what every JavaScript declaration produces. The result is pure
+ * LEGB precedence without any cross-space logic, which is exactly what
+ * JavaScript needs.
+ *
+ * Reuse rather than reimplementing to keep the single source of truth for
+ * the tier (local 0 / import-namespace-reexport 1 / wildcard 2) ordering.
+ */
+import type { BindingRef } from '../../../../_shared/index.js';
+export declare function jsMergeBindings(bindings: readonly BindingRef[]): readonly BindingRef[];

package/dist/core/ingestion/languages/javascript/merge-bindings.js

@@ -0,0 +1,18 @@
+/**
+ * Binding-merge precedence for JavaScript.
+ *
+ * JavaScript has no TypeScript declaration-merging (no `interface + class`
+ * coexisting in the same scope, no `namespace + class` dual-space declarations).
+ * However, `typescriptMergeBindings` handles these by falling back to
+ * `['value']` for any `NodeLabel` not explicitly mapped to multiple spaces —
+ * which is what every JavaScript declaration produces. The result is pure
+ * LEGB precedence without any cross-space logic, which is exactly what
+ * JavaScript needs.
+ *
+ * Reuse rather than reimplementing to keep the single source of truth for
+ * the tier (local 0 / import-namespace-reexport 1 / wildcard 2) ordering.
+ */
+import { typescriptMergeBindings } from '../typescript/merge-bindings.js';
+export function jsMergeBindings(bindings) {
+    return typescriptMergeBindings(bindings);
+}

package/dist/core/ingestion/languages/javascript/query.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Tree-sitter query for JavaScript scope captures (RFC §5.1, Ring 3).
+ *
+ * Subset of the TypeScript scope query (`languages/typescript/query.ts`)
+ * compiled against `tree-sitter-javascript`. TypeScript-only node types
+ * (`interface_declaration`, `type_alias_declaration`, `enum_declaration`,
+ * `internal_module`, `abstract_class_declaration`, `function_signature`,
+ * `method_signature`, `abstract_method_signature`, `type_annotation`,
+ * `public_field_definition`) are dropped because:
+ *
+ *   1. The JS grammar doesn't define them — the query compiler would
+ *      throw `InvalidNodeType` if they were included.
+ *   2. JavaScript has no static type annotations, so the `@type-binding.*`
+ *      patterns derived from TS annotation nodes don't apply.
+ *
+ * What IS shared with the TypeScript query:
+ *
+ *   - Scope patterns: `program`, `class_declaration`, `(class)` (the JS
+ *     grammar node for class expressions — NOT `class_expression`, which
+ *     does not exist in `tree-sitter-javascript`), `function_declaration`,
+ *     `generator_function_declaration`, `function_expression`,
+ *     `arrow_function`, `method_definition`.
+ *   - Declaration patterns for functions, classes, const/let/var,
+ *     object-property arrows (Zustand, TanStack, etc.), and HOC-wrapped
+ *     variable declarations (forwardRef / memo / useCallback / useMemo).
+ *   - Import patterns: `import_statement`, `export_statement` re-exports,
+ *     and dynamic `import()` (represented as `call_expression(import)` in
+ *     both grammars — the `import` leaf node exists in tree-sitter-javascript
+ *     as well as tree-sitter-typescript).
+ *   - Type-binding patterns that work without static annotations:
+ *     constructor inference (`new User()`), call-result alias
+ *     (`const u = getUser()`), member-access alias (`const a = u.addr`),
+ *     identifier alias, assignment rebind, and for-of element bindings.
+ *     JSDoc-derived type bindings (`@param {User} u`, `@returns {User}`)
+ *     are handled separately in `captures.ts` via comment-node scanning.
+ *   - Reference patterns: free calls, member calls, constructor calls,
+ *     write-access, read-access, and dynamic import.
+ *
+ * CJS `require()` is NOT captured here; it is handled in `captures.ts`
+ * by scanning parent context (destructured vs. namespace) of `call_expression`
+ * nodes whose callee is the identifier `require`.
+ *
+ * Grammar version: `tree-sitter-javascript` pinned in gitnexus/package.json.
+ *
+ * Exposes lazy `Parser` and `Query` singletons so callers don't pay
+ * tree-sitter init cost per file.
+ */
+import Parser from 'tree-sitter';
+export declare function getJsParser(filePath?: string): Parser;
+export declare function getJsScopeQuery(filePath?: string): Parser.Query;
+/** Validate that a cached Tree was produced by the JS grammar. */
+export declare function jsCachedTreeMatchesGrammar(tree: unknown): boolean;