FindMyShitV2/electron-file-search/electron/ipc/handlers.ts

import { ipcMain } from 'electron';
import { DocumentMetadata, LLMConfig, ServiceError } from '../types';
const fs = require('fs');
const path = require('path');
const os = require('os');

interface IpcHandlerParams {
  _: unknown;
  dirPath?: string;
  path?: string;
  question?: string;
  config?: LLMConfig;
  content?: string;
  metadata?: DocumentMetadata;
}

export function setupIpcHandlers() {
  // File System Handlers
  ipcMain.handle('start-watching', async (_: unknown, dirPath: string) => {
    try {
      await (await import('../services/fileSystem')).fileSystemService.startWatching(dirPath);
      return { success: true };
    } catch (error) {
      const err = error as Error;
      console.error('Error starting watch:', err);
      return { success: false, error: err.message };
    }
  });

  ipcMain.handle('stop-watching', async (_: unknown, dirPath: string) => {
    try {
      await (await import('../services/fileSystem')).fileSystemService.stopWatching(dirPath);
      return { success: true };
    } catch (error) {
      const err = error as Error;
      console.error('Error stopping watch:', err);
      return { success: false, error: err.message };
    }
  });

  ipcMain.handle('add-excluded-path', async (_: unknown, path: string) => {
    try {
      (await import('../services/fileSystem')).fileSystemService.addExcludedPath(path);
      return { success: true };
    } catch (error) {
      const err = error as Error;
      console.error('Error adding excluded path:', err);
      return { success: false, error: err.message };
    }
  });

  // LLM Handlers
  ipcMain.handle('query-llm', async (event, question: string) => {
    try {
      const webContents = event.sender;
      const response = await (await import('../services/llmService')).llmService.query(
        question,
        (chunk: string) => {
          webContents.send('llm-response-chunk', chunk);
        }
      );
      return response;
    } catch (error) {
      const err = error as Error;
      console.error('Error querying LLM:', err);
      throw err;
    }
  });

  ipcMain.handle('update-llm-config', async (_: unknown, config: LLMConfig) => {
    try {
      await (await import('../services/llmService')).llmService.updateConfig(config);
      return { success: true };
    } catch (error) {
      const err = error as Error;
      console.error('Error updating LLM config:', err);
      return { success: false, error: err.message };
    }
  });

  ipcMain.handle('get-llm-config', async () => {
    try {
      const config = (await import('../services/llmService')).llmService.getConfig();
      return { success: true, data: config };
    } catch (error) {
      const err = error as Error;
      console.error('Error getting LLM config:', err);
      return { success: false, error: err.message };
    }
  });

  ipcMain.handle('get-ollama-models', async () => {
    try {
      const models = await (await import('../services/llmService')).llmService.getOllamaModels();
      return { success: true, data: models };
    } catch (error) {
      const err = error as Error;
      console.error('Error getting Ollama models:', err);
      return { success: false, error: err.message };
    }
  });

  ipcMain.handle('get-documents', async () => {
    try {
      const documents = (await import('../services/vectorStore')).vectorStoreService.getDocuments();
      return { success: true, data: documents };
    } catch (error) {
      const err = error as Error;
      console.error('Error getting documents:', err);
      return { success: false, error: err.message };
    }
  });

  // Vector Store Handlers
  ipcMain.handle('add-document', async (_: unknown, content: string, metadata: DocumentMetadata) => {
    try {
      await (await import('../services/vectorStore')).vectorStoreService.addDocument(content, metadata);
      return { success: true };
    } catch (error) {
      const err = error as Error;
      console.error('Error adding document:', err);
      return { success: false, error: err.message };
    }
  });

  ipcMain.handle('delete-document', async (_: unknown, path: string) => {
    try {
      await (await import('../services/vectorStore')).vectorStoreService.deleteDocument(path);
      return { success: true };
    } catch (error) {
      const err = error as Error;
      console.error('Error deleting document:', err);
      return { success: false, error: err.message };
    }
  });

  ipcMain.handle('update-document', async (_: unknown, content: string, metadata: DocumentMetadata) => {
    try {
      await (await import('../services/vectorStore')).vectorStoreService.updateDocument(content, metadata);
      return { success: true };
    } catch (error) {
      const err = error as Error;
      console.error('Error updating document:', err);
      return { success: false, error: err.message };
    }
  });

  ipcMain.handle('get-user-home', async () => {
    try {
      const homeDir = os.homedir();
      return { success: true, data: homeDir };
    } catch (error) {
      const err = error as Error;
      console.error('Error getting user home:', err);
      return { success: false, error: err.message };
    }
  });

  ipcMain.handle('list-directories', async (_: unknown, dirPath: string) => {
    try {
      const directories = await new Promise<Array<{name: string; path: string}>>((resolve, reject) => {
        fs.readdir(dirPath, { withFileTypes: true }, (err, items) => {
          if (err) {
            reject(err);
            return;
          }
          
          const folders = items
            .filter(item => item.isDirectory())
            .map(item => ({
              name: item.name,
              path: path.join(dirPath, item.name)
            }));
          resolve(folders);
        });
      });
  
      return { success: true, data: directories };
    } catch (error) {
      const err = error as Error;
      console.error('Error listing directories:', err);
      return { success: false, error: err.message };
    }
  });
}

export default setupIpcHandlers;