aidex-mcp 1.4.1

package/build/db/schema.sql

@@ -0,0 +1,136 @@
+-- ============================================================
+-- AiDex SQLite Schema
+-- Version: 1.0
+-- ============================================================
+
+PRAGMA foreign_keys = ON;
+PRAGMA journal_mode = WAL;
+
+-- ------------------------------------------------------------
+-- Dateibaum
+-- ------------------------------------------------------------
+CREATE TABLE IF NOT EXISTS files (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    path TEXT NOT NULL UNIQUE,
+    hash TEXT NOT NULL,
+    last_indexed INTEGER NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_files_path ON files(path);
+CREATE INDEX IF NOT EXISTS idx_files_hash ON files(hash);
+
+-- ------------------------------------------------------------
+-- Zeilenobjekte
+-- ------------------------------------------------------------
+CREATE TABLE IF NOT EXISTS lines (
+    id INTEGER NOT NULL,
+    file_id INTEGER NOT NULL,
+    line_number INTEGER NOT NULL,
+    line_type TEXT NOT NULL CHECK(line_type IN ('code', 'comment', 'struct', 'method', 'property', 'string')),
+    line_hash TEXT,
+    modified INTEGER,
+    PRIMARY KEY (file_id, id),
+    FOREIGN KEY (file_id) REFERENCES files(id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_lines_file ON lines(file_id);
+CREATE INDEX IF NOT EXISTS idx_lines_type ON lines(line_type);
+
+-- ------------------------------------------------------------
+-- Items (Terme)
+-- ------------------------------------------------------------
+CREATE TABLE IF NOT EXISTS items (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    term TEXT NOT NULL UNIQUE COLLATE NOCASE
+);
+
+CREATE INDEX IF NOT EXISTS idx_items_term ON items(term);
+
+-- ------------------------------------------------------------
+-- Item-Vorkommen
+-- ------------------------------------------------------------
+CREATE TABLE IF NOT EXISTS occurrences (
+    item_id INTEGER NOT NULL,
+    file_id INTEGER NOT NULL,
+    line_id INTEGER NOT NULL,
+    PRIMARY KEY (item_id, file_id, line_id),
+    FOREIGN KEY (item_id) REFERENCES items(id) ON DELETE CASCADE,
+    FOREIGN KEY (file_id, line_id) REFERENCES lines(file_id, id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_occurrences_item ON occurrences(item_id);
+CREATE INDEX IF NOT EXISTS idx_occurrences_file ON occurrences(file_id);
+
+-- ------------------------------------------------------------
+-- Datei-Signaturen
+-- ------------------------------------------------------------
+CREATE TABLE IF NOT EXISTS signatures (
+    file_id INTEGER PRIMARY KEY,
+    header_comments TEXT,
+    FOREIGN KEY (file_id) REFERENCES files(id) ON DELETE CASCADE
+);
+
+-- ------------------------------------------------------------
+-- Methoden/Funktionen
+-- ------------------------------------------------------------
+CREATE TABLE IF NOT EXISTS methods (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    file_id INTEGER NOT NULL,
+    name TEXT NOT NULL,
+    prototype TEXT NOT NULL,
+    line_number INTEGER NOT NULL,
+    visibility TEXT,
+    is_static INTEGER DEFAULT 0,
+    is_async INTEGER DEFAULT 0,
+    FOREIGN KEY (file_id) REFERENCES files(id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_methods_file ON methods(file_id);
+CREATE INDEX IF NOT EXISTS idx_methods_name ON methods(name);
+
+-- ------------------------------------------------------------
+-- Klassen/Structs/Interfaces
+-- ------------------------------------------------------------
+CREATE TABLE IF NOT EXISTS types (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    file_id INTEGER NOT NULL,
+    name TEXT NOT NULL,
+    kind TEXT NOT NULL CHECK(kind IN ('class', 'struct', 'interface', 'enum', 'type')),
+    line_number INTEGER NOT NULL,
+    FOREIGN KEY (file_id) REFERENCES files(id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_types_file ON types(file_id);
+CREATE INDEX IF NOT EXISTS idx_types_name ON types(name);
+
+-- ------------------------------------------------------------
+-- Abhängigkeiten zu anderen AiDex-Instanzen
+-- ------------------------------------------------------------
+CREATE TABLE IF NOT EXISTS dependencies (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    path TEXT NOT NULL UNIQUE,
+    name TEXT,
+    last_checked INTEGER
+);
+
+-- ------------------------------------------------------------
+-- Projektstruktur (alle Dateien + Verzeichnisse)
+-- ------------------------------------------------------------
+CREATE TABLE IF NOT EXISTS project_files (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    path TEXT NOT NULL UNIQUE,
+    type TEXT NOT NULL CHECK(type IN ('dir', 'code', 'config', 'doc', 'asset', 'test', 'other')),
+    extension TEXT,
+    indexed INTEGER DEFAULT 0
+);
+
+CREATE INDEX IF NOT EXISTS idx_project_files_path ON project_files(path);
+CREATE INDEX IF NOT EXISTS idx_project_files_type ON project_files(type);
+
+-- ------------------------------------------------------------
+-- Metadaten
+-- ------------------------------------------------------------
+CREATE TABLE IF NOT EXISTS metadata (
+    key TEXT PRIMARY KEY,
+    value TEXT
+);

package/build/index.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+/**
+ * AiDex - MCP Server Entry Point
+ *
+ * Provides persistent code indexing for Claude Code.
+ *
+ * Usage:
+ *   node build/index.js              - Start MCP server (default)
+ *   node build/index.js scan <path>  - Scan for .aidex directories
+ *   node build/index.js init <path>  - Index a project
+ */
+export {};
+//# sourceMappingURL=index.d.ts.map

package/build/index.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+/**
+ * AiDex - MCP Server Entry Point
+ *
+ * Provides persistent code indexing for Claude Code.
+ *
+ * Usage:
+ *   node build/index.js              - Start MCP server (default)
+ *   node build/index.js scan <path>  - Scan for .aidex directories
+ *   node build/index.js init <path>  - Index a project
+ */
+import { createServer } from './server/mcp-server.js';
+import { scan, init } from './commands/index.js';
+import { PRODUCT_NAME, PRODUCT_NAME_LOWER } from './constants.js';
+async function main() {
+    const args = process.argv.slice(2);
+    // CLI mode: scan
+    if (args[0] === 'scan') {
+        const searchPath = args[1];
+        if (!searchPath) {
+            console.error(`Usage: ${PRODUCT_NAME_LOWER} scan <path>`);
+            process.exit(1);
+        }
+        const result = scan({ path: searchPath });
+        if (!result.success) {
+            console.error(`Error: ${result.error}`);
+            process.exit(1);
+        }
+        console.log(`\n${PRODUCT_NAME} Indexes Found: ${result.projects.length}`);
+        console.log(`Scanned: ${result.scannedDirs} directories\n`);
+        if (result.projects.length === 0) {
+            console.log('No indexed projects found.');
+        }
+        else {
+            for (const proj of result.projects) {
+                console.log(`${proj.name}`);
+                console.log(`  Path: ${proj.path}`);
+                console.log(`  Files: ${proj.files} | Items: ${proj.items} | Methods: ${proj.methods} | Types: ${proj.types}`);
+                console.log(`  Last indexed: ${proj.lastIndexed}`);
+                console.log();
+            }
+        }
+        return;
+    }
+    // CLI mode: init
+    if (args[0] === 'init') {
+        const projectPath = args[1];
+        if (!projectPath) {
+            console.error(`Usage: ${PRODUCT_NAME_LOWER} init <path>`);
+            process.exit(1);
+        }
+        console.log(`Indexing: ${projectPath}`);
+        const result = await init({ path: projectPath });
+        if (!result.success) {
+            console.error(`Error: ${result.errors.join(', ')}`);
+            process.exit(1);
+        }
+        console.log(`Done!`);
+        console.log(`  Files: ${result.filesIndexed}`);
+        console.log(`  Items: ${result.itemsFound}`);
+        console.log(`  Methods: ${result.methodsFound}`);
+        console.log(`  Types: ${result.typesFound}`);
+        console.log(`  Time: ${result.durationMs}ms`);
+        return;
+    }
+    // Default: Start MCP server
+    const server = createServer();
+    await server.start();
+}
+main().catch((error) => {
+    console.error(`Failed to start ${PRODUCT_NAME}:`, error);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map

package/build/parser/extractor.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Code extractor - extracts items, lines, and metadata from source files
+ */
+import { type SupportedLanguage } from './tree-sitter.js';
+import type { LineRow } from '../db/queries.js';
+export interface ExtractedItem {
+    term: string;
+    lineNumber: number;
+    lineType: LineRow['line_type'];
+}
+export interface ExtractedLine {
+    lineNumber: number;
+    lineType: LineRow['line_type'];
+}
+export interface ExtractedMethod {
+    name: string;
+    prototype: string;
+    lineNumber: number;
+    visibility: string | null;
+    isStatic: boolean;
+    isAsync: boolean;
+}
+export interface ExtractedType {
+    name: string;
+    kind: 'class' | 'struct' | 'interface' | 'enum' | 'type';
+    lineNumber: number;
+}
+export interface ExtractionResult {
+    language: SupportedLanguage;
+    items: ExtractedItem[];
+    lines: ExtractedLine[];
+    methods: ExtractedMethod[];
+    types: ExtractedType[];
+    headerComments: string[];
+}
+/**
+ * Extract all indexable information from source code
+ */
+export declare function extract(sourceCode: string, filePath: string): ExtractionResult | null;
+export { detectLanguage, isSupported, getSupportedExtensions } from './tree-sitter.js';
+//# sourceMappingURL=extractor.d.ts.map

package/build/parser/extractor.js

@@ -0,0 +1,249 @@
+/**
+ * Code extractor - extracts items, lines, and metadata from source files
+ */
+import { detectLanguage, parseFile } from './tree-sitter.js';
+import { getLanguageConfig } from './languages/index.js';
+// ============================================================
+// Main extraction function
+// ============================================================
+/**
+ * Extract all indexable information from source code
+ */
+export function extract(sourceCode, filePath) {
+    const detectedLanguage = detectLanguage(filePath);
+    if (!detectedLanguage) {
+        return null;
+    }
+    const language = detectedLanguage;
+    const tree = parseFile(sourceCode, filePath);
+    if (!tree) {
+        return null;
+    }
+    const config = getLanguageConfig(language);
+    const sourceLines = sourceCode.split('\n');
+    const items = [];
+    const linesMap = new Map();
+    const methods = [];
+    const types = [];
+    const headerComments = [];
+    // Track if we've seen non-comment code (for header comments)
+    let seenCode = false;
+    /**
+     * Recursively visit all nodes in the tree
+     */
+    function visit(node) {
+        const lineNumber = node.startPosition.row + 1; // 1-based
+        // Check for comments
+        if (config.commentNodes.has(node.type)) {
+            if (!seenCode) {
+                // This is a header comment
+                headerComments.push(extractCommentText(node.text));
+            }
+            setLineType(lineNumber, 'comment');
+            extractIdentifiersFromComment(node.text, lineNumber, items, config.isKeyword);
+            return; // Don't recurse into comments
+        }
+        // Check for type declarations (class, struct, interface, etc.)
+        if (config.typeNodes.has(node.type)) {
+            seenCode = true;
+            const typeInfo = extractTypeInfo(node, language);
+            if (typeInfo) {
+                types.push(typeInfo);
+                setLineType(lineNumber, 'struct');
+            }
+        }
+        // Check for method declarations
+        if (config.methodNodes.has(node.type)) {
+            seenCode = true;
+            const methodInfo = extractMethodInfo(node, language, sourceLines);
+            if (methodInfo) {
+                methods.push(methodInfo);
+                setLineType(lineNumber, 'method');
+            }
+        }
+        // Check for property declarations
+        if (config.propertyNodes?.has(node.type)) {
+            seenCode = true;
+            setLineType(lineNumber, 'property');
+        }
+        // Check for identifiers
+        if (config.identifierNodes.has(node.type)) {
+            seenCode = true;
+            const term = node.text;
+            // Filter out keywords and very short terms
+            if (term.length >= 2 && !config.isKeyword(term)) {
+                items.push({
+                    term,
+                    lineNumber,
+                    lineType: linesMap.get(lineNumber) ?? 'code',
+                });
+                setLineType(lineNumber, linesMap.get(lineNumber) ?? 'code');
+            }
+        }
+        // Recurse into children
+        for (const child of node.children) {
+            visit(child);
+        }
+    }
+    /**
+     * Set line type (doesn't overwrite more specific types)
+     */
+    function setLineType(lineNumber, type) {
+        const existing = linesMap.get(lineNumber);
+        if (!existing || shouldUpgrade(existing, type)) {
+            linesMap.set(lineNumber, type);
+        }
+    }
+    // Start traversal
+    visit(tree.rootNode);
+    // Convert lines map to array
+    const lines = Array.from(linesMap.entries())
+        .map(([lineNumber, lineType]) => ({ lineNumber, lineType }))
+        .sort((a, b) => a.lineNumber - b.lineNumber);
+    // Update item line types from final linesMap
+    for (const item of items) {
+        item.lineType = linesMap.get(item.lineNumber) ?? 'code';
+    }
+    return {
+        language,
+        items,
+        lines,
+        methods,
+        types,
+        headerComments,
+    };
+}
+// ============================================================
+// Helper functions
+// ============================================================
+/**
+ * Priority order for line types (higher = more specific)
+ */
+const LINE_TYPE_PRIORITY = {
+    code: 0,
+    string: 1,
+    comment: 2,
+    property: 3,
+    method: 4,
+    struct: 5,
+};
+/**
+ * Check if we should upgrade from one type to another
+ */
+function shouldUpgrade(existing, newType) {
+    return LINE_TYPE_PRIORITY[newType] > LINE_TYPE_PRIORITY[existing];
+}
+/**
+ * Extract plain text from a comment (remove comment markers)
+ */
+function extractCommentText(commentText) {
+    return commentText
+        .replace(/^\/\/\s*/gm, '') // Remove //
+        .replace(/^\/\*+\s*/g, '') // Remove /*
+        .replace(/\s*\*+\/$/g, '') // Remove */
+        .replace(/^\s*\*\s?/gm, '') // Remove * at start of lines
+        .replace(/^#+\s*/gm, '') // Remove # (Python)
+        .trim();
+}
+/**
+ * Extract identifiers from comment text
+ */
+function extractIdentifiersFromComment(commentText, lineNumber, items, isKeyword) {
+    // Extract words that look like identifiers (CamelCase, snake_case, etc.)
+    const identifierPattern = /\b[A-Za-z_][A-Za-z0-9_]*\b/g;
+    const matches = commentText.match(identifierPattern) ?? [];
+    for (const term of matches) {
+        if (term.length >= 3 && !isKeyword(term)) {
+            items.push({
+                term,
+                lineNumber,
+                lineType: 'comment',
+            });
+        }
+    }
+}
+/**
+ * Extract type information from a type declaration node
+ */
+function extractTypeInfo(node, language) {
+    // Find the name child
+    const nameNode = node.children.find(c => c.type === 'identifier' || c.type === 'type_identifier' || c.type === 'name');
+    if (!nameNode) {
+        return null;
+    }
+    // Determine kind from node type
+    let kind = 'class';
+    const nodeType = node.type.toLowerCase();
+    if (nodeType.includes('struct'))
+        kind = 'struct';
+    else if (nodeType.includes('interface'))
+        kind = 'interface';
+    else if (nodeType.includes('enum'))
+        kind = 'enum';
+    else if (nodeType.includes('type_alias'))
+        kind = 'type';
+    return {
+        name: nameNode.text,
+        kind,
+        lineNumber: node.startPosition.row + 1,
+    };
+}
+/**
+ * Extract method information from a method declaration node
+ */
+function extractMethodInfo(node, language, sourceLines) {
+    // Find method name
+    let name = null;
+    let visibility = null;
+    let isStatic = false;
+    let isAsync = false;
+    for (const child of node.children) {
+        if (child.type === 'identifier' || child.type === 'property_identifier' || child.type === 'name') {
+            if (!name)
+                name = child.text;
+        }
+        // Check modifiers
+        const text = child.text.toLowerCase();
+        if (text === 'public' || text === 'private' || text === 'protected' || text === 'internal') {
+            visibility = text;
+        }
+        if (text === 'static')
+            isStatic = true;
+        if (text === 'async')
+            isAsync = true;
+    }
+    if (!name) {
+        return null;
+    }
+    // Extract prototype (first line of method, cleaned up)
+    const startLine = node.startPosition.row;
+    const endLine = Math.min(startLine + 2, sourceLines.length - 1); // Max 3 lines for prototype
+    let prototype = '';
+    for (let i = startLine; i <= endLine; i++) {
+        const line = sourceLines[i]?.trim() ?? '';
+        prototype += (prototype ? ' ' : '') + line;
+        // Stop at opening brace or arrow
+        if (line.includes('{') || line.includes('=>')) {
+            prototype = prototype.replace(/\s*\{.*$/, '').replace(/\s*=>.*$/, '').trim();
+            break;
+        }
+    }
+    // Clean up prototype
+    prototype = prototype
+        .replace(/\s+/g, ' ')
+        .replace(/\s*,\s*/g, ', ')
+        .trim();
+    return {
+        name,
+        prototype,
+        lineNumber: node.startPosition.row + 1,
+        visibility,
+        isStatic,
+        isAsync,
+    };
+}
+// ============================================================
+// Exports
+// ============================================================
+export { detectLanguage, isSupported, getSupportedExtensions } from './tree-sitter.js';
+//# sourceMappingURL=extractor.js.map

package/build/parser/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Parser module exports
+ */
+export { extract, detectLanguage, isSupported, getSupportedExtensions, type ExtractionResult, type ExtractedItem, type ExtractedLine, type ExtractedMethod, type ExtractedType, } from './extractor.js';
+export { parse, parseFile, getParser, type SupportedLanguage } from './tree-sitter.js';
+export { getLanguageConfig, isKeyword } from './languages/index.js';
+//# sourceMappingURL=index.d.ts.map

package/build/parser/index.js

@@ -0,0 +1,7 @@
+/**
+ * Parser module exports
+ */
+export { extract, detectLanguage, isSupported, getSupportedExtensions, } from './extractor.js';
+export { parse, parseFile, getParser } from './tree-sitter.js';
+export { getLanguageConfig, isKeyword } from './languages/index.js';
+//# sourceMappingURL=index.js.map

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

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

package/build/parser/languages/c.js

@@ -0,0 +1,70 @@
+/**
+ * C language configuration for AiDex
+ */
+/**
+ * C keywords that should be filtered out during indexing
+ */
+export const C_KEYWORDS = new Set([
+    // Storage class specifiers
+    'auto', 'extern', 'inline', 'register', 'static', 'thread_local',
+    '__inline', '__inline__', '__forceinline', '__thread',
+    // Type qualifiers
+    'const', 'constexpr', 'restrict', 'volatile',
+    '__restrict__', '__extension__', '_Atomic', '_Noreturn',
+    'noreturn', '_Nonnull', 'alignas', '_Alignas',
+    // Primitive types
+    'bool', 'char', 'double', 'float', 'int', 'void',
+    'signed', 'unsigned', 'short', 'long',
+    'size_t', 'ssize_t', 'ptrdiff_t', 'intptr_t', 'uintptr_t',
+    'int8_t', 'int16_t', 'int32_t', 'int64_t',
+    'uint8_t', 'uint16_t', 'uint32_t', 'uint64_t',
+    // Control flow
+    'break', 'case', 'continue', 'default', 'do', 'else',
+    'for', 'goto', 'if', 'return', 'switch', 'while',
+    // Type declaration
+    'enum', 'struct', 'typedef', 'union',
+    // Special operations
+    'alignof', 'offsetof', 'sizeof', '_alignof', '_Generic',
+    '__alignof', '__alignof__', '__asm', '__asm__', 'asm',
+    // Exception handling (Windows)
+    '__except', '__finally', '__leave', '__try',
+    // Literal values
+    'NULL', 'nullptr', 'true', 'false', 'TRUE', 'FALSE',
+]);
+/**
+ * Tree-sitter node types that represent identifiers in C
+ */
+export const C_IDENTIFIER_NODES = new Set([
+    'identifier',
+    'type_identifier',
+    'field_identifier',
+]);
+/**
+ * Tree-sitter node types for comments
+ */
+export const C_COMMENT_NODES = new Set([
+    'comment',
+]);
+/**
+ * Tree-sitter node types for function declarations
+ */
+export const C_METHOD_NODES = new Set([
+    'function_definition',
+    'function_declarator',
+]);
+/**
+ * Tree-sitter node types for type declarations
+ */
+export const C_TYPE_NODES = new Set([
+    'struct_specifier',
+    'union_specifier',
+    'enum_specifier',
+    'type_definition',
+]);
+/**
+ * Check if a term is a C keyword
+ */
+export function isKeyword(term) {
+    return C_KEYWORDS.has(term);
+}
+//# sourceMappingURL=c.js.map

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

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