aidex-mcp 1.4.1

package/build/commands/init.js

@@ -0,0 +1,396 @@
+/**
+ * init command - Initialize AiDex for a project
+ */
+import { existsSync, mkdirSync, readFileSync, statSync } from 'fs';
+import { join, basename, extname } from 'path';
+import { glob } from 'glob';
+import { createHash } from 'crypto';
+import { minimatch } from 'minimatch';
+import { INDEX_DIR } from '../constants.js';
+import { createDatabase, createQueries } from '../db/index.js';
+import { extract, getSupportedExtensions } from '../parser/index.js';
+// ============================================================
+// Default patterns
+// ============================================================
+const DEFAULT_EXCLUDE = [
+    // Package managers
+    '**/node_modules/**',
+    '**/packages/**',
+    '**/vendor/**', // PHP Composer, Go
+    '**/vendor/bundle/**', // Ruby Bundler
+    // Build output
+    '**/bin/**',
+    '**/obj/**',
+    '**/bld/**', // Alternative build folder
+    '**/build/**',
+    '**/dist/**',
+    '**/out/**', // VS Code, some TS configs
+    '**/target/**', // Rust, Maven
+    '**/Debug/**', // Visual Studio
+    '**/Release/**', // Visual Studio
+    '**/x64/**', // Visual Studio
+    '**/x86/**', // Visual Studio
+    '**/[Aa][Rr][Mm]/**', // Visual Studio ARM
+    '**/[Aa][Rr][Mm]64/**', // Visual Studio ARM64
+    '**/__pycache__/**', // Python
+    '**/.pyc', // Python bytecode
+    '**/venv/**', // Python virtual env
+    '**/.venv/**', // Python virtual env
+    '**/env/**', // Python virtual env
+    '**/*.egg-info/**', // Python package metadata
+    // IDE/Editor
+    '**/.git/**',
+    '**/.vs/**',
+    '**/.idea/**',
+    '**/.vscode/**',
+    // Framework-specific
+    '**/.next/**', // Next.js
+    '**/coverage/**', // Test coverage
+    '**/tmp/**', // Ruby, temp files
+    // Generated files
+    '**/*.min.js',
+    '**/*.generated.*',
+    '**/*.g.cs', // C# source generators
+    '**/*.Designer.cs', // WinForms designer
+];
+// ============================================================
+// .gitignore support
+// ============================================================
+function readGitignore(projectPath) {
+    const gitignorePath = join(projectPath, '.gitignore');
+    if (!existsSync(gitignorePath))
+        return [];
+    const content = readFileSync(gitignorePath, 'utf-8');
+    return content
+        .split('\n')
+        .map(line => line.trim())
+        .filter(line => line && !line.startsWith('#')) // Keine Kommentare/Leerzeilen
+        .map(pattern => {
+        // Glob-kompatibel machen
+        if (pattern.endsWith('/')) {
+            return `**/${pattern}**`; // Verzeichnis: foo/ → **/foo/**
+        }
+        if (!pattern.includes('/') && !pattern.startsWith('*')) {
+            return `**/${pattern}`; // Datei/Ordner: foo → **/foo
+        }
+        return pattern;
+    });
+}
+// ============================================================
+// File type detection
+// ============================================================
+const CODE_EXTENSIONS = new Set([
+    '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
+    '.cs', '.rs', '.py', '.pyw',
+    '.c', '.h', '.cpp', '.cc', '.cxx', '.hpp', '.hxx',
+    '.java', '.go', '.php', '.rb', '.rake'
+]);
+const CONFIG_EXTENSIONS = new Set([
+    '.json', '.yaml', '.yml', '.toml', '.xml', '.ini', '.env', '.config',
+    '.eslintrc', '.prettierrc', '.babelrc', '.editorconfig'
+]);
+const DOC_EXTENSIONS = new Set([
+    '.md', '.txt', '.rst', '.adoc', '.doc', '.docx', '.pdf'
+]);
+const ASSET_EXTENSIONS = new Set([
+    '.png', '.jpg', '.jpeg', '.gif', '.svg', '.ico', '.webp',
+    '.woff', '.woff2', '.ttf', '.eot', '.otf',
+    '.mp3', '.mp4', '.wav', '.ogg', '.webm',
+    '.zip', '.tar', '.gz', '.rar'
+]);
+function detectFileType(filePath) {
+    const ext = extname(filePath).toLowerCase();
+    const lowerPath = filePath.toLowerCase();
+    // Check for test files first (before code check)
+    if (lowerPath.includes('.test.') || lowerPath.includes('.spec.') ||
+        lowerPath.includes('_test.') || lowerPath.includes('_spec.') ||
+        lowerPath.includes('/test/') || lowerPath.includes('/tests/') ||
+        lowerPath.includes('/__tests__/')) {
+        return 'test';
+    }
+    if (CODE_EXTENSIONS.has(ext))
+        return 'code';
+    if (CONFIG_EXTENSIONS.has(ext))
+        return 'config';
+    if (DOC_EXTENSIONS.has(ext))
+        return 'doc';
+    if (ASSET_EXTENSIONS.has(ext))
+        return 'asset';
+    return 'other';
+}
+// ============================================================
+// Main init function
+// ============================================================
+export async function init(params) {
+    const startTime = Date.now();
+    const errors = [];
+    // Validate project path
+    if (!existsSync(params.path)) {
+        return {
+            success: false,
+            indexPath: '',
+            filesIndexed: 0,
+            filesSkipped: 0,
+            filesRemoved: 0,
+            itemsFound: 0,
+            methodsFound: 0,
+            typesFound: 0,
+            durationMs: Date.now() - startTime,
+            errors: [`Project path does not exist: ${params.path}`],
+        };
+    }
+    const stat = statSync(params.path);
+    if (!stat.isDirectory()) {
+        return {
+            success: false,
+            indexPath: '',
+            filesIndexed: 0,
+            filesSkipped: 0,
+            filesRemoved: 0,
+            itemsFound: 0,
+            methodsFound: 0,
+            typesFound: 0,
+            durationMs: Date.now() - startTime,
+            errors: [`Path is not a directory: ${params.path}`],
+        };
+    }
+    // Create index directory
+    const indexDir = join(params.path, INDEX_DIR);
+    if (!existsSync(indexDir)) {
+        mkdirSync(indexDir, { recursive: true });
+    }
+    const dbPath = join(indexDir, 'index.db');
+    const projectName = params.name ?? basename(params.path);
+    // Determine if incremental (default) or fresh re-index
+    const dbExists = existsSync(dbPath);
+    const incremental = dbExists && !params.fresh;
+    // Create database (incremental keeps existing data)
+    const db = createDatabase(dbPath, projectName, params.path, incremental);
+    const queries = createQueries(db);
+    // Build glob pattern for supported files
+    const extensions = getSupportedExtensions();
+    const patterns = extensions.map(ext => `**/*${ext}`);
+    // Merge exclude patterns (including .gitignore)
+    const gitignorePatterns = readGitignore(params.path);
+    const exclude = [...DEFAULT_EXCLUDE, ...gitignorePatterns, ...(params.exclude ?? [])];
+    // Find all source files
+    let files = [];
+    for (const pattern of patterns) {
+        const found = await glob(pattern, {
+            cwd: params.path,
+            ignore: exclude,
+            nodir: true,
+            absolute: false,
+        });
+        files.push(...found);
+    }
+    // Remove duplicates, normalize to forward slashes, and sort
+    files = [...new Set(files)].map(f => f.replace(/\\/g, '/')).sort();
+    // Index each file
+    let filesIndexed = 0;
+    let filesSkipped = 0;
+    let totalItems = 0;
+    let totalMethods = 0;
+    let totalTypes = 0;
+    // Use transaction for bulk insert
+    db.transaction(() => {
+        for (const filePath of files) {
+            try {
+                const result = indexFile(params.path, filePath, db, queries, incremental);
+                if (result.skipped) {
+                    filesSkipped++;
+                }
+                else if (result.success) {
+                    filesIndexed++;
+                    totalItems += result.items;
+                    totalMethods += result.methods;
+                    totalTypes += result.types;
+                }
+                else if (result.error) {
+                    errors.push(`${filePath}: ${result.error}`);
+                }
+            }
+            catch (err) {
+                errors.push(`${filePath}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+    });
+    // Cleanup unused items
+    queries.deleteUnusedItems();
+    // --------------------------------------------------------
+    // Cleanup: Remove files that are now excluded
+    // (e.g., build/ was indexed before exclude pattern was added)
+    // --------------------------------------------------------
+    let filesRemoved = 0;
+    const existingFiles = queries.getAllFiles();
+    db.transaction(() => {
+        for (const file of existingFiles) {
+            // Check if this file path matches any exclude pattern
+            const shouldExclude = exclude.some(pattern => minimatch(file.path, pattern, { dot: true }));
+            if (shouldExclude) {
+                // Remove from index
+                queries.clearFileData(file.id);
+                queries.deleteFile(file.id);
+                filesRemoved++;
+            }
+        }
+    });
+    if (filesRemoved > 0) {
+        // Cleanup items that are now orphaned
+        queries.deleteUnusedItems();
+    }
+    // --------------------------------------------------------
+    // Scan project structure (all files, not just code)
+    // --------------------------------------------------------
+    const indexedFilesSet = new Set(files); // Code files we indexed
+    // Find ALL files in project
+    const allFiles = await glob('**/*', {
+        cwd: params.path,
+        ignore: exclude,
+        nodir: true,
+        absolute: false,
+    });
+    // Normalize paths and collect directories
+    const directories = new Set();
+    const normalizedAllFiles = allFiles.map(f => f.replace(/\\/g, '/'));
+    for (const filePath of normalizedAllFiles) {
+        // Extract all parent directories
+        const parts = filePath.split('/');
+        for (let i = 1; i < parts.length; i++) {
+            directories.add(parts.slice(0, i).join('/'));
+        }
+    }
+    // Insert directories
+    db.transaction(() => {
+        for (const dir of directories) {
+            queries.insertProjectFile(dir, 'dir', null, false);
+        }
+        // Insert all files with type detection
+        for (const filePath of normalizedAllFiles) {
+            const ext = extname(filePath).toLowerCase() || null;
+            const fileType = detectFileType(filePath);
+            const isIndexed = indexedFilesSet.has(filePath);
+            queries.insertProjectFile(filePath, fileType, ext, isIndexed);
+        }
+    });
+    // Reset session tracking after full re-index
+    const now = Date.now().toString();
+    db.setMetadata('last_session_start', now);
+    db.setMetadata('last_session_end', now);
+    db.setMetadata('current_session_start', now);
+    db.close();
+    return {
+        success: true,
+        indexPath: indexDir,
+        filesIndexed,
+        filesSkipped,
+        filesRemoved,
+        itemsFound: totalItems,
+        methodsFound: totalMethods,
+        typesFound: totalTypes,
+        durationMs: Date.now() - startTime,
+        errors,
+    };
+}
+function indexFile(projectPath, relativePath, db, queries, incremental = false) {
+    const absolutePath = join(projectPath, relativePath);
+    // Read file content
+    let content;
+    try {
+        content = readFileSync(absolutePath, 'utf-8');
+    }
+    catch (err) {
+        return {
+            success: false,
+            items: 0,
+            methods: 0,
+            types: 0,
+            error: `Cannot read file: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+    // Calculate hash
+    const hash = createHash('sha256').update(content).digest('hex').substring(0, 16);
+    // In incremental mode, skip unchanged files
+    if (incremental) {
+        const existingFile = queries.getFileByPath(relativePath);
+        if (existingFile && existingFile.hash === hash) {
+            return {
+                success: true,
+                skipped: true,
+                items: 0,
+                methods: 0,
+                types: 0,
+            };
+        }
+        // File changed - clear old data before re-indexing
+        if (existingFile) {
+            queries.clearFileData(existingFile.id);
+            queries.deleteFile(existingFile.id);
+        }
+    }
+    // Extract data from file
+    const extraction = extract(content, relativePath);
+    if (!extraction) {
+        return {
+            success: false,
+            items: 0,
+            methods: 0,
+            types: 0,
+            error: 'Unsupported file type or parse error',
+        };
+    }
+    // Insert file record
+    const fileId = queries.insertFile(relativePath, hash);
+    // Split content into lines for hashing
+    const contentLines = content.split('\n');
+    const now = Date.now();
+    // Insert lines with hash
+    let lineId = 1;
+    for (const line of extraction.lines) {
+        const lineContent = contentLines[line.lineNumber - 1] ?? '';
+        const lineHash = createHash('sha256').update(lineContent).digest('hex').substring(0, 16);
+        queries.insertLine(fileId, lineId++, line.lineNumber, line.lineType, lineHash, now);
+    }
+    // Build line number to line ID mapping
+    const lineNumberToId = new Map();
+    lineId = 1;
+    for (const line of extraction.lines) {
+        lineNumberToId.set(line.lineNumber, lineId++);
+    }
+    // Insert items and occurrences
+    const itemsInserted = new Set();
+    for (const item of extraction.items) {
+        const lineIdForItem = lineNumberToId.get(item.lineNumber);
+        if (lineIdForItem === undefined) {
+            // Line wasn't recorded, add it now
+            const newLineId = lineId++;
+            const lineContent = contentLines[item.lineNumber - 1] ?? '';
+            const lineHash = createHash('sha256').update(lineContent).digest('hex').substring(0, 16);
+            queries.insertLine(fileId, newLineId, item.lineNumber, item.lineType, lineHash, now);
+            lineNumberToId.set(item.lineNumber, newLineId);
+        }
+        const itemId = queries.getOrCreateItem(item.term);
+        const finalLineId = lineNumberToId.get(item.lineNumber);
+        queries.insertOccurrence(itemId, fileId, finalLineId);
+        itemsInserted.add(item.term);
+    }
+    // Insert methods
+    for (const method of extraction.methods) {
+        queries.insertMethod(fileId, method.name, method.prototype, method.lineNumber, method.visibility, method.isStatic, method.isAsync);
+    }
+    // Insert types
+    for (const type of extraction.types) {
+        queries.insertType(fileId, type.name, type.kind, type.lineNumber);
+    }
+    // Insert signature (header comments)
+    if (extraction.headerComments.length > 0) {
+        queries.insertSignature(fileId, extraction.headerComments.join('\n'));
+    }
+    return {
+        success: true,
+        items: itemsInserted.size,
+        methods: extraction.methods.length,
+        types: extraction.types.length,
+    };
+}
+//# sourceMappingURL=init.js.map

package/build/commands/link.d.ts

@@ -0,0 +1,45 @@
+/**
+ * link command - Link dependency projects
+ *
+ * Allows cross-project queries by linking other AiDex instances.
+ */
+export interface LinkParams {
+    path: string;
+    dependency: string;
+    name?: string;
+}
+export interface LinkResult {
+    success: boolean;
+    dependencyId?: number;
+    name: string;
+    filesAvailable: number;
+    error?: string;
+}
+export interface UnlinkParams {
+    path: string;
+    dependency: string;
+}
+export interface UnlinkResult {
+    success: boolean;
+    removed: boolean;
+    error?: string;
+}
+export interface ListLinksParams {
+    path: string;
+}
+export interface LinkedProject {
+    id: number;
+    path: string;
+    name: string | null;
+    filesAvailable: number;
+    available: boolean;
+}
+export interface ListLinksResult {
+    success: boolean;
+    dependencies: LinkedProject[];
+    error?: string;
+}
+export declare function link(params: LinkParams): LinkResult;
+export declare function unlink(params: UnlinkParams): UnlinkResult;
+export declare function listLinks(params: ListLinksParams): ListLinksResult;
+//# sourceMappingURL=link.d.ts.map

package/build/commands/link.js

@@ -0,0 +1,167 @@
+/**
+ * link command - Link dependency projects
+ *
+ * Allows cross-project queries by linking other AiDex instances.
+ */
+import { existsSync } from 'fs';
+import { join, basename } from 'path';
+import { PRODUCT_NAME, INDEX_DIR, TOOL_PREFIX } from '../constants.js';
+import { openDatabase } from '../db/index.js';
+// ============================================================
+// Link implementation
+// ============================================================
+export function link(params) {
+    const { path: projectPath, dependency: dependencyPath, name } = params;
+    // Validate project path
+    const indexDir = join(projectPath, INDEX_DIR);
+    const dbPath = join(indexDir, 'index.db');
+    if (!existsSync(dbPath)) {
+        return {
+            success: false,
+            name: '',
+            filesAvailable: 0,
+            error: `No ${PRODUCT_NAME} index found at ${projectPath}. Run ${TOOL_PREFIX}init first.`,
+        };
+    }
+    // Validate dependency path
+    const depIndexDir = join(dependencyPath, INDEX_DIR);
+    const depDbPath = join(depIndexDir, 'index.db');
+    if (!existsSync(depDbPath)) {
+        return {
+            success: false,
+            name: '',
+            filesAvailable: 0,
+            error: `No ${PRODUCT_NAME} index found at ${dependencyPath}. Run ${TOOL_PREFIX}init on dependency first.`,
+        };
+    }
+    // Open main database
+    const db = openDatabase(dbPath);
+    try {
+        // Get dependency info
+        const depDb = openDatabase(depDbPath, true);
+        const depStats = depDb.getStats();
+        const depName = name ?? depDb.getMetadata('project_name') ?? basename(dependencyPath);
+        depDb.close();
+        // Check if already linked
+        const existingDep = db.getDb().prepare('SELECT * FROM dependencies WHERE path = ?').get(dependencyPath);
+        let dependencyId;
+        if (existingDep) {
+            // Update existing
+            db.getDb().prepare('UPDATE dependencies SET name = ?, last_checked = ? WHERE id = ?').run(depName, Date.now(), existingDep.id);
+            dependencyId = existingDep.id;
+        }
+        else {
+            // Insert new
+            const result = db.getDb().prepare('INSERT INTO dependencies (path, name, last_checked) VALUES (?, ?, ?)').run(dependencyPath, depName, Date.now());
+            dependencyId = result.lastInsertRowid;
+        }
+        db.close();
+        return {
+            success: true,
+            dependencyId,
+            name: depName,
+            filesAvailable: depStats.files,
+        };
+    }
+    catch (err) {
+        db.close();
+        return {
+            success: false,
+            name: '',
+            filesAvailable: 0,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+// ============================================================
+// Unlink implementation
+// ============================================================
+export function unlink(params) {
+    const { path: projectPath, dependency: dependencyPath } = params;
+    // Validate project path
+    const indexDir = join(projectPath, INDEX_DIR);
+    const dbPath = join(indexDir, 'index.db');
+    if (!existsSync(dbPath)) {
+        return {
+            success: false,
+            removed: false,
+            error: `No ${PRODUCT_NAME} index found at ${projectPath}. Run ${TOOL_PREFIX}init first.`,
+        };
+    }
+    // Open database
+    const db = openDatabase(dbPath);
+    try {
+        const result = db.getDb().prepare('DELETE FROM dependencies WHERE path = ?').run(dependencyPath);
+        db.close();
+        return {
+            success: true,
+            removed: result.changes > 0,
+        };
+    }
+    catch (err) {
+        db.close();
+        return {
+            success: false,
+            removed: false,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+// ============================================================
+// List links implementation
+// ============================================================
+export function listLinks(params) {
+    const { path: projectPath } = params;
+    // Validate project path
+    const indexDir = join(projectPath, INDEX_DIR);
+    const dbPath = join(indexDir, 'index.db');
+    if (!existsSync(dbPath)) {
+        return {
+            success: false,
+            dependencies: [],
+            error: `No ${PRODUCT_NAME} index found at ${projectPath}. Run ${TOOL_PREFIX}init first.`,
+        };
+    }
+    // Open database
+    const db = openDatabase(dbPath, true);
+    try {
+        const deps = db.getDb().prepare('SELECT * FROM dependencies ORDER BY name').all();
+        const dependencies = [];
+        for (const dep of deps) {
+            const depDbPath = join(dep.path, INDEX_DIR, 'index.db');
+            const available = existsSync(depDbPath);
+            let filesAvailable = 0;
+            if (available) {
+                try {
+                    const depDb = openDatabase(depDbPath, true);
+                    filesAvailable = depDb.getStats().files;
+                    depDb.close();
+                }
+                catch {
+                    // Ignore errors reading dependency
+                }
+            }
+            dependencies.push({
+                id: dep.id,
+                path: dep.path,
+                name: dep.name,
+                filesAvailable,
+                available,
+            });
+        }
+        db.close();
+        return {
+            success: true,
+            dependencies,
+        };
+    }
+    catch (err) {
+        db.close();
+        return {
+            success: false,
+            dependencies: [],
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+//# sourceMappingURL=link.js.map

package/build/commands/note.d.ts

@@ -0,0 +1,29 @@
+/**
+ * note command - Session notes for cross-session communication
+ *
+ * Stores a single text note in the project's AiDex database that persists
+ * between sessions. Useful for:
+ * - Reminders for the next session ("Test glob pattern fix!")
+ * - User requests ("Remember to refactor X")
+ * - Auto-generated notes before session end
+ *
+ * v1.3.0 - Session tracking integration
+ */
+export interface NoteParams {
+    path: string;
+    note?: string;
+    append?: boolean;
+    clear?: boolean;
+}
+export interface NoteResult {
+    success: boolean;
+    note: string | null;
+    action: 'read' | 'write' | 'append' | 'clear';
+    error?: string;
+}
+export declare function note(params: NoteParams): NoteResult;
+/**
+ * Get note for a project (used internally by other tools to include in output)
+ */
+export declare function getSessionNote(projectPath: string): string | null;
+//# sourceMappingURL=note.d.ts.map