aidex-mcp 1.4.1

package/build/parser/languages/python.js

@@ -0,0 +1,67 @@
+/**
+ * Python language configuration for AiDex
+ */
+/**
+ * Python keywords that should be filtered out during indexing
+ */
+export const PYTHON_KEYWORDS = new Set([
+    // Keywords
+    'False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await',
+    'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except',
+    'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is',
+    'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return',
+    'try', 'while', 'with', 'yield',
+    // Soft keywords (Python 3.10+)
+    'match', 'case', 'type',
+    // Built-in types
+    'int', 'float', 'str', 'bool', 'bytes', 'list', 'dict', 'set',
+    'tuple', 'frozenset', 'object', 'type',
+    // Built-in functions (common ones)
+    'print', 'len', 'range', 'enumerate', 'zip', 'map', 'filter',
+    'sorted', 'reversed', 'sum', 'min', 'max', 'abs', 'round',
+    'open', 'input', 'isinstance', 'issubclass', 'hasattr', 'getattr',
+    'setattr', 'delattr', 'callable', 'iter', 'next', 'super',
+    'staticmethod', 'classmethod', 'property',
+    // Common exceptions
+    'Exception', 'ValueError', 'TypeError', 'KeyError', 'IndexError',
+    'AttributeError', 'RuntimeError', 'StopIteration',
+    // Common decorators
+    'abstractmethod', 'dataclass', 'overload',
+    // Type hints
+    'Optional', 'List', 'Dict', 'Set', 'Tuple', 'Union', 'Any',
+    'Callable', 'Iterable', 'Iterator', 'Generator',
+    'TypeVar', 'Generic', 'Protocol',
+    // Magic names (dunder)
+    'self', 'cls',
+]);
+/**
+ * Tree-sitter node types that represent identifiers in Python
+ */
+export const PYTHON_IDENTIFIER_NODES = new Set([
+    'identifier',
+]);
+/**
+ * Tree-sitter node types for comments
+ */
+export const PYTHON_COMMENT_NODES = new Set([
+    'comment',
+]);
+/**
+ * Tree-sitter node types for function declarations
+ */
+export const PYTHON_METHOD_NODES = new Set([
+    'function_definition',
+]);
+/**
+ * Tree-sitter node types for type declarations
+ */
+export const PYTHON_TYPE_NODES = new Set([
+    'class_definition',
+]);
+/**
+ * Check if a term is a Python keyword
+ */
+export function isKeyword(term) {
+    return PYTHON_KEYWORDS.has(term);
+}
+//# sourceMappingURL=python.js.map

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

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

package/build/parser/languages/ruby.js

@@ -0,0 +1,68 @@
+/**
+ * Ruby language configuration for AiDex
+ */
+/**
+ * Ruby keywords that should be filtered out during indexing
+ */
+export const RUBY_KEYWORDS = new Set([
+    // Control flow
+    'if', 'elsif', 'else', 'unless', 'then',
+    'while', 'until', 'do', 'end',
+    'for', 'in', 'case', 'when',
+    // Definition
+    'def', 'class', 'module', 'super', 'alias', 'undef',
+    // Exception handling
+    'begin', 'rescue', 'ensure', 'retry', 'raise',
+    // Return & Flow control
+    'return', 'yield', 'break', 'next', 'redo',
+    // Literals & Values
+    'true', 'false', 'nil', 'self',
+    // Logical operators
+    'and', 'or', 'not',
+    // Special
+    'defined?', 'BEGIN', 'END',
+    // Magic constants
+    '__LINE__', '__FILE__', '__ENCODING__',
+    // Common built-ins (often noise)
+    'attr_reader', 'attr_writer', 'attr_accessor',
+    'private', 'protected', 'public',
+    'require', 'require_relative', 'include', 'extend', 'prepend',
+]);
+/**
+ * Tree-sitter node types that represent identifiers in Ruby
+ */
+export const RUBY_IDENTIFIER_NODES = new Set([
+    'identifier',
+    'constant',
+    'instance_variable',
+    'class_variable',
+    'global_variable',
+]);
+/**
+ * Tree-sitter node types for comments
+ */
+export const RUBY_COMMENT_NODES = new Set([
+    'comment',
+]);
+/**
+ * Tree-sitter node types for function declarations
+ */
+export const RUBY_METHOD_NODES = new Set([
+    'method',
+    'singleton_method',
+]);
+/**
+ * Tree-sitter node types for type declarations
+ */
+export const RUBY_TYPE_NODES = new Set([
+    'class',
+    'module',
+    'singleton_class',
+]);
+/**
+ * Check if a term is a Ruby keyword
+ */
+export function isKeyword(term) {
+    return RUBY_KEYWORDS.has(term);
+}
+//# sourceMappingURL=ruby.js.map

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

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

package/build/parser/languages/rust.js

@@ -0,0 +1,73 @@
+/**
+ * Rust language configuration for AiDex
+ */
+/**
+ * Rust keywords that should be filtered out during indexing
+ */
+export const RUST_KEYWORDS = new Set([
+    // Strict keywords
+    'as', 'async', 'await', 'break', 'const', 'continue', 'crate',
+    'dyn', 'else', 'enum', 'extern', 'false', 'fn', 'for', 'if',
+    'impl', 'in', 'let', 'loop', 'match', 'mod', 'move', 'mut',
+    'pub', 'ref', 'return', 'self', 'Self', 'static', 'struct',
+    'super', 'trait', 'true', 'type', 'unsafe', 'use', 'where', 'while',
+    // Reserved keywords
+    'abstract', 'become', 'box', 'do', 'final', 'macro', 'override',
+    'priv', 'try', 'typeof', 'unsized', 'virtual', 'yield',
+    // Weak keywords
+    'union', 'dyn',
+    // Primitive types
+    'bool', 'char', 'str',
+    'i8', 'i16', 'i32', 'i64', 'i128', 'isize',
+    'u8', 'u16', 'u32', 'u64', 'u128', 'usize',
+    'f32', 'f64',
+    // Common types (often noise)
+    'Option', 'Some', 'None', 'Result', 'Ok', 'Err',
+    'Vec', 'String', 'Box', 'Rc', 'Arc', 'Cell', 'RefCell',
+    'HashMap', 'HashSet', 'BTreeMap', 'BTreeSet',
+    'Fn', 'FnMut', 'FnOnce',
+    'Send', 'Sync', 'Copy', 'Clone', 'Debug', 'Default',
+    'Iterator', 'IntoIterator',
+    // Common macros
+    'println', 'print', 'format', 'panic', 'assert', 'assert_eq',
+    'vec', 'todo', 'unimplemented', 'unreachable',
+]);
+/**
+ * Tree-sitter node types that represent identifiers in Rust
+ */
+export const RUST_IDENTIFIER_NODES = new Set([
+    'identifier',
+    'type_identifier',
+    'field_identifier',
+]);
+/**
+ * Tree-sitter node types for comments
+ */
+export const RUST_COMMENT_NODES = new Set([
+    'line_comment',
+    'block_comment',
+]);
+/**
+ * Tree-sitter node types for function declarations
+ */
+export const RUST_METHOD_NODES = new Set([
+    'function_item',
+    'function_signature_item',
+]);
+/**
+ * Tree-sitter node types for type declarations
+ */
+export const RUST_TYPE_NODES = new Set([
+    'struct_item',
+    'enum_item',
+    'trait_item',
+    'type_item',
+    'impl_item',
+]);
+/**
+ * Check if a term is a Rust keyword
+ */
+export function isKeyword(term) {
+    return RUST_KEYWORDS.has(term);
+}
+//# sourceMappingURL=rust.js.map

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

@@ -0,0 +1,28 @@
+/**
+ * TypeScript/JavaScript language configuration for AiDex
+ */
+/**
+ * TypeScript/JavaScript keywords that should be filtered out during indexing
+ */
+export declare const TYPESCRIPT_KEYWORDS: Set<string>;
+/**
+ * Tree-sitter node types that represent identifiers in TypeScript
+ */
+export declare const TYPESCRIPT_IDENTIFIER_NODES: Set<string>;
+/**
+ * Tree-sitter node types for comments
+ */
+export declare const TYPESCRIPT_COMMENT_NODES: Set<string>;
+/**
+ * Tree-sitter node types for function declarations
+ */
+export declare const TYPESCRIPT_METHOD_NODES: Set<string>;
+/**
+ * Tree-sitter node types for type declarations
+ */
+export declare const TYPESCRIPT_TYPE_NODES: Set<string>;
+/**
+ * Check if a term is a TypeScript keyword
+ */
+export declare function isKeyword(term: string): boolean;
+//# sourceMappingURL=typescript.d.ts.map

package/build/parser/languages/typescript.js

@@ -0,0 +1,82 @@
+/**
+ * TypeScript/JavaScript language configuration for AiDex
+ */
+/**
+ * TypeScript/JavaScript keywords that should be filtered out during indexing
+ */
+export const TYPESCRIPT_KEYWORDS = new Set([
+    // Declarations
+    'function', 'class', 'interface', 'type', 'enum',
+    'const', 'let', 'var',
+    'namespace', 'module', 'declare',
+    // Modifiers
+    'export', 'import', 'from', 'as',
+    'public', 'private', 'protected',
+    'static', 'readonly', 'abstract',
+    'async', 'await',
+    'override',
+    // Primitive types
+    'void', 'number', 'string', 'boolean', 'symbol', 'bigint',
+    'any', 'unknown', 'never', 'object',
+    // Control flow
+    'if', 'else', 'switch', 'case', 'default',
+    'for', 'while', 'do',
+    'break', 'continue', 'return',
+    'try', 'catch', 'finally', 'throw',
+    'in', 'of',
+    // Operators and literals
+    'new', 'typeof', 'instanceof', 'delete', 'keyof',
+    'true', 'false', 'null', 'undefined',
+    'this', 'super',
+    'is', 'infer', 'extends', 'implements',
+    // Property accessors
+    'get', 'set',
+    // Other
+    'constructor', 'with', 'debugger',
+    'yield', 'satisfies',
+    // Common framework types (often noise)
+    'Promise', 'Array', 'Map', 'Set', 'Object', 'Function',
+    'Record', 'Partial', 'Required', 'Readonly', 'Pick', 'Omit',
+    'Exclude', 'Extract', 'ReturnType', 'Parameters',
+]);
+/**
+ * Tree-sitter node types that represent identifiers in TypeScript
+ */
+export const TYPESCRIPT_IDENTIFIER_NODES = new Set([
+    'identifier',
+    'type_identifier',
+    'property_identifier',
+    'shorthand_property_identifier',
+]);
+/**
+ * Tree-sitter node types for comments
+ */
+export const TYPESCRIPT_COMMENT_NODES = new Set([
+    'comment',
+]);
+/**
+ * Tree-sitter node types for function declarations
+ */
+export const TYPESCRIPT_METHOD_NODES = new Set([
+    'function_declaration',
+    'method_definition',
+    'arrow_function',
+    'function_expression',
+    'generator_function_declaration',
+]);
+/**
+ * Tree-sitter node types for type declarations
+ */
+export const TYPESCRIPT_TYPE_NODES = new Set([
+    'class_declaration',
+    'interface_declaration',
+    'type_alias_declaration',
+    'enum_declaration',
+]);
+/**
+ * Check if a term is a TypeScript keyword
+ */
+export function isKeyword(term) {
+    return TYPESCRIPT_KEYWORDS.has(term.toLowerCase());
+}
+//# sourceMappingURL=typescript.js.map

package/build/parser/tree-sitter.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Tree-sitter parser integration for AiDex
+ */
+import Parser from 'tree-sitter';
+export type SupportedLanguage = 'csharp' | 'typescript' | 'javascript' | 'rust' | 'python' | 'c' | 'cpp' | 'java' | 'go' | 'php' | 'ruby';
+/**
+ * Get or create a parser for the given language
+ */
+export declare function getParser(language: SupportedLanguage): Parser;
+/**
+ * Detect language from file extension
+ */
+export declare function detectLanguage(filePath: string): SupportedLanguage | null;
+/**
+ * Check if a file extension is supported
+ */
+export declare function isSupported(filePath: string): boolean;
+/**
+ * Get all supported file extensions
+ */
+export declare function getSupportedExtensions(): string[];
+/**
+ * Parse source code and return the syntax tree
+ */
+export declare function parse(sourceCode: string, language: SupportedLanguage): Parser.Tree;
+/**
+ * Parse a file's content with auto-detected language
+ */
+export declare function parseFile(sourceCode: string, filePath: string): Parser.Tree | null;
+//# sourceMappingURL=tree-sitter.d.ts.map

package/build/parser/tree-sitter.js

@@ -0,0 +1,132 @@
+/**
+ * Tree-sitter parser integration for AiDex
+ */
+import Parser from 'tree-sitter';
+// Language grammars
+import CSharp from 'tree-sitter-c-sharp';
+import TypeScript from 'tree-sitter-typescript';
+import Rust from 'tree-sitter-rust';
+import Python from 'tree-sitter-python';
+import C from 'tree-sitter-c';
+import Cpp from 'tree-sitter-cpp';
+import Java from 'tree-sitter-java';
+import Go from 'tree-sitter-go';
+import Php from 'tree-sitter-php';
+import Ruby from 'tree-sitter-ruby';
+// File extension to language mapping
+const EXTENSION_MAP = {
+    '.cs': 'csharp',
+    '.ts': 'typescript',
+    '.tsx': 'typescript',
+    '.js': 'javascript',
+    '.jsx': 'javascript',
+    '.mjs': 'javascript',
+    '.cjs': 'javascript',
+    '.rs': 'rust',
+    '.py': 'python',
+    '.pyw': 'python',
+    '.c': 'c',
+    '.h': 'c',
+    '.cpp': 'cpp',
+    '.cc': 'cpp',
+    '.cxx': 'cpp',
+    '.hpp': 'cpp',
+    '.hxx': 'cpp',
+    '.java': 'java',
+    '.go': 'go',
+    '.php': 'php',
+    '.rb': 'ruby',
+    '.rake': 'ruby',
+};
+// Cached parsers per language
+const parsers = new Map();
+/**
+ * Get or create a parser for the given language
+ */
+export function getParser(language) {
+    let parser = parsers.get(language);
+    if (parser) {
+        return parser;
+    }
+    parser = new Parser();
+    switch (language) {
+        case 'csharp':
+            parser.setLanguage(CSharp);
+            break;
+        case 'typescript':
+            parser.setLanguage(TypeScript.typescript);
+            break;
+        case 'javascript':
+            parser.setLanguage(TypeScript.typescript); // TS parser handles JS too
+            break;
+        case 'rust':
+            parser.setLanguage(Rust);
+            break;
+        case 'python':
+            parser.setLanguage(Python);
+            break;
+        case 'c':
+            parser.setLanguage(C);
+            break;
+        case 'cpp':
+            parser.setLanguage(Cpp);
+            break;
+        case 'java':
+            parser.setLanguage(Java);
+            break;
+        case 'go':
+            parser.setLanguage(Go);
+            break;
+        case 'php':
+            parser.setLanguage(Php.php);
+            break;
+        case 'ruby':
+            parser.setLanguage(Ruby);
+            break;
+        default:
+            throw new Error(`Unsupported language: ${language}`);
+    }
+    parsers.set(language, parser);
+    return parser;
+}
+/**
+ * Detect language from file extension
+ */
+export function detectLanguage(filePath) {
+    const ext = filePath.substring(filePath.lastIndexOf('.')).toLowerCase();
+    return EXTENSION_MAP[ext] ?? null;
+}
+/**
+ * Check if a file extension is supported
+ */
+export function isSupported(filePath) {
+    return detectLanguage(filePath) !== null;
+}
+/**
+ * Get all supported file extensions
+ */
+export function getSupportedExtensions() {
+    return Object.keys(EXTENSION_MAP);
+}
+// Default buffer size for tree-sitter parser (1 MB)
+// Fixes "Invalid argument" error for files > 32KB
+// See: https://github.com/tree-sitter/tree-sitter/issues/3473
+const PARSE_BUFFER_SIZE = 1024 * 1024;
+/**
+ * Parse source code and return the syntax tree
+ */
+export function parse(sourceCode, language) {
+    const parser = getParser(language);
+    return parser.parse(sourceCode, undefined, { bufferSize: PARSE_BUFFER_SIZE });
+}
+/**
+ * Parse a file's content with auto-detected language
+ */
+export function parseFile(sourceCode, filePath) {
+    const language = detectLanguage(filePath);
+    if (!language) {
+        return null;
+    }
+    return parse(sourceCode, language);
+}
+//# sourceMappingURL=tree-sitter.js.map

package/build/server/mcp-server.d.ts

@@ -0,0 +1,7 @@
+/**
+ * MCP Server implementation for AiDex
+ */
+export declare function createServer(): {
+    start(): Promise<void>;
+};
+//# sourceMappingURL=mcp-server.d.ts.map

package/build/server/mcp-server.js

@@ -0,0 +1,36 @@
+/**
+ * MCP Server implementation for AiDex
+ */
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { registerTools, handleToolCall } from './tools.js';
+import { PRODUCT_NAME, PRODUCT_NAME_LOWER } from '../constants.js';
+export function createServer() {
+    const server = new Server({
+        name: PRODUCT_NAME_LOWER,
+        version: '1.3.0',
+    }, {
+        capabilities: {
+            tools: {},
+        },
+    });
+    // Register tool list handler
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        return {
+            tools: registerTools(),
+        };
+    });
+    // Register tool call handler
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        return handleToolCall(request.params.name, request.params.arguments ?? {});
+    });
+    return {
+        async start() {
+            const transport = new StdioServerTransport();
+            await server.connect(transport);
+            console.error(`${PRODUCT_NAME} MCP server started`);
+        },
+    };
+}
+//# sourceMappingURL=mcp-server.js.map

package/build/server/tools.d.ts

@@ -0,0 +1,18 @@
+/**
+ * MCP Tool definitions and handlers for AiDex
+ */
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+/**
+ * Register all available tools
+ */
+export declare function registerTools(): Tool[];
+/**
+ * Handle tool calls
+ */
+export declare function handleToolCall(name: string, args: Record<string, unknown>): Promise<{
+    content: Array<{
+        type: string;
+        text: string;
+    }>;
+}>;
+//# sourceMappingURL=tools.d.ts.map