@ngao/search 0.1.0 → 0.1.2

package/src/backend/services/ngao-search-service.ts

@@ -0,0 +1,430 @@
+/**
+ * Core NGAO Search Service
+ * Centralizes all business logic for search operations
+ * This service is used by both REST API and MCP transports
+ */
+
+import {
+  SearchEngine,
+  LanceBlockRepository,
+  LanceMetadataRepository,
+  IndexInformationService,
+  type SearchResult,
+  type IndexStats,
+  type Block,
+  type SearchOptions,
+  type IndexOptions,
+  type IBlockRepository,
+  type IMetadataRepository,
+} from '@ngao/search-core';
+import { SessionManager } from './session-manager';
+import { ReindexManager } from './reindex-manager';
+import { FileWatcher } from './file-watcher';
+import * as ServiceTypes from '../service-types';
+import * as path from 'path';
+import * as fs from 'fs';
+
+/**
+ * NgaoSearchService is the central business logic facade
+ * All transport layers (REST, MCP) delegate to this service
+ *
+ * Uses SearchEngine from @ngao/search-core
+ */
+export class NgaoSearchService {
+  private _searchEngine: SearchEngine;
+  private _sessionManager: SessionManager;
+  private _reindexManager: ReindexManager;
+  private _indexInformationService: IndexInformationService;
+
+  // Store project configuration
+  private _projectDir: string;
+  private _includePaths: string[];
+  private _excludePaths: string[];
+
+  /**
+   * Initialize service with SearchEngine from core
+   * Loads configuration from project directory
+   *
+   * @param projectDir Optional project directory to load .ngao-search.json from (default: current directory)
+   */
+  constructor(projectDir?: string) {
+    const resolvedProjectDir = projectDir || process.env.NGAO_SEARCH_PROJECT || process.cwd();
+    this._projectDir = resolvedProjectDir;
+
+    // Load configuration from project
+    const configPath = path.join(resolvedProjectDir, '.ngao-search.json');
+    const defaultConfig = { projectId: '', databasePath: '', includePaths: [], excludePaths: [] };
+    let config = defaultConfig;
+
+    if (fs.existsSync(configPath)) {
+      try {
+        const configContent = fs.readFileSync(configPath, 'utf-8');
+        const parsed = JSON.parse(configContent);
+        config = { ...defaultConfig, ...parsed };
+      } catch (error) {
+        console.warn(`Failed to load config from ${configPath}, using defaults`);
+      }
+    }
+
+    // Load include/exclude paths with sensible defaults
+    this._includePaths = config.includePaths && config.includePaths.length > 0
+      ? config.includePaths
+      : ['**/*.ts', '**/*.tsx', '**/*.js', '**/*.jsx', '**/*.py', '**/*.md'];
+    this._excludePaths = config.excludePaths && config.excludePaths.length > 0
+      ? config.excludePaths
+      : ['node_modules/**', 'dist/**', '.git/**'];
+
+    // Initialize repositories for SearchEngine
+    const dataDir = config.databasePath || path.join(resolvedProjectDir, '.ngao');
+    const projectId = config.projectId || '';
+
+    const blockRepository: IBlockRepository = new LanceBlockRepository(dataDir, projectId);
+    const metadataRepository: IMetadataRepository = new LanceMetadataRepository(dataDir, projectId);
+
+    // Initialize search engine with repositories
+    this._searchEngine = new SearchEngine(
+      blockRepository,
+      metadataRepository,
+      undefined,
+      { enableVectorSearch: true }
+    );
+
+    // Initialize index information service - will be set after SearchEngine is created
+    // (done below after _searchEngine is assigned)
+
+    // Initialize services
+    this._sessionManager = new SessionManager();
+    this._reindexManager = new ReindexManager(this._searchEngine);
+
+    // Now initialize index information service with metadataRepository and SearchEngine
+    this._indexInformationService = new IndexInformationService(metadataRepository, this._searchEngine);
+  }
+
+  /**
+   * Eagerly initialize database components (but not embedding model)
+   * Call this during setup or startup to pre-initialize storage
+   * The embedding model will lazy-load on first search (requires network)
+   *
+   * @throws Error if database initialization fails
+   */
+  async ensureInitialized(): Promise<void> {
+    // Core engine handles initialization internally
+    // This method is kept for compatibility
+    return Promise.resolve();
+  }
+
+  /**
+   * Get the project directory
+   */
+  getProjectDir(): string {
+    return this._projectDir;
+  }
+
+  /**
+   * Get the include paths patterns
+   */
+  getIncludePaths(): string[] {
+    return this._includePaths;
+  }
+
+  /**
+   * Get the exclude paths patterns
+   */
+  getExcludePaths(): string[] {
+    return this._excludePaths;
+  }
+
+  /**
+   * Perform a search operation
+   */
+  async search(
+    params: ServiceTypes.SearchParams
+  ): Promise<ServiceTypes.SearchOperationResult> {
+    try {
+      const options: SearchOptions | undefined = params.maxResults ? { maxResults: params.maxResults } : undefined;
+
+      const startTime = Date.now();
+      const results = await this._searchEngine.search(params.query, options);
+      const executionTime = Date.now() - startTime;
+
+      // Track search in session history if sessionId provided
+      if (params.sessionId) {
+        this._sessionManager.addSearchToHistory(params.sessionId, {
+          id: crypto.randomUUID ? crypto.randomUUID() : Math.random().toString(),
+          query: params.query,
+          timestamp: Date.now(),
+          resultCount: results.length,
+          executionTimeMs: executionTime,
+        });
+      }
+
+      return {
+        success: true,
+        resultCount: results.length,
+        executionTimeMs: executionTime,
+        results: results.map((r) => ({
+          rank: r.rank,
+          score: r.relevanceScore,
+          type: r.block.itemType,
+          name: r.block.name,
+          file: r.block.filePath,
+          lineRange: `${r.block.location.startLine}:${r.block.location.endLine}`,
+          scope: r.block.scopeHierarchy.join('.'),
+          content: r.block.content.substring(0, 200),
+        })),
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: String(error),
+      };
+    }
+  }
+
+  /**
+   * Index a directory
+   */
+  async index(
+    params: ServiceTypes.IndexParams
+  ): Promise<ServiceTypes.IndexOperationResult> {
+    try {
+      const options: Partial<IndexOptions & { includePaths?: string[]; excludePaths?: string[] }> = {
+        includePaths: this._includePaths,
+        excludePaths: this._excludePaths,
+      };
+
+      const stats = await this._searchEngine.indexDirectory(params.dirPath, options as IndexOptions & { includePaths?: string[]; excludePaths?: string[] });
+
+      return {
+        success: true,
+        message: `Successfully indexed directory: ${params.dirPath}`,
+        stats: {
+          totalFiles: stats.totalFiles,
+          totalBlocks: stats.totalBlocks,
+          lastUpdated: new Date(stats.lastUpdatedAt).toISOString(),
+        },
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: String(error),
+      };
+    }
+  }
+
+  /**
+   * Auto-index the current project directory during setup
+   * Used by the setup process to initialize the index
+   * Respects the includePaths and excludePaths from project configuration
+   *
+   * @param projectDir The project directory to index
+   * @throws Error if indexing fails critically (non-fatal errors are logged and continue)
+   */
+  async autoIndexProjectDirectory(projectDir: string): Promise<{ success: boolean; message: string; stats?: { totalFiles: number; totalBlocks: number; lastUpdated: string }; error?: string }> {
+    try {
+      const options: Partial<IndexOptions & { includePaths?: string[]; excludePaths?: string[] }> = {
+        includePaths: this._includePaths,
+        excludePaths: this._excludePaths,
+      };
+
+      const stats = await this._searchEngine.indexDirectory(projectDir, options as IndexOptions & { includePaths?: string[]; excludePaths?: string[] });
+
+      return {
+        success: true,
+        message: `Successfully indexed project directory: ${projectDir}`,
+        stats: {
+          totalFiles: stats.totalFiles,
+          totalBlocks: stats.totalBlocks,
+          lastUpdated: new Date(stats.lastUpdatedAt).toISOString(),
+        },
+      };
+    } catch (error) {
+      // Return error but don't throw - setup should continue even if indexing fails
+      return {
+        success: false,
+        message: `Indexing may have encountered issues: ${String(error)}`,
+        error: String(error),
+      };
+    }
+  }
+
+  /**
+   * Get global indexing statistics
+   */
+  async getStats(): Promise<ServiceTypes.StatsOperationResult> {
+    try {
+      const stats = await this._searchEngine.getStats();
+
+      return {
+        success: true,
+        stats: {
+          totalFiles: stats.totalFiles,
+          totalBlocks: stats.totalBlocks,
+          indexedFiles: stats.indexedFiles,
+          lastUpdated: new Date(stats.lastUpdatedAt).toISOString(),
+        },
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: String(error),
+      };
+    }
+  }
+
+  /**
+   * Get detailed index information
+   */
+  async getIndexInfo(): Promise<ServiceTypes.IndexInfoOperationResult> {
+    try {
+      const info = await this._indexInformationService.getDetailedIndexInfo();
+
+      return {
+        success: true,
+        data: info,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: String(error),
+      };
+    }
+  }
+
+  /**
+   * Get file statistics
+   */
+  async getFileStatistics(
+    params: ServiceTypes.FileStatisticsParams
+  ): Promise<ServiceTypes.FileStatisticsOperationResult> {
+    try {
+      const stats = await this._indexInformationService.getFileStatistics(
+        params.filePath
+      );
+
+      return {
+        success: true,
+        data: stats,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: String(error),
+      };
+    }
+  }
+
+  /**
+   * Get search history for a session
+   */
+  getSearchHistory(
+    params: ServiceTypes.SearchHistoryParams
+  ): ServiceTypes.SearchHistoryOperationResult {
+    try {
+      const history = this._sessionManager.getSearchHistory(params.sessionId);
+
+      if (!history) {
+        return {
+          success: false,
+          error: `Session not found: ${params.sessionId}`,
+        };
+      }
+
+      return {
+        success: true,
+        data: history,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: String(error),
+      };
+    }
+  }
+
+  /**
+   * Start a reindex operation
+   */
+  async startReindex(
+    params: ServiceTypes.StartReindexParams
+  ): Promise<ServiceTypes.StartReindexOperationResult> {
+    try {
+      // startReindex only takes dirPath as string, not an object
+      const stats = await this._reindexManager.startReindex(params.dirPath);
+
+      // Generate a simple reindexId
+      const reindexId = `reindex-${Date.now()}`;
+
+      return {
+        success: true,
+        data: {
+          reindexId,
+          dirPath: params.dirPath,
+          mode: params.mode || 'incremental',
+        },
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: String(error),
+      };
+    }
+  }
+
+  /**
+   * Get reindex operation status
+   */
+  getReindexStatus(
+    params: ServiceTypes.GetReindexStatusParams
+  ): ServiceTypes.GetReindexStatusOperationResult {
+    try {
+      // Get basic progress information
+      const progress = this._reindexManager.getProgress();
+
+      return {
+        success: true,
+        data: {
+          reindexId: params.reindexId,
+          status: this._reindexManager.isReindexingNow() ? 'in_progress' : 'completed',
+          filesProcessed: progress.filesProcessed,
+          totalFiles: progress.totalFiles,
+        },
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: String(error),
+      };
+    }
+  }
+
+  /**
+   * List all indexed directories
+   */
+  async listIndexedDirs(): Promise<ServiceTypes.ListIndexedDirsOperationResult> {
+    try {
+      // TODO: Implement proper directory listing
+      // For now, return the project directory
+      const dirs = [this._projectDir];
+
+      return {
+        success: true,
+        data: dirs,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: String(error),
+      };
+    }
+  }
+
+  /**
+   * Create a new session
+   */
+  createSession(): ServiceTypes.CreateSessionResponse {
+    return {
+      sessionId: this._sessionManager.createSession(),
+    };
+  }
+}

package/src/backend/services/reindex-manager.ts

@@ -0,0 +1,90 @@
+import { SearchEngine, type IndexStats } from '@ngao/search-core';
+import { EventEmitter } from 'events';
+
+export interface ReindexEvent {
+  status: 'started' | 'in_progress' | 'completed' | 'error'
+  filesProcessed: number
+  totalFiles: number
+  currentFile?: string
+  error?: Error
+}
+
+export class ReindexManager extends EventEmitter {
+  private isReindexing = false
+  private filesProcessed = 0
+  private totalFiles = 0
+
+  constructor(private searchEngine: SearchEngine) {
+    super()
+  }
+
+  async startReindex(dirPath: string): Promise<IndexStats> {
+    if (this.isReindexing) {
+      throw new Error('Reindexing already in progress')
+    }
+
+    this.isReindexing = true
+    this.filesProcessed = 0
+    this.totalFiles = 0
+
+    try {
+      this.emit('reindex', {
+        status: 'started',
+        filesProcessed: 0,
+        totalFiles: 0,
+      } as ReindexEvent)
+
+      const stats = await this.searchEngine.indexDirectory(dirPath)
+      
+      this.filesProcessed = stats.totalFiles
+      this.totalFiles = stats.totalFiles
+
+      this.emit('reindex', {
+        status: 'completed',
+        filesProcessed: this.filesProcessed,
+        totalFiles: this.totalFiles,
+      } as ReindexEvent)
+
+      return stats
+    } catch (error) {
+      this.emit('reindex', {
+        status: 'error',
+        filesProcessed: this.filesProcessed,
+        totalFiles: this.totalFiles,
+        error: error instanceof Error ? error : new Error(String(error)),
+      } as ReindexEvent)
+      throw error
+    } finally {
+      this.isReindexing = false
+    }
+  }
+
+  async reindexFile(filePath: string): Promise<void> {
+    try {
+      // TODO: @ngao/search-core doesn't have reindexFile method
+      // await this.searchEngine.reindexFile(filePath)
+      // For now, reindex the parent directory
+      const path = require('path');
+      const dirPath = path.dirname(filePath);
+      await this.searchEngine.indexDirectory(dirPath);
+      this.emit('file-reindexed', { filePath })
+    } catch (error) {
+      this.emit('file-reindex-error', { 
+        filePath, 
+        error: error instanceof Error ? error : new Error(String(error))
+      })
+      throw error
+    }
+  }
+
+  isReindexingNow(): boolean {
+    return this.isReindexing
+  }
+
+  getProgress(): { filesProcessed: number; totalFiles: number } {
+    return {
+      filesProcessed: this.filesProcessed,
+      totalFiles: this.totalFiles,
+    }
+  }
+}