cgraphx 2.0.2 → 2.0.3

package/dist/core/code/engine/core/ingestion/field-extractors/configs/csharp.js

@@ -0,0 +1,124 @@
+"use strict";
+// cgraph/src/core/ingestion/field-extractors/configs/csharp.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.csharpConfig = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+const helpers_js_1 = require("./helpers.js");
+const shared_js_1 = require("../../type-extractors/shared.js");
+const CSHARP_VIS = new Set(['public', 'private', 'protected', 'internal']);
+const extractCsharpDeclaredType = (typeNode) => {
+    if (typeNode.type === 'generic_name')
+        return typeNode.text.trim();
+    return (0, shared_js_1.extractSimpleTypeName)(typeNode) ?? typeNode.text?.trim();
+};
+/**
+ * C# field extraction config.
+ *
+ * Handles field_declaration and property_declaration inside class/struct/interface bodies.
+ * The body node in tree-sitter-c-sharp is 'declaration_list'.
+ */
+exports.csharpConfig = {
+    language: index_js_1.SupportedLanguages.CSharp,
+    typeDeclarationNodes: [
+        'class_declaration',
+        'struct_declaration',
+        'interface_declaration',
+        'record_declaration',
+    ],
+    fieldNodeTypes: ['field_declaration', 'property_declaration'],
+    bodyNodeTypes: ['declaration_list'],
+    defaultVisibility: 'private',
+    extractName(node) {
+        // field_declaration > variable_declaration > variable_declarator > identifier
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child?.type === 'variable_declaration') {
+                for (let j = 0; j < child.namedChildCount; j++) {
+                    const declarator = child.namedChild(j);
+                    if (declarator?.type === 'variable_declarator') {
+                        const name = declarator.childForFieldName('name');
+                        return name?.text ?? declarator.firstNamedChild?.text;
+                    }
+                }
+            }
+        }
+        // property_declaration: name field
+        const nameNode = node.childForFieldName('name');
+        if (nameNode)
+            return nameNode.text;
+        return undefined;
+    },
+    extractType(node) {
+        // field_declaration > variable_declaration > type:(predefined_type | identifier | ...)
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child?.type === 'variable_declaration') {
+                const typeNode = child.childForFieldName('type');
+                if (typeNode)
+                    return extractCsharpDeclaredType(typeNode);
+                // fallback: first child that is a type
+                const first = child.firstNamedChild;
+                if (first && first.type !== 'variable_declarator') {
+                    return extractCsharpDeclaredType(first);
+                }
+            }
+        }
+        // property_declaration: type is first named child
+        const typeNode = node.childForFieldName('type');
+        if (typeNode)
+            return extractCsharpDeclaredType(typeNode);
+        return undefined;
+    },
+    extractVisibility(node) {
+        // Detect compound C# visibilities: protected internal, private protected
+        const mods = (0, helpers_js_1.collectModifierTexts)(node);
+        if (mods.has('protected') && mods.has('internal'))
+            return 'protected internal';
+        if (mods.has('private') && mods.has('protected'))
+            return 'private protected';
+        return (0, helpers_js_1.findVisibility)(node, CSHARP_VIS, 'private', 'modifier');
+    },
+    isStatic(node) {
+        return (0, helpers_js_1.hasKeyword)(node, 'static') || (0, helpers_js_1.hasModifier)(node, 'modifier', 'static');
+    },
+    isReadonly(node) {
+        return (0, helpers_js_1.hasKeyword)(node, 'readonly') || (0, helpers_js_1.hasModifier)(node, 'modifier', 'readonly');
+    },
+    extractPrimaryFields(ownerNode, context) {
+        // C# record positional parameters become public init-only properties.
+        // C# 12 class primary constructor parameters are captured as private fields.
+        // The parameter_list has no field name — find it by type.
+        let paramList = null;
+        for (let i = 0; i < ownerNode.namedChildCount; i++) {
+            const child = ownerNode.namedChild(i);
+            if (child?.type === 'parameter_list') {
+                paramList = child;
+                break;
+            }
+        }
+        if (!paramList)
+            return [];
+        const isRecord = ownerNode.type === 'record_declaration';
+        const fields = [];
+        for (let i = 0; i < paramList.namedChildCount; i++) {
+            const param = paramList.namedChild(i);
+            if (!param || param.type !== 'parameter')
+                continue;
+            const nameNode = param.childForFieldName('name');
+            const typeNode = param.childForFieldName('type');
+            if (!nameNode)
+                continue;
+            fields.push({
+                name: nameNode.text,
+                type: typeNode ? ((0, shared_js_1.extractSimpleTypeName)(typeNode) ?? typeNode.text?.trim() ?? null) : null,
+                // Record params are public init-only properties; class params are private captured fields
+                visibility: isRecord ? 'public' : 'private',
+                isStatic: false,
+                isReadonly: isRecord, // record properties are init-only (readonly)
+                sourceFile: context.filePath,
+                line: param.startPosition.row + 1,
+            });
+        }
+        return fields;
+    },
+};

package/dist/core/code/engine/core/ingestion/field-extractors/configs/dart.js

@@ -0,0 +1,99 @@
+"use strict";
+// cgraph/src/core/ingestion/field-extractors/configs/dart.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dartConfig = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+const helpers_js_1 = require("./helpers.js");
+const shared_js_1 = require("../../type-extractors/shared.js");
+/**
+ * Dart field extraction config.
+ *
+ * Dart class fields appear as `declaration` nodes inside `class_body`.
+ * Two shapes carry the field name(s):
+ *   - instance / plain fields → `initialized_identifier_list`
+ *     (`int z = 0;`, `int a = 1, b = 2;`)
+ *   - `static const` / `static final` / `const` fields → `static_final_declaration_list`
+ *     (`static const a = 1;`, `static final String b = 'x', c = 'y';`)
+ * Both shapes may declare SEVERAL fields in one declaration, so name extraction
+ * is multi-name (`extractNames`). The structure query (`DART_QUERIES`) emits one
+ * `@definition.property` per name for both shapes; this config enriches each.
+ *
+ * Visibility is convention-based: underscore prefix = private.
+ */
+/** All field names declared by a `declaration` node, across both Dart shapes. */
+function extractDartFieldNames(node) {
+    const names = [];
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (!child)
+            continue;
+        // instance / plain fields: initialized_identifier_list > initialized_identifier > identifier
+        if (child.type === 'initialized_identifier_list') {
+            for (let j = 0; j < child.namedChildCount; j++) {
+                const init = child.namedChild(j);
+                if (init?.type === 'initialized_identifier') {
+                    const ident = init.firstNamedChild;
+                    if (ident?.type === 'identifier')
+                        names.push(ident.text);
+                }
+            }
+        }
+        // static const / final fields: static_final_declaration_list > static_final_declaration > identifier
+        if (child.type === 'static_final_declaration_list') {
+            for (let j = 0; j < child.namedChildCount; j++) {
+                const decl = child.namedChild(j);
+                if (decl?.type === 'static_final_declaration') {
+                    const ident = decl.firstNamedChild;
+                    if (ident?.type === 'identifier')
+                        names.push(ident.text);
+                }
+            }
+        }
+    }
+    return names;
+}
+exports.dartConfig = {
+    language: index_js_1.SupportedLanguages.Dart,
+    typeDeclarationNodes: ['class_definition'],
+    fieldNodeTypes: ['declaration'],
+    bodyNodeTypes: ['class_body'],
+    defaultVisibility: 'public',
+    // One AST `declaration` node may declare several fields (`int a, b;`,
+    // `static final String b = 'x', c = 'y';`), so use the multi-name path.
+    extractName(node) {
+        return extractDartFieldNames(node)[0];
+    },
+    extractNames(node) {
+        return extractDartFieldNames(node);
+    },
+    extractType(node) {
+        // declaration > type_identifier (the type annotation, present for both the
+        // instance-field shape and `static final String b = …`). `static const a = 1;`
+        // has no annotation → undefined (untyped).
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child && (child.type === 'type_identifier' || child.type === 'function_type')) {
+                return (0, shared_js_1.extractSimpleTypeName)(child) ?? child.text?.trim();
+            }
+        }
+        return undefined;
+    },
+    // Per-name: Dart convention is underscore-prefixed = private. A single
+    // declaration can mix visibilities (`static const _p = 1, q = 2;`), so the
+    // decision is keyed on the individual field name.
+    extractVisibilityForName(_node, name) {
+        return name.startsWith('_') ? 'private' : 'public';
+    },
+    extractVisibility(node) {
+        const first = extractDartFieldNames(node)[0];
+        return first?.startsWith('_') ? 'private' : 'public';
+    },
+    isStatic(node) {
+        return (0, helpers_js_1.hasKeyword)(node, 'static');
+    },
+    isReadonly(node) {
+        // `final` / `const` (both `final_builtin`/`const_builtin` nodes whose text
+        // is `final`/`const`) are read-only.
+        return (0, helpers_js_1.hasKeyword)(node, 'final') || (0, helpers_js_1.hasKeyword)(node, 'const');
+    },
+};

package/dist/core/code/engine/core/ingestion/field-extractors/configs/go.js

@@ -0,0 +1,102 @@
+"use strict";
+// cgraph/src/core/ingestion/field-extractors/configs/go.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.goConfig = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+const shared_js_1 = require("../../type-extractors/shared.js");
+/**
+ * Go field extraction config.
+ *
+ * Go struct fields live inside type_declaration > type_spec > struct_type >
+ * field_declaration_list > field_declaration.
+ *
+ * Visibility in Go is based on the first character: uppercase = exported (public),
+ * lowercase = unexported (package).
+ */
+function goVisibilityForName(name) {
+    const first = name.charAt(0);
+    return first === first.toUpperCase() && first !== first.toLowerCase() ? 'public' : 'package';
+}
+function extractGoFieldNames(node) {
+    const names = [];
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === 'field_identifier')
+            names.push(child.text);
+    }
+    return names;
+}
+exports.goConfig = {
+    language: index_js_1.SupportedLanguages.Go,
+    typeDeclarationNodes: ['type_declaration', 'struct_type'],
+    fieldNodeTypes: ['field_declaration'],
+    bodyNodeTypes: ['field_declaration_list'],
+    defaultVisibility: 'package',
+    extractOwnerName(node) {
+        if (node.type === 'struct_type') {
+            return node.parent?.type === 'type_spec'
+                ? node.parent.childForFieldName('name')?.text
+                : undefined;
+        }
+        const typeSpec = node.namedChildren.find((child) => child.type === 'type_spec');
+        return typeSpec?.childForFieldName('name')?.text;
+    },
+    findBodyNodes(node) {
+        if (node.type === 'struct_type') {
+            const body = node.namedChildren.find((child) => child.type === 'field_declaration_list');
+            return body ? [body] : [];
+        }
+        const typeSpec = node.namedChildren.find((child) => child.type === 'type_spec');
+        const typeNode = typeSpec?.childForFieldName('type');
+        const body = typeNode?.namedChildren.find((child) => child.type === 'field_declaration_list');
+        return body ? [body] : [];
+    },
+    extractName(node) {
+        const firstName = extractGoFieldNames(node)[0];
+        if (firstName)
+            return firstName;
+        // field_declaration > name:(field_identifier)
+        const name = node.childForFieldName('name');
+        if (name)
+            return name.text;
+        // fallback: first field_identifier child
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child?.type === 'field_identifier')
+                return child.text;
+        }
+        return undefined;
+    },
+    extractNames: extractGoFieldNames,
+    extractType(node) {
+        // field_declaration > type:(type_identifier | pointer_type | ...)
+        const typeNode = node.childForFieldName('type');
+        if (typeNode)
+            return (0, shared_js_1.extractSimpleTypeName)(typeNode) ?? typeNode.text?.trim();
+        // fallback: second named child is usually the type
+        if (node.namedChildCount >= 2) {
+            const t = node.namedChild(1);
+            if (t)
+                return (0, shared_js_1.extractSimpleTypeName)(t) ?? t.text?.trim();
+        }
+        return undefined;
+    },
+    extractVisibility(node) {
+        const name = node.childForFieldName('name');
+        const text = name?.text;
+        if (text && text.length > 0) {
+            const first = text.charAt(0);
+            return first === first.toUpperCase() && first !== first.toLowerCase() ? 'public' : 'package';
+        }
+        return 'package';
+    },
+    extractVisibilityForName(_node, name) {
+        return goVisibilityForName(name);
+    },
+    isStatic(_node) {
+        return false; // Go has no static fields
+    },
+    isReadonly(_node) {
+        return false; // Go fields are not readonly
+    },
+};

package/dist/core/code/engine/core/ingestion/field-extractors/configs/helpers.js

@@ -0,0 +1,198 @@
+"use strict";
+// cgraph/src/core/ingestion/field-extractors/configs/helpers.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasKeyword = hasKeyword;
+exports.hasModifier = hasModifier;
+exports.extractAnnotations = extractAnnotations;
+exports.findVisibility = findVisibility;
+exports.firstChildText = firstChildText;
+exports.firstChildOfType = firstChildOfType;
+exports.typeFromField = typeFromField;
+exports.typeFromAnnotation = typeFromAnnotation;
+exports.typeFromDescendant = typeFromDescendant;
+exports.collectModifierTexts = collectModifierTexts;
+const shared_js_1 = require("../../type-extractors/shared.js");
+// ---------------------------------------------------------------------------
+// Modifier scanning
+// ---------------------------------------------------------------------------
+/**
+ * Check whether any child of `node` (named or unnamed) has .text matching
+ * the given `keyword`.
+ *
+ * Skips the `name` field child to avoid false positives when a method is
+ * named after a contextual keyword (e.g. `abstract()` in TypeScript).
+ */
+function hasKeyword(node, keyword) {
+    const nameNode = node.childForFieldName('name');
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (!child || child === nameNode)
+            continue;
+        if (child.text.trim() === keyword)
+            return true;
+    }
+    return false;
+}
+/**
+ * Check whether a named child of type `modifierType` contains `keyword`.
+ * Useful for languages that group modifiers under a wrapper node
+ * (e.g. Java 'modifiers', Kotlin 'modifiers').
+ */
+function hasModifier(node, modifierType, keyword) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child && child.type === modifierType) {
+            for (let j = 0; j < child.childCount; j++) {
+                const mod = child.child(j);
+                if (mod && mod.text.trim() === keyword)
+                    return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Collect `'@Name'`-prefixed annotation names from a declaration node's
+ * modifier-wrapper children (e.g. Java `modifiers`). Handles both
+ * `marker_annotation` (`@Autowired`) and `annotation`
+ * (`@Autowired(required=false)`) node types. Node-type-agnostic: works for
+ * any declaration (method, field, ...) that groups annotations under a
+ * wrapper child of type `modifierType`.
+ *
+ * Shared by the JVM method- and field-extractor configs (moved verbatim from
+ * `method-extractors/configs/jvm.ts` in PR #2200 U2).
+ */
+function extractAnnotations(node, modifierType) {
+    const annotations = [];
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child && child.type === modifierType) {
+            for (let j = 0; j < child.namedChildCount; j++) {
+                const mod = child.namedChild(j);
+                if (mod && (mod.type === 'marker_annotation' || mod.type === 'annotation')) {
+                    const nameNode = mod.childForFieldName('name') ?? mod.firstNamedChild;
+                    if (nameNode)
+                        annotations.push('@' + nameNode.text);
+                }
+            }
+        }
+    }
+    return annotations;
+}
+/**
+ * Return the first matching visibility keyword found either as a direct keyword
+ * child or inside a modifier wrapper node.
+ * Skips the `name` field child (same rationale as hasKeyword).
+ */
+function findVisibility(node, keywords, defaultVis, modifierNodeType) {
+    const nameNode = node.childForFieldName('name');
+    // Direct keyword children
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (!child || child === nameNode)
+            continue;
+        const text = child.text.trim();
+        if (text && keywords.has(text))
+            return text;
+    }
+    // Modifier wrapper
+    if (modifierNodeType) {
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child && child.type === modifierNodeType) {
+                for (let j = 0; j < child.childCount; j++) {
+                    const mod = child.child(j);
+                    const modText = mod?.text.trim();
+                    if (modText && keywords.has(modText))
+                        return modText;
+                }
+            }
+        }
+    }
+    return defaultVis;
+}
+// ---------------------------------------------------------------------------
+// Name and type extraction
+// ---------------------------------------------------------------------------
+/**
+ * Extract the text of the first named child whose type is in `types`.
+ */
+function firstChildText(node, types) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child && types.has(child.type))
+            return child.text;
+    }
+    return undefined;
+}
+/**
+ * Extract the first named child node whose type is in `types`.
+ */
+function firstChildOfType(node, types) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child && types.has(child.type))
+            return child;
+    }
+    return null;
+}
+/**
+ * Get type text from a named field on the node, using extractSimpleTypeName.
+ * Falls back to raw .text of the field child if extractSimpleTypeName returns undefined.
+ */
+function typeFromField(node, fieldName) {
+    const typeNode = node.childForFieldName(fieldName);
+    if (!typeNode)
+        return undefined;
+    return (0, shared_js_1.extractSimpleTypeName)(typeNode) ?? typeNode.text?.trim();
+}
+/**
+ * Walk named children looking for a type_annotation node and extract its type.
+ */
+function typeFromAnnotation(node) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child && child.type === 'type_annotation') {
+            const inner = child.firstNamedChild;
+            if (inner)
+                return (0, shared_js_1.extractSimpleTypeName)(inner) ?? inner.text?.trim();
+        }
+    }
+    return undefined;
+}
+/**
+ * Find the first descendant (depth-first, one level) matching one of the given types
+ * and return its text via extractSimpleTypeName.
+ */
+function typeFromDescendant(node, types) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (!child)
+            continue;
+        if (types.has(child.type)) {
+            return (0, shared_js_1.extractSimpleTypeName)(child) ?? child.text?.trim();
+        }
+        // one more level
+        for (let j = 0; j < child.namedChildCount; j++) {
+            const grandchild = child.namedChild(j);
+            if (grandchild && types.has(grandchild.type)) {
+                return (0, shared_js_1.extractSimpleTypeName)(grandchild) ?? grandchild.text?.trim();
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Collect all modifier keyword texts from a declaration node's named `modifier` children.
+ * Used by C# configs to detect compound visibilities (protected internal, private protected).
+ */
+function collectModifierTexts(node) {
+    const result = new Set();
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child && child.type === 'modifier') {
+            result.add(child.text.trim());
+        }
+    }
+    return result;
+}