@saluzi/codegraph 0.1.0 → 0.2.0

package/dist/extraction/languages/php.js

@@ -1,107 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.phpExtractor = void 0;
-const tree_sitter_helpers_1 = require("../tree-sitter-helpers");
-exports.phpExtractor = {
-    functionTypes: ['function_definition'],
-    classTypes: ['class_declaration', 'trait_declaration'],
-    methodTypes: ['method_declaration'],
-    interfaceTypes: ['interface_declaration'],
-    structTypes: [],
-    enumTypes: ['enum_declaration'],
-    enumMemberTypes: ['enum_case'],
-    typeAliasTypes: [],
-    importTypes: ['namespace_use_declaration'],
-    callTypes: ['function_call_expression', 'member_call_expression', 'scoped_call_expression'],
-    variableTypes: ['const_declaration'],
-    fieldTypes: ['property_declaration'],
-    nameField: 'name',
-    bodyField: 'body',
-    paramsField: 'parameters',
-    returnField: 'return_type',
-    classifyClassNode: (node) => {
-        return node.type === 'trait_declaration' ? 'trait' : 'class';
-    },
-    getVisibility: (node) => {
-        for (let i = 0; i < node.childCount; i++) {
-            const child = node.child(i);
-            if (child?.type === 'visibility_modifier') {
-                const text = child.text;
-                if (text === 'public')
-                    return 'public';
-                if (text === 'private')
-                    return 'private';
-                if (text === 'protected')
-                    return 'protected';
-            }
-        }
-        return 'public'; // PHP defaults to public
-    },
-    isStatic: (node) => {
-        for (let i = 0; i < node.childCount; i++) {
-            const child = node.child(i);
-            if (child?.type === 'static_modifier')
-                return true;
-        }
-        return false;
-    },
-    visitNode: (node, ctx) => {
-        // Handle class constants: const_declaration inside classes
-        // These are skipped by the main visitor because variableTypes check excludes class-like contexts
-        if (node.type === 'const_declaration') {
-            const constElements = node.namedChildren.filter((c) => c.type === 'const_element');
-            for (const elem of constElements) {
-                const nameNode = elem.namedChildren.find((c) => c.type === 'name');
-                if (!nameNode)
-                    continue;
-                const name = (0, tree_sitter_helpers_1.getNodeText)(nameNode, ctx.source);
-                ctx.createNode('constant', name, elem, {});
-            }
-            return true; // handled
-        }
-        // Handle trait usage: use TraitName, OtherTrait; inside classes
-        // Creates unresolved references that will be resolved to 'implements' edges
-        if (node.type === 'use_declaration') {
-            const names = node.namedChildren.filter((c) => c.type === 'name' || c.type === 'qualified_name');
-            const parentId = ctx.nodeStack.length > 0 ? ctx.nodeStack[ctx.nodeStack.length - 1] : undefined;
-            if (parentId) {
-                for (const nameNode of names) {
-                    const traitName = (0, tree_sitter_helpers_1.getNodeText)(nameNode, ctx.source);
-                    ctx.addUnresolvedReference({
-                        fromNodeId: parentId,
-                        referenceName: traitName,
-                        referenceKind: 'implements',
-                        filePath: ctx.filePath,
-                        line: node.startPosition.row + 1,
-                        column: node.startPosition.column,
-                    });
-                }
-            }
-            return true; // handled
-        }
-        return false;
-    },
-    extractImport: (node, source) => {
-        const importText = source.substring(node.startIndex, node.endIndex).trim();
-        // Check for grouped imports: use X\{A, B} - return null for core fallback
-        const namespacePrefix = node.namedChildren.find((c) => c.type === 'namespace_name');
-        const useGroup = node.namedChildren.find((c) => c.type === 'namespace_use_group');
-        if (namespacePrefix && useGroup) {
-            return null; // Grouped imports create multiple nodes - let core handle
-        }
-        // Single import - find namespace_use_clause
-        const useClause = node.namedChildren.find((c) => c.type === 'namespace_use_clause');
-        if (useClause) {
-            const qualifiedName = useClause.namedChildren.find((c) => c.type === 'qualified_name');
-            if (qualifiedName) {
-                return { moduleName: (0, tree_sitter_helpers_1.getNodeText)(qualifiedName, source), signature: importText };
-            }
-            const name = useClause.namedChildren.find((c) => c.type === 'name');
-            if (name) {
-                return { moduleName: (0, tree_sitter_helpers_1.getNodeText)(name, source), signature: importText };
-            }
-        }
-        return null;
-    },
-};
-//# sourceMappingURL=php.js.map

package/dist/extraction/languages/python.d.ts

@@ -1,3 +0,0 @@
-import type { LanguageExtractor } from '../tree-sitter-types'
-export declare const pythonExtractor: LanguageExtractor
-//# sourceMappingURL=python.d.ts.map

package/dist/extraction/languages/python.js

@@ -1,56 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.pythonExtractor = void 0;
-const tree_sitter_helpers_1 = require("../tree-sitter-helpers");
-exports.pythonExtractor = {
-    functionTypes: ['function_definition'],
-    classTypes: ['class_definition'],
-    methodTypes: ['function_definition'], // Methods are functions inside classes
-    interfaceTypes: [],
-    structTypes: [],
-    enumTypes: [],
-    typeAliasTypes: [],
-    importTypes: ['import_statement', 'import_from_statement'],
-    callTypes: ['call'],
-    variableTypes: ['assignment'], // Python uses assignment for variable declarations
-    nameField: 'name',
-    bodyField: 'body',
-    paramsField: 'parameters',
-    returnField: 'return_type',
-    getSignature: (node, source) => {
-        const params = (0, tree_sitter_helpers_1.getChildByField)(node, 'parameters');
-        const returnType = (0, tree_sitter_helpers_1.getChildByField)(node, 'return_type');
-        if (!params)
-            return undefined;
-        let sig = (0, tree_sitter_helpers_1.getNodeText)(params, source);
-        if (returnType) {
-            sig += ' -> ' + (0, tree_sitter_helpers_1.getNodeText)(returnType, source);
-        }
-        return sig;
-    },
-    isAsync: (node) => {
-        const prev = node.previousSibling;
-        return prev?.type === 'async';
-    },
-    isStatic: (node) => {
-        // Check for @staticmethod decorator
-        const prev = node.previousNamedSibling;
-        if (prev?.type === 'decorator') {
-            const text = prev.text;
-            return text.includes('staticmethod');
-        }
-        return false;
-    },
-    extractImport: (node, source) => {
-        const importText = source.substring(node.startIndex, node.endIndex).trim();
-        if (node.type === 'import_from_statement') {
-            const moduleNode = node.childForFieldName('module_name');
-            if (moduleNode) {
-                return { moduleName: source.substring(moduleNode.startIndex, moduleNode.endIndex), signature: importText };
-            }
-        }
-        // import_statement creates multiple imports - return null for core fallback
-        return null;
-    },
-};
-//# sourceMappingURL=python.js.map

package/dist/extraction/languages/ruby.d.ts

@@ -1,3 +0,0 @@
-import type { LanguageExtractor } from '../tree-sitter-types'
-export declare const rubyExtractor: LanguageExtractor
-//# sourceMappingURL=ruby.d.ts.map

package/dist/extraction/languages/ruby.js

@@ -1,114 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.rubyExtractor = void 0;
-const tree_sitter_helpers_1 = require("../tree-sitter-helpers");
-exports.rubyExtractor = {
-    functionTypes: ['method'],
-    classTypes: ['class'],
-    methodTypes: ['method', 'singleton_method'],
-    interfaceTypes: [], // Ruby uses modules (handled via visitNode hook)
-    structTypes: [],
-    enumTypes: [],
-    typeAliasTypes: [],
-    importTypes: ['call'], // require/require_relative
-    callTypes: ['call', 'method_call'],
-    variableTypes: ['assignment'], // Ruby uses assignment like Python
-    nameField: 'name',
-    bodyField: 'body',
-    paramsField: 'parameters',
-    visitNode: (node, ctx) => {
-        if (node.type !== 'module')
-            return false;
-        const nameNode = node.childForFieldName('name');
-        if (!nameNode)
-            return false;
-        const name = nameNode.text;
-        const moduleNode = ctx.createNode('module', name, node);
-        if (!moduleNode)
-            return false;
-        // Push module onto scope stack so children get proper qualified names
-        ctx.pushScope(moduleNode.id);
-        const body = node.childForFieldName('body');
-        if (body) {
-            for (let i = 0; i < body.namedChildCount; i++) {
-                const child = body.namedChild(i);
-                if (child)
-                    ctx.visitNode(child);
-            }
-        }
-        ctx.popScope();
-        return true; // handled
-    },
-    extractBareCall: (node, _source) => {
-        // Ruby bare method calls (no parens, no receiver) parse as plain identifiers.
-        // e.g., `reset` in a method body is `identifier "reset"` not a `call` node.
-        if (node.type !== 'identifier')
-            return undefined;
-        const parent = node.parent;
-        if (!parent)
-            return undefined;
-        // Only statement-level identifiers — direct children of block/body nodes
-        const BLOCK_PARENTS = new Set([
-            'body_statement', 'then', 'else', 'do', 'begin',
-            'rescue', 'ensure', 'when',
-        ]);
-        if (!BLOCK_PARENTS.has(parent.type))
-            return undefined;
-        const name = node.text;
-        // Skip Ruby keywords/literals
-        const SKIP = new Set([
-            'true', 'false', 'nil', 'self', 'super',
-            '__FILE__', '__LINE__', '__dir__',
-        ]);
-        if (SKIP.has(name))
-            return undefined;
-        // Skip constants (uppercase start) — these are class/module refs, not calls
-        if (name.length > 0 && name.charCodeAt(0) >= 65 && name.charCodeAt(0) <= 90)
-            return undefined;
-        return name;
-    },
-    getVisibility: (node) => {
-        // Ruby visibility is based on preceding visibility modifiers
-        let sibling = node.previousNamedSibling;
-        while (sibling) {
-            if (sibling.type === 'call') {
-                const methodName = (0, tree_sitter_helpers_1.getChildByField)(sibling, 'method');
-                if (methodName) {
-                    const text = methodName.text;
-                    if (text === 'private')
-                        return 'private';
-                    if (text === 'protected')
-                        return 'protected';
-                    if (text === 'public')
-                        return 'public';
-                }
-            }
-            sibling = sibling.previousNamedSibling;
-        }
-        return 'public';
-    },
-    extractImport: (node, source) => {
-        const importText = source.substring(node.startIndex, node.endIndex).trim();
-        // Check if this is a require/require_relative call
-        const identifier = node.namedChildren.find((c) => c.type === 'identifier');
-        if (!identifier)
-            return null;
-        const methodName = (0, tree_sitter_helpers_1.getNodeText)(identifier, source);
-        if (methodName !== 'require' && methodName !== 'require_relative') {
-            return null; // Not an import, skip
-        }
-        // Find the argument (string)
-        const argList = node.namedChildren.find((c) => c.type === 'argument_list');
-        if (argList) {
-            const stringNode = argList.namedChildren.find((c) => c.type === 'string');
-            if (stringNode) {
-                const stringContent = stringNode.namedChildren.find((c) => c.type === 'string_content');
-                if (stringContent) {
-                    return { moduleName: (0, tree_sitter_helpers_1.getNodeText)(stringContent, source), signature: importText };
-                }
-            }
-        }
-        return null;
-    },
-};
-//# sourceMappingURL=ruby.js.map

package/dist/extraction/languages/rust.d.ts

@@ -1,3 +0,0 @@
-import type { LanguageExtractor } from '../tree-sitter-types'
-export declare const rustExtractor: LanguageExtractor
-//# sourceMappingURL=rust.d.ts.map

package/dist/extraction/languages/rust.js

@@ -1,109 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.rustExtractor = void 0;
-const tree_sitter_helpers_1 = require("../tree-sitter-helpers");
-exports.rustExtractor = {
-    functionTypes: ['function_item'],
-    classTypes: [], // Rust has impl blocks
-    methodTypes: ['function_item'], // Methods are functions in impl blocks
-    interfaceTypes: ['trait_item'],
-    structTypes: ['struct_item'],
-    enumTypes: ['enum_item'],
-    enumMemberTypes: ['enum_variant'],
-    typeAliasTypes: ['type_item'], // Rust type aliases
-    importTypes: ['use_declaration'],
-    callTypes: ['call_expression'],
-    variableTypes: ['let_declaration', 'const_item', 'static_item'],
-    interfaceKind: 'trait',
-    nameField: 'name',
-    bodyField: 'body',
-    paramsField: 'parameters',
-    returnField: 'return_type',
-    getSignature: (node, source) => {
-        const params = (0, tree_sitter_helpers_1.getChildByField)(node, 'parameters');
-        const returnType = (0, tree_sitter_helpers_1.getChildByField)(node, 'return_type');
-        if (!params)
-            return undefined;
-        let sig = (0, tree_sitter_helpers_1.getNodeText)(params, source);
-        if (returnType) {
-            sig += ' -> ' + (0, tree_sitter_helpers_1.getNodeText)(returnType, source);
-        }
-        return sig;
-    },
-    isAsync: (node) => {
-        for (let i = 0; i < node.childCount; i++) {
-            const child = node.child(i);
-            if (child?.type === 'async')
-                return true;
-        }
-        return false;
-    },
-    getVisibility: (node) => {
-        for (let i = 0; i < node.childCount; i++) {
-            const child = node.child(i);
-            if (child?.type === 'visibility_modifier') {
-                return child.text.includes('pub') ? 'public' : 'private';
-            }
-        }
-        return 'private'; // Rust defaults to private
-    },
-    getReceiverType: (node, source) => {
-        // Walk up the tree-sitter AST to find a parent impl_item
-        let parent = node.parent;
-        while (parent) {
-            if (parent.type === 'impl_item') {
-                // For `impl Type { ... }` — the type is a direct type_identifier child
-                // For `impl Trait for Type { ... }` — the type is the LAST type_identifier
-                // (the first is part of the trait path)
-                const children = parent.namedChildren;
-                // Find all direct type_identifier children (not nested in scoped paths)
-                const typeIdents = children.filter((c) => c.type === 'type_identifier');
-                if (typeIdents.length > 0) {
-                    // Last type_identifier is always the implementing type
-                    const typeNode = typeIdents[typeIdents.length - 1];
-                    return source.substring(typeNode.startIndex, typeNode.endIndex);
-                }
-                // Handle generic types: impl<T> MyStruct<T> { ... }
-                const genericType = children.find((c) => c.type === 'generic_type');
-                if (genericType) {
-                    const innerType = genericType.namedChildren.find((c) => c.type === 'type_identifier');
-                    if (innerType) {
-                        return source.substring(innerType.startIndex, innerType.endIndex);
-                    }
-                }
-                return undefined;
-            }
-            parent = parent.parent;
-        }
-        return undefined;
-    },
-    extractImport: (node, source) => {
-        const importText = source.substring(node.startIndex, node.endIndex).trim();
-        // Helper to get the root crate/module from a scoped path
-        const getRootModule = (scopedNode) => {
-            const firstChild = scopedNode.namedChild(0);
-            if (!firstChild)
-                return source.substring(scopedNode.startIndex, scopedNode.endIndex);
-            if (firstChild.type === 'identifier' ||
-                firstChild.type === 'crate' ||
-                firstChild.type === 'super' ||
-                firstChild.type === 'self') {
-                return source.substring(firstChild.startIndex, firstChild.endIndex);
-            }
-            else if (firstChild.type === 'scoped_identifier') {
-                return getRootModule(firstChild);
-            }
-            return source.substring(firstChild.startIndex, firstChild.endIndex);
-        };
-        // Find the use argument (scoped_use_list or scoped_identifier)
-        const useArg = node.namedChildren.find((c) => c.type === 'scoped_use_list' ||
-            c.type === 'scoped_identifier' ||
-            c.type === 'use_list' ||
-            c.type === 'identifier');
-        if (useArg) {
-            return { moduleName: getRootModule(useArg), signature: importText };
-        }
-        return null;
-    },
-};
-//# sourceMappingURL=rust.js.map

package/dist/extraction/languages/scala.d.ts

@@ -1,3 +0,0 @@
-import type { LanguageExtractor } from '../tree-sitter-types'
-export declare const scalaExtractor: LanguageExtractor
-//# sourceMappingURL=scala.d.ts.map

package/dist/extraction/languages/scala.js

@@ -1,139 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.scalaExtractor = void 0;
-const tree_sitter_helpers_1 = require("../tree-sitter-helpers");
-function getValVarName(node, source) {
-    const patternNode = node.childForFieldName('pattern');
-    if (!patternNode)
-        return null;
-    if (patternNode.type === 'identifier')
-        return (0, tree_sitter_helpers_1.getNodeText)(patternNode, source);
-    const identChild = patternNode.namedChildren.find((c) => c.type === 'identifier');
-    return identChild ? (0, tree_sitter_helpers_1.getNodeText)(identChild, source) : null;
-}
-function extractVisibility(node) {
-    for (let i = 0; i < node.namedChildCount; i++) {
-        const child = node.namedChild(i);
-        if (!child)
-            continue;
-        if (child.type === 'modifiers' || child.type === 'access_modifier') {
-            const text = child.text;
-            if (text.includes('private'))
-                return 'private';
-            if (text.includes('protected'))
-                return 'protected';
-        }
-    }
-    return 'public';
-}
-exports.scalaExtractor = {
-    // top-level function_definition is handled via methodTypes (same pattern as Kotlin)
-    functionTypes: [],
-    classTypes: ['class_definition', 'object_definition', 'trait_definition'],
-    methodTypes: ['function_definition', 'function_declaration'],
-    interfaceTypes: [],
-    structTypes: [],
-    enumTypes: ['enum_definition'],
-    enumMemberTypes: [], // handled in visitNode — enum_case_definitions wraps the cases
-    typeAliasTypes: ['type_definition'],
-    importTypes: ['import_declaration'],
-    callTypes: ['call_expression'],
-    variableTypes: [], // val/var handled in visitNode (use `pattern` field, not `name`)
-    fieldTypes: [],
-    extraClassNodeTypes: [],
-    nameField: 'name',
-    bodyField: 'body',
-    paramsField: 'parameters',
-    returnField: 'return_type',
-    interfaceKind: 'trait',
-    classifyClassNode: (node) => {
-        if (node.type === 'trait_definition')
-            return 'trait';
-        return 'class';
-    },
-    getSignature: (node, source) => {
-        const params = node.childForFieldName('parameters');
-        const returnType = node.childForFieldName('return_type');
-        if (!params && !returnType)
-            return undefined;
-        let sig = params ? (0, tree_sitter_helpers_1.getNodeText)(params, source) : '';
-        if (returnType)
-            sig += ': ' + (0, tree_sitter_helpers_1.getNodeText)(returnType, source);
-        return sig || undefined;
-    },
-    getVisibility: (node) => extractVisibility(node),
-    isAsync: () => false,
-    isStatic: (node) => {
-        for (let i = 0; i < node.namedChildCount; i++) {
-            const child = node.namedChild(i);
-            if (child?.type === 'modifiers' && child.text.includes('static'))
-                return true;
-        }
-        return false;
-    },
-    visitNode: (node, ctx) => {
-        const t = node.type;
-        // val/var: name is in `pattern` field (identifier), not `name`
-        if (t === 'val_definition' || t === 'var_definition') {
-            const name = getValVarName(node, ctx.source);
-            if (!name)
-                return false;
-            const isInClass = ctx.nodeStack.length > 0 &&
-                (() => {
-                    const parentId = ctx.nodeStack[ctx.nodeStack.length - 1];
-                    const parentNode = ctx.nodes.find((n) => n.id === parentId);
-                    return parentNode != null && (parentNode.kind === 'class' || parentNode.kind === 'trait' ||
-                        parentNode.kind === 'interface' || parentNode.kind === 'struct' ||
-                        parentNode.kind === 'enum' || parentNode.kind === 'module');
-                })();
-            const kind = isInClass ? 'field' : (t === 'val_definition' ? 'constant' : 'variable');
-            const typeNode = node.childForFieldName('type');
-            const sig = typeNode
-                ? `${t === 'val_definition' ? 'val' : 'var'} ${name}: ${(0, tree_sitter_helpers_1.getNodeText)(typeNode, ctx.source)}`
-                : undefined;
-            ctx.createNode(kind, name, node, { signature: sig, visibility: extractVisibility(node) });
-            return true;
-        }
-        // enum_case_definitions wraps simple_enum_case / full_enum_case children
-        if (t === 'enum_case_definitions') {
-            for (let i = 0; i < node.namedChildCount; i++) {
-                const child = node.namedChild(i);
-                if (!child)
-                    continue;
-                if (child.type === 'simple_enum_case' || child.type === 'full_enum_case') {
-                    const nameNode = child.childForFieldName('name');
-                    if (nameNode)
-                        ctx.createNode('enum_member', (0, tree_sitter_helpers_1.getNodeText)(nameNode, ctx.source), child);
-                }
-            }
-            return true;
-        }
-        // extension_definition: visit body children directly, no container node
-        if (t === 'extension_definition') {
-            const body = node.childForFieldName('body');
-            if (body) {
-                for (let i = 0; i < body.namedChildCount; i++) {
-                    const child = body.namedChild(i);
-                    if (child)
-                        ctx.visitNode(child);
-                }
-            }
-            return true;
-        }
-        return false;
-    },
-    extractImport: (node, source) => {
-        const importText = (0, tree_sitter_helpers_1.getNodeText)(node, source).trim();
-        const pathNode = node.childForFieldName('path');
-        if (pathNode)
-            return { moduleName: (0, tree_sitter_helpers_1.getNodeText)(pathNode, source), signature: importText };
-        for (let i = 0; i < node.namedChildCount; i++) {
-            const child = node.namedChild(i);
-            if (child?.type === 'identifier' || child?.type === 'stable_identifier') {
-                return { moduleName: (0, tree_sitter_helpers_1.getNodeText)(child, source), signature: importText };
-            }
-        }
-        return null;
-    },
-};
-//# sourceMappingURL=scala.js.map

package/dist/extraction/languages/swift.d.ts

@@ -1,3 +0,0 @@
-import type { LanguageExtractor } from '../tree-sitter-types'
-export declare const swiftExtractor: LanguageExtractor
-//# sourceMappingURL=swift.d.ts.map

package/dist/extraction/languages/swift.js

@@ -1,91 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.swiftExtractor = void 0;
-const tree_sitter_helpers_1 = require("../tree-sitter-helpers");
-exports.swiftExtractor = {
-    functionTypes: ['function_declaration'],
-    classTypes: ['class_declaration'],
-    methodTypes: ['function_declaration'], // Methods are functions inside classes
-    interfaceTypes: ['protocol_declaration'],
-    structTypes: ['struct_declaration'],
-    enumTypes: ['enum_declaration'],
-    enumMemberTypes: ['enum_entry'],
-    typeAliasTypes: ['typealias_declaration'],
-    importTypes: ['import_declaration'],
-    callTypes: ['call_expression'],
-    variableTypes: ['property_declaration', 'constant_declaration'],
-    nameField: 'name',
-    bodyField: 'body',
-    paramsField: 'parameter',
-    returnField: 'return_type',
-    getSignature: (node, source) => {
-        // Swift function signature: func name(params) -> ReturnType
-        const params = (0, tree_sitter_helpers_1.getChildByField)(node, 'parameter');
-        const returnType = (0, tree_sitter_helpers_1.getChildByField)(node, 'return_type');
-        if (!params)
-            return undefined;
-        let sig = (0, tree_sitter_helpers_1.getNodeText)(params, source);
-        if (returnType) {
-            sig += ' -> ' + (0, tree_sitter_helpers_1.getNodeText)(returnType, source);
-        }
-        return sig;
-    },
-    getVisibility: (node) => {
-        // Check for visibility modifiers in Swift
-        for (let i = 0; i < node.childCount; i++) {
-            const child = node.child(i);
-            if (child?.type === 'modifiers') {
-                const text = child.text;
-                if (text.includes('public'))
-                    return 'public';
-                if (text.includes('private'))
-                    return 'private';
-                if (text.includes('internal'))
-                    return 'internal';
-                if (text.includes('fileprivate'))
-                    return 'private';
-            }
-        }
-        return 'internal'; // Swift defaults to internal
-    },
-    isStatic: (node) => {
-        for (let i = 0; i < node.childCount; i++) {
-            const child = node.child(i);
-            if (child?.type === 'modifiers') {
-                if (child.text.includes('static') || child.text.includes('class')) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    },
-    classifyClassNode: (node) => {
-        // Swift uses class_declaration for classes, structs, and enums
-        for (let i = 0; i < node.childCount; i++) {
-            const child = node.child(i);
-            if (child?.type === 'struct')
-                return 'struct';
-            if (child?.type === 'enum')
-                return 'enum';
-        }
-        return 'class';
-    },
-    isAsync: (node) => {
-        for (let i = 0; i < node.childCount; i++) {
-            const child = node.child(i);
-            if (child?.type === 'modifiers' && child.text.includes('async')) {
-                return true;
-            }
-        }
-        return false;
-    },
-    extractImport: (node, source) => {
-        const importText = source.substring(node.startIndex, node.endIndex).trim();
-        const identifier = node.namedChildren.find((c) => c.type === 'identifier');
-        if (identifier) {
-            return { moduleName: source.substring(identifier.startIndex, identifier.endIndex), signature: importText };
-        }
-        return null;
-    },
-};
-//# sourceMappingURL=swift.js.map

package/dist/extraction/languages/typescript.d.ts

@@ -1,3 +0,0 @@
-import type { LanguageExtractor } from '../tree-sitter-types'
-export declare const typescriptExtractor: LanguageExtractor
-//# sourceMappingURL=typescript.d.ts.map