aidex-mcp 1.4.1

package/build/commands/session.js

@@ -0,0 +1,216 @@
+/**
+ * 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
+ */
+import { existsSync, readFileSync } from 'fs';
+import { join, resolve } from 'path';
+import { createHash } from 'crypto';
+import { PRODUCT_NAME, INDEX_DIR, TOOL_PREFIX } from '../constants.js';
+import { openDatabase, createQueries } from '../db/index.js';
+import { update } from './update.js';
+// ============================================================
+// Constants
+// ============================================================
+const KEY_LAST_SESSION_START = 'last_session_start';
+const KEY_LAST_SESSION_END = 'last_session_end';
+const KEY_CURRENT_SESSION_START = 'current_session_start';
+const KEY_SESSION_NOTE = 'session_note';
+// Session is considered "new" if more than 5 minutes have passed since last activity
+const SESSION_TIMEOUT_MS = 5 * 60 * 1000;
+// ============================================================
+// Implementation
+// ============================================================
+/**
+ * Start or continue a session.
+ * - If new session: detect external changes, store previous session times
+ * - Always: update session_end timestamp
+ */
+export function session(params) {
+    const { path: projectPath } = params;
+    // Validate project path
+    const dbPath = join(projectPath, INDEX_DIR, 'index.db');
+    if (!existsSync(dbPath)) {
+        return {
+            success: false,
+            isNewSession: false,
+            sessionInfo: { lastSessionStart: null, lastSessionEnd: null, currentSessionStart: null },
+            externalChanges: [],
+            reindexed: [],
+            note: null,
+            error: `No ${PRODUCT_NAME} index found at ${projectPath}. Run ${TOOL_PREFIX}init first.`,
+        };
+    }
+    const db = openDatabase(dbPath, false);
+    const queries = createQueries(db);
+    const now = Date.now();
+    try {
+        // Get current session info
+        const currentStart = db.getMetadata(KEY_CURRENT_SESSION_START);
+        const lastEnd = db.getMetadata(KEY_LAST_SESSION_END);
+        // Determine if this is a new session
+        const lastActivity = lastEnd ? parseInt(lastEnd, 10) : (currentStart ? parseInt(currentStart, 10) : 0);
+        const isNewSession = !currentStart || (now - lastActivity > SESSION_TIMEOUT_MS);
+        let sessionInfo;
+        let externalChanges = [];
+        let reindexed = [];
+        if (isNewSession) {
+            // Archive previous session times
+            if (currentStart) {
+                db.setMetadata(KEY_LAST_SESSION_START, currentStart);
+            }
+            if (lastEnd) {
+                // Use the last recorded end time as last_session_end
+            }
+            else if (currentStart) {
+                db.setMetadata(KEY_LAST_SESSION_END, currentStart);
+            }
+            // Start new session
+            db.setMetadata(KEY_CURRENT_SESSION_START, now.toString());
+            // Detect external changes
+            externalChanges = detectExternalChanges(projectPath, queries);
+            // Auto-reindex modified files
+            for (const change of externalChanges) {
+                if (change.reason === 'modified') {
+                    const result = update({ path: projectPath, file: change.path });
+                    if (result.success) {
+                        reindexed.push(change.path);
+                    }
+                }
+            }
+            sessionInfo = {
+                lastSessionStart: currentStart ? parseInt(currentStart, 10) : null,
+                lastSessionEnd: lastEnd ? parseInt(lastEnd, 10) : null,
+                currentSessionStart: now,
+            };
+        }
+        else {
+            // Continue existing session
+            sessionInfo = {
+                lastSessionStart: db.getMetadata(KEY_LAST_SESSION_START) ? parseInt(db.getMetadata(KEY_LAST_SESSION_START), 10) : null,
+                lastSessionEnd: db.getMetadata(KEY_LAST_SESSION_END) ? parseInt(db.getMetadata(KEY_LAST_SESSION_END), 10) : null,
+                currentSessionStart: parseInt(currentStart, 10),
+            };
+        }
+        // Always update session end time (heartbeat)
+        db.setMetadata(KEY_LAST_SESSION_END, now.toString());
+        // Get session note
+        const note = db.getMetadata(KEY_SESSION_NOTE);
+        db.close();
+        return {
+            success: true,
+            isNewSession,
+            sessionInfo,
+            externalChanges,
+            reindexed,
+            note,
+        };
+    }
+    catch (error) {
+        db.close();
+        return {
+            success: false,
+            isNewSession: false,
+            sessionInfo: { lastSessionStart: null, lastSessionEnd: null, currentSessionStart: null },
+            externalChanges: [],
+            reindexed: [],
+            note: null,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Update session heartbeat (call periodically during session)
+ */
+export function updateSessionHeartbeat(projectPath) {
+    const dbPath = join(projectPath, INDEX_DIR, 'index.db');
+    if (!existsSync(dbPath)) {
+        return;
+    }
+    try {
+        const db = openDatabase(dbPath, false);
+        db.setMetadata(KEY_LAST_SESSION_END, Date.now().toString());
+        db.close();
+    }
+    catch {
+        // Silently ignore errors
+    }
+}
+/**
+ * Get session info without starting/updating
+ */
+export function getSessionInfo(projectPath) {
+    const dbPath = join(projectPath, INDEX_DIR, 'index.db');
+    if (!existsSync(dbPath)) {
+        return null;
+    }
+    try {
+        const db = openDatabase(dbPath, true);
+        const info = {
+            lastSessionStart: db.getMetadata(KEY_LAST_SESSION_START) ? parseInt(db.getMetadata(KEY_LAST_SESSION_START), 10) : null,
+            lastSessionEnd: db.getMetadata(KEY_LAST_SESSION_END) ? parseInt(db.getMetadata(KEY_LAST_SESSION_END), 10) : null,
+            currentSessionStart: db.getMetadata(KEY_CURRENT_SESSION_START) ? parseInt(db.getMetadata(KEY_CURRENT_SESSION_START), 10) : null,
+        };
+        db.close();
+        return info;
+    }
+    catch {
+        return null;
+    }
+}
+// ============================================================
+// Helper functions
+// ============================================================
+/**
+ * Detect files that were changed outside of the session
+ */
+function detectExternalChanges(projectPath, queries) {
+    const changes = [];
+    const projectRoot = resolve(projectPath);
+    // Get all indexed files
+    const indexedFiles = queries.getAllFiles();
+    for (const file of indexedFiles) {
+        const fullPath = join(projectRoot, file.path);
+        if (!existsSync(fullPath)) {
+            // File was deleted
+            changes.push({ path: file.path, reason: 'deleted' });
+            continue;
+        }
+        // Check if file hash changed
+        try {
+            const content = readFileSync(fullPath);
+            const currentHash = createHash('sha256').update(content).digest('hex');
+            if (currentHash !== file.hash) {
+                changes.push({ path: file.path, reason: 'modified' });
+            }
+        }
+        catch {
+            // Can't read file - skip
+        }
+    }
+    return changes;
+}
+/**
+ * Format session time for display
+ */
+export function formatSessionTime(timestamp) {
+    if (!timestamp)
+        return 'N/A';
+    return new Date(timestamp).toISOString();
+}
+/**
+ * Format duration between two timestamps
+ */
+export function formatDuration(startMs, endMs) {
+    const durationMs = endMs - startMs;
+    const minutes = Math.floor(durationMs / 60000);
+    const hours = Math.floor(minutes / 60);
+    if (hours > 0) {
+        return `${hours}h ${minutes % 60}m`;
+    }
+    return `${minutes}m`;
+}
+//# sourceMappingURL=session.js.map

package/build/commands/signature.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Signature commands for AiDex
+ * Retrieves file signatures (header comments, types, methods)
+ */
+export interface SignatureParams {
+    /** Project path (containing index dir) */
+    path: string;
+    /** Relative file path within the project */
+    file: string;
+}
+export interface SignatureResult {
+    success: boolean;
+    file: string;
+    headerComments: string | null;
+    types: Array<{
+        name: string;
+        kind: string;
+        lineNumber: number;
+    }>;
+    methods: Array<{
+        name: string;
+        prototype: string;
+        lineNumber: number;
+        visibility: string | null;
+        isStatic: boolean;
+        isAsync: boolean;
+    }>;
+    error?: string;
+}
+export interface SignaturesParams {
+    /** Project path (containing index dir) */
+    path: string;
+    /** Glob pattern to match files (e.g., "src/Core/**.cs") */
+    pattern?: string;
+    /** Explicit list of relative file paths */
+    files?: string[];
+}
+export interface SignaturesResult {
+    success: boolean;
+    signatures: SignatureResult[];
+    totalFiles: number;
+    error?: string;
+}
+/**
+ * Get signature for a single file
+ */
+export declare function signature(params: SignatureParams): SignatureResult;
+/**
+ * Get signatures for multiple files
+ */
+export declare function signatures(params: SignaturesParams): SignaturesResult;
+//# sourceMappingURL=signature.d.ts.map

package/build/commands/signature.js

@@ -0,0 +1,171 @@
+/**
+ * Signature commands for AiDex
+ * Retrieves file signatures (header comments, types, methods)
+ */
+import { join } from 'path';
+import { existsSync } from 'fs';
+import { PRODUCT_NAME, INDEX_DIR, TOOL_PREFIX } from '../constants.js';
+import { openDatabase } from '../db/index.js';
+import { createQueries } from '../db/queries.js';
+// ============================================================
+// Implementation
+// ============================================================
+/**
+ * Get signature for a single file
+ */
+export function signature(params) {
+    const { path: projectPath } = params;
+    // Normalize path to forward slashes
+    const file = 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,
+            headerComments: null,
+            types: [],
+            methods: [],
+            error: `No ${PRODUCT_NAME} index found at ${projectPath}. Run ${TOOL_PREFIX}init first.`,
+        };
+    }
+    // Open database
+    const db = openDatabase(dbPath, true); // readonly
+    const queries = createQueries(db);
+    try {
+        // Find file in database
+        const fileRow = queries.getFileByPath(file);
+        if (!fileRow) {
+            db.close();
+            return {
+                success: false,
+                file,
+                headerComments: null,
+                types: [],
+                methods: [],
+                error: `File "${file}" not found in index. It may not be indexed or the path is incorrect.`,
+            };
+        }
+        // Get signature data
+        const signatureRow = queries.getSignatureByFile(fileRow.id);
+        const methodRows = queries.getMethodsByFile(fileRow.id);
+        const typeRows = queries.getTypesByFile(fileRow.id);
+        db.close();
+        return {
+            success: true,
+            file: fileRow.path,
+            headerComments: signatureRow?.header_comments ?? null,
+            types: typeRows.map(t => ({
+                name: t.name,
+                kind: t.kind,
+                lineNumber: t.line_number,
+            })),
+            methods: methodRows.map(m => ({
+                name: m.name,
+                prototype: m.prototype,
+                lineNumber: m.line_number,
+                visibility: m.visibility,
+                isStatic: m.is_static === 1,
+                isAsync: m.is_async === 1,
+            })),
+        };
+    }
+    catch (error) {
+        db.close();
+        return {
+            success: false,
+            file,
+            headerComments: null,
+            types: [],
+            methods: [],
+            error: `Error retrieving signature: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+/**
+ * Get signatures for multiple files
+ */
+export function signatures(params) {
+    const { path: projectPath, pattern, files } = params;
+    // Validate project path
+    const indexDir = join(projectPath, INDEX_DIR);
+    const dbPath = join(indexDir, 'index.db');
+    if (!existsSync(dbPath)) {
+        return {
+            success: false,
+            signatures: [],
+            totalFiles: 0,
+            error: `No ${PRODUCT_NAME} index found at ${projectPath}. Run ${TOOL_PREFIX}init first.`,
+        };
+    }
+    // Determine which files to query
+    let filesToQuery = [];
+    if (files && files.length > 0) {
+        // Use explicit file list (paths as-is, signature() handles normalization)
+        filesToQuery = files;
+    }
+    else if (pattern) {
+        // Use glob pattern against indexed files
+        const db = openDatabase(dbPath, true);
+        const queries = createQueries(db);
+        const allFiles = queries.getAllFiles();
+        db.close();
+        // Convert glob pattern to regex (normalize pattern to forward slashes)
+        const normalizedPattern = pattern.replace(/\\/g, '/');
+        const regex = globToRegex(normalizedPattern);
+        // Test against both original path and forward-slash normalized version
+        filesToQuery = allFiles
+            .map(f => f.path)
+            .filter(p => {
+            const normalizedPath = p.replace(/\\/g, '/');
+            return regex.test(normalizedPath);
+        });
+    }
+    else {
+        return {
+            success: false,
+            signatures: [],
+            totalFiles: 0,
+            error: 'Either pattern or files parameter is required.',
+        };
+    }
+    // Get signatures for all matched files
+    const results = [];
+    for (const file of filesToQuery) {
+        const result = signature({ path: projectPath, file });
+        results.push(result);
+    }
+    return {
+        success: true,
+        signatures: results,
+        totalFiles: results.length,
+    };
+}
+/**
+ * Convert a glob pattern to a regular expression
+ * Supports: *, **, ?
+ */
+function globToRegex(pattern) {
+    // Normalize to forward slashes
+    pattern = pattern.replace(/\\/g, '/');
+    // Escape regex special chars except * and ?
+    let regex = pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+    // Convert glob patterns to regex:
+    // ** matches any path (including /)
+    // * matches any characters except /
+    // ? matches any single character except /
+    // Handle ** first (must match across directories)
+    // **/ at start or middle means "any path prefix"
+    regex = regex.replace(/\*\*\//g, '(.*/)?');
+    // /** at end means "any path suffix"
+    regex = regex.replace(/\/\*\*/g, '(/.*)?');
+    // Standalone ** (rare)
+    regex = regex.replace(/\*\*/g, '.*');
+    // Handle single * (matches within directory)
+    regex = regex.replace(/\*/g, '[^/]*');
+    // Handle ? (single character)
+    regex = regex.replace(/\?/g, '[^/]');
+    return new RegExp(`^${regex}$`, 'i');
+}
+//# sourceMappingURL=signature.js.map

package/build/commands/summary.d.ts

@@ -0,0 +1,56 @@
+/**
+ * summary and tree commands
+ *
+ * - summary: Get project summary with auto-detected info
+ * - tree: Get indexed file tree with optional stats
+ */
+export interface SummaryParams {
+    path: string;
+}
+export interface SummaryResult {
+    success: boolean;
+    name: string;
+    content: string;
+    autoGenerated: {
+        entryPoints: string[];
+        mainTypes: string[];
+        fileCount: number;
+        languages: string[];
+    };
+    error?: string;
+}
+export interface TreeParams {
+    path: string;
+    subpath?: string;
+    depth?: number;
+    includeStats?: boolean;
+}
+export interface TreeEntry {
+    path: string;
+    type: 'file' | 'directory';
+    itemCount?: number;
+    methodCount?: number;
+    typeCount?: number;
+}
+export interface TreeResult {
+    success: boolean;
+    root: string;
+    entries: TreeEntry[];
+    totalFiles: number;
+    error?: string;
+}
+export declare function summary(params: SummaryParams): SummaryResult;
+export declare function tree(params: TreeParams): TreeResult;
+export interface DescribeParams {
+    path: string;
+    section: 'purpose' | 'architecture' | 'concepts' | 'patterns' | 'notes';
+    content: string;
+    replace?: boolean;
+}
+export interface DescribeResult {
+    success: boolean;
+    section: string;
+    error?: string;
+}
+export declare function describe(params: DescribeParams): DescribeResult;
+//# sourceMappingURL=summary.d.ts.map