refactor: Relocate file search modules

src/core/file-search/match/coreplugin-match.ts

@@ -0,0 +1,91 @@
+import { App, TFile  } from "obsidian";
+import {
+    MAX_RESULTS,
+    truncateLine,
+    findLineDetails,
+    SearchResult,
+    formatResults,
+} from '../search-common';
+
+/**
+ * Searches using Obsidian's core search plugin and builds context for each match.
+ *
+ * @param app The Obsidian App instance.
+ * @param query The query to search for.
+ * @returns A promise that resolves to a formatted string of search results.
+ */
+export async function matchSearchUsingCorePlugin(
+    query: string,
+    app: App,
+): Promise<string> {
+    try {
+        const searchPlugin = (app as any).internalPlugins.plugins['global-search']?.instance;
+        if (!searchPlugin) {
+            throw new Error("Core search plugin is not available.");
+        }
+
+        // This function opens the search pane and executes the search.
+        // It does not return the results directly.
+        searchPlugin.openGlobalSearch(query);
+
+        const searchLeaf = app.workspace.getLeavesOfType('search')[0];
+        if (!searchLeaf) {
+            throw new Error("No active search pane found after triggering search.");
+        }
+
+        // Ensure the view is fully loaded before we try to access its properties.
+        const view = await searchLeaf.open(searchLeaf.view);
+        const searchResultsMap = await new Promise<Map<TFile, any>>(resolve => {
+            setTimeout(() => {
+                // @ts-ignore
+                const results = (view as any).dom?.resultDomLookup;
+                resolve(results || new Map());
+            }, 5000)
+        });
+
+        if (!searchResultsMap || searchResultsMap.size === 0) {
+			console.error("No results found or search results map is not available.");
+			return "No results found."
+        }
+
+        const results: SearchResult[] = [];
+        const vault = app.vault;
+
+        for (const [file, fileMatches] of searchResultsMap.entries()) {
+            if (results.length >= MAX_RESULTS) {
+                break;
+            }
+
+            const content = await vault.cachedRead(file as TFile);
+            const lines = content.split('\n');
+
+            // `fileMatches.result.content` holds an array of matches for the file.
+            // Each match is an array: [matched_text, start_offset]
+            for (const match of fileMatches.result.content) {
+                if (results.length >= MAX_RESULTS) break;
+                
+                const startOffset = match[1];
+                const { lineNumber, columnNumber, lineContent } = findLineDetails(lines, startOffset);
+
+                if (lineNumber === -1) continue;
+
+                results.push({
+                    file: file.path,
+                    line: lineNumber + 1, // ripgrep is 1-based, so we adjust
+                    column: columnNumber + 1,
+                    match: truncateLine(lineContent.trimEnd()),
+                    beforeContext: lineNumber > 0 ? [truncateLine(lines[lineNumber - 1].trimEnd())] : [],
+                    afterContext:
+                        lineNumber < lines.length - 1
+                            ? [truncateLine(lines[lineNumber + 1].trimEnd())]
+                            : [],
+                });
+            }
+        }
+
+        return formatResults(results, ".\\");
+    } catch (error) {
+		console.error("Error during core plugin processing:", error);
+		return "An error occurred during the search.";
+	}
+}

src/core/file-search/match/omnisearch-match.ts

@@ -0,0 +1,112 @@
+import { App } from "obsidian";
+import {
+	MAX_RESULTS,
+	truncateLine,
+	findLineDetails,
+	SearchResult,
+	formatResults,
+} from '../search-common';
+
+type SearchMatchApi = {
+	match: string;
+	offset: number;
+};
+
+type ResultNoteApi = {
+	score: number;
+	vault: string;
+	path: string;
+	basename: string;
+	foundWords: string[];
+	matches: SearchMatchApi[];
+	excerpt: string;
+};
+
+type OmnisearchApi = {
+	search: (query: string) => Promise<ResultNoteApi[]>;
+	// ... other API methods
+};
+
+declare global {
+	interface Window {
+		omnisearch: OmnisearchApi;
+	}
+}
+
+/**
+ * Checks if the Omnisearch plugin's API is available.
+ * @returns {boolean} True if the API is ready, false otherwise.
+ */
+function isOmnisearchAvailable(): boolean {
+	return window.omnisearch && typeof window.omnisearch.search === "function";
+}
+
+/**
+ * Searches using Omnisearch and builds context for each match.
+ * @param query The search query for Omnisearch. Note: Omnisearch does not support full regex.
+ * @param app The Obsidian App instance.
+ * @returns A formatted string of search results.
+ */
+export async function matchSearchUsingOmnisearch(
+	query: string,
+	app: App,
+): Promise<string> {
+	try {
+		if (!isOmnisearchAvailable()) {
+			throw new Error(
+				"Omnisearch plugin not found or not active. Please install and enable it to use this search feature."
+			);
+		}
+
+		// Omnisearch is not a regex engine.
+		// The `query` will be treated as a keyword/fuzzy search by the plugin.
+		const apiResults = await window.omnisearch.search(query);
+		if (!apiResults || apiResults.length === 0) {
+			console.error("No results found.");
+			return "No results found."
+		}
+
+		const results: SearchResult[] = [];
+
+		for (const result of apiResults) {
+			if (results.length >= MAX_RESULTS) {
+				break; // Stop processing new files if we have enough results
+			}
+			if (!result.matches || result.matches.length === 0) continue;
+
+			const fileContent = await app.vault.adapter.read(result.path);
+			const lines = fileContent.split("\n");
+
+			for (const match of result.matches) {
+				if (results.length >= MAX_RESULTS) {
+					break; // Stop processing matches if we have enough results
+				}
+
+				const { lineNumber, columnNumber, lineContent } = findLineDetails(
+					lines,
+					match.offset
+				);
+
+				if (lineNumber === -1) continue;
+
+				const searchResult: SearchResult = {
+					file: result.path,
+					line: lineNumber + 1, // ripgrep is 1-based, so we adjust
+					column: columnNumber + 1,
+					match: truncateLine(lineContent.trimEnd()),
+					beforeContext: lineNumber > 0 ? [truncateLine(lines[lineNumber - 1].trimEnd())] : [],
+					afterContext:
+						lineNumber < lines.length - 1
+							? [truncateLine(lines[lineNumber + 1].trimEnd())]
+							: [],
+				};
+				results.push(searchResult);
+			}
+		}
+
+		return formatResults(results, ".\\");
+	} catch (error) {
+		console.error("Error during Omnisearch processing:", error);
+		return "An error occurred during the search.";
+	}
+}

src/core/file-search/regex/coreplugin-regex.ts

@@ -0,0 +1,17 @@
+import { App } from "obsidian";
+import { matchSearchUsingCorePlugin } from '../match/coreplugin-match'
+
+/**
+ * Performs a regular expression search using Obsidian's core search plugin.
+ *
+ * @param app The Obsidian App instance.
+ * @param regex The regular expression to search for.
+ * @returns A promise that resolves to a formatted string of search results.
+ */
+export async function regexSearchUsingCorePlugin(
+    regex: string,
+    app: App,
+): Promise<string> {
+    const regexQuery = `/${regex}/`;
+    return matchSearchUsingCorePlugin(regexQuery, app);
+}

src/core/file-search/regex/ripgrep-regex.ts

@@ -0,0 +1,147 @@
+// import * as vscode from "vscode"
+import * as childProcess from "child_process"
+import * as fs from "fs"
+import * as path from "path"
+import * as readline from "readline"
+import {
+	MAX_RESULTS,
+	truncateLine,
+	SearchResult,
+	formatResults
+} from '../search-common'
+
+const isWindows = /^win/.test(process.platform)
+const binName = isWindows ? "rg.exe" : "rg"
+
+async function getBinPath(ripgrepPath: string): Promise<string | undefined> {
+	const binPath = path.join(ripgrepPath, binName)
+	return (await pathExists(binPath)) ? binPath : undefined
+}
+
+async function pathExists(path: string): Promise<boolean> {
+	return new Promise((resolve) => {
+		fs.access(path, (err) => {
+			resolve(err === null)
+		})
+	})
+}
+
+async function execRipgrep(bin: string, args: string[]): Promise<string> {
+	return new Promise((resolve, reject) => {
+		const rgProcess = childProcess.spawn(bin, args)
+		// cross-platform alternative to head, which is ripgrep author's recommendation for limiting output.
+		const rl = readline.createInterface({
+			input: rgProcess.stdout,
+			crlfDelay: Infinity, // treat \r\n as a single line break even if it's split across chunks. This ensures consistent behavior across different operating systems.
+		})
+
+		let output = ""
+		let lineCount = 0
+		const maxLines = MAX_RESULTS * 5 // limiting ripgrep output with max lines since there's no other way to limit results. it's okay that we're outputting as json, since we're parsing it line by line and ignore anything that's not part of a match. This assumes each result is at most 5 lines.
+
+		rl.on("line", (line) => {
+			if (lineCount < maxLines) {
+				output += line + "\n"
+				lineCount++
+			} else {
+				rl.close()
+				rgProcess.kill()
+			}
+		})
+
+		let errorOutput = ""
+		rgProcess.stderr.on("data", (data) => {
+			errorOutput += data.toString()
+		})
+		rl.on("close", () => {
+			if (errorOutput) {
+				reject(new Error(`ripgrep process error: ${errorOutput}`))
+			} else {
+				resolve(output)
+			}
+		})
+		rgProcess.on("error", (error) => {
+			reject(new Error(`ripgrep process error: ${error.message}`))
+		})
+	})
+}
+
+export async function regexSearchUsingRipgrep(
+	directoryPath: string,
+	regex: string,
+	ripgrepPath: string,
+): Promise<string> {
+	const rgPath = await getBinPath(ripgrepPath)
+
+	if (!rgPath) {
+		throw new Error("Could not find ripgrep binary")
+	}
+
+	// use --glob param to exclude .obsidian directory
+	const args = [
+		"--json", 
+		"-e", 
+		regex, 
+		"--glob", 
+		"!.obsidian/**", // exclude .obsidian directory and all its subdirectories
+		"--glob",
+		"!.git/**",
+		"--context", 
+		"1", 
+		directoryPath
+	]
+
+	let output: string
+	try {
+		output = await execRipgrep(rgPath, args)
+	} catch (error) {
+		console.error("Error executing ripgrep:", error)
+		return "No results found."
+	}
+	const results: SearchResult[] = []
+	let currentResult: Partial<SearchResult> | null = null
+
+	output.split("\n").forEach((line) => {
+		if (line) {
+			try {
+				const parsed = JSON.parse(line)
+				if (parsed.type === "match") {
+					if (currentResult) {
+						results.push(currentResult as SearchResult)
+					}
+
+					// Safety check: truncate extremely long lines to prevent excessive output
+					const matchText = parsed.data.lines.text
+					const truncatedMatch = truncateLine(matchText)
+
+					currentResult = {
+						file: parsed.data.path.text,
+						line: parsed.data.line_number,
+						column: parsed.data.submatches[0].start,
+						match: truncatedMatch,
+						beforeContext: [],
+						afterContext: [],
+					}
+				} else if (parsed.type === "context" && currentResult) {
+					// Apply the same truncation logic to context lines
+					const contextText = parsed.data.lines.text
+					const truncatedContext = truncateLine(contextText)
+
+					if (parsed.data.line_number < currentResult.line!) {
+						currentResult.beforeContext!.push(truncatedContext)
+					} else {
+						currentResult.afterContext!.push(truncatedContext)
+					}
+				}
+			} catch (error) {
+				console.error("Error parsing ripgrep output:", error)
+			}
+		}
+	})
+
+	if (currentResult) {
+		results.push(currentResult as SearchResult)
+	}
+	
+	return formatResults(results, directoryPath)
+}

src/core/file-search/search-common.ts

@@ -0,0 +1,89 @@
+import * as path from "path"
+
+// Constants
+export const MAX_RESULTS = 300
+export const MAX_LINE_LENGTH = 500
+
+/**
+ * Truncates a line if it exceeds the maximum length
+ * @param line The line to truncate
+ * @param maxLength The maximum allowed length (defaults to MAX_LINE_LENGTH)
+ * @returns The truncated line, or the original line if it's shorter than maxLength
+ */
+export function truncateLine(line: string, maxLength: number = MAX_LINE_LENGTH): string {
+	return line.length > maxLength ? line.substring(0, maxLength) + " [truncated...]" : line
+}
+
+/**
+ * Finds the line number and content for a given character offset within a file's content.
+ * @param lines All lines in the file.
+ * @param offset The character offset of the match.
+ * @returns An object with line number, column number, and the full line content.
+ */
+export function findLineDetails(
+	lines: string[],
+	offset: number
+): { lineNumber: number; columnNumber: number; lineContent: string } {
+	let charCount = 0;
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		// The line ending length (1 for \n, 2 for \r\n) can vary.
+		// A simple +1 is a reasonable approximation for this calculation.
+		const lineEndOffset = charCount + line.length + 1; 
+
+		if (offset < lineEndOffset) {
+			const columnNumber = offset - charCount;
+			return { lineNumber: i, columnNumber, lineContent: line };
+		}
+		charCount = lineEndOffset;
+	}
+	return { lineNumber: -1, columnNumber: -1, lineContent: "" };
+}
+
+export interface SearchResult {
+	file: string
+	line: number
+	column?: number
+	match?: string
+	beforeContext: string[]
+	afterContext: string[]
+}
+
+export function formatResults(results: SearchResult[], cwd: string): string {
+	const groupedResults: { [key: string]: SearchResult[] } = {}
+
+	let output = ""
+	if (results.length >= MAX_RESULTS) {
+		output += `Showing first ${MAX_RESULTS} of ${MAX_RESULTS}+ results. Use a more specific search if necessary.\n\n`
+	} else {
+		output += `Found ${results.length === 1 ? "1 result" : `${results.length.toLocaleString()} results`}.\n\n`
+	}
+
+	// Group results by file name
+	results.slice(0, MAX_RESULTS).forEach((result) => {
+		const relativeFilePath = path.relative(cwd, result.file)
+		if (!groupedResults[relativeFilePath]) {
+			groupedResults[relativeFilePath] = []
+		}
+		groupedResults[relativeFilePath].push(result)
+	})
+
+	for (const [filePath, fileResults] of Object.entries(groupedResults)) {
+		output += `${filePath.toPosix()}\n│----\n`
+
+		fileResults.forEach((result, index) => {
+			const allLines = [...result.beforeContext, result.match, ...result.afterContext]
+			allLines.forEach((line) => {
+				output += `│${line?.trimEnd() ?? ""}\n`
+			})
+
+			if (index < fileResults.length - 1) {
+				output += "│----\n"
+			}
+		})
+
+		output += "│----\n\n"
+	}
+
+	return output.trim()
+}