cgraphx 2.0.2 → 2.0.3

package/dist/core/code/engine/core/ingestion/languages/go/generic-type-parameters.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stampGoInterfaceTypeParameters = stampGoInterfaceTypeParameters;
+exports.readGoTypeParameters = readGoTypeParameters;
+exports.matchingGoDelimiter = matchingGoDelimiter;
+exports.splitTopLevelGoList = splitTopLevelGoList;
+/**
+ * Stamp every generic interface in `parsedFiles` with its type-parameter names,
+ * read out of the declaration's own source text.
+ *
+ * WHY SOURCE TEXT AND NOT A CAPTURE. The tree has the list right there
+ * (`type_spec` carries a `type_parameters` field), and capturing it would be two
+ * lines. But captures run inside the PARSE WORKER, whose script is resolved from
+ * the compiled `dist/` build, and their output is additionally memoized by the
+ * parse cache and the durable ParsedFile store — so a capture-side change is
+ * invisible until a rebuild AND a cache-version bump, and silently wrong in
+ * between. Everything here runs on the main thread from data the pipeline
+ * already materialized, so it is correct on the first run and needs neither.
+ *
+ * The scan is exact rather than a grep over the file: an interface declaration
+ * owns a `Class` scope whose range spans exactly its `type_spec`
+ * (`Repo[T any] interface{ … }`), so the text is sliced by that range and the
+ * type parameters are, by grammar, whatever sits between the brackets that
+ * IMMEDIATELY follow the name. Comments and strings elsewhere in the file cannot
+ * reach it.
+ */
+function stampGoInterfaceTypeParameters(parsedFiles, fileContents) {
+    for (const parsed of parsedFiles) {
+        // Deferred so a file with no interface declaration never indexes its lines.
+        let lines;
+        for (const scope of parsed.scopes) {
+            if (scope.kind !== 'Class')
+                continue;
+            const iface = scope.ownedDefs.find((def) => def.type === 'Interface');
+            if (iface?.qualifiedName === undefined)
+                continue;
+            if (lines === undefined) {
+                const source = fileContents.get(parsed.filePath);
+                if (source === undefined)
+                    break;
+                lines = { source, starts: buildLineStarts(source) };
+            }
+            const declaration = sliceRange(lines.source, lines.starts, scope.range);
+            if (declaration === undefined)
+                continue;
+            const names = goTypeParameterNames(declaration, simpleGoName(iface.qualifiedName));
+            if (names === undefined)
+                continue;
+            iface.goTypeParameters = names;
+        }
+    }
+}
+/** Read back a stamp, rejecting anything whose shape does not match — the
+ *  sidecar is optional and a hand-built fixture def carries none. */
+function readGoTypeParameters(def) {
+    const names = def.goTypeParameters;
+    if (!Array.isArray(names) || names.length === 0)
+        return undefined;
+    return names.every((name) => typeof name === 'string') ? names : undefined;
+}
+/**
+ * The declared type-parameter names of `Name[…] interface{…}`, in source order,
+ * or `undefined` when the declaration is not generic.
+ *
+ * Go spec, Type parameter declarations: the list is comma-separated and one
+ * entry may declare SEVERAL names sharing one constraint — `[K, V any]` declares
+ * `K` and `V`, and `[S ~[]E, E any]` declares `S` and `E`. Each entry therefore
+ * contributes exactly its FIRST token as a name; anything after it is the
+ * constraint, which is not needed here (satisfaction of a constraint is a
+ * separate question from implementation of an interface, and constraints are
+ * never harvested as instantiations — see `interface-impls.ts`).
+ */
+function goTypeParameterNames(declaration, interfaceName) {
+    if (!declaration.startsWith(interfaceName))
+        return undefined;
+    if (declaration[interfaceName.length] !== '[')
+        return undefined;
+    const close = matchingGoDelimiter(declaration, interfaceName.length);
+    if (close === -1)
+        return undefined;
+    const names = [];
+    for (const entry of splitTopLevelGoList(declaration.slice(interfaceName.length + 1, close))) {
+        const name = /^[A-Za-z_][A-Za-z0-9_]*/.exec(entry)?.[0];
+        if (name === undefined)
+            return undefined;
+        names.push(name);
+    }
+    return names.length === 0 ? undefined : names;
+}
+/** Index of the delimiter closing the one at `open`, or -1 when unbalanced.
+ *  Tracks `[]`, `{}` and `()` together so an `interface{ M(a, b int) }`
+ *  constraint cannot end the list early. */
+function matchingGoDelimiter(text, open) {
+    let depth = 0;
+    for (let i = open; i < text.length; i += 1) {
+        const ch = text[i];
+        if (ch === '[' || ch === '{' || ch === '(')
+            depth += 1;
+        else if (ch === ']' || ch === '}' || ch === ')') {
+            depth -= 1;
+            if (depth === 0)
+                return i;
+        }
+    }
+    return -1;
+}
+/** Split on commas that are not nested inside brackets, braces or parens. */
+function splitTopLevelGoList(text) {
+    const parts = [];
+    let depth = 0;
+    let start = 0;
+    for (let i = 0; i < text.length; i += 1) {
+        const ch = text[i];
+        if (ch === '[' || ch === '{' || ch === '(')
+            depth += 1;
+        else if (ch === ']' || ch === '}' || ch === ')')
+            depth -= 1;
+        else if (ch === ',' && depth === 0) {
+            parts.push(text.slice(start, i));
+            start = i + 1;
+        }
+    }
+    parts.push(text.slice(start));
+    return parts.map((part) => part.trim()).filter((part) => part.length > 0);
+}
+function simpleGoName(qualifiedName) {
+    const dot = qualifiedName.lastIndexOf('.');
+    return dot === -1 ? qualifiedName : qualifiedName.slice(dot + 1);
+}
+/** Offsets at which each 1-based line begins. */
+function buildLineStarts(source) {
+    const starts = [0, 0];
+    for (let i = 0; i < source.length; i += 1) {
+        if (source[i] === '\n')
+            starts.push(i + 1);
+    }
+    return starts;
+}
+/** `Range` is 1-based on lines and 0-based on columns (`syntheticCapture`). */
+function sliceRange(source, lineStarts, range) {
+    const start = lineStarts[range.startLine];
+    const end = lineStarts[range.endLine];
+    if (start === undefined || end === undefined)
+        return undefined;
+    return source.slice(start + range.startCol, end + range.endCol);
+}

package/dist/core/code/engine/core/ingestion/languages/go/import-decomposer.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitGoImportStatement = splitGoImportStatement;
+const ast_helpers_js_1 = require("../../utils/ast-helpers.js");
+function splitGoImportStatement(node) {
+    if (node.type === 'import_declaration') {
+        const out = [];
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child?.type === 'import_spec')
+                out.push(...splitGoImportStatement(child));
+            if (child?.type === 'import_spec_list') {
+                for (let j = 0; j < child.namedChildCount; j++) {
+                    const spec = child.namedChild(j);
+                    if (spec?.type === 'import_spec')
+                        out.push(...splitGoImportStatement(spec));
+                }
+            }
+        }
+        return out;
+    }
+    if (node.type !== 'import_spec')
+        return [];
+    const pathNode = node.childForFieldName('path');
+    if (pathNode === null)
+        return [];
+    const rawPath = pathNode.text.replace(/^"|"$/g, '').replace(/^`|`$/g, '');
+    const nameNode = node.childForFieldName('name');
+    const alias = nameNode?.text;
+    const leaf = rawPath.split('/').filter(Boolean).pop() ?? rawPath;
+    const kind = alias === '.' ? 'dot' : alias === '_' ? 'blank' : alias === undefined ? 'namespace' : 'alias';
+    // Blank imports (import _ "pkg") are dropped in V1 — they represent
+    // side-effect registrations (e.g. database drivers), but emitting
+    // side-effect edges is deferred. See test: go-imports.test.ts.
+    if (kind === 'blank')
+        return [];
+    const aliased = alias !== undefined && alias !== '.' && alias !== '_';
+    return [
+        {
+            '@import.statement': (0, ast_helpers_js_1.syntheticCapture)('@import.statement', node, node.text),
+            '@import.kind': (0, ast_helpers_js_1.syntheticCapture)('@import.kind', node, kind),
+            '@import.source': (0, ast_helpers_js_1.syntheticCapture)('@import.source', pathNode, rawPath),
+            '@import.name': (0, ast_helpers_js_1.syntheticCapture)('@import.name', nameNode ?? pathNode, aliased ? alias : leaf),
+            ...(aliased ? { '@import.alias': (0, ast_helpers_js_1.syntheticCapture)('@import.alias', nameNode, alias) } : {}),
+        },
+    ];
+}

package/dist/core/code/engine/core/ingestion/languages/go/import-target.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveGoImportTarget = resolveGoImportTarget;
+/**
+ * Resolve a Go import path to ALL .go files in the matching package directory.
+ *
+ * Go packages are directory-scoped: one import statement brings in every
+ * (non-test) .go file in the package directory. Return all matching files so
+ * the shared finalize pass creates one ImportEdge per file — enabling both
+ * IMPORTS edge fanout AND binding materialization for every exported symbol in
+ * the package.
+ *
+ * Strategy (first match wins):
+ *   1. go.mod-based: strip module prefix, match package directory
+ *   2. Non-go.mod / GOPATH: progressively shorter directory suffixes
+ */
+function resolveGoImportTarget(targetRaw, _fromFile, allFilePaths, resolutionConfig) {
+    if (!targetRaw)
+        return null;
+    const goModule = resolutionConfig;
+    // 1) go.mod-based: strip module prefix, match directory
+    if (goModule != null &&
+        (targetRaw === goModule.modulePath || targetRaw.startsWith(`${goModule.modulePath}/`))) {
+        const relativePkg = targetRaw === goModule.modulePath ? '' : targetRaw.slice(goModule.modulePath.length + 1); // e.g. "internal/models"
+        const files = relativePkg === ''
+            ? findRootPackageFiles(allFilePaths)
+            : findAllFilesInPkgDir(allFilePaths, relativePkg);
+        if (files.length > 0)
+            return files;
+    }
+    // 2) Non-go.mod / GOPATH: progressively shorter directory suffixes.
+    //    "github.com/xxx/yyy/pkg" → try "github.com/xxx/yyy/pkg/" → "xxx/yyy/pkg/" → "yyy/pkg/"
+    // Stop at ≥2 segments to avoid matching a single-segment suffix (e.g.
+    // "pkg", "util", "internal") to a local directory with the same name.
+    const parts = targetRaw.split('/').filter(Boolean);
+    for (let i = 0; i < parts.length - 1; i++) {
+        const files = findAllFilesInPkgDir(allFilePaths, parts.slice(i).join('/'));
+        if (files.length > 0)
+            return files;
+    }
+    return null;
+}
+function findRootPackageFiles(allFilePaths) {
+    const result = [];
+    for (const raw of allFilePaths) {
+        const normalized = raw.replace(/\\/g, '/');
+        if (normalized.includes('/'))
+            continue;
+        if (!normalized.endsWith('.go') || normalized.endsWith('_test.go'))
+            continue;
+        result.push(raw);
+    }
+    return result.sort();
+}
+function findAllFilesInPkgDir(allFilePaths, pkgPath) {
+    const pkgDir = '/' + pkgPath + '/';
+    const result = [];
+    for (const raw of allFilePaths) {
+        const normalized = '/' + raw.replace(/\\/g, '/');
+        if (!normalized.includes(pkgDir))
+            continue;
+        if (!normalized.endsWith('.go') || normalized.endsWith('_test.go'))
+            continue;
+        // Ensure file is directly in the package directory (not a subdirectory)
+        const afterPkg = normalized.substring(normalized.indexOf(pkgDir) + pkgDir.length);
+        if (!afterPkg.includes('/'))
+            result.push(raw);
+    }
+    return result;
+}

package/dist/core/code/engine/core/ingestion/languages/go/index.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mirrorGoNamespaceTypeBindings = exports.detectGoInterfaceImplementations = exports.populateGoRangeBindings = exports.populateGoPackageSiblings = exports.resolveGoImportTarget = exports.goReceiverBinding = exports.goImportOwningScope = exports.goBindingScopeFor = exports.goMergeBindings = exports.goArityCompatibility = exports.synthesizeGoTypeBindings = exports.synthesizeGoReceiverBinding = exports.splitGoImportStatement = exports.normalizeGoTypeName = exports.interpretGoTypeBinding = exports.interpretGoImport = exports.resetGoCaptureCacheStats = exports.getGoCaptureCacheStats = exports.emitGoScopeCaptures = void 0;
+/**
+ * Go scope-resolution hooks (RFC #909 Ring 3).
+ */
+var captures_js_1 = require("./captures.js");
+Object.defineProperty(exports, "emitGoScopeCaptures", { enumerable: true, get: function () { return captures_js_1.emitGoScopeCaptures; } });
+var cache_stats_js_1 = require("./cache-stats.js");
+Object.defineProperty(exports, "getGoCaptureCacheStats", { enumerable: true, get: function () { return cache_stats_js_1.getGoCaptureCacheStats; } });
+Object.defineProperty(exports, "resetGoCaptureCacheStats", { enumerable: true, get: function () { return cache_stats_js_1.resetGoCaptureCacheStats; } });
+var interpret_js_1 = require("./interpret.js");
+Object.defineProperty(exports, "interpretGoImport", { enumerable: true, get: function () { return interpret_js_1.interpretGoImport; } });
+Object.defineProperty(exports, "interpretGoTypeBinding", { enumerable: true, get: function () { return interpret_js_1.interpretGoTypeBinding; } });
+Object.defineProperty(exports, "normalizeGoTypeName", { enumerable: true, get: function () { return interpret_js_1.normalizeGoTypeName; } });
+var import_decomposer_js_1 = require("./import-decomposer.js");
+Object.defineProperty(exports, "splitGoImportStatement", { enumerable: true, get: function () { return import_decomposer_js_1.splitGoImportStatement; } });
+var receiver_binding_js_1 = require("./receiver-binding.js");
+Object.defineProperty(exports, "synthesizeGoReceiverBinding", { enumerable: true, get: function () { return receiver_binding_js_1.synthesizeGoReceiverBinding; } });
+var type_binding_js_1 = require("./type-binding.js");
+Object.defineProperty(exports, "synthesizeGoTypeBindings", { enumerable: true, get: function () { return type_binding_js_1.synthesizeGoTypeBindings; } });
+var arity_js_1 = require("./arity.js");
+Object.defineProperty(exports, "goArityCompatibility", { enumerable: true, get: function () { return arity_js_1.goArityCompatibility; } });
+var merge_bindings_js_1 = require("./merge-bindings.js");
+Object.defineProperty(exports, "goMergeBindings", { enumerable: true, get: function () { return merge_bindings_js_1.goMergeBindings; } });
+var simple_hooks_js_1 = require("./simple-hooks.js");
+Object.defineProperty(exports, "goBindingScopeFor", { enumerable: true, get: function () { return simple_hooks_js_1.goBindingScopeFor; } });
+Object.defineProperty(exports, "goImportOwningScope", { enumerable: true, get: function () { return simple_hooks_js_1.goImportOwningScope; } });
+Object.defineProperty(exports, "goReceiverBinding", { enumerable: true, get: function () { return simple_hooks_js_1.goReceiverBinding; } });
+var import_target_js_1 = require("./import-target.js");
+Object.defineProperty(exports, "resolveGoImportTarget", { enumerable: true, get: function () { return import_target_js_1.resolveGoImportTarget; } });
+var package_siblings_js_1 = require("./package-siblings.js");
+Object.defineProperty(exports, "populateGoPackageSiblings", { enumerable: true, get: function () { return package_siblings_js_1.populateGoPackageSiblings; } });
+var range_binding_js_1 = require("./range-binding.js");
+Object.defineProperty(exports, "populateGoRangeBindings", { enumerable: true, get: function () { return range_binding_js_1.populateGoRangeBindings; } });
+var interface_impls_js_1 = require("./interface-impls.js");
+Object.defineProperty(exports, "detectGoInterfaceImplementations", { enumerable: true, get: function () { return interface_impls_js_1.detectGoInterfaceImplementations; } });
+var namespace_mirror_js_1 = require("./namespace-mirror.js");
+Object.defineProperty(exports, "mirrorGoNamespaceTypeBindings", { enumerable: true, get: function () { return namespace_mirror_js_1.mirrorGoNamespaceTypeBindings; } });