aidex-mcp 1.4.1

package/build/commands/note.js

@@ -0,0 +1,105 @@
+/**
+ * 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
+ */
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { PRODUCT_NAME, INDEX_DIR, TOOL_PREFIX } from '../constants.js';
+import { openDatabase } from '../db/index.js';
+// ============================================================
+// Constants
+// ============================================================
+const NOTE_KEY = 'session_note';
+// ============================================================
+// Implementation
+// ============================================================
+export function note(params) {
+    const { path: projectPath, note: newNote, append, clear } = params;
+    // Validate project path
+    const dbPath = join(projectPath, INDEX_DIR, 'index.db');
+    if (!existsSync(dbPath)) {
+        return {
+            success: false,
+            note: null,
+            action: 'read',
+            error: `No ${PRODUCT_NAME} index found at ${projectPath}. Run ${TOOL_PREFIX}init first.`,
+        };
+    }
+    // Open database (read-write for writing, read-only for reading)
+    const isWriteOperation = newNote !== undefined || clear;
+    const db = openDatabase(dbPath, !isWriteOperation);
+    try {
+        if (clear) {
+            // Clear the note
+            db.deleteMetadata(NOTE_KEY);
+            db.close();
+            return {
+                success: true,
+                note: null,
+                action: 'clear',
+            };
+        }
+        if (newNote !== undefined) {
+            // Write or append note
+            let finalNote = newNote;
+            if (append) {
+                // Get existing note first
+                const existing = db.getMetadata(NOTE_KEY);
+                if (existing) {
+                    finalNote = existing + '\n' + newNote;
+                }
+            }
+            // Save the note
+            db.setMetadata(NOTE_KEY, finalNote);
+            db.close();
+            return {
+                success: true,
+                note: finalNote,
+                action: append ? 'append' : 'write',
+            };
+        }
+        // Read note
+        const currentNote = db.getMetadata(NOTE_KEY);
+        db.close();
+        return {
+            success: true,
+            note: currentNote,
+            action: 'read',
+        };
+    }
+    catch (error) {
+        db.close();
+        return {
+            success: false,
+            note: null,
+            action: 'read',
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Get note for a project (used internally by other tools to include in output)
+ */
+export function getSessionNote(projectPath) {
+    const dbPath = join(projectPath, INDEX_DIR, 'index.db');
+    if (!existsSync(dbPath)) {
+        return null;
+    }
+    try {
+        const db = openDatabase(dbPath, true);
+        const currentNote = db.getMetadata(NOTE_KEY);
+        db.close();
+        return currentNote;
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=note.js.map

package/build/commands/query.d.ts

@@ -0,0 +1,36 @@
+/**
+ * query command - Search for terms in the index
+ */
+export type QueryMode = 'exact' | 'contains' | 'starts_with';
+export interface QueryParams {
+    path: string;
+    term: string;
+    mode?: QueryMode;
+    fileFilter?: string;
+    typeFilter?: string[];
+    modifiedSince?: string;
+    modifiedBefore?: string;
+    limit?: number;
+}
+export interface QueryMatch {
+    file: string;
+    lineNumber: number;
+    lineType: string;
+    modified?: number;
+}
+export interface QueryResult {
+    success: boolean;
+    term: string;
+    mode: QueryMode;
+    matches: QueryMatch[];
+    totalMatches: number;
+    truncated: boolean;
+    error?: string;
+}
+export declare function query(params: QueryParams): QueryResult;
+/**
+ * Parse time offset string to Unix timestamp
+ * Supports: "2h" (hours), "30m" (minutes), "1d" (days), "1w" (weeks), or ISO date string
+ */
+export declare function parseTimeOffset(input: string): number | null;
+//# sourceMappingURL=query.d.ts.map

package/build/commands/query.js

@@ -0,0 +1,176 @@
+/**
+ * query command - Search for terms in the index
+ */
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { PRODUCT_NAME, INDEX_DIR, TOOL_PREFIX } from '../constants.js';
+import { openDatabase, createQueries } from '../db/index.js';
+// ============================================================
+// Main query function
+// ============================================================
+export function query(params) {
+    const mode = params.mode ?? 'exact';
+    const limit = params.limit ?? 100;
+    // Validate project path
+    const dbPath = join(params.path, INDEX_DIR, 'index.db');
+    if (!existsSync(dbPath)) {
+        return {
+            success: false,
+            term: params.term,
+            mode,
+            matches: [],
+            totalMatches: 0,
+            truncated: false,
+            error: `No ${PRODUCT_NAME} index found at ${params.path}. Run ${TOOL_PREFIX}init first.`,
+        };
+    }
+    // Open database
+    const db = openDatabase(dbPath, true);
+    const queries = createQueries(db);
+    try {
+        // Search for items
+        const items = queries.searchItems(params.term, mode, 1000);
+        if (items.length === 0) {
+            db.close();
+            return {
+                success: true,
+                term: params.term,
+                mode,
+                matches: [],
+                totalMatches: 0,
+                truncated: false,
+            };
+        }
+        // Parse time filters
+        const modifiedSinceTs = params.modifiedSince ? parseTimeOffset(params.modifiedSince) : null;
+        const modifiedBeforeTs = params.modifiedBefore ? parseTimeOffset(params.modifiedBefore) : null;
+        // Collect all occurrences
+        let allMatches = [];
+        for (const item of items) {
+            const occurrences = queries.getOccurrencesByItem(item.id);
+            for (const occ of occurrences) {
+                // Apply file filter
+                if (params.fileFilter && !matchesGlob(occ.path, params.fileFilter)) {
+                    continue;
+                }
+                // Apply type filter
+                if (params.typeFilter && params.typeFilter.length > 0) {
+                    if (!params.typeFilter.includes(occ.line_type)) {
+                        continue;
+                    }
+                }
+                // Apply time filters
+                if (modifiedSinceTs !== null && occ.modified !== null) {
+                    if (occ.modified < modifiedSinceTs) {
+                        continue;
+                    }
+                }
+                if (modifiedBeforeTs !== null && occ.modified !== null) {
+                    if (occ.modified > modifiedBeforeTs) {
+                        continue;
+                    }
+                }
+                allMatches.push({
+                    file: occ.path,
+                    lineNumber: occ.line_number,
+                    lineType: occ.line_type,
+                    modified: occ.modified ?? undefined,
+                });
+            }
+        }
+        // Remove duplicates (same file + line)
+        const seen = new Set();
+        allMatches = allMatches.filter(m => {
+            const key = `${m.file}:${m.lineNumber}`;
+            if (seen.has(key))
+                return false;
+            seen.add(key);
+            return true;
+        });
+        // Sort by file, then line number
+        allMatches.sort((a, b) => {
+            const fileCompare = a.file.localeCompare(b.file);
+            if (fileCompare !== 0)
+                return fileCompare;
+            return a.lineNumber - b.lineNumber;
+        });
+        const totalMatches = allMatches.length;
+        const truncated = allMatches.length > limit;
+        if (truncated) {
+            allMatches = allMatches.slice(0, limit);
+        }
+        db.close();
+        return {
+            success: true,
+            term: params.term,
+            mode,
+            matches: allMatches,
+            totalMatches,
+            truncated,
+        };
+    }
+    catch (error) {
+        db.close();
+        return {
+            success: false,
+            term: params.term,
+            mode,
+            matches: [],
+            totalMatches: 0,
+            truncated: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+// ============================================================
+// Helper functions
+// ============================================================
+/**
+ * Parse time offset string to Unix timestamp
+ * Supports: "2h" (hours), "30m" (minutes), "1d" (days), "1w" (weeks), or ISO date string
+ */
+export function parseTimeOffset(input) {
+    if (!input)
+        return null;
+    // Try relative time format: 2h, 30m, 1d, 1w
+    const match = input.match(/^(\d+)([mhdw])$/i);
+    if (match) {
+        const value = parseInt(match[1], 10);
+        const unit = match[2].toLowerCase();
+        const now = Date.now();
+        switch (unit) {
+            case 'm': return now - value * 60 * 1000; // minutes
+            case 'h': return now - value * 60 * 60 * 1000; // hours
+            case 'd': return now - value * 24 * 60 * 60 * 1000; // days
+            case 'w': return now - value * 7 * 24 * 60 * 60 * 1000; // weeks
+        }
+    }
+    // Try ISO date string
+    const date = new Date(input);
+    if (!isNaN(date.getTime())) {
+        return date.getTime();
+    }
+    return null;
+}
+/**
+ * Simple glob matching (supports * and ** patterns)
+ * Handles patterns like "** /folder/** " correctly for paths starting with folder/
+ */
+function matchesGlob(path, pattern) {
+    // Normalize path separators
+    const normalizedPath = path.replace(/\\/g, '/');
+    const normalizedPattern = pattern.replace(/\\/g, '/');
+    // Convert glob to regex using placeholders to avoid interference
+    let regex = normalizedPattern
+        .replace(/\./g, '\\.') // Escape dots
+        .replace(/\*\*\//g, '<<<STARSTAR_SLASH>>>') // **/ placeholder
+        .replace(/\/\*\*/g, '<<<SLASH_STARSTAR>>>') // /** placeholder
+        .replace(/\*\*/g, '<<<STARSTAR>>>') // standalone ** placeholder
+        .replace(/\*/g, '[^/]*') // * matches anything except /
+        .replace(/<<<STARSTAR_SLASH>>>/g, '(.*/)?') // **/ = optional prefix ending with /
+        .replace(/<<<SLASH_STARSTAR>>>/g, '(/.*)?') // /** = optional suffix starting with /
+        .replace(/<<<STARSTAR>>>/g, '.*'); // ** matches anything
+    regex = '^' + regex + '$';
+    return new RegExp(regex, 'i').test(normalizedPath);
+}
+//# sourceMappingURL=query.js.map

package/build/commands/scan.d.ts

@@ -0,0 +1,25 @@
+/**
+ * scan command - Find all AiDex index directories!
+ */
+export interface ScanParams {
+    path: string;
+    maxDepth?: number;
+}
+export interface IndexedProject {
+    path: string;
+    name: string;
+    files: number;
+    items: number;
+    methods: number;
+    types: number;
+    lastIndexed: string;
+}
+export interface ScanResult {
+    success: boolean;
+    searchPath: string;
+    projects: IndexedProject[];
+    scannedDirs: number;
+    error?: string;
+}
+export declare function scan(params: ScanParams): ScanResult;
+//# sourceMappingURL=scan.d.ts.map

package/build/commands/scan.js

@@ -0,0 +1,104 @@
+/**
+ * scan command - Find all AiDex index directories!
+ */
+import { existsSync, readdirSync } from 'fs';
+import { join, basename } from 'path';
+import { INDEX_DIR } from '../constants.js';
+import { openDatabase } from '../db/index.js';
+// ============================================================
+// Default excluded directories
+// ============================================================
+const EXCLUDED_DIRS = new Set([
+    'node_modules',
+    '.git',
+    '.svn',
+    '.hg',
+    '__pycache__',
+    '.cache',
+    'dist',
+    'build',
+    'out',
+    'target',
+    'bin',
+    'obj',
+    '.next',
+    '.nuxt',
+    'vendor',
+    '.gradle',
+    '.idea',
+    '.vscode',
+]);
+// ============================================================
+// Main scan function
+// ============================================================
+export function scan(params) {
+    const { path: searchPath, maxDepth = 10 } = params;
+    // Validate path
+    if (!existsSync(searchPath)) {
+        return {
+            success: false,
+            searchPath,
+            projects: [],
+            scannedDirs: 0,
+            error: `Path does not exist: ${searchPath}`,
+        };
+    }
+    const projects = [];
+    let scannedDirs = 0;
+    function scanDirectory(dirPath, depth) {
+        if (depth > maxDepth)
+            return;
+        scannedDirs++;
+        // Check if this directory has an index dir
+        const indexPath = join(dirPath, INDEX_DIR);
+        const dbPath = join(indexPath, 'index.db');
+        if (existsSync(dbPath)) {
+            try {
+                const db = openDatabase(dbPath, true);
+                const stats = db.getStats();
+                const projectName = db.getMetadata('project_name') ?? basename(dirPath);
+                const lastIndexed = db.getMetadata('last_indexed') ?? 'unknown';
+                db.close();
+                projects.push({
+                    path: dirPath,
+                    name: projectName,
+                    files: stats.files,
+                    items: stats.items,
+                    methods: stats.methods,
+                    types: stats.types,
+                    lastIndexed,
+                });
+            }
+            catch {
+                // Skip invalid databases
+            }
+        }
+        // Scan subdirectories
+        try {
+            const entries = readdirSync(dirPath, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                if (entry.name.startsWith('.') && entry.name !== INDEX_DIR)
+                    continue;
+                if (EXCLUDED_DIRS.has(entry.name))
+                    continue;
+                const subPath = join(dirPath, entry.name);
+                scanDirectory(subPath, depth + 1);
+            }
+        }
+        catch {
+            // Skip directories we can't read
+        }
+    }
+    scanDirectory(searchPath, 0);
+    // Sort by path
+    projects.sort((a, b) => a.path.localeCompare(b.path));
+    return {
+        success: true,
+        searchPath,
+        projects,
+        scannedDirs,
+    };
+}
+//# sourceMappingURL=scan.js.map

package/build/commands/session.d.ts

@@ -0,0 +1,52 @@
+/**
+ * session command - Session tracking and external change detection
+ *
+ * Tracks session start/end times and detects files changed outside of sessions.
+ * This enables:
+ * - "What did we do last session?" queries using time filtering
+ * - Automatic detection of externally modified files that need re-indexing
+ */
+export interface SessionParams {
+    path: string;
+}
+export interface SessionInfo {
+    lastSessionStart: number | null;
+    lastSessionEnd: number | null;
+    currentSessionStart: number | null;
+}
+export interface ChangedFile {
+    path: string;
+    reason: 'modified' | 'deleted' | 'new';
+}
+export interface SessionResult {
+    success: boolean;
+    isNewSession: boolean;
+    sessionInfo: SessionInfo;
+    externalChanges: ChangedFile[];
+    reindexed: string[];
+    note: string | null;
+    error?: string;
+}
+/**
+ * Start or continue a session.
+ * - If new session: detect external changes, store previous session times
+ * - Always: update session_end timestamp
+ */
+export declare function session(params: SessionParams): SessionResult;
+/**
+ * Update session heartbeat (call periodically during session)
+ */
+export declare function updateSessionHeartbeat(projectPath: string): void;
+/**
+ * Get session info without starting/updating
+ */
+export declare function getSessionInfo(projectPath: string): SessionInfo | null;
+/**
+ * Format session time for display
+ */
+export declare function formatSessionTime(timestamp: number | null): string;
+/**
+ * Format duration between two timestamps
+ */
+export declare function formatDuration(startMs: number, endMs: number): string;
+//# sourceMappingURL=session.d.ts.map