gitnexus 1.6.3-rc.15 → 1.6.3-rc.17

package/dist/_shared/graph/types.d.ts

@@ -61,5 +61,21 @@ export interface GraphRelationship {
     confidence: number;
     reason: string;
     step?: number;
+    /**
+     * Per-signal evidence trace for edges emitted by the scope-based
+     * resolution pipeline (RFC #909 Ring 2 PKG #925). Populated by
+     * `emit-references.ts` when draining `ReferenceIndex` into the graph
+     * so downstream query / audit tools can inspect *why* a given edge
+     * was emitted with its confidence value.
+     *
+     * Optional and additive — every existing edge emitter ignores this
+     * field, and every existing query continues to work whether or not
+     * an edge carries it.
+     */
+    evidence?: readonly {
+        readonly kind: string;
+        readonly weight: number;
+        readonly note?: string;
+    }[];
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/_shared/graph/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/graph/types.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/graph/types.ts"],"names":[],"mappings":"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"}

package/dist/core/ingestion/emit-references.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Phase 5 of the RFC #909 ingestion lifecycle: drain `ReferenceIndex`
+ * into the knowledge graph as labeled edges with `confidence` and
+ * `evidence` properties (Ring 2 PKG #925).
+ *
+ * The resolution phase (future PR) writes `Reference` records into
+ * `model.scopes.referenceSites`-derived `ReferenceIndex`; this module
+ * materializes those records as `GraphRelationship`s via
+ * `graph.addRelationship`. Every emitted edge carries:
+ *
+ *   - `type`: one of `'CALLS' | 'ACCESSES' | 'INHERITS' | 'USES'`
+ *     (mapped from `Reference.kind` — `'read'` and `'write'` both route
+ *     to `ACCESSES`; `'type-reference'` and `'import-use'` route to
+ *     `USES`; `'call'` stays `CALLS`; `'inherits'` stays `INHERITS`).
+ *   - `confidence`: the pre-computed confidence from the Reference record.
+ *   - `reason`: human-readable summary (`"scope-resolution: call | confidence 0.75"`).
+ *   - `evidence`: the full `ResolutionEvidence[]` trace — additive graph
+ *     property (see `GraphRelationship.evidence` in gitnexus-shared),
+ *     so queries that don't know about it are unaffected.
+ *   - `step`: carries the reference's access-kind discriminant when
+ *     available (`1` for read, `2` for write) so `ACCESSES` edges retain
+ *     the read/write distinction without forcing a new edge type.
+ *
+ * ## Optional scope-tree flush
+ *
+ * When `INGESTION_EMIT_SCOPES=1` is set, this module also emits:
+ *
+ *   - `Scope` nodes for every `Scope` in the tree
+ *   - `CONTAINS` edges from parent scope to child scope
+ *   - `DEFINES` edges from scope to its `ownedDefs` members
+ *   - `IMPORTS` edges from scope to `targetModuleScope` of each finalized
+ *     `ImportEdge` that carries one
+ *
+ * Off by default — existing queries that don't know about `Scope` nodes
+ * continue to work, and the storage cost is opt-in.
+ *
+ * ## Source-of-truth: the caller def for a reference
+ *
+ * A `Reference` says "some code inside `fromScope` references `toDef`".
+ * The graph wants `(callerNodeId, calleeNodeId)`. We resolve the caller
+ * by walking up the scope tree from `fromScope` until we find a scope
+ * whose `ownedDefs` contains a Function-like def. If no such ancestor
+ * exists, the edge is attributed to the first def owned by the innermost
+ * ancestor scope, and if THAT produces nothing either the edge is
+ * skipped (with a count returned in `EmitStats.skippedNoCaller`).
+ */
+import type { ReferenceIndex } from '../../_shared/index.js';
+import type { KnowledgeGraph } from '../graph/types.js';
+import type { ScopeResolutionIndexes } from './model/scope-resolution-indexes.js';
+export interface EmitStats {
+    readonly edgesEmitted: number;
+    /** References dropped because no caller def could be resolved. */
+    readonly skippedNoCaller: number;
+    /** References dropped because `toDef` was not found in the DefIndex. */
+    readonly skippedMissingTarget: number;
+    /** Scope nodes emitted — `0` unless `INGESTION_EMIT_SCOPES=1`. */
+    readonly scopeNodesEmitted: number;
+    /** Scope-tree structural edges emitted — `0` unless `INGESTION_EMIT_SCOPES=1`. */
+    readonly scopeEdgesEmitted: number;
+}
+export interface EmitReferencesInput {
+    readonly graph: KnowledgeGraph;
+    readonly scopes: ScopeResolutionIndexes;
+    readonly referenceIndex: ReferenceIndex;
+    /** Human-consumable label for the `reason` prefix. Defaults to `'scope-resolution'`. */
+    readonly sourceLabel?: string;
+}
+/**
+ * Drain `referenceIndex.bySourceScope` into graph edges.
+ *
+ * The scope-tree flush is controlled separately by
+ * `INGESTION_EMIT_SCOPES` — callers can run `emitReferencesToGraph`
+ * without scope-node emission or layer the two calls as needed.
+ */
+export declare function emitReferencesToGraph(input: EmitReferencesInput): EmitStats;
+/**
+ * Emit `Scope` nodes + `CONTAINS`/`DEFINES`/`IMPORTS` edges representing
+ * the lexical scope tree itself. Skipped unless `INGESTION_EMIT_SCOPES=1`
+ * at the public entry point; exported here for tests that want to
+ * exercise the path directly.
+ */
+export declare function emitScopeGraph(input: {
+    readonly graph: KnowledgeGraph;
+    readonly scopes: ScopeResolutionIndexes;
+}): {
+    readonly scopeNodesEmitted: number;
+    readonly scopeEdgesEmitted: number;
+};

package/dist/core/ingestion/emit-references.js

@@ -0,0 +1,229 @@
+/**
+ * Phase 5 of the RFC #909 ingestion lifecycle: drain `ReferenceIndex`
+ * into the knowledge graph as labeled edges with `confidence` and
+ * `evidence` properties (Ring 2 PKG #925).
+ *
+ * The resolution phase (future PR) writes `Reference` records into
+ * `model.scopes.referenceSites`-derived `ReferenceIndex`; this module
+ * materializes those records as `GraphRelationship`s via
+ * `graph.addRelationship`. Every emitted edge carries:
+ *
+ *   - `type`: one of `'CALLS' | 'ACCESSES' | 'INHERITS' | 'USES'`
+ *     (mapped from `Reference.kind` — `'read'` and `'write'` both route
+ *     to `ACCESSES`; `'type-reference'` and `'import-use'` route to
+ *     `USES`; `'call'` stays `CALLS`; `'inherits'` stays `INHERITS`).
+ *   - `confidence`: the pre-computed confidence from the Reference record.
+ *   - `reason`: human-readable summary (`"scope-resolution: call | confidence 0.75"`).
+ *   - `evidence`: the full `ResolutionEvidence[]` trace — additive graph
+ *     property (see `GraphRelationship.evidence` in gitnexus-shared),
+ *     so queries that don't know about it are unaffected.
+ *   - `step`: carries the reference's access-kind discriminant when
+ *     available (`1` for read, `2` for write) so `ACCESSES` edges retain
+ *     the read/write distinction without forcing a new edge type.
+ *
+ * ## Optional scope-tree flush
+ *
+ * When `INGESTION_EMIT_SCOPES=1` is set, this module also emits:
+ *
+ *   - `Scope` nodes for every `Scope` in the tree
+ *   - `CONTAINS` edges from parent scope to child scope
+ *   - `DEFINES` edges from scope to its `ownedDefs` members
+ *   - `IMPORTS` edges from scope to `targetModuleScope` of each finalized
+ *     `ImportEdge` that carries one
+ *
+ * Off by default — existing queries that don't know about `Scope` nodes
+ * continue to work, and the storage cost is opt-in.
+ *
+ * ## Source-of-truth: the caller def for a reference
+ *
+ * A `Reference` says "some code inside `fromScope` references `toDef`".
+ * The graph wants `(callerNodeId, calleeNodeId)`. We resolve the caller
+ * by walking up the scope tree from `fromScope` until we find a scope
+ * whose `ownedDefs` contains a Function-like def. If no such ancestor
+ * exists, the edge is attributed to the first def owned by the innermost
+ * ancestor scope, and if THAT produces nothing either the edge is
+ * skipped (with a count returned in `EmitStats.skippedNoCaller`).
+ */
+/**
+ * Drain `referenceIndex.bySourceScope` into graph edges.
+ *
+ * The scope-tree flush is controlled separately by
+ * `INGESTION_EMIT_SCOPES` — callers can run `emitReferencesToGraph`
+ * without scope-node emission or layer the two calls as needed.
+ */
+export function emitReferencesToGraph(input) {
+    const { graph, scopes, referenceIndex } = input;
+    const sourceLabel = input.sourceLabel ?? 'scope-resolution';
+    let edgesEmitted = 0;
+    let skippedNoCaller = 0;
+    let skippedMissingTarget = 0;
+    for (const [fromScope, refs] of referenceIndex.bySourceScope) {
+        for (const ref of refs) {
+            const targetDef = scopes.defs.get(ref.toDef);
+            if (targetDef === undefined) {
+                skippedMissingTarget++;
+                continue;
+            }
+            const callerId = resolveCallerNodeId(fromScope, scopes);
+            if (callerId === undefined) {
+                skippedNoCaller++;
+                continue;
+            }
+            graph.addRelationship(buildRelationship(ref, callerId, targetDef, sourceLabel));
+            edgesEmitted++;
+        }
+    }
+    const scopeStats = isScopeEmissionEnabled()
+        ? emitScopeGraph({ graph, scopes })
+        : { scopeNodesEmitted: 0, scopeEdgesEmitted: 0 };
+    return { edgesEmitted, skippedNoCaller, skippedMissingTarget, ...scopeStats };
+}
+/**
+ * Emit `Scope` nodes + `CONTAINS`/`DEFINES`/`IMPORTS` edges representing
+ * the lexical scope tree itself. Skipped unless `INGESTION_EMIT_SCOPES=1`
+ * at the public entry point; exported here for tests that want to
+ * exercise the path directly.
+ */
+export function emitScopeGraph(input) {
+    const { graph, scopes } = input;
+    let scopeNodesEmitted = 0;
+    let scopeEdgesEmitted = 0;
+    for (const scope of scopes.scopeTree.byId.values()) {
+        graph.addNode({
+            id: scope.id,
+            label: 'CodeElement', // the generic bucket for non-symbol graph nodes
+            properties: {
+                name: scope.kind,
+                filePath: scope.filePath,
+                startLine: scope.range.startLine,
+                endLine: scope.range.endLine,
+                description: `Scope: ${scope.kind}`,
+            },
+        });
+        scopeNodesEmitted++;
+        if (scope.parent !== null) {
+            graph.addRelationship({
+                id: `rel:contains:${scope.parent}->${scope.id}`,
+                sourceId: scope.parent,
+                targetId: scope.id,
+                type: 'CONTAINS',
+                confidence: 1,
+                reason: 'scope-tree parent/child',
+            });
+            scopeEdgesEmitted++;
+        }
+        for (const def of scope.ownedDefs) {
+            graph.addRelationship({
+                id: `rel:defines:${scope.id}->${def.nodeId}`,
+                sourceId: scope.id,
+                targetId: def.nodeId,
+                type: 'DEFINES',
+                confidence: 1,
+                reason: 'scope.ownedDefs',
+            });
+            scopeEdgesEmitted++;
+        }
+    }
+    for (const [scopeId, edges] of scopes.imports) {
+        for (const edge of edges) {
+            if (edge.targetModuleScope === undefined)
+                continue;
+            graph.addRelationship({
+                id: `rel:imports:${scopeId}->${edge.targetModuleScope}:${edge.localName}`,
+                sourceId: scopeId,
+                targetId: edge.targetModuleScope,
+                type: 'IMPORTS',
+                confidence: edge.linkStatus === 'unresolved' ? 0.5 : 1,
+                reason: `import ${edge.kind} ${edge.localName}`,
+            });
+            scopeEdgesEmitted++;
+        }
+    }
+    return { scopeNodesEmitted, scopeEdgesEmitted };
+}
+// ─── Internal ───────────────────────────────────────────────────────────────
+/** Accepted truthy values for `INGESTION_EMIT_SCOPES`. */
+const TRUTHY = new Set(['true', '1', 'yes']);
+function isScopeEmissionEnabled() {
+    const raw = process.env['INGESTION_EMIT_SCOPES'];
+    if (raw === undefined)
+        return false;
+    return TRUTHY.has(raw.trim().toLowerCase());
+}
+/**
+ * Walk up from `startScope` looking for the first ancestor scope whose
+ * `ownedDefs` contains a Function-like def (Function / Method /
+ * Constructor). Fall back to the innermost ancestor's first `ownedDef`
+ * if none is found; return `undefined` if all ancestors have no defs.
+ */
+function resolveCallerNodeId(startScope, scopes) {
+    const tree = scopes.scopeTree;
+    let current = startScope;
+    const visited = new Set();
+    let firstOwnedFallback;
+    while (current !== null) {
+        if (visited.has(current))
+            break;
+        visited.add(current);
+        const scope = tree.getScope(current);
+        if (scope === undefined)
+            break;
+        // Prefer a Function-like owner.
+        const fnDef = scope.ownedDefs.find((d) => isFunctionLike(d.type));
+        if (fnDef !== undefined)
+            return fnDef.nodeId;
+        // Stash the first owned def we see as a conservative fallback.
+        if (firstOwnedFallback === undefined && scope.ownedDefs.length > 0) {
+            firstOwnedFallback = scope.ownedDefs[0].nodeId;
+        }
+        current = scope.parent;
+    }
+    return firstOwnedFallback;
+}
+function isFunctionLike(type) {
+    return type === 'Function' || type === 'Method' || type === 'Constructor';
+}
+function buildRelationship(ref, callerId, targetDef, sourceLabel) {
+    const type = mapKindToType(ref.kind);
+    const reason = `${sourceLabel}: ${ref.kind} | confidence ${ref.confidence.toFixed(3)}`;
+    // `step` encodes read/write discriminator for ACCESSES edges (1=read, 2=write).
+    // Other kinds omit `step`.
+    const step = ref.kind === 'read' ? 1 : ref.kind === 'write' ? 2 : undefined;
+    return {
+        id: `rel:${type}:${callerId}->${targetDef.nodeId}:${ref.atRange.startLine}:${ref.atRange.startCol}`,
+        sourceId: callerId,
+        targetId: targetDef.nodeId,
+        type,
+        confidence: ref.confidence,
+        reason,
+        evidence: ref.evidence.map(serializeEvidence),
+        ...(step !== undefined ? { step } : {}),
+    };
+}
+/**
+ * Map a `Reference.kind` to an existing `RelationshipType`. Read/write
+ * both fold into `ACCESSES`; `type-reference` + `import-use` both fold
+ * into `USES`. This keeps the graph schema additive — no new
+ * RelationshipType values are introduced by this module.
+ */
+function mapKindToType(kind) {
+    switch (kind) {
+        case 'call':
+            return 'CALLS';
+        case 'read':
+        case 'write':
+            return 'ACCESSES';
+        case 'inherits':
+            return 'INHERITS';
+        case 'type-reference':
+        case 'import-use':
+            return 'USES';
+    }
+}
+function serializeEvidence(e) {
+    return {
+        kind: e.kind,
+        weight: e.weight,
+        ...(e.note !== undefined ? { note: e.note } : {}),
+    };
+}

package/dist/core/ingestion/framework-detection.js

@@ -21,10 +21,14 @@ import { SupportedLanguages } from '../../_shared/index.js';
  */
 export function detectFrameworkFromPath(filePath) {
     // Normalize path separators and ensure leading slash for consistent matching
-    let p = filePath.toLowerCase().replace(/\\/g, '/');
+    const originalPath = filePath.replace(/\\/g, '/');
+    let p = originalPath.toLowerCase();
     if (!p.startsWith('/')) {
         p = '/' + p; // Add leading slash so patterns like '/app/' match 'app/...'
     }
+    const originalPathWithLeadingSlash = originalPath.startsWith('/')
+        ? originalPath
+        : `/${originalPath}`;
     // ========== JAVASCRIPT / TYPESCRIPT FRAMEWORKS ==========
     // Next.js - Pages Router (high confidence)
     if (p.includes('/pages/') && !p.includes('/_') && !p.includes('/api/')) {
@@ -91,7 +95,7 @@ export function detectFrameworkFromPath(filePath) {
     if ((p.includes('/components/') || p.includes('/views/')) &&
         (p.endsWith('.tsx') || p.endsWith('.jsx'))) {
         // Only boost if PascalCase filename (likely a component, not util)
-        const fileName = p.split('/').pop() || '';
+        const fileName = originalPathWithLeadingSlash.split('/').pop() || '';
         if (/^[A-Z]/.test(fileName)) {
             return { framework: 'react', entryPointMultiplier: 1.5, reason: 'react-component' };
         }

package/package.json

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