aidex-mcp 1.4.1

package/build/parser/languages/cpp.js

@@ -0,0 +1,91 @@
+/**
+ * C++ language configuration for AiDex
+ */
+/**
+ * C++ keywords that should be filtered out during indexing
+ */
+export const CPP_KEYWORDS = new Set([
+    // Access/Type modifiers
+    'public', 'private', 'protected',
+    'class', 'struct', 'union', 'enum',
+    'namespace', 'using',
+    // Type keywords
+    'typename',
+    'void', 'bool',
+    'char', 'char8_t', 'char16_t', 'char32_t', 'wchar_t',
+    'short', 'int', 'long',
+    'signed', 'unsigned',
+    'float', 'double',
+    // Modifiers
+    'static', 'extern', 'const', 'volatile', 'mutable',
+    'constexpr', 'consteval', 'constinit',
+    'inline', 'virtual', 'explicit', 'export',
+    'friend', 'typedef',
+    // Control flow
+    'if', 'else', 'switch', 'case', 'default',
+    'for', 'while', 'do',
+    'break', 'continue', 'return', 'goto',
+    'try', 'catch', 'throw',
+    // Operators & literals
+    'new', 'delete', 'this', 'nullptr',
+    'true', 'false',
+    'sizeof', 'typeid', 'decltype',
+    'static_cast', 'dynamic_cast', 'reinterpret_cast', 'const_cast',
+    'operator',
+    // C++11 features
+    'alignas', 'alignof', 'auto',
+    'static_assert', 'noexcept',
+    'thread_local',
+    // C++17/20 features
+    'concept', 'requires',
+    'co_await', 'co_return', 'co_yield',
+    // Alternative operators (ISO C++)
+    'and', 'or', 'not',
+    'and_eq', 'or_eq', 'xor', 'xor_eq',
+    'bitand', 'bitor', 'compl', 'not_eq',
+    // Contextual keywords
+    'final', 'override', 'import', 'module',
+    // Other
+    'asm', 'register',
+]);
+/**
+ * Tree-sitter node types that represent identifiers in C++
+ */
+export const CPP_IDENTIFIER_NODES = new Set([
+    'identifier',
+    'type_identifier',
+    'field_identifier',
+    'namespace_identifier',
+]);
+/**
+ * Tree-sitter node types for comments
+ */
+export const CPP_COMMENT_NODES = new Set([
+    'comment',
+]);
+/**
+ * Tree-sitter node types for function declarations
+ */
+export const CPP_METHOD_NODES = new Set([
+    'function_definition',
+    'function_declarator',
+    'template_function',
+]);
+/**
+ * Tree-sitter node types for type declarations
+ */
+export const CPP_TYPE_NODES = new Set([
+    'class_specifier',
+    'struct_specifier',
+    'union_specifier',
+    'enum_specifier',
+    'type_definition',
+    'template_declaration',
+]);
+/**
+ * Check if a term is a C++ keyword
+ */
+export function isKeyword(term) {
+    return CPP_KEYWORDS.has(term);
+}
+//# sourceMappingURL=cpp.js.map

package/build/parser/languages/csharp.d.ts

@@ -0,0 +1,32 @@
+/**
+ * C# language configuration for AiDex
+ */
+/**
+ * C# keywords that should be filtered out during indexing
+ */
+export declare const CSHARP_KEYWORDS: Set<string>;
+/**
+ * Tree-sitter node types that represent identifiers in C#
+ */
+export declare const CSHARP_IDENTIFIER_NODES: Set<string>;
+/**
+ * Tree-sitter node types for comments
+ */
+export declare const CSHARP_COMMENT_NODES: Set<string>;
+/**
+ * Tree-sitter node types for method declarations
+ */
+export declare const CSHARP_METHOD_NODES: Set<string>;
+/**
+ * Tree-sitter node types for type declarations
+ */
+export declare const CSHARP_TYPE_NODES: Set<string>;
+/**
+ * Tree-sitter node types for property declarations
+ */
+export declare const CSHARP_PROPERTY_NODES: Set<string>;
+/**
+ * Check if a term is a C# keyword
+ */
+export declare function isKeyword(term: string): boolean;
+//# sourceMappingURL=csharp.d.ts.map

package/build/parser/languages/csharp.js

@@ -0,0 +1,97 @@
+/**
+ * C# language configuration for AiDex
+ */
+/**
+ * C# keywords that should be filtered out during indexing
+ */
+export const CSHARP_KEYWORDS = new Set([
+    // Access modifiers
+    'public', 'private', 'protected', 'internal',
+    // Type keywords
+    'class', 'struct', 'interface', 'enum', 'record',
+    'namespace', 'using',
+    // Modifiers
+    'static', 'readonly', 'const', 'volatile',
+    'virtual', 'override', 'abstract', 'sealed',
+    'async', 'await', 'partial', 'extern',
+    'unsafe', 'fixed',
+    // Primitive types
+    'void', 'int', 'uint', 'long', 'ulong', 'short', 'ushort',
+    'byte', 'sbyte', 'float', 'double', 'decimal',
+    'bool', 'char', 'string', 'object', 'dynamic', 'var',
+    'nint', 'nuint',
+    // Control flow
+    'if', 'else', 'switch', 'case', 'default',
+    'for', 'foreach', 'while', 'do',
+    'break', 'continue', 'return', 'yield',
+    'try', 'catch', 'finally', 'throw',
+    'goto', 'when',
+    // Operators and literals
+    'new', 'typeof', 'sizeof', 'nameof', 'default',
+    'is', 'as', 'in', 'out', 'ref', 'params',
+    'true', 'false', 'null',
+    'this', 'base', 'value',
+    // Property accessors
+    'get', 'set', 'init', 'add', 'remove',
+    // LINQ
+    'where', 'select', 'from', 'orderby', 'group', 'by',
+    'into', 'join', 'on', 'equals', 'let', 'ascending', 'descending',
+    // Other
+    'delegate', 'event', 'operator',
+    'implicit', 'explicit',
+    'checked', 'unchecked',
+    'lock', 'stackalloc',
+    'with', 'and', 'or', 'not',
+    'required', 'file', 'scoped',
+    // Common framework types (often noise)
+    'Task', 'Action', 'Func', 'List', 'Dictionary',
+    'IEnumerable', 'IList', 'ICollection',
+]);
+/**
+ * Tree-sitter node types that represent identifiers in C#
+ */
+export const CSHARP_IDENTIFIER_NODES = new Set([
+    'identifier',
+    'type_identifier',
+]);
+/**
+ * Tree-sitter node types for comments
+ */
+export const CSHARP_COMMENT_NODES = new Set([
+    'comment',
+    'multiline_comment',
+]);
+/**
+ * Tree-sitter node types for method declarations
+ */
+export const CSHARP_METHOD_NODES = new Set([
+    'method_declaration',
+    'constructor_declaration',
+    'operator_declaration',
+    'conversion_operator_declaration',
+    'local_function_statement',
+]);
+/**
+ * Tree-sitter node types for type declarations
+ */
+export const CSHARP_TYPE_NODES = new Set([
+    'class_declaration',
+    'struct_declaration',
+    'interface_declaration',
+    'enum_declaration',
+    'record_declaration',
+]);
+/**
+ * Tree-sitter node types for property declarations
+ */
+export const CSHARP_PROPERTY_NODES = new Set([
+    'property_declaration',
+    'indexer_declaration',
+]);
+/**
+ * Check if a term is a C# keyword
+ */
+export function isKeyword(term) {
+    return CSHARP_KEYWORDS.has(term.toLowerCase());
+}
+//# sourceMappingURL=csharp.js.map

package/build/parser/languages/go.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Go language configuration for AiDex
+ */
+/**
+ * Go keywords that should be filtered out during indexing
+ */
+export declare const GO_KEYWORDS: Set<string>;
+/**
+ * Tree-sitter node types that represent identifiers in Go
+ */
+export declare const GO_IDENTIFIER_NODES: Set<string>;
+/**
+ * Tree-sitter node types for comments
+ */
+export declare const GO_COMMENT_NODES: Set<string>;
+/**
+ * Tree-sitter node types for function declarations
+ */
+export declare const GO_METHOD_NODES: Set<string>;
+/**
+ * Tree-sitter node types for type declarations
+ */
+export declare const GO_TYPE_NODES: Set<string>;
+/**
+ * Check if a term is a Go keyword
+ */
+export declare function isKeyword(term: string): boolean;
+//# sourceMappingURL=go.d.ts.map

package/build/parser/languages/go.js

@@ -0,0 +1,83 @@
+/**
+ * Go language configuration for AiDex
+ */
+/**
+ * Go keywords that should be filtered out during indexing
+ */
+export const GO_KEYWORDS = new Set([
+    'break',
+    'case',
+    'chan',
+    'const',
+    'continue',
+    'default',
+    'defer',
+    'else',
+    'fallthrough',
+    'for',
+    'func',
+    'go',
+    'goto',
+    'if',
+    'import',
+    'interface',
+    'map',
+    'package',
+    'range',
+    'return',
+    'select',
+    'struct',
+    'switch',
+    'type',
+    'var',
+    // Built-in types
+    'bool', 'byte', 'complex64', 'complex128',
+    'error', 'float32', 'float64',
+    'int', 'int8', 'int16', 'int32', 'int64',
+    'rune', 'string',
+    'uint', 'uint8', 'uint16', 'uint32', 'uint64', 'uintptr',
+    // Built-in constants
+    'true', 'false', 'iota', 'nil',
+    // Built-in functions (often noise)
+    'append', 'cap', 'close', 'complex', 'copy', 'delete',
+    'imag', 'len', 'make', 'new', 'panic', 'print', 'println',
+    'real', 'recover',
+]);
+/**
+ * Tree-sitter node types that represent identifiers in Go
+ */
+export const GO_IDENTIFIER_NODES = new Set([
+    'identifier',
+    'type_identifier',
+    'field_identifier',
+    'package_identifier',
+]);
+/**
+ * Tree-sitter node types for comments
+ */
+export const GO_COMMENT_NODES = new Set([
+    'comment',
+]);
+/**
+ * Tree-sitter node types for function declarations
+ */
+export const GO_METHOD_NODES = new Set([
+    'function_declaration',
+    'method_declaration',
+]);
+/**
+ * Tree-sitter node types for type declarations
+ */
+export const GO_TYPE_NODES = new Set([
+    'type_declaration',
+    'type_spec',
+    'struct_type',
+    'interface_type',
+]);
+/**
+ * Check if a term is a Go keyword
+ */
+export function isKeyword(term) {
+    return GO_KEYWORDS.has(term);
+}
+//# sourceMappingURL=go.js.map

package/build/parser/languages/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Language configuration registry
+ */
+import type { SupportedLanguage } from '../tree-sitter.js';
+export interface LanguageConfig {
+    isKeyword: (term: string) => boolean;
+    identifierNodes: Set<string>;
+    commentNodes: Set<string>;
+    methodNodes: Set<string>;
+    typeNodes: Set<string>;
+    propertyNodes?: Set<string>;
+}
+/**
+ * Get language configuration
+ */
+export declare function getLanguageConfig(language: SupportedLanguage): LanguageConfig;
+/**
+ * Check if a term is a keyword for the given language
+ */
+export declare function isKeyword(term: string, language: SupportedLanguage): boolean;
+//# sourceMappingURL=index.d.ts.map

package/build/parser/languages/index.js

@@ -0,0 +1,107 @@
+/**
+ * Language configuration registry
+ */
+import * as csharp from './csharp.js';
+import * as typescript from './typescript.js';
+import * as rust from './rust.js';
+import * as python from './python.js';
+import * as c from './c.js';
+import * as cpp from './cpp.js';
+import * as java from './java.js';
+import * as go from './go.js';
+import * as php from './php.js';
+import * as ruby from './ruby.js';
+const configs = {
+    csharp: {
+        isKeyword: csharp.isKeyword,
+        identifierNodes: csharp.CSHARP_IDENTIFIER_NODES,
+        commentNodes: csharp.CSHARP_COMMENT_NODES,
+        methodNodes: csharp.CSHARP_METHOD_NODES,
+        typeNodes: csharp.CSHARP_TYPE_NODES,
+        propertyNodes: csharp.CSHARP_PROPERTY_NODES,
+    },
+    typescript: {
+        isKeyword: typescript.isKeyword,
+        identifierNodes: typescript.TYPESCRIPT_IDENTIFIER_NODES,
+        commentNodes: typescript.TYPESCRIPT_COMMENT_NODES,
+        methodNodes: typescript.TYPESCRIPT_METHOD_NODES,
+        typeNodes: typescript.TYPESCRIPT_TYPE_NODES,
+    },
+    javascript: {
+        // JavaScript uses same config as TypeScript
+        isKeyword: typescript.isKeyword,
+        identifierNodes: typescript.TYPESCRIPT_IDENTIFIER_NODES,
+        commentNodes: typescript.TYPESCRIPT_COMMENT_NODES,
+        methodNodes: typescript.TYPESCRIPT_METHOD_NODES,
+        typeNodes: typescript.TYPESCRIPT_TYPE_NODES,
+    },
+    rust: {
+        isKeyword: rust.isKeyword,
+        identifierNodes: rust.RUST_IDENTIFIER_NODES,
+        commentNodes: rust.RUST_COMMENT_NODES,
+        methodNodes: rust.RUST_METHOD_NODES,
+        typeNodes: rust.RUST_TYPE_NODES,
+    },
+    python: {
+        isKeyword: python.isKeyword,
+        identifierNodes: python.PYTHON_IDENTIFIER_NODES,
+        commentNodes: python.PYTHON_COMMENT_NODES,
+        methodNodes: python.PYTHON_METHOD_NODES,
+        typeNodes: python.PYTHON_TYPE_NODES,
+    },
+    c: {
+        isKeyword: c.isKeyword,
+        identifierNodes: c.C_IDENTIFIER_NODES,
+        commentNodes: c.C_COMMENT_NODES,
+        methodNodes: c.C_METHOD_NODES,
+        typeNodes: c.C_TYPE_NODES,
+    },
+    cpp: {
+        isKeyword: cpp.isKeyword,
+        identifierNodes: cpp.CPP_IDENTIFIER_NODES,
+        commentNodes: cpp.CPP_COMMENT_NODES,
+        methodNodes: cpp.CPP_METHOD_NODES,
+        typeNodes: cpp.CPP_TYPE_NODES,
+    },
+    java: {
+        isKeyword: java.isKeyword,
+        identifierNodes: java.JAVA_IDENTIFIER_NODES,
+        commentNodes: java.JAVA_COMMENT_NODES,
+        methodNodes: java.JAVA_METHOD_NODES,
+        typeNodes: java.JAVA_TYPE_NODES,
+    },
+    go: {
+        isKeyword: go.isKeyword,
+        identifierNodes: go.GO_IDENTIFIER_NODES,
+        commentNodes: go.GO_COMMENT_NODES,
+        methodNodes: go.GO_METHOD_NODES,
+        typeNodes: go.GO_TYPE_NODES,
+    },
+    php: {
+        isKeyword: php.isKeyword,
+        identifierNodes: php.PHP_IDENTIFIER_NODES,
+        commentNodes: php.PHP_COMMENT_NODES,
+        methodNodes: php.PHP_METHOD_NODES,
+        typeNodes: php.PHP_TYPE_NODES,
+    },
+    ruby: {
+        isKeyword: ruby.isKeyword,
+        identifierNodes: ruby.RUBY_IDENTIFIER_NODES,
+        commentNodes: ruby.RUBY_COMMENT_NODES,
+        methodNodes: ruby.RUBY_METHOD_NODES,
+        typeNodes: ruby.RUBY_TYPE_NODES,
+    },
+};
+/**
+ * Get language configuration
+ */
+export function getLanguageConfig(language) {
+    return configs[language];
+}
+/**
+ * Check if a term is a keyword for the given language
+ */
+export function isKeyword(term, language) {
+    return configs[language].isKeyword(term);
+}
+//# sourceMappingURL=index.js.map

package/build/parser/languages/java.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Java language configuration for AiDex
+ */
+/**
+ * Java keywords that should be filtered out during indexing
+ */
+export declare const JAVA_KEYWORDS: Set<string>;
+/**
+ * Tree-sitter node types that represent identifiers in Java
+ */
+export declare const JAVA_IDENTIFIER_NODES: Set<string>;
+/**
+ * Tree-sitter node types for comments
+ */
+export declare const JAVA_COMMENT_NODES: Set<string>;
+/**
+ * Tree-sitter node types for function declarations
+ */
+export declare const JAVA_METHOD_NODES: Set<string>;
+/**
+ * Tree-sitter node types for type declarations
+ */
+export declare const JAVA_TYPE_NODES: Set<string>;
+/**
+ * Check if a term is a Java keyword
+ */
+export declare function isKeyword(term: string): boolean;
+//# sourceMappingURL=java.d.ts.map

package/build/parser/languages/java.js

@@ -0,0 +1,58 @@
+/**
+ * Java language configuration for AiDex
+ */
+/**
+ * Java keywords that should be filtered out during indexing
+ */
+export const JAVA_KEYWORDS = new Set([
+    // Reserved keywords
+    'abstract', 'assert', 'boolean', 'break', 'byte', 'case', 'catch', 'char',
+    'class', 'const', 'continue', 'default', 'do', 'double', 'else', 'enum',
+    'extends', 'final', 'finally', 'float', 'for', 'goto', 'if', 'implements',
+    'import', 'instanceof', 'int', 'interface', 'long', 'native', 'new',
+    'package', 'private', 'protected', 'public', 'return', 'short', 'static',
+    'strictfp', 'super', 'switch', 'synchronized', 'this', 'throw', 'throws',
+    'transient', 'try', 'void', 'volatile', 'while',
+    // Contextual keywords (reserved in specific contexts)
+    'var', 'record', 'sealed', 'permits', 'yield', 'non-sealed',
+    // Literals
+    'true', 'false', 'null',
+]);
+/**
+ * Tree-sitter node types that represent identifiers in Java
+ */
+export const JAVA_IDENTIFIER_NODES = new Set([
+    'identifier',
+    'type_identifier',
+]);
+/**
+ * Tree-sitter node types for comments
+ */
+export const JAVA_COMMENT_NODES = new Set([
+    'line_comment',
+    'block_comment',
+]);
+/**
+ * Tree-sitter node types for function declarations
+ */
+export const JAVA_METHOD_NODES = new Set([
+    'method_declaration',
+    'constructor_declaration',
+]);
+/**
+ * Tree-sitter node types for type declarations
+ */
+export const JAVA_TYPE_NODES = new Set([
+    'class_declaration',
+    'interface_declaration',
+    'enum_declaration',
+    'record_declaration',
+    'annotation_type_declaration',
+]);
+/**
+ * Check if a term is a Java keyword
+ */
+export function isKeyword(term) {
+    return JAVA_KEYWORDS.has(term);
+}
+//# sourceMappingURL=java.js.map

package/build/parser/languages/php.d.ts

@@ -0,0 +1,28 @@
+/**
+ * PHP language configuration for AiDex
+ */
+/**
+ * PHP keywords that should be filtered out during indexing
+ */
+export declare const PHP_KEYWORDS: Set<string>;
+/**
+ * Tree-sitter node types that represent identifiers in PHP
+ */
+export declare const PHP_IDENTIFIER_NODES: Set<string>;
+/**
+ * Tree-sitter node types for comments
+ */
+export declare const PHP_COMMENT_NODES: Set<string>;
+/**
+ * Tree-sitter node types for function declarations
+ */
+export declare const PHP_METHOD_NODES: Set<string>;
+/**
+ * Tree-sitter node types for type declarations
+ */
+export declare const PHP_TYPE_NODES: Set<string>;
+/**
+ * Check if a term is a PHP keyword
+ */
+export declare function isKeyword(term: string): boolean;
+//# sourceMappingURL=php.d.ts.map

package/build/parser/languages/php.js

@@ -0,0 +1,75 @@
+/**
+ * PHP language configuration for AiDex
+ */
+/**
+ * PHP keywords that should be filtered out during indexing
+ */
+export const PHP_KEYWORDS = new Set([
+    // Control flow
+    'if', 'elseif', 'else', 'switch', 'case', 'default',
+    'for', 'foreach', 'while', 'do', 'break', 'continue',
+    'goto', 'throw', 'try', 'catch', 'finally',
+    // Functions & Classes
+    'function', 'class', 'interface', 'trait', 'namespace',
+    'abstract', 'final', 'static', 'const', 'var',
+    // Visibility
+    'public', 'protected', 'private', 'readonly',
+    // Include/Require
+    'include', 'include_once', 'require', 'require_once',
+    'use',
+    // Object operators
+    'new', 'clone', 'instanceof', 'insteadof', 'implements', 'extends',
+    // Output
+    'echo', 'print',
+    // Logical operators
+    'and', 'or', 'xor',
+    // Language constructs
+    'array', 'list', 'eval', 'unset', 'empty', 'isset',
+    'return', 'yield',
+    // Declarations
+    'declare', 'enddeclare', 'endif', 'endfor', 'endforeach',
+    'endswitch', 'endwhile', 'callable',
+    // Other
+    '__halt_compiler', 'die', 'exit', 'fn', 'match', 'global',
+    // Magic constants
+    '__CLASS__', '__DIR__', '__FILE__', '__FUNCTION__',
+    '__LINE__', '__METHOD__', '__NAMESPACE__', '__TRAIT__',
+    // Literals
+    'true', 'false', 'null',
+]);
+/**
+ * Tree-sitter node types that represent identifiers in PHP
+ */
+export const PHP_IDENTIFIER_NODES = new Set([
+    'name',
+    'variable_name',
+]);
+/**
+ * Tree-sitter node types for comments
+ */
+export const PHP_COMMENT_NODES = new Set([
+    'comment',
+]);
+/**
+ * Tree-sitter node types for function declarations
+ */
+export const PHP_METHOD_NODES = new Set([
+    'function_definition',
+    'method_declaration',
+]);
+/**
+ * Tree-sitter node types for type declarations
+ */
+export const PHP_TYPE_NODES = new Set([
+    'class_declaration',
+    'interface_declaration',
+    'trait_declaration',
+    'enum_declaration',
+]);
+/**
+ * Check if a term is a PHP keyword
+ */
+export function isKeyword(term) {
+    return PHP_KEYWORDS.has(term.toLowerCase());
+}
+//# sourceMappingURL=php.js.map

package/build/parser/languages/python.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Python language configuration for AiDex
+ */
+/**
+ * Python keywords that should be filtered out during indexing
+ */
+export declare const PYTHON_KEYWORDS: Set<string>;
+/**
+ * Tree-sitter node types that represent identifiers in Python
+ */
+export declare const PYTHON_IDENTIFIER_NODES: Set<string>;
+/**
+ * Tree-sitter node types for comments
+ */
+export declare const PYTHON_COMMENT_NODES: Set<string>;
+/**
+ * Tree-sitter node types for function declarations
+ */
+export declare const PYTHON_METHOD_NODES: Set<string>;
+/**
+ * Tree-sitter node types for type declarations
+ */
+export declare const PYTHON_TYPE_NODES: Set<string>;
+/**
+ * Check if a term is a Python keyword
+ */
+export declare function isKeyword(term: string): boolean;
+//# sourceMappingURL=python.d.ts.map