cgraphx 2.0.2 → 2.0.6

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

@@ -0,0 +1,111 @@
+"use strict";
+// cgraph/src/core/ingestion/variable-extractors/configs/dart.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dartVariableConfig = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+/**
+ * Dart variable extraction config.
+ *
+ * Top-level Dart variables are NOT wrapped in a `declaration` node (that wrapper
+ * only occurs for class-body members). The structure query (`DART_QUERIES`)
+ * captures them as `@definition.variable` on the loose container node, which is
+ * one of two real shapes:
+ *
+ *   - `var name = 'x';` / `int x = 5;`
+ *       → initialized_identifier_list > initialized_identifier > identifier
+ *   - `final int count = 3;` / `const a = 1, b = 2;`
+ *       → static_final_declaration_list > static_final_declaration > identifier
+ *
+ * The variable extractor is invoked on that captured container node to enrich
+ * the Variable symbol with name(s)/type/const/mutable metadata.
+ *
+ * NOTE: the const/final modifier (`const_builtin` / `final_builtin`) and the
+ * type annotation (`type_identifier`) are siblings of the captured container —
+ * they live on the parent (program), NOT inside it — so const-ness and the type
+ * are read from the captured node's parent. (This is why the previous
+ * `type_identifier`-as-direct-child read found nothing.)
+ */
+/** The `initialized_identifier` / `static_final_declaration` name children. */
+function nameNodes(container) {
+    const out = [];
+    for (let i = 0; i < container.namedChildCount; i++) {
+        const entry = container.namedChild(i);
+        if (!entry)
+            continue;
+        if (entry.type === 'initialized_identifier' || entry.type === 'static_final_declaration') {
+            const ident = entry.firstNamedChild;
+            if (ident?.type === 'identifier')
+                out.push(ident);
+        }
+    }
+    return out;
+}
+function extractDartVarNames(node) {
+    return nameNodes(node).map((n) => n.text);
+}
+/**
+ * Scan the container's immediately-preceding siblings (the modifier / type
+ * nodes of THIS declaration), stopping at the previous statement's `;` so a
+ * neighbouring declaration's modifiers/type never bleed in. Top-level Dart
+ * declarations sit as loose siblings under `program` separated by `;`:
+ *   final int count = 3; var name = 'x'; const a = 1, b = 2;
+ * so the leading `type_identifier` / `const_builtin` / `final_builtin` of a
+ * declaration are the siblings between the prior `;` and the captured container.
+ */
+function scanLeadingSiblings(node) {
+    const out = [];
+    let sib = node.previousSibling;
+    while (sib !== null && sib.type !== ';') {
+        out.push(sib);
+        sib = sib.previousSibling;
+    }
+    return out;
+}
+/**
+ * The declared type annotation, read from the captured container's leading
+ * sibling `type_identifier`. Returns undefined for inferred (`var`)
+ * declarations, which have an `inferred_type` sibling instead.
+ */
+function extractDartVarType(node) {
+    for (const sib of scanLeadingSiblings(node)) {
+        if (sib.type === 'type_identifier')
+            return sib.text;
+    }
+    return undefined;
+}
+/** Whether a `const_builtin` / `final_builtin` leads this declaration. */
+function hasReadonlyModifier(node) {
+    for (const sib of scanLeadingSiblings(node)) {
+        if (sib.type === 'const_builtin' || sib.type === 'final_builtin')
+            return true;
+    }
+    return false;
+}
+exports.dartVariableConfig = {
+    language: index_js_1.SupportedLanguages.Dart,
+    constNodeTypes: [],
+    staticNodeTypes: [],
+    // The two real top-level container shapes captured as @definition.variable.
+    variableNodeTypes: ['initialized_identifier_list', 'static_final_declaration_list'],
+    extractName: (node) => extractDartVarNames(node)[0],
+    extractNames: extractDartVarNames,
+    extractType: extractDartVarType,
+    extractVisibilityForName(_node, name) {
+        // Dart convention: underscore prefix = library-private.
+        return name.startsWith('_') ? 'private' : 'public';
+    },
+    extractVisibility(node) {
+        const first = extractDartVarNames(node)[0];
+        if (!first)
+            return 'public';
+        return first.startsWith('_') ? 'private' : 'public';
+    },
+    isConst: hasReadonlyModifier,
+    isStatic(_node) {
+        // Top-level Dart variables are not static.
+        return false;
+    },
+    isMutable(node) {
+        return !hasReadonlyModifier(node);
+    },
+};

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

@@ -0,0 +1,153 @@
+"use strict";
+// cgraph/src/core/ingestion/variable-extractors/configs/go.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.goVariableConfig = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+const shared_js_1 = require("../../type-extractors/shared.js");
+/**
+ * Go variable extraction config.
+ *
+ * Go has package-scoped var and const declarations:
+ * - `var x int = 5`
+ * - `const MaxSize = 100`
+ * - `var ( ... )` grouped declarations
+ *
+ * tree-sitter-go uses:
+ * - var_declaration → var_spec → identifier, type
+ * - const_declaration → const_spec → identifier, type
+ *
+ * Visibility: uppercase first letter = exported (public), lowercase = unexported (package).
+ */
+function goVisibilityForName(name) {
+    const firstChar = name.charAt(0);
+    return firstChar === firstChar.toUpperCase() && firstChar !== firstChar.toLowerCase()
+        ? 'public'
+        : 'package';
+}
+function collectGoSpecNames(spec) {
+    const names = [];
+    for (let i = 0; i < spec.namedChildCount; i++) {
+        const child = spec.namedChild(i);
+        if (!child)
+            continue;
+        if (child.type === 'identifier') {
+            names.push(child.text);
+            continue;
+        }
+        break;
+    }
+    return names;
+}
+function collectGoSpecs(node) {
+    const specs = [];
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === 'var_spec' || child?.type === 'const_spec') {
+            specs.push(child);
+            continue;
+        }
+        if (child?.type === 'var_spec_list') {
+            specs.push(...collectGoSpecs(child));
+        }
+    }
+    return specs;
+}
+function collectGoDeclarationNames(node) {
+    if (node.type === 'short_var_declaration') {
+        const left = node.childForFieldName('left');
+        if (left?.type !== 'expression_list')
+            return [];
+        return left.namedChildren
+            .filter((child) => child.type === 'identifier')
+            .map((child) => child.text);
+    }
+    const names = [];
+    for (const spec of collectGoSpecs(node))
+        names.push(...collectGoSpecNames(spec));
+    return names;
+}
+function findGoSpecForName(node, name) {
+    for (const spec of collectGoSpecs(node)) {
+        if (collectGoSpecNames(spec).includes(name))
+            return spec;
+    }
+    return undefined;
+}
+function extractGoSpecType(spec) {
+    const typeNode = spec.childForFieldName('type');
+    return typeNode ? ((0, shared_js_1.extractSimpleTypeName)(typeNode) ?? typeNode.text?.trim()) : undefined;
+}
+function extractGoVarName(node) {
+    const firstName = collectGoDeclarationNames(node)[0];
+    if (firstName)
+        return firstName;
+    // var_declaration/const_declaration → var_spec/const_spec → identifier
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === 'var_spec' || child?.type === 'const_spec') {
+            const name = child.childForFieldName('name');
+            if (name)
+                return name.text;
+            // Fallback: first identifier child
+            for (let j = 0; j < child.namedChildCount; j++) {
+                const gc = child.namedChild(j);
+                if (gc?.type === 'identifier')
+                    return gc.text;
+            }
+        }
+    }
+    // short_var_declaration: x := 5 → expression_list → identifier
+    if (node.type === 'short_var_declaration') {
+        const left = node.childForFieldName('left');
+        if (left?.type === 'expression_list') {
+            const firstIdent = left.namedChildren.find((c) => c.type === 'identifier');
+            if (firstIdent)
+                return firstIdent.text;
+        }
+    }
+    return undefined;
+}
+function extractGoVarType(node) {
+    for (const spec of collectGoSpecs(node)) {
+        const typeName = extractGoSpecType(spec);
+        if (typeName)
+            return typeName;
+    }
+    return undefined;
+}
+exports.goVariableConfig = {
+    language: index_js_1.SupportedLanguages.Go,
+    constNodeTypes: ['const_declaration'],
+    staticNodeTypes: [],
+    variableNodeTypes: ['var_declaration', 'short_var_declaration'],
+    extractName: extractGoVarName,
+    extractType: extractGoVarType,
+    extractTypeForName(node, name) {
+        const spec = findGoSpecForName(node, name);
+        return spec ? extractGoSpecType(spec) : undefined;
+    },
+    extractVisibility(node) {
+        const name = extractGoVarName(node);
+        if (!name)
+            return 'package';
+        // Go visibility: uppercase first letter = exported
+        const firstChar = name.charAt(0);
+        return firstChar === firstChar.toUpperCase() && firstChar !== firstChar.toLowerCase()
+            ? 'public'
+            : 'package';
+    },
+    extractNames: collectGoDeclarationNames,
+    extractVisibilityForName(_node, name) {
+        return goVisibilityForName(name);
+    },
+    isConst(node) {
+        return node.type === 'const_declaration';
+    },
+    isStatic(_node) {
+        // Go does not have static declarations
+        return false;
+    },
+    isMutable(node) {
+        return node.type !== 'const_declaration';
+    },
+};

package/dist/core/code/engine/core/ingestion/variable-extractors/configs/jvm.js

@@ -0,0 +1,145 @@
+"use strict";
+// cgraph/src/core/ingestion/variable-extractors/configs/jvm.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kotlinVariableConfig = exports.javaVariableConfig = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+const helpers_js_1 = require("../../field-extractors/configs/helpers.js");
+const shared_js_1 = require("../../type-extractors/shared.js");
+/**
+ * Java variable extraction config.
+ *
+ * Java does not have true module-level variables — all declarations are
+ * class-scoped. However, `static final` fields at class scope act like
+ * constants. These are already handled by the field extractor. This config
+ * covers any rare local_variable_declaration captures at file scope
+ * (e.g., in scripts or top-level code blocks in JShell).
+ */
+exports.javaVariableConfig = {
+    language: index_js_1.SupportedLanguages.Java,
+    constNodeTypes: [],
+    staticNodeTypes: [],
+    variableNodeTypes: ['local_variable_declaration'],
+    extractName(node) {
+        const declarator = node.namedChildren.find((c) => c.type === 'variable_declarator');
+        const name = declarator?.childForFieldName('name');
+        return name?.type === 'identifier' ? name.text : undefined;
+    },
+    extractType(node) {
+        const typeNode = node.childForFieldName('type');
+        if (typeNode)
+            return (0, shared_js_1.extractSimpleTypeName)(typeNode) ?? typeNode.text?.trim();
+        return undefined;
+    },
+    extractVisibility(node) {
+        if ((0, helpers_js_1.hasModifier)(node, 'modifiers', 'public'))
+            return 'public';
+        if ((0, helpers_js_1.hasModifier)(node, 'modifiers', 'private'))
+            return 'private';
+        if ((0, helpers_js_1.hasModifier)(node, 'modifiers', 'protected'))
+            return 'protected';
+        return 'package';
+    },
+    isConst(node) {
+        return (0, helpers_js_1.hasModifier)(node, 'modifiers', 'final');
+    },
+    isStatic(node) {
+        return (0, helpers_js_1.hasModifier)(node, 'modifiers', 'static');
+    },
+    isMutable(node) {
+        return !(0, helpers_js_1.hasModifier)(node, 'modifiers', 'final');
+    },
+};
+/** Single-binding name of a Kotlin property_declaration:
+ *  property_declaration → variable_declaration → simple_identifier. */
+function kotlinSingleVarName(node) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === 'variable_declaration') {
+            const ident = child.namedChildren.find((c) => c.type === 'simple_identifier');
+            return ident?.text;
+        }
+    }
+    return undefined;
+}
+/**
+ * Kotlin variable extraction config.
+ *
+ * Kotlin has true top-level val/var declarations outside classes.
+ * tree-sitter-kotlin uses 'property_declaration' for both.
+ */
+exports.kotlinVariableConfig = {
+    language: index_js_1.SupportedLanguages.Kotlin,
+    constNodeTypes: [],
+    staticNodeTypes: [],
+    variableNodeTypes: ['property_declaration'],
+    extractName: kotlinSingleVarName,
+    // F51 (issue #1919): destructuring declarations bind several names at one
+    // node. `val (a, b) = pair` parses as
+    //   property_declaration → multi_variable_declaration
+    //     → variable_declaration → simple_identifier (one per name)
+    // (real-parse-verified). The single-name `extractName` above misses these
+    // entirely. When a multi_variable_declaration is present we return EACH
+    // bound name; the Kotlin `_` placeholder is a discard and is skipped. A
+    // plain single declaration falls through to the existing variable_declaration
+    // shape so `val x = 1` still yields exactly one name (no double-count).
+    extractNames(node) {
+        const multi = node.namedChildren.find((c) => c.type === 'multi_variable_declaration');
+        if (multi !== undefined) {
+            const names = [];
+            for (const decl of multi.namedChildren) {
+                if (decl.type !== 'variable_declaration')
+                    continue;
+                const ident = decl.namedChildren.find((c) => c.type === 'simple_identifier');
+                if (ident !== undefined && ident.text !== '_')
+                    names.push(ident.text);
+            }
+            return names;
+        }
+        const single = kotlinSingleVarName(node);
+        return single !== undefined ? [single] : [];
+    },
+    extractType(node) {
+        // Look for type annotation in variable_declaration child
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child?.type === 'variable_declaration') {
+                const typeNode = child.namedChildren.find((c) => c.type === 'user_type' || c.type === 'nullable_type');
+                if (typeNode)
+                    return (0, shared_js_1.extractSimpleTypeName)(typeNode) ?? typeNode.text?.trim();
+            }
+        }
+        return undefined;
+    },
+    extractVisibility(node) {
+        if ((0, helpers_js_1.hasModifier)(node, 'modifiers', 'public'))
+            return 'public';
+        if ((0, helpers_js_1.hasModifier)(node, 'modifiers', 'private'))
+            return 'private';
+        if ((0, helpers_js_1.hasModifier)(node, 'modifiers', 'protected'))
+            return 'protected';
+        if ((0, helpers_js_1.hasModifier)(node, 'modifiers', 'internal'))
+            return 'internal';
+        return 'public'; // Kotlin default is public
+    },
+    isConst(node) {
+        // val is immutable; also check for `const` modifier
+        for (let i = 0; i < node.childCount; i++) {
+            const child = node.child(i);
+            if (child?.text === 'val')
+                return true;
+        }
+        return (0, helpers_js_1.hasModifier)(node, 'modifiers', 'const');
+    },
+    isStatic(_node) {
+        // Top-level Kotlin properties are not static in the Java sense
+        return false;
+    },
+    isMutable(node) {
+        for (let i = 0; i < node.childCount; i++) {
+            const child = node.child(i);
+            if (child?.text === 'var')
+                return true;
+        }
+        return false;
+    },
+};

package/dist/core/code/engine/core/ingestion/variable-extractors/configs/php.js

@@ -0,0 +1,61 @@
+"use strict";
+// cgraph/src/core/ingestion/variable-extractors/configs/php.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.phpVariableConfig = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+const helpers_js_1 = require("../../field-extractors/configs/helpers.js");
+/**
+ * PHP variable extraction config.
+ *
+ * PHP has const declarations at namespace/file scope and global variables:
+ * - `const MAX_SIZE = 100;`
+ * - `define('MAX_SIZE', 100);`
+ * - `$variable = value;`
+ *
+ * tree-sitter-php uses:
+ * - const_declaration at namespace/program scope
+ * - expression_statement containing assignment_expression for variables
+ */
+exports.phpVariableConfig = {
+    language: index_js_1.SupportedLanguages.PHP,
+    constNodeTypes: ['const_declaration'],
+    staticNodeTypes: [],
+    variableNodeTypes: ['expression_statement'],
+    extractName(node) {
+        if (node.type === 'const_declaration') {
+            // const_declaration → const_element → name (identifier)
+            for (let i = 0; i < node.namedChildCount; i++) {
+                const child = node.namedChild(i);
+                if (child?.type === 'const_element') {
+                    const name = child.childForFieldName('name');
+                    return name?.text;
+                }
+            }
+            return undefined;
+        }
+        // expression_statement → assignment_expression → variable_name
+        const inner = node.firstNamedChild;
+        if (inner?.type === 'assignment_expression') {
+            const left = inner.childForFieldName('left');
+            if (left?.type === 'variable_name')
+                return left.text;
+        }
+        return undefined;
+    },
+    extractType(_node) {
+        // PHP is dynamically typed — no inline type annotations for variables
+        return undefined;
+    },
+    extractVisibility(_node) {
+        return 'public';
+    },
+    isConst(node) {
+        return node.type === 'const_declaration';
+    },
+    isStatic(node) {
+        return (0, helpers_js_1.hasKeyword)(node, 'static');
+    },
+    isMutable(node) {
+        return node.type !== 'const_declaration';
+    },
+};

package/dist/core/code/engine/core/ingestion/variable-extractors/configs/python.js

@@ -0,0 +1,104 @@
+"use strict";
+// cgraph/src/core/ingestion/variable-extractors/configs/python.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pythonVariableConfig = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+const shared_js_1 = require("../../type-extractors/shared.js");
+/**
+ * Python variable extraction config.
+ *
+ * Handles module-level assignments and annotated assignments:
+ * - `MAX_SIZE = 100` → const by UPPER_CASE convention
+ * - `name: str = "default"` → annotated assignment with type
+ * - `_private_var = 42` → protected by convention
+ * - `__private_var = 42` → private by convention
+ *
+ * tree-sitter-python uses:
+ * - expression_statement containing assignment or type nodes
+ */
+function extractNameFromPython(node) {
+    const inner = node.firstNamedChild;
+    if (!inner)
+        return undefined;
+    // Annotated assignment: name: str = "default"
+    // AST: expression_statement > type > identifier
+    if (inner.type === 'type') {
+        const ident = inner.childForFieldName('name') ?? inner.firstNamedChild;
+        return ident?.type === 'identifier' ? ident.text : undefined;
+    }
+    // Plain assignment: x = 5
+    if (inner.type === 'assignment') {
+        const left = inner.childForFieldName('left');
+        if (left?.type === 'identifier')
+            return left.text;
+    }
+    return undefined;
+}
+function extractTypeFromPython(node) {
+    const inner = node.firstNamedChild;
+    if (!inner)
+        return undefined;
+    // Standalone annotated type without assignment: `name: str`
+    if (inner.type === 'type') {
+        const typeNode = inner.childForFieldName('type') ?? inner.namedChild(1);
+        if (typeNode)
+            return (0, shared_js_1.extractSimpleTypeName)(typeNode) ?? typeNode.text?.trim();
+    }
+    // Annotated assignment: `name: str = "hello"`
+    // AST: expression_statement > assignment > [identifier, type > identifier, ...]
+    if (inner.type === 'assignment') {
+        for (let i = 0; i < inner.childCount; i++) {
+            const child = inner.child(i);
+            if (child?.type === 'type') {
+                const typeId = child.firstNamedChild;
+                if (typeId)
+                    return (0, shared_js_1.extractSimpleTypeName)(typeId) ?? typeId.text?.trim();
+            }
+        }
+    }
+    return undefined;
+}
+function extractVisFromPython(node) {
+    const name = extractNameFromPython(node);
+    if (!name)
+        return 'public';
+    // Dunder names (__name__, __all__) are public Python conventions
+    if (name.startsWith('__') && name.endsWith('__'))
+        return 'public';
+    // Double underscore prefix (name mangled) = private
+    if (name.startsWith('__'))
+        return 'private';
+    // Single underscore prefix = protected by convention
+    if (name.startsWith('_'))
+        return 'protected';
+    return 'public';
+}
+exports.pythonVariableConfig = {
+    language: index_js_1.SupportedLanguages.Python,
+    constNodeTypes: [],
+    staticNodeTypes: [],
+    // expression_statement is broad — isVariableDeclaration returns true for
+    // all expression_statement nodes, but extract() safely filters non-assignments
+    // by returning null when extractNameFromPython finds no assignment target.
+    variableNodeTypes: ['expression_statement'],
+    extractName: extractNameFromPython,
+    extractType: extractTypeFromPython,
+    extractVisibility: extractVisFromPython,
+    isConst(node) {
+        // Python convention: UPPER_CASE names are constants
+        const name = extractNameFromPython(node);
+        if (!name)
+            return false;
+        return name === name.toUpperCase() && /^[A-Z][A-Z0-9_]*$/.test(name);
+    },
+    isStatic(_node) {
+        return false;
+    },
+    isMutable(node) {
+        const name = extractNameFromPython(node);
+        if (!name)
+            return true;
+        // By convention, UPPER_CASE names are immutable constants
+        return !(name === name.toUpperCase() && /^[A-Z][A-Z0-9_]*$/.test(name));
+    },
+};

package/dist/core/code/engine/core/ingestion/variable-extractors/configs/ruby.js

@@ -0,0 +1,55 @@
+"use strict";
+// cgraph/src/core/ingestion/variable-extractors/configs/ruby.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rubyVariableConfig = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+/**
+ * Ruby variable extraction config.
+ *
+ * Ruby module-level constants use UPPER_CASE identifiers or start with
+ * an uppercase letter. Ruby uses:
+ * - assignment for variable declarations at module scope
+ * - Constants: `MAX_SIZE = 100` or `Config = ...`
+ * - Global variables: `$global = ...`
+ */
+exports.rubyVariableConfig = {
+    language: index_js_1.SupportedLanguages.Ruby,
+    constNodeTypes: [],
+    staticNodeTypes: [],
+    variableNodeTypes: ['assignment'],
+    extractName(node) {
+        const left = node.childForFieldName('left');
+        if (!left)
+            return undefined;
+        if (left.type === 'identifier' || left.type === 'constant')
+            return left.text;
+        if (left.type === 'global_variable')
+            return left.text;
+        return undefined;
+    },
+    extractType(_node) {
+        // Ruby is dynamically typed — no type annotations at module level
+        return undefined;
+    },
+    extractVisibility(_node) {
+        const left = _node.childForFieldName('left');
+        if (!left)
+            return 'public';
+        // Constants (uppercase start) and global variables are effectively public
+        if (left.type === 'constant' || left.type === 'global_variable')
+            return 'public';
+        return 'private';
+    },
+    isConst(node) {
+        const left = node.childForFieldName('left');
+        return left?.type === 'constant';
+    },
+    isStatic(_node) {
+        return false;
+    },
+    isMutable(node) {
+        const left = node.childForFieldName('left');
+        // Constants are immutable by convention
+        return left?.type !== 'constant';
+    },
+};