gitnexus 1.6.0 → 1.6.2-rc.1

package/dist/core/group/extractors/tree-sitter-scanner.d.ts

@@ -0,0 +1,113 @@
+import Parser from 'tree-sitter';
+/**
+ * Shared, language-agnostic tree-sitter scanning utilities used by group
+ * extractors (topic, http, grpc, ...).
+ *
+ * Design goals:
+ *  - The top-level extractors must not import any tree-sitter grammar.
+ *  - Per-language plugins own their grammar import, their query sources,
+ *    and the mapping from capture → meta.
+ *  - This module provides the plumbing: compile queries once per plugin,
+ *    parse a file with a given grammar, run all patterns, and return the
+ *    captured `string_literal`-style nodes together with the plugin's meta.
+ */
+/**
+ * One pattern owned by a language plugin. Each pattern owns a tree-sitter
+ * S-expression query. Plugins can freely choose which capture names to
+ * use — the scanner exposes every capture in the returned `captures`
+ * map and does not privilege any particular name.
+ *
+ * `TMeta` is the plugin-specific payload the orchestrator receives back
+ * when this pattern matches — e.g. for topic extraction it carries the
+ * broker name, role, confidence, symbol name.
+ */
+export interface PatternSpec<TMeta> {
+    /** Tree-sitter S-expression. */
+    query: string;
+    /** Plugin-specific payload returned on every match. */
+    meta: TMeta;
+}
+/**
+ * A set of patterns owned by one language plugin, bound to a specific
+ * tree-sitter grammar.
+ *
+ * `language` is typed as `unknown` because tree-sitter's TypeScript
+ * declarations use `any` for the grammar object, and the grammar modules
+ * export different shapes (plain grammar vs. namespace with `typescript`
+ * / `tsx` members). Callers pass the concrete grammar object; this
+ * module forwards it to `parser.setLanguage` / `new Parser.Query`.
+ */
+export interface LanguagePatterns<TMeta> {
+    /** Human-readable plugin name for diagnostics. */
+    name: string;
+    /** tree-sitter grammar object. */
+    language: unknown;
+    /** Patterns authored against `language`. */
+    patterns: PatternSpec<TMeta>[];
+}
+/**
+ * Compiled form of a `LanguagePatterns` bundle. Queries are compiled
+ * eagerly at module load time so a broken grammar/query pair fails
+ * loudly the first time the plugin is imported, instead of silently
+ * at scan time when no contract is produced.
+ */
+export interface CompiledPatterns<TMeta> {
+    name: string;
+    language: unknown;
+    patterns: CompiledPattern<TMeta>[];
+}
+export interface CompiledPattern<TMeta> {
+    query: Parser.Query;
+    meta: TMeta;
+}
+/**
+ * Map from capture name → syntax node. Every named capture the query
+ * binds is exposed as an entry. If a query captures the same name more
+ * than once (unusual), the first occurrence wins — plugins that need
+ * all occurrences should use distinct capture names or fall back to
+ * `match.captures` array directly by iterating `query.matches()`
+ * themselves.
+ */
+export type CaptureMap = Record<string, Parser.SyntaxNode>;
+/**
+ * One match returned by `scanFile` / `runCompiledPatterns`. The caller
+ * receives the full capture map plus the plugin meta, and is
+ * responsible for turning it into a domain object.
+ */
+export interface ScanMatch<TMeta> {
+    meta: TMeta;
+    captures: CaptureMap;
+}
+/**
+ * Compile a LanguagePatterns bundle. Call this once per plugin, at
+ * module load time, and export the result. Throws if any pattern
+ * fails to compile against the grammar — that's a bug in the plugin
+ * author's query, not a runtime condition.
+ */
+export declare function compilePatterns<TMeta>(bundle: LanguagePatterns<TMeta>): CompiledPatterns<TMeta>;
+/**
+ * Run every compiled pattern in `plugin` against an already-parsed
+ * tree. Use this when a plugin needs multiple query bundles against
+ * the same file (e.g. one query for class-level prefixes and another
+ * for method-level annotations) and wants to avoid re-parsing.
+ */
+export declare function runCompiledPatterns<TMeta>(plugin: CompiledPatterns<TMeta>, tree: Parser.Tree): ScanMatch<TMeta>[];
+/**
+ * Parse `content` with the plugin's grammar and run every compiled
+ * pattern against the AST. Returns one `ScanMatch` per matched query
+ * occurrence, carrying the plugin's meta payload.
+ *
+ * Errors are swallowed at the file level (malformed file must not abort
+ * the whole extract). Individual pattern failures are swallowed too so
+ * a single unusable query doesn't block the rest of the plugin.
+ */
+export declare function scanFile<TMeta>(parser: Parser, plugin: CompiledPatterns<TMeta>, content: string): ScanMatch<TMeta>[];
+/**
+ * Strip enclosing quotes from a tree-sitter string literal node's text.
+ * Handles single / double / template quotes, Python triple-quoted strings,
+ * and Go raw string literals (backticks).
+ *
+ * Returns null for empty/nullish input so callers can uniformly skip
+ * captures whose value is missing.
+ */
+export declare function unquoteLiteral(raw: string): string | null;

package/dist/core/group/extractors/tree-sitter-scanner.js

@@ -0,0 +1,94 @@
+import Parser from 'tree-sitter';
+/**
+ * Compile a LanguagePatterns bundle. Call this once per plugin, at
+ * module load time, and export the result. Throws if any pattern
+ * fails to compile against the grammar — that's a bug in the plugin
+ * author's query, not a runtime condition.
+ */
+export function compilePatterns(bundle) {
+    const compiled = [];
+    for (const spec of bundle.patterns) {
+        try {
+            const query = new Parser.Query(bundle.language, spec.query);
+            compiled.push({ query, meta: spec.meta });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            throw new Error(`[tree-sitter-scanner] Failed to compile pattern in ${bundle.name}: ${message}\n` +
+                `Query source:\n${spec.query}`);
+        }
+    }
+    return { name: bundle.name, language: bundle.language, patterns: compiled };
+}
+/**
+ * Run every compiled pattern in `plugin` against an already-parsed
+ * tree. Use this when a plugin needs multiple query bundles against
+ * the same file (e.g. one query for class-level prefixes and another
+ * for method-level annotations) and wants to avoid re-parsing.
+ */
+export function runCompiledPatterns(plugin, tree) {
+    const out = [];
+    for (const compiled of plugin.patterns) {
+        let matches;
+        try {
+            matches = compiled.query.matches(tree.rootNode);
+        }
+        catch {
+            continue;
+        }
+        for (const match of matches) {
+            const captures = {};
+            for (const cap of match.captures) {
+                if (!(cap.name in captures))
+                    captures[cap.name] = cap.node;
+            }
+            out.push({ meta: compiled.meta, captures });
+        }
+    }
+    return out;
+}
+/**
+ * Parse `content` with the plugin's grammar and run every compiled
+ * pattern against the AST. Returns one `ScanMatch` per matched query
+ * occurrence, carrying the plugin's meta payload.
+ *
+ * Errors are swallowed at the file level (malformed file must not abort
+ * the whole extract). Individual pattern failures are swallowed too so
+ * a single unusable query doesn't block the rest of the plugin.
+ */
+export function scanFile(parser, plugin, content) {
+    let tree;
+    try {
+        parser.setLanguage(plugin.language);
+        tree = parser.parse(content);
+    }
+    catch {
+        return [];
+    }
+    return runCompiledPatterns(plugin, tree);
+}
+/**
+ * Strip enclosing quotes from a tree-sitter string literal node's text.
+ * Handles single / double / template quotes, Python triple-quoted strings,
+ * and Go raw string literals (backticks).
+ *
+ * Returns null for empty/nullish input so callers can uniformly skip
+ * captures whose value is missing.
+ */
+export function unquoteLiteral(raw) {
+    if (!raw)
+        return null;
+    // Python triple-quoted
+    if ((raw.startsWith('"""') && raw.endsWith('"""')) ||
+        (raw.startsWith("'''") && raw.endsWith("'''"))) {
+        return raw.slice(3, -3);
+    }
+    const first = raw[0];
+    const last = raw[raw.length - 1];
+    if ((first === '"' || first === "'" || first === '`') && last === first && raw.length >= 2) {
+        return raw.slice(1, -1);
+    }
+    // Some grammars expose the string content without quotes already (e.g.
+    // Python `string_content` child). Return as-is.
+    return raw;
+}

package/dist/core/ingestion/binding-accumulator.d.ts

@@ -36,9 +36,12 @@
  * or (b) post-process worker-path entries through a follow-up resolution
  * pass after the main-thread `SymbolTable` is complete.
  *
- * **Lifecycle contract**: `append → finalize → consume → dispose`. See
- * `finalize()` and `dispose()` for the state machine. Disposal is
- * orthogonal to finalization: either order is legal.
+ * **Lifecycle contract**: single-use — `append* → finalize → consume → dispose`.
+ * After `dispose()` the accumulator is permanently dead: any mutating call
+ * (`appendFile`) throws, and read methods return empty/undefined as if the
+ * accumulator had never been appended to. The instance is not recyclable;
+ * construct a new one for a new pipeline run. Finalization and disposal are
+ * orthogonal state dimensions and may be invoked in either order.
  */
 export interface BindingEntry {
     readonly scope: string;
@@ -119,28 +122,30 @@ export declare class BindingAccumulator {
     finalize(): void;
     /**
      * Release the accumulator's heap footprint. Clears both internal storage
-     * maps and resets `_totalBindings` to zero. Idempotent and orthogonal to
-     * `finalize()` — calling `dispose()` does not change the finalized state.
+     * maps and resets `_totalBindings` to zero. Idempotent — calling twice
+     * is a no-op. Orthogonal to `finalize()` — calling `dispose()` does not
+     * change the finalized state.
      *
-     * Post-dispose contract: all read methods return empty/undefined state
-     * matching a never-appended-to accumulator. Specifically:
+     * **Single-use lifecycle.** This is a one-way terminal transition: the
+     * accumulator is not recyclable. Any subsequent `appendFile` call throws
+     * (`'BindingAccumulator: use after dispose'`), regardless of whether
+     * `finalize()` was called first. Post-dispose reads do not throw —
+     * they return empty/undefined state matching a never-appended-to
+     * accumulator:
      *   - `fileCount === 0`
      *   - `totalBindings === 0`
      *   - `files()` yields an empty iterator
      *   - `getFile(x)` returns `undefined` for all `x`
      *   - `fileScopeEntries(x)` returns `[]` for all `x`
+     *   - `fileScopeGet(x, y)` returns `undefined` for all `x, y`
      *   - `estimateMemoryBytes()` returns `0`
      *
-     * If `dispose()` is called **before** `finalize()`, subsequent `appendFile`
-     * calls succeed — the accumulator behaves like a fresh one. If called
-     * **after** `finalize()`, subsequent `appendFile` calls throw the existing
-     * "finalized" error.
-     *
-     * Lifecycle note: the pipeline disposes the accumulator after both Phase 9
-     * consumers (`processCallsFromExtracted`, `processAssignmentsFromExtracted`)
-     * and the ExportedTypeMap enrichment loop have completed, so the heap is
-     * released before Phase 14 (`runCrossFileBindingPropagation`) and
-     * `runGraphAnalysisPhases` begin their long-running work.
+     * Lifecycle note: the pipeline disposes the accumulator inside the
+     * `finally` of the `crossFile` phase, which is scheduled after every
+     * other accumulator consumer (Phase 9 call/assignment processing and
+     * the ExportedTypeMap enrichment loop). The dispose call therefore
+     * runs once, on both the happy path and the throw path of the
+     * crossFile phase.
      */
     dispose(): void;
     /** Get all bindings for a file, or undefined if the file is unknown. */

package/dist/core/ingestion/binding-accumulator.js

@@ -36,9 +36,12 @@
  * or (b) post-process worker-path entries through a follow-up resolution
  * pass after the main-thread `SymbolTable` is complete.
  *
- * **Lifecycle contract**: `append → finalize → consume → dispose`. See
- * `finalize()` and `dispose()` for the state machine. Disposal is
- * orthogonal to finalization: either order is legal.
+ * **Lifecycle contract**: single-use — `append* → finalize → consume → dispose`.
+ * After `dispose()` the accumulator is permanently dead: any mutating call
+ * (`appendFile`) throws, and read methods return empty/undefined as if the
+ * accumulator had never been appended to. The instance is not recyclable;
+ * construct a new one for a new pipeline run. Finalization and disposal are
+ * orthogonal state dimensions and may be invoked in either order.
  */
 /**
  * Merge file-scope bindings from a (finalized) `BindingAccumulator` into an
@@ -137,17 +140,16 @@ export class BindingAccumulator {
         if (this._finalized) {
             throw new Error('[BindingAccumulator] appendFile after finalize — no further appends allowed');
         }
+        // Single-use lifecycle: once disposed, the accumulator is dead. A
+        // post-dispose append almost always indicates a missed wiring step
+        // (the consumer is reading state that was supposed to be released),
+        // so convert the silent use-after-dispose into a loud failure.
+        if (this._disposed) {
+            throw new Error('BindingAccumulator: use after dispose');
+        }
         if (entries.length === 0) {
             return;
         }
-        // Contract consistency: if this accumulator was previously disposed
-        // without being finalized, `dispose()` is documented to leave it
-        // "behaving like a fresh one" for subsequent appends. Clear the
-        // `_disposed` flag here so the `disposed` getter tracks the actual
-        // live state, not a stale signal from the prior lifecycle cycle.
-        if (this._disposed) {
-            this._disposed = false;
-        }
         // Note on the file-scope-only invariant:
         // The accumulator does NOT reject function-scope entries at this
         // boundary. The narrowing contract is enforced by the two production
@@ -213,28 +215,30 @@ export class BindingAccumulator {
     }
     /**
      * Release the accumulator's heap footprint. Clears both internal storage
-     * maps and resets `_totalBindings` to zero. Idempotent and orthogonal to
-     * `finalize()` — calling `dispose()` does not change the finalized state.
+     * maps and resets `_totalBindings` to zero. Idempotent — calling twice
+     * is a no-op. Orthogonal to `finalize()` — calling `dispose()` does not
+     * change the finalized state.
      *
-     * Post-dispose contract: all read methods return empty/undefined state
-     * matching a never-appended-to accumulator. Specifically:
+     * **Single-use lifecycle.** This is a one-way terminal transition: the
+     * accumulator is not recyclable. Any subsequent `appendFile` call throws
+     * (`'BindingAccumulator: use after dispose'`), regardless of whether
+     * `finalize()` was called first. Post-dispose reads do not throw —
+     * they return empty/undefined state matching a never-appended-to
+     * accumulator:
      *   - `fileCount === 0`
      *   - `totalBindings === 0`
      *   - `files()` yields an empty iterator
      *   - `getFile(x)` returns `undefined` for all `x`
      *   - `fileScopeEntries(x)` returns `[]` for all `x`
+     *   - `fileScopeGet(x, y)` returns `undefined` for all `x, y`
      *   - `estimateMemoryBytes()` returns `0`
      *
-     * If `dispose()` is called **before** `finalize()`, subsequent `appendFile`
-     * calls succeed — the accumulator behaves like a fresh one. If called
-     * **after** `finalize()`, subsequent `appendFile` calls throw the existing
-     * "finalized" error.
-     *
-     * Lifecycle note: the pipeline disposes the accumulator after both Phase 9
-     * consumers (`processCallsFromExtracted`, `processAssignmentsFromExtracted`)
-     * and the ExportedTypeMap enrichment loop have completed, so the heap is
-     * released before Phase 14 (`runCrossFileBindingPropagation`) and
-     * `runGraphAnalysisPhases` begin their long-running work.
+     * Lifecycle note: the pipeline disposes the accumulator inside the
+     * `finally` of the `crossFile` phase, which is scheduled after every
+     * other accumulator consumer (Phase 9 call/assignment processing and
+     * the ExportedTypeMap enrichment loop). The dispose call therefore
+     * runs once, on both the happy path and the throw path of the
+     * crossFile phase.
      */
     dispose() {
         this._allByFile.clear();

package/dist/core/ingestion/cobol-processor.d.ts

@@ -50,5 +50,5 @@ export declare function isJclFile(filePath: string): boolean;
  * @param allPathSet - Set of all file paths in the repository
  * @returns Summary of what was extracted
  */
-export declare const processCobol: (graph: KnowledgeGraph, files: CobolFile[], allPathSet: Set<string>) => CobolProcessResult;
+export declare const processCobol: (graph: KnowledgeGraph, files: CobolFile[], allPathSet: ReadonlySet<string>) => CobolProcessResult;
 export {};

package/dist/core/ingestion/import-processor.js

@@ -8,7 +8,7 @@ import { yieldToEventLoop } from './utils/event-loop.js';
 import { getTreeSitterBufferSize } from './constants.js';
 import { loadImportConfigs } from './language-config.js';
 import { buildSuffixIndex } from './import-resolvers/utils.js';
-const isDev = process.env.NODE_ENV === 'development';
+import { isDev } from './utils/env.js';
 /** Group files by provider (only those with implicit import wiring), then call each wirer
  *  with its own language's files. O(n) over files, O(1) per provider lookup. */
 function wireImplicitImports(files, importMap, addImportEdge, projectConfig) {

package/dist/core/ingestion/language-config.js

@@ -1,6 +1,6 @@
 import fs from 'fs/promises';
 import path from 'path';
-const isDev = process.env.NODE_ENV === 'development';
+import { isDev } from './utils/env.js';
 // ============================================================================
 // LANGUAGE-SPECIFIC CONFIG LOADERS
 // ============================================================================

package/dist/core/ingestion/language-provider.d.ts

@@ -21,8 +21,25 @@ import type { SyntaxNode } from './utils/ast-helpers.js';
 import type { NodeLabel } from '../../_shared/index.js';
 /** Tree-sitter query captures: capture name → AST node (or undefined if not captured). */
 export type CaptureMap = Record<string, SyntaxNode | undefined>;
-/** How a language handles imports — determines wildcard synthesis behavior. */
-export type ImportSemantics = 'named' | 'wildcard' | 'namespace';
+/**
+ * How a language handles imports — determines wildcard synthesis behavior.
+ *
+ * Import resolution is a graph-traversal policy with multiple distinct strategies,
+ * analogous to MRO for method resolution. Each tag picks a strategy:
+ *
+ * | Tag                   | Mechanism                                      | Traversal           | Languages                                  |
+ * |-----------------------|------------------------------------------------|---------------------|--------------------------------------------|
+ * | `named`               | Per-symbol imports                             | None (use-site)     | JS/TS, Java, C#, Rust, PHP, Kotlin, Vue    |
+ * | `wildcard-transitive` | Textual paste, symbols chain through files     | BFS closure         | C, C++ (future: Obj-C, Fortran, Nim)       |
+ * | `wildcard-leaf`       | Whole public API, single hop                   | None (direct only)  | Go, Ruby, Swift, Dart                      |
+ * | `namespace`           | Qualified handle; symbols resolved at call site| None at import      | Python                                     |
+ * | `explicit-reexport`   | Opt-in per-symbol re-export (SCAFFOLD)         | Topological DAG     | (future: TS `export *`, Rust `pub use`)    |
+ *
+ * The `explicit-reexport` tag is a compile-time scaffold; no provider claims it yet.
+ * It falls through to `wildcard-leaf` behavior in synthesis so today's TS/Rust
+ * handling is unchanged. A future PR will implement the DAG walk for `export *`.
+ */
+export type ImportSemantics = 'named' | 'wildcard-transitive' | 'wildcard-leaf' | 'namespace' | 'explicit-reexport';
 /**
  * Everything a language needs to provide.
  * Required fields must be explicitly set; optional fields have defaults
@@ -51,10 +68,12 @@ interface LanguageProviderConfig {
     /** Named binding extraction from import statements.
      *  Default: undefined (language uses wildcard/whole-module imports). */
     readonly namedBindingExtractor?: NamedBindingExtractorFn;
-    /** How this language handles imports.
+    /** How this language handles imports. See `ImportSemantics` for the full taxonomy.
      *  - 'named': per-symbol imports (JS/TS, Java, C#, Rust, PHP, Kotlin)
-     *  - 'wildcard': whole-module imports, needs synthesis (Go, Ruby, C/C++, Swift)
-     *  - 'namespace': namespace imports, needs moduleAliasMap (Python)
+     *  - 'wildcard-transitive': textual-include closure; imports chain through files (C, C++)
+     *  - 'wildcard-leaf': whole-module single-hop imports; no transitive chaining (Go, Ruby, Swift, Dart)
+     *  - 'namespace': qualified namespace imports, needs moduleAliasMap (Python)
+     *  - 'explicit-reexport': opt-in per-symbol re-export (scaffold; no provider uses yet)
      *  Default: 'named'. */
     readonly importSemantics?: ImportSemantics;
     /** Language-specific transformation of raw import path text before resolution.
@@ -66,6 +85,14 @@ interface LanguageProviderConfig {
      *  Called with only THIS language's files (pre-grouped by the processor).
      *  Default: undefined (no implicit imports). */
     readonly implicitImportWirer?: (languageFiles: string[], importMap: ReadonlyMap<string, ReadonlySet<string>>, addImportEdge: (src: string, target: string) => void, projectConfig: unknown) => void;
+    /** Resolve a container node during enclosing-owner tree walks.
+     *  Called when a CLASS_CONTAINER_TYPES node is found while walking up.
+     *  - Return a different SyntaxNode to remap the container (e.g., Ruby
+     *    singleton_class → enclosing class/module).
+     *  - Return null to skip this container and keep walking up.
+     *  - Omit (undefined) to use the container node as-is (default).
+     *  Default: undefined (no remapping). */
+    readonly resolveEnclosingOwner?: (node: SyntaxNode) => SyntaxNode | null;
     /** Resolve the enclosing function name + label from an AST ancestor node
      *  that is NOT a standard FUNCTION_NODE_TYPE.  For languages where the
      *  function body is a sibling of the signature (e.g. Dart: function_body ↔

package/dist/core/ingestion/languages/c-cpp.js

@@ -293,7 +293,7 @@ export const cProvider = defineLanguage({
     typeConfig: cCppConfig,
     exportChecker: cCppExportChecker,
     importResolver: resolveCImport,
-    importSemantics: 'wildcard',
+    importSemantics: 'wildcard-transitive',
     fieldExtractor: createFieldExtractor(cFieldConfig),
     methodExtractor: createMethodExtractor({
         ...cMethodConfig,
@@ -310,7 +310,7 @@ export const cppProvider = defineLanguage({
     typeConfig: cCppConfig,
     exportChecker: cCppExportChecker,
     importResolver: resolveCppImport,
-    importSemantics: 'wildcard',
+    importSemantics: 'wildcard-transitive',
     mroStrategy: 'leftmost-base',
     fieldExtractor: createFieldExtractor(cppFieldConfig),
     methodExtractor: createMethodExtractor({

package/dist/core/ingestion/languages/dart.d.ts

@@ -2,7 +2,7 @@
  * Dart Language Provider
  *
  * Dart traits:
- *   - importSemantics: 'wildcard' (Dart imports bring everything public into scope)
+ *   - importSemantics: 'wildcard-leaf' (Dart imports bring everything public into scope)
  *   - exportChecker: public if no leading underscore
  *   - Dart SDK imports (dart:*) and external packages are skipped
  *   - enclosingFunctionFinder: Dart's tree-sitter grammar places function_body

package/dist/core/ingestion/languages/dart.js

@@ -2,7 +2,7 @@
  * Dart Language Provider
  *
  * Dart traits:
- *   - importSemantics: 'wildcard' (Dart imports bring everything public into scope)
+ *   - importSemantics: 'wildcard-leaf' (Dart imports bring everything public into scope)
  *   - exportChecker: public if no leading underscore
  *   - Dart SDK imports (dart:*) and external packages are skipped
  *   - enclosingFunctionFinder: Dart's tree-sitter grammar places function_body
@@ -83,7 +83,7 @@ export const dartProvider = defineLanguage({
     typeConfig: dartConfig,
     exportChecker: dartExportChecker,
     importResolver: resolveDartImport,
-    importSemantics: 'wildcard',
+    importSemantics: 'wildcard-leaf',
     fieldExtractor: createFieldExtractor(dartFieldConfig),
     methodExtractor: createMethodExtractor(dartMethodConfig),
     classExtractor: createClassExtractor({

package/dist/core/ingestion/languages/go.d.ts

@@ -5,7 +5,7 @@
  * LanguageProvider, following the Strategy pattern used by the pipeline.
  *
  * Key Go traits:
- *   - importSemantics: 'wildcard' (Go imports entire packages)
+ *   - importSemantics: 'wildcard-leaf' (Go imports entire packages)
  *   - callRouter: present (Go method calls may need routing)
  */
 export declare const goProvider: import("../language-provider.js").LanguageProvider;

package/dist/core/ingestion/languages/go.js

@@ -5,7 +5,7 @@
  * LanguageProvider, following the Strategy pattern used by the pipeline.
  *
  * Key Go traits:
- *   - importSemantics: 'wildcard' (Go imports entire packages)
+ *   - importSemantics: 'wildcard-leaf' (Go imports entire packages)
  *   - callRouter: present (Go method calls may need routing)
  */
 import { SupportedLanguages } from '../../../_shared/index.js';
@@ -26,7 +26,7 @@ export const goProvider = defineLanguage({
     typeConfig: goConfig,
     exportChecker: goExportChecker,
     importResolver: resolveGoImport,
-    importSemantics: 'wildcard',
+    importSemantics: 'wildcard-leaf',
     fieldExtractor: createFieldExtractor(goFieldConfig),
     methodExtractor: createMethodExtractor(goMethodConfig),
     classExtractor: createClassExtractor({

package/dist/core/ingestion/languages/ruby.js

@@ -99,7 +99,22 @@ export const rubyProvider = defineLanguage({
     exportChecker: rubyExportChecker,
     importResolver: resolveRubyImport,
     callRouter: routeRubyCall,
-    importSemantics: 'wildcard',
+    importSemantics: 'wildcard-leaf',
+    resolveEnclosingOwner(node) {
+        // Ruby singleton_class (class << self) should resolve to the enclosing
+        // class or module for owner/container resolution (HAS_METHOD edges, class IDs).
+        if (node.type === 'singleton_class') {
+            let ancestor = node.parent;
+            while (ancestor) {
+                if (ancestor.type === 'class' || ancestor.type === 'module') {
+                    return ancestor;
+                }
+                ancestor = ancestor.parent;
+            }
+            return null; // no enclosing class/module — skip
+        }
+        return node; // use as-is for all other container types
+    },
     fieldExtractor: createFieldExtractor(rubyFieldConfig),
     methodExtractor: createMethodExtractor({
         ...rubyMethodConfig,

package/dist/core/ingestion/languages/swift.d.ts

@@ -5,7 +5,7 @@
  * LanguageProvider, following the Strategy pattern used by the pipeline.
  *
  * Key Swift traits:
- *   - importSemantics: 'wildcard' (Swift imports entire modules)
+ *   - importSemantics: 'wildcard-leaf' (Swift imports entire modules)
  *   - heritageDefaultEdge: 'IMPLEMENTS' (protocols are more common than class inheritance)
  *   - implicitImportWirer: all files in the same SPM target see each other
  */

package/dist/core/ingestion/languages/swift.js

@@ -5,7 +5,7 @@
  * LanguageProvider, following the Strategy pattern used by the pipeline.
  *
  * Key Swift traits:
- *   - importSemantics: 'wildcard' (Swift imports entire modules)
+ *   - importSemantics: 'wildcard-leaf' (Swift imports entire modules)
  *   - heritageDefaultEdge: 'IMPLEMENTS' (protocols are more common than class inheritance)
  *   - implicitImportWirer: all files in the same SPM target see each other
  */
@@ -221,7 +221,7 @@ export const swiftProvider = defineLanguage({
     typeConfig: swiftConfig,
     exportChecker: swiftExportChecker,
     importResolver: resolveSwiftImport,
-    importSemantics: 'wildcard',
+    importSemantics: 'wildcard-leaf',
     heritageDefaultEdge: 'IMPLEMENTS',
     fieldExtractor: createFieldExtractor(swiftFieldConfig),
     methodExtractor: createMethodExtractor({

package/dist/core/ingestion/markdown-processor.d.ts

@@ -10,7 +10,7 @@ interface MdFile {
     path: string;
     content: string;
 }
-export declare const processMarkdown: (graph: KnowledgeGraph, files: MdFile[], allPathSet: Set<string>) => {
+export declare const processMarkdown: (graph: KnowledgeGraph, files: MdFile[], allPathSet: ReadonlySet<string>) => {
     sections: number;
     links: number;
 };

package/dist/core/ingestion/method-extractors/configs/jvm.js

@@ -248,6 +248,7 @@ export const kotlinMethodConfig = {
     typeDeclarationNodes: ['class_declaration', 'object_declaration', 'companion_object'],
     methodNodeTypes: ['function_declaration'],
     bodyNodeTypes: ['class_body'],
+    staticOwnerTypes: new Set(['companion_object', 'object_declaration']),
     extractName(node) {
         for (let i = 0; i < node.namedChildCount; i++) {
             const child = node.namedChild(i);

package/dist/core/ingestion/method-extractors/configs/ruby.js

@@ -202,6 +202,7 @@ export const rubyMethodConfig = {
     typeDeclarationNodes: ['class', 'module', 'singleton_class'],
     methodNodeTypes: ['method', 'singleton_method'],
     bodyNodeTypes: ['body_statement'],
+    staticOwnerTypes: new Set(['singleton_class']),
     extractOwnerName(node) {
         // singleton_class (class << self) inherits the enclosing class/module name
         if (node.type === 'singleton_class') {

package/dist/core/ingestion/method-extractors/generic.d.ts

@@ -1,5 +1,11 @@
 import type { MethodExtractor, MethodExtractionConfig } from '../method-types.js';
 /**
  * Create a MethodExtractor from a declarative config.
+ *
+ * @throws {Error} if `typeDeclarationNodes` contains a static-implying owner
+ *   type (companion_object / object_declaration / singleton_class) that is
+ *   not covered by `staticOwnerTypes`. The guard fires once per language at
+ *   provider construction to prevent silent `isStatic=false` regressions. See
+ *   `STATIC_IMPLYING_OWNER_TYPES` for the exact opt-out convention.
  */
 export declare function createMethodExtractor(config: MethodExtractionConfig): MethodExtractor;