cgraphx 2.0.2 → 2.0.3

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

@@ -0,0 +1,79 @@
+"use strict";
+// cgraph/src/core/ingestion/variable-extractors/configs/rust.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rustVariableConfig = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+const shared_js_1 = require("../../type-extractors/shared.js");
+/**
+ * Rust variable extraction config.
+ *
+ * Rust has module-scoped const, static, and let declarations:
+ * - `const MAX_SIZE: usize = 100;`
+ * - `static COUNTER: AtomicUsize = AtomicUsize::new(0);`
+ * - `static mut BUFFER: Vec<u8> = Vec::new();`
+ * - `let x = 5;` (block-scoped, but included for completeness)
+ *
+ * tree-sitter-rust uses:
+ * - const_item → identifier, type
+ * - static_item → identifier, type
+ * - let_declaration → identifier, type
+ */
+function hasVisibilityModifier(node) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === 'visibility_modifier')
+            return true;
+    }
+    return false;
+}
+function hasMutKeyword(node) {
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child?.text === 'mut')
+            return true;
+    }
+    return false;
+}
+exports.rustVariableConfig = {
+    language: index_js_1.SupportedLanguages.Rust,
+    constNodeTypes: ['const_item'],
+    staticNodeTypes: ['static_item'],
+    variableNodeTypes: ['let_declaration'],
+    extractName(node) {
+        const name = node.childForFieldName('name');
+        if (name)
+            return name.text;
+        // Fallback: first identifier child
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child?.type === 'identifier')
+                return child.text;
+        }
+        return undefined;
+    },
+    extractType(node) {
+        const typeNode = node.childForFieldName('type');
+        if (typeNode)
+            return (0, shared_js_1.extractSimpleTypeName)(typeNode) ?? typeNode.text?.trim();
+        return undefined;
+    },
+    extractVisibility(node) {
+        return hasVisibilityModifier(node) ? 'public' : 'private';
+    },
+    isConst(node) {
+        return node.type === 'const_item';
+    },
+    isStatic(node) {
+        return node.type === 'static_item';
+    },
+    isMutable(node) {
+        if (node.type === 'const_item')
+            return false;
+        if (node.type === 'static_item')
+            return hasMutKeyword(node);
+        // let_declaration: check for mut keyword
+        if (node.type === 'let_declaration')
+            return hasMutKeyword(node);
+        return true;
+    },
+};

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

@@ -0,0 +1,91 @@
+"use strict";
+// cgraph/src/core/ingestion/variable-extractors/configs/swift.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.swiftVariableConfig = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+const shared_js_1 = require("../../type-extractors/shared.js");
+/**
+ * Swift variable extraction config.
+ *
+ * Swift has top-level let/var declarations:
+ * - `let maxSize = 100`
+ * - `var counter = 0`
+ * - `public let apiKey: String = "..."`
+ *
+ * tree-sitter-swift uses:
+ * - property_declaration for both class and top-level declarations
+ */
+function extractSwiftVarName(node) {
+    // property_declaration → pattern → ... → simple_identifier / identifier
+    const pattern = node.namedChildren.find((c) => c.type === 'pattern');
+    if (pattern) {
+        const ident = pattern.namedChildren.find((c) => c.type === 'simple_identifier' || c.type === 'identifier');
+        if (ident)
+            return ident.text;
+    }
+    // Fallback: look for simple_identifier directly
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === 'simple_identifier')
+            return child.text;
+    }
+    return undefined;
+}
+function extractSwiftVarType(node) {
+    // Look for type_annotation child
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === 'type_annotation') {
+            const typeNode = child.firstNamedChild;
+            if (typeNode)
+                return (0, shared_js_1.extractSimpleTypeName)(typeNode) ?? typeNode.text?.trim();
+        }
+    }
+    return undefined;
+}
+function hasSwiftKeyword(node, keyword) {
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child?.text === keyword)
+            return true;
+    }
+    return false;
+}
+const SWIFT_VISIBILITY = new Set(['public', 'private', 'internal', 'fileprivate', 'open']);
+exports.swiftVariableConfig = {
+    language: index_js_1.SupportedLanguages.Swift,
+    constNodeTypes: [],
+    staticNodeTypes: [],
+    variableNodeTypes: ['property_declaration'],
+    extractName: extractSwiftVarName,
+    extractType: extractSwiftVarType,
+    extractVisibility(node) {
+        // Check modifiers for visibility keywords
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child?.type === 'modifiers') {
+                for (let j = 0; j < child.childCount; j++) {
+                    const mod = child.child(j);
+                    if (mod && SWIFT_VISIBILITY.has(mod.text))
+                        return mod.text;
+                }
+            }
+        }
+        // Direct keyword check
+        for (let i = 0; i < node.childCount; i++) {
+            const child = node.child(i);
+            if (child && SWIFT_VISIBILITY.has(child.text))
+                return child.text;
+        }
+        return 'internal'; // Swift default visibility
+    },
+    isConst(node) {
+        return hasSwiftKeyword(node, 'let');
+    },
+    isStatic(node) {
+        return hasSwiftKeyword(node, 'static') || hasSwiftKeyword(node, 'class');
+    },
+    isMutable(node) {
+        return hasSwiftKeyword(node, 'var');
+    },
+};

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

@@ -0,0 +1,86 @@
+"use strict";
+// cgraph/src/core/ingestion/variable-extractors/configs/typescript-javascript.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.javascriptVariableConfig = exports.typescriptVariableConfig = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+const helpers_js_1 = require("../../field-extractors/configs/helpers.js");
+/**
+ * TypeScript/JavaScript variable extraction config.
+ *
+ * Handles module-scoped const/let/var declarations:
+ * - `export const X = ...` → public, const
+ * - `const X = ...` → private, const
+ * - `let x = ...` → private, mutable
+ * - `var x = ...` → private, mutable
+ *
+ * tree-sitter node structure:
+ *   lexical_declaration (const/let) → variable_declarator → identifier (name)
+ *   variable_declaration (var) → variable_declarator → identifier (name)
+ */
+function extractNameFromDecl(node) {
+    // lexical_declaration / variable_declaration → variable_declarator → name
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === 'variable_declarator') {
+            const name = child.childForFieldName('name');
+            if (name?.type === 'identifier')
+                return name.text;
+        }
+    }
+    return undefined;
+}
+function extractTypeFromDecl(node) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === 'variable_declarator') {
+            return (0, helpers_js_1.typeFromAnnotation)(child);
+        }
+    }
+    return undefined;
+}
+function extractVisFromDecl(node) {
+    // Check parent for export_statement wrapper
+    const parent = node.parent;
+    if (parent?.type === 'export_statement')
+        return 'public';
+    // Check for 'export' keyword as direct child
+    if ((0, helpers_js_1.hasKeyword)(node, 'export'))
+        return 'public';
+    return 'private';
+}
+const shared = {
+    constNodeTypes: ['lexical_declaration'],
+    staticNodeTypes: [],
+    variableNodeTypes: ['variable_declaration'],
+    extractName: extractNameFromDecl,
+    extractType: extractTypeFromDecl,
+    extractVisibility: extractVisFromDecl,
+    isConst(node) {
+        // lexical_declaration with 'const' keyword
+        if (node.type === 'lexical_declaration') {
+            return (0, helpers_js_1.hasKeyword)(node, 'const');
+        }
+        return false;
+    },
+    isStatic(_node) {
+        // JS/TS module-level variables are not static in the class sense
+        return false;
+    },
+    isMutable(node) {
+        // var or let declarations are mutable; const is not
+        if (node.type === 'variable_declaration')
+            return true;
+        if (node.type === 'lexical_declaration') {
+            return (0, helpers_js_1.hasKeyword)(node, 'let');
+        }
+        return false;
+    },
+};
+exports.typescriptVariableConfig = {
+    ...shared,
+    language: index_js_1.SupportedLanguages.TypeScript,
+};
+exports.javascriptVariableConfig = {
+    ...shared,
+    language: index_js_1.SupportedLanguages.JavaScript,
+};

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

@@ -0,0 +1,111 @@
+"use strict";
+// cgraph/src/core/ingestion/variable-extractors/generic.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createVariableExtractor = createVariableExtractor;
+/**
+ * Type-declaration node types whose body can be a bare `block`. tree-sitter-python
+ * models a class body as a `block` node — the same node type used for function and
+ * control-flow bodies — so a class attribute would otherwise look block-scoped. Most
+ * other grammars give class bodies dedicated node types (`class_body`,
+ * `declaration_list`, `body_statement`), which are not in the block-scope list below,
+ * so this guard is a no-op for them but keeps the rule language-agnostic.
+ */
+const CLASS_LIKE_CONTAINERS = new Set([
+    'class_definition',
+    'class_declaration',
+    'class_specifier',
+    'struct_item',
+    'impl_item',
+    'trait_item',
+    'interface_declaration',
+    'enum_declaration',
+    'object_declaration',
+]);
+/**
+ * Create a VariableExtractor from a declarative config.
+ */
+function createVariableExtractor(config) {
+    const staticNodeSet = new Set(config.staticNodeTypes);
+    // Combined set for fast isVariableDeclaration checks
+    const allNodeTypes = new Set([
+        ...config.constNodeTypes,
+        ...config.staticNodeTypes,
+        ...config.variableNodeTypes,
+    ]);
+    function determineScope(node) {
+        // Walk up to determine scope:
+        // - 'module': node is inside a top-level program/module/source_file container
+        // - 'block': node is inside a function, method, or block scope
+        // - 'file': fallback when no recognizable container is found (e.g., standalone snippets)
+        let current = node.parent;
+        while (current) {
+            const t = current.type;
+            // Top-level program/module nodes indicate module/file scope
+            if (t === 'program' ||
+                t === 'source_file' ||
+                t === 'module' ||
+                t === 'translation_unit' ||
+                t === 'compilation_unit') {
+                return 'module';
+            }
+            // Function/method boundaries indicate block scope
+            if (t === 'function_declaration' ||
+                t === 'function_definition' ||
+                t === 'function_item' ||
+                t === 'method_declaration' ||
+                t === 'method_definition' ||
+                t === 'arrow_function' ||
+                t === 'function_expression' ||
+                t === 'lambda' ||
+                t === 'function_body' ||
+                t === 'compound_statement') {
+                return 'block';
+            }
+            // A bare `block` is block scope UNLESS it is a class body. A class member
+            // (e.g. Python `class C: MAX = 100`) is not an inert function-local — keep
+            // walking so it resolves to its true enclosing scope ('module' for a
+            // top-level class) instead of being misclassified and pruned.
+            if (t === 'block' && !(current.parent && CLASS_LIKE_CONTAINERS.has(current.parent.type))) {
+                return 'block';
+            }
+            current = current.parent;
+        }
+        return 'file';
+    }
+    return {
+        language: config.language,
+        isVariableDeclaration(node) {
+            return allNodeTypes.has(node.type);
+        },
+        extract(node, context) {
+            return this.extractAll(node, context)[0] ?? null;
+        },
+        extractAll(node, context) {
+            if (!allNodeTypes.has(node.type))
+                return [];
+            const names = config.extractNames
+                ? config.extractNames(node)
+                : [config.extractName(node)].filter((name) => Boolean(name));
+            if (names.length === 0)
+                return [];
+            // isConst/isStatic: node type membership is a hint, but config.isConst/isStatic
+            // has final say. For languages where const and non-const share a node type
+            // (e.g., TS lexical_declaration for both const and let), config.isConst disambiguates.
+            const isConst = config.isConst(node);
+            const isStatic = staticNodeSet.has(node.type) || config.isStatic(node);
+            const isMutable = config.isMutable(node);
+            const scope = determineScope(node);
+            return names.map((name) => ({
+                name,
+                type: config.extractTypeForName?.(node, name) ?? config.extractType(node) ?? null,
+                visibility: config.extractVisibilityForName?.(node, name) ?? config.extractVisibility(node),
+                isConst,
+                isStatic,
+                isMutable,
+                scope,
+                sourceFile: context.filePath,
+                line: node.startPosition.row + 1,
+            }));
+        },
+    };
+}

package/dist/core/code/engine/core/ingestion/variable-types.js

@@ -0,0 +1,3 @@
+"use strict";
+// cgraph/src/core/ingestion/variable-types.ts
+Object.defineProperty(exports, "__esModule", { value: true });