aidex-mcp 1.4.1

package/build/commands/summary.js

@@ -0,0 +1,324 @@
+/**
+ * summary and tree commands
+ *
+ * - summary: Get project summary with auto-detected info
+ * - tree: Get indexed file tree with optional stats
+ */
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { join, basename } from 'path';
+import { PRODUCT_NAME, INDEX_DIR, TOOL_PREFIX } from '../constants.js';
+import { openDatabase, createQueries } from '../db/index.js';
+// ============================================================
+// Summary implementation
+// ============================================================
+export function summary(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,
+            name: '',
+            content: '',
+            autoGenerated: {
+                entryPoints: [],
+                mainTypes: [],
+                fileCount: 0,
+                languages: [],
+            },
+            error: `No ${PRODUCT_NAME} index found at ${projectPath}. Run ${TOOL_PREFIX}init first.`,
+        };
+    }
+    // Open database
+    const db = openDatabase(dbPath, true);
+    const queries = createQueries(db);
+    try {
+        const projectName = db.getMetadata('project_name') ?? basename(projectPath);
+        // Read summary.md if exists
+        const summaryPath = join(indexDir, 'summary.md');
+        let content = '';
+        if (existsSync(summaryPath)) {
+            content = readFileSync(summaryPath, 'utf-8');
+        }
+        // Auto-detect entry points
+        const entryPoints = detectEntryPoints(queries);
+        // Get main types (most referenced)
+        const mainTypes = getMainTypes(queries);
+        // Get file count
+        const stats = db.getStats();
+        // Detect languages from file extensions
+        const languages = detectLanguages(queries);
+        db.close();
+        return {
+            success: true,
+            name: projectName,
+            content,
+            autoGenerated: {
+                entryPoints,
+                mainTypes,
+                fileCount: stats.files,
+                languages,
+            },
+        };
+    }
+    catch (err) {
+        db.close();
+        return {
+            success: false,
+            name: '',
+            content: '',
+            autoGenerated: {
+                entryPoints: [],
+                mainTypes: [],
+                fileCount: 0,
+                languages: [],
+            },
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+/**
+ * Detect entry points based on common patterns
+ */
+function detectEntryPoints(queries) {
+    const files = queries.getAllFiles();
+    const entryPatterns = [
+        /^(program|main|index|app|application)\.(cs|ts|js|py|rs)$/i,
+        /^src\/(program|main|index|app)\.(cs|ts|js|py|rs)$/i,
+        /^src\/(main|lib)\.(rs)$/i,
+    ];
+    const entryPoints = [];
+    for (const file of files) {
+        const fileName = file.path.replace(/\\/g, '/');
+        for (const pattern of entryPatterns) {
+            if (pattern.test(fileName) || pattern.test(basename(fileName))) {
+                entryPoints.push(file.path);
+                break;
+            }
+        }
+    }
+    return entryPoints;
+}
+/**
+ * Get main types (classes/interfaces with most methods)
+ */
+function getMainTypes(queries) {
+    const files = queries.getAllFiles();
+    const typeMethodCounts = [];
+    for (const file of files) {
+        const types = queries.getTypesByFile(file.id);
+        const methods = queries.getMethodsByFile(file.id);
+        for (const type of types) {
+            // Count methods that likely belong to this type (same file, after type definition)
+            const methodCount = methods.filter(m => m.line_number > type.line_number).length;
+            typeMethodCounts.push({
+                name: type.name,
+                file: file.path,
+                methodCount,
+            });
+        }
+    }
+    // Sort by method count and return top 5
+    typeMethodCounts.sort((a, b) => b.methodCount - a.methodCount);
+    return typeMethodCounts.slice(0, 5).map(t => `${t.name} (${t.file})`);
+}
+/**
+ * Detect languages from indexed file extensions
+ */
+function detectLanguages(queries) {
+    const files = queries.getAllFiles();
+    const extensionMap = {
+        '.cs': 'C#',
+        '.ts': 'TypeScript',
+        '.tsx': 'TypeScript',
+        '.js': 'JavaScript',
+        '.jsx': 'JavaScript',
+        '.mjs': 'JavaScript',
+        '.cjs': 'JavaScript',
+        '.rs': 'Rust',
+        '.py': 'Python',
+        '.pyw': 'Python',
+    };
+    const languages = new Set();
+    for (const file of files) {
+        const ext = file.path.substring(file.path.lastIndexOf('.')).toLowerCase();
+        if (extensionMap[ext]) {
+            languages.add(extensionMap[ext]);
+        }
+    }
+    return [...languages].sort();
+}
+// ============================================================
+// Tree implementation
+// ============================================================
+export function tree(params) {
+    const { path: projectPath, subpath, depth, includeStats } = params;
+    // Validate project path
+    const indexDir = join(projectPath, INDEX_DIR);
+    const dbPath = join(indexDir, 'index.db');
+    if (!existsSync(dbPath)) {
+        return {
+            success: false,
+            root: '',
+            entries: [],
+            totalFiles: 0,
+            error: `No ${PRODUCT_NAME} index found at ${projectPath}. Run ${TOOL_PREFIX}init first.`,
+        };
+    }
+    // Open database
+    const db = openDatabase(dbPath, true);
+    const queries = createQueries(db);
+    try {
+        const files = queries.getAllFiles();
+        const normalizedSubpath = subpath?.replace(/\\/g, '/').replace(/^\/|\/$/g, '') ?? '';
+        // Filter files by subpath
+        let filteredFiles = files;
+        if (normalizedSubpath) {
+            filteredFiles = files.filter(f => {
+                const normalizedPath = f.path.replace(/\\/g, '/');
+                return normalizedPath.startsWith(normalizedSubpath + '/') ||
+                    normalizedPath === normalizedSubpath;
+            });
+        }
+        // Build tree structure
+        const directories = new Set();
+        const entries = [];
+        for (const file of filteredFiles) {
+            const normalizedPath = file.path.replace(/\\/g, '/');
+            const relativePath = normalizedSubpath
+                ? normalizedPath.substring(normalizedSubpath.length + 1)
+                : normalizedPath;
+            // Check depth
+            const pathDepth = relativePath.split('/').length;
+            if (depth !== undefined && pathDepth > depth) {
+                // Just add parent directories up to depth
+                const parts = relativePath.split('/');
+                for (let i = 0; i < Math.min(depth, parts.length - 1); i++) {
+                    const dirPath = parts.slice(0, i + 1).join('/');
+                    directories.add(dirPath);
+                }
+                continue;
+            }
+            // Add parent directories
+            const parts = relativePath.split('/');
+            for (let i = 0; i < parts.length - 1; i++) {
+                const dirPath = parts.slice(0, i + 1).join('/');
+                directories.add(dirPath);
+            }
+            // Add file entry
+            const entry = {
+                path: relativePath,
+                type: 'file',
+            };
+            if (includeStats) {
+                const occurrences = queries.getOccurrencesByFile(file.id);
+                const methods = queries.getMethodsByFile(file.id);
+                const types = queries.getTypesByFile(file.id);
+                entry.itemCount = new Set(occurrences.map(o => o.item_id)).size;
+                entry.methodCount = methods.length;
+                entry.typeCount = types.length;
+            }
+            entries.push(entry);
+        }
+        // Add directory entries
+        for (const dir of directories) {
+            entries.push({
+                path: dir,
+                type: 'directory',
+            });
+        }
+        // Sort: directories first, then alphabetically
+        entries.sort((a, b) => {
+            if (a.type !== b.type) {
+                return a.type === 'directory' ? -1 : 1;
+            }
+            return a.path.localeCompare(b.path);
+        });
+        db.close();
+        return {
+            success: true,
+            root: normalizedSubpath || '.',
+            entries,
+            totalFiles: filteredFiles.length,
+        };
+    }
+    catch (err) {
+        db.close();
+        return {
+            success: false,
+            root: '',
+            entries: [],
+            totalFiles: 0,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+export function describe(params) {
+    const { path: projectPath, section, content, replace = false } = params;
+    // Validate project path
+    const indexDir = join(projectPath, INDEX_DIR);
+    const dbPath = join(indexDir, 'index.db');
+    if (!existsSync(dbPath)) {
+        return {
+            success: false,
+            section,
+            error: `No ${PRODUCT_NAME} index found at ${projectPath}. Run ${TOOL_PREFIX}init first.`,
+        };
+    }
+    const summaryPath = join(indexDir, 'summary.md');
+    try {
+        // Read existing summary or create new
+        let summaryContent = '';
+        if (existsSync(summaryPath)) {
+            summaryContent = readFileSync(summaryPath, 'utf-8');
+        }
+        // Section headers
+        const sectionHeaders = {
+            purpose: '## Purpose',
+            architecture: '## Architecture',
+            concepts: '## Key Concepts',
+            patterns: '## Patterns',
+            notes: '## Notes',
+        };
+        const header = sectionHeaders[section];
+        const sectionRegex = new RegExp(`^${header}\\n([\\s\\S]*?)(?=^## |$)`, 'm');
+        if (replace) {
+            // Replace entire section
+            if (sectionRegex.test(summaryContent)) {
+                summaryContent = summaryContent.replace(sectionRegex, `${header}\n${content}\n\n`);
+            }
+            else {
+                // Add new section at end
+                summaryContent = summaryContent.trimEnd() + `\n\n${header}\n${content}\n`;
+            }
+        }
+        else {
+            // Append to section
+            const match = summaryContent.match(sectionRegex);
+            if (match) {
+                const existingContent = match[1].trimEnd();
+                const newContent = existingContent ? `${existingContent}\n${content}` : content;
+                summaryContent = summaryContent.replace(sectionRegex, `${header}\n${newContent}\n\n`);
+            }
+            else {
+                // Add new section at end
+                summaryContent = summaryContent.trimEnd() + `\n\n${header}\n${content}\n`;
+            }
+        }
+        // Write back
+        writeFileSync(summaryPath, summaryContent.trimStart());
+        return {
+            success: true,
+            section,
+        };
+    }
+    catch (err) {
+        return {
+            success: false,
+            section,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+//# sourceMappingURL=summary.js.map

package/build/commands/update.d.ts

@@ -0,0 +1,36 @@
+/**
+ * update command - Update index for a single file
+ *
+ * Supports:
+ * - Full re-index of a file (no line range specified)
+ * - Incremental update of a line range (from_line/to_line specified) - future
+ */
+export interface UpdateParams {
+    path: string;
+    file: string;
+    fromLine?: number;
+    toLine?: number;
+}
+export interface UpdateResult {
+    success: boolean;
+    file: string;
+    itemsAdded: number;
+    itemsRemoved: number;
+    methodsUpdated: number;
+    typesUpdated: number;
+    durationMs: number;
+    error?: string;
+}
+export declare function update(params: UpdateParams): UpdateResult;
+export interface RemoveParams {
+    path: string;
+    file: string;
+}
+export interface RemoveResult {
+    success: boolean;
+    file: string;
+    removed: boolean;
+    error?: string;
+}
+export declare function remove(params: RemoveParams): RemoveResult;
+//# sourceMappingURL=update.d.ts.map

package/build/commands/update.js

@@ -0,0 +1,273 @@
+/**
+ * update command - Update index for a single file
+ *
+ * Supports:
+ * - Full re-index of a file (no line range specified)
+ * - Incremental update of a line range (from_line/to_line specified) - future
+ */
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { createHash } from 'crypto';
+import { PRODUCT_NAME, INDEX_DIR, TOOL_PREFIX } from '../constants.js';
+import { openDatabase, createQueries } from '../db/index.js';
+import { extract } from '../parser/index.js';
+// ============================================================
+// Main update function
+// ============================================================
+export function update(params) {
+    const startTime = Date.now();
+    const { path: projectPath } = params;
+    // Normalize path to forward slashes (consistent with how paths are stored)
+    const relativePath = params.file.replace(/\\/g, '/');
+    // Validate project path
+    const indexDir = join(projectPath, INDEX_DIR);
+    const dbPath = join(indexDir, 'index.db');
+    if (!existsSync(dbPath)) {
+        return {
+            success: false,
+            file: relativePath,
+            itemsAdded: 0,
+            itemsRemoved: 0,
+            methodsUpdated: 0,
+            typesUpdated: 0,
+            durationMs: Date.now() - startTime,
+            error: `No ${PRODUCT_NAME} index found at ${projectPath}. Run ${TOOL_PREFIX}init first.`,
+        };
+    }
+    // Check if file exists
+    const absolutePath = join(projectPath, relativePath);
+    if (!existsSync(absolutePath)) {
+        return {
+            success: false,
+            file: relativePath,
+            itemsAdded: 0,
+            itemsRemoved: 0,
+            methodsUpdated: 0,
+            typesUpdated: 0,
+            durationMs: Date.now() - startTime,
+            error: `File does not exist: ${relativePath}`,
+        };
+    }
+    // Open database
+    const db = openDatabase(dbPath);
+    const queries = createQueries(db);
+    try {
+        // Check if file is already indexed
+        const existingFile = queries.getFileByPath(relativePath);
+        // Read file content
+        let content;
+        try {
+            content = readFileSync(absolutePath, 'utf-8');
+        }
+        catch (err) {
+            return {
+                success: false,
+                file: relativePath,
+                itemsAdded: 0,
+                itemsRemoved: 0,
+                methodsUpdated: 0,
+                typesUpdated: 0,
+                durationMs: Date.now() - startTime,
+                error: `Cannot read file: ${err instanceof Error ? err.message : String(err)}`,
+            };
+        }
+        // Calculate new hash
+        const newHash = createHash('sha256').update(content).digest('hex').substring(0, 16);
+        // Check if file has actually changed
+        if (existingFile && existingFile.hash === newHash) {
+            return {
+                success: true,
+                file: relativePath,
+                itemsAdded: 0,
+                itemsRemoved: 0,
+                methodsUpdated: 0,
+                typesUpdated: 0,
+                durationMs: Date.now() - startTime,
+                error: 'File unchanged (hash match)',
+            };
+        }
+        // Extract data from file
+        const extraction = extract(content, relativePath);
+        if (!extraction) {
+            return {
+                success: false,
+                file: relativePath,
+                itemsAdded: 0,
+                itemsRemoved: 0,
+                methodsUpdated: 0,
+                typesUpdated: 0,
+                durationMs: Date.now() - startTime,
+                error: 'Unsupported file type or parse error',
+            };
+        }
+        // Count old items for comparison
+        let oldItemCount = 0;
+        let oldMethodCount = 0;
+        let oldTypeCount = 0;
+        if (existingFile) {
+            const oldOccurrences = queries.getOccurrencesByFile(existingFile.id);
+            oldItemCount = new Set(oldOccurrences.map(o => o.item_id)).size;
+            oldMethodCount = queries.getMethodsByFile(existingFile.id).length;
+            oldTypeCount = queries.getTypesByFile(existingFile.id).length;
+        }
+        // Split content into lines for hashing
+        const contentLines = content.split('\n');
+        const now = Date.now();
+        // Build map of old line hashes to modified timestamps (for diff tracking)
+        // Key is the hash, not line_number - so moved lines keep their timestamp
+        const oldHashToModified = new Map();
+        if (existingFile) {
+            const oldLines = queries.getLinesByFile(existingFile.id);
+            for (const line of oldLines) {
+                if (line.line_hash && line.modified) {
+                    // If same hash appears multiple times, keep the oldest timestamp
+                    const existing = oldHashToModified.get(line.line_hash);
+                    if (!existing || line.modified < existing) {
+                        oldHashToModified.set(line.line_hash, line.modified);
+                    }
+                }
+            }
+        }
+        // Perform update in transaction
+        let fileId;
+        let newItemCount = 0;
+        db.transaction(() => {
+            if (existingFile) {
+                // Clear existing data for this file
+                queries.clearFileData(existingFile.id);
+                // Update hash
+                queries.updateFileHash(existingFile.id, newHash);
+                fileId = existingFile.id;
+            }
+            else {
+                // Insert new file record
+                fileId = queries.insertFile(relativePath, newHash);
+            }
+            // Insert lines with diff tracking
+            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);
+                // Check if this hash existed before (regardless of line number)
+                const oldModified = oldHashToModified.get(lineHash);
+                const modified = oldModified ?? now; // Keep old timestamp if hash existed
+                queries.insertLine(fileId, lineId++, line.lineNumber, line.lineType, lineHash, modified);
+            }
+            // 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) {
+                let itemLineId = lineNumberToId.get(item.lineNumber);
+                if (itemLineId === 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);
+                    const oldModified = oldHashToModified.get(lineHash);
+                    const modified = oldModified ?? now;
+                    queries.insertLine(fileId, newLineId, item.lineNumber, item.lineType, lineHash, modified);
+                    lineNumberToId.set(item.lineNumber, newLineId);
+                    itemLineId = newLineId;
+                }
+                const itemId = queries.getOrCreateItem(item.term);
+                queries.insertOccurrence(itemId, fileId, itemLineId);
+                itemsInserted.add(item.term);
+            }
+            newItemCount = itemsInserted.size;
+            // 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'));
+            }
+        });
+        // Cleanup unused items
+        queries.deleteUnusedItems();
+        db.close();
+        return {
+            success: true,
+            file: relativePath,
+            itemsAdded: Math.max(0, newItemCount - oldItemCount),
+            itemsRemoved: Math.max(0, oldItemCount - newItemCount),
+            methodsUpdated: extraction.methods.length,
+            typesUpdated: extraction.types.length,
+            durationMs: Date.now() - startTime,
+        };
+    }
+    catch (err) {
+        db.close();
+        return {
+            success: false,
+            file: relativePath,
+            itemsAdded: 0,
+            itemsRemoved: 0,
+            methodsUpdated: 0,
+            typesUpdated: 0,
+            durationMs: Date.now() - startTime,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+export function remove(params) {
+    const { path: projectPath } = params;
+    // Normalize path to forward slashes
+    const relativePath = params.file.replace(/\\/g, '/');
+    // Validate project path
+    const indexDir = join(projectPath, INDEX_DIR);
+    const dbPath = join(indexDir, 'index.db');
+    if (!existsSync(dbPath)) {
+        return {
+            success: false,
+            file: relativePath,
+            removed: false,
+            error: `No ${PRODUCT_NAME} index found at ${projectPath}. Run ${TOOL_PREFIX}init first.`,
+        };
+    }
+    // Open database
+    const db = openDatabase(dbPath);
+    const queries = createQueries(db);
+    try {
+        const existingFile = queries.getFileByPath(relativePath);
+        if (!existingFile) {
+            db.close();
+            return {
+                success: true,
+                file: relativePath,
+                removed: false,
+                error: 'File not found in index',
+            };
+        }
+        // Delete file (CASCADE will handle related data)
+        db.transaction(() => {
+            queries.deleteFile(existingFile.id);
+            queries.deleteUnusedItems();
+        });
+        db.close();
+        return {
+            success: true,
+            file: relativePath,
+            removed: true,
+        };
+    }
+    catch (err) {
+        db.close();
+        return {
+            success: false,
+            file: relativePath,
+            removed: false,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+//# sourceMappingURL=update.js.map

package/build/constants.d.ts

@@ -0,0 +1,10 @@
+/**
+ * AiDex - Global constants
+ *
+ * Change product name here to rename the entire tool.
+ */
+export declare const PRODUCT_NAME = "AiDex";
+export declare const PRODUCT_NAME_LOWER = "aidex";
+export declare const INDEX_DIR = ".aidex";
+export declare const TOOL_PREFIX = "aidex_";
+//# sourceMappingURL=constants.d.ts.map

package/build/constants.js

@@ -0,0 +1,10 @@
+/**
+ * AiDex - Global constants
+ *
+ * Change product name here to rename the entire tool.
+ */
+export const PRODUCT_NAME = 'AiDex';
+export const PRODUCT_NAME_LOWER = 'aidex';
+export const INDEX_DIR = '.aidex';
+export const TOOL_PREFIX = 'aidex_';
+//# sourceMappingURL=constants.js.map