@mseep/obsidian-agent-client 0.10.6

package/src/utils/mention-parser.ts

@@ -0,0 +1,129 @@
+import { TFile } from "obsidian";
+import { getLogger } from "./logger";
+
+// Interface for mention service to avoid circular dependency
+export interface IMentionService {
+	getAllFiles(): TFile[];
+}
+
+// Mention detection utilities
+export interface MentionContext {
+	start: number; // Start index of the @ symbol
+	end: number; // Current cursor position
+	query: string; // Text after @ symbol
+}
+
+// Detect @-mention at current cursor position
+export function detectMention(
+	text: string,
+	cursorPosition: number,
+): MentionContext | null {
+	const logger = getLogger();
+
+	if (cursorPosition < 0 || cursorPosition > text.length) {
+		logger.log("[detectMention] Invalid cursor position:", cursorPosition);
+		return null;
+	}
+
+	// Get text up to cursor position
+	const textUpToCursor = text.slice(0, cursorPosition);
+
+	// Find the last @ symbol
+	const atIndex = textUpToCursor.lastIndexOf("@");
+	if (atIndex === -1) {
+		return null;
+	}
+
+	// Get the token after @
+	const afterAt = textUpToCursor.slice(atIndex + 1);
+
+	// Trigger on @ and allow typing query directly
+	let query = "";
+	let endPos = cursorPosition;
+
+	// If already in @[[...]] format, handle it (allow spaces inside brackets)
+	if (afterAt.startsWith("[[")) {
+		const closingBrackets = afterAt.indexOf("]]");
+		if (closingBrackets === -1) {
+			// Still typing inside brackets
+			query = afterAt.slice(2); // Remove opening [[
+			endPos = cursorPosition;
+		} else {
+			// Found closing brackets - check if cursor is after them
+			const closingBracketsPos = atIndex + 1 + closingBrackets + 1; // +1 for second ]
+			if (cursorPosition > closingBracketsPos) {
+				// Cursor is after ]], no longer a mention
+				return null;
+			}
+			// Complete bracket format
+			query = afterAt.slice(2, closingBrackets); // Between [[ and ]]
+			endPos = closingBracketsPos + 1; // Include closing ]]
+		}
+	} else {
+		// Simple @query format - use everything after @
+		// But end at whitespace (space, tab, newline)
+		if (
+			afterAt.includes(" ") ||
+			afterAt.includes("\t") ||
+			afterAt.includes("\n")
+		) {
+			return null;
+		}
+		query = afterAt;
+		endPos = cursorPosition;
+	}
+
+	const mentionContext = {
+		start: atIndex,
+		end: endPos,
+		query: query,
+	};
+	logger.log("[detectMention] Mention context:", mentionContext);
+	return mentionContext;
+}
+
+// Replace mention in text with the selected note
+export function replaceMention(
+	text: string,
+	mentionContext: MentionContext,
+	noteTitle: string,
+): { newText: string; newCursorPos: number } {
+	const before = text.slice(0, mentionContext.start);
+	const after = text.slice(mentionContext.end);
+
+	// Always use @[[filename]] format
+	const replacement = ` @[[${noteTitle}]] `;
+
+	const newText = before + replacement + after;
+	const newCursorPos = mentionContext.start + replacement.length;
+
+	return { newText, newCursorPos };
+}
+
+// Extract all @mentions from text
+export function extractMentionedNotes(
+	text: string,
+	noteMentionService: IMentionService,
+): Array<{ noteTitle: string; file: TFile | undefined }> {
+	const mentionRegex = /@\[\[([^\]]+)\]\]/g;
+	const matches = Array.from(text.matchAll(mentionRegex));
+	const result: Array<{ noteTitle: string; file: TFile | undefined }> = [];
+	const seen = new Set<string>(); // Avoid duplicates
+
+	for (const match of matches) {
+		const noteTitle = match[1];
+		if (seen.has(noteTitle)) {
+			continue;
+		}
+		seen.add(noteTitle);
+
+		// Find the file by basename
+		const file = noteMentionService
+			.getAllFiles()
+			.find((f: TFile) => f.basename === noteTitle);
+
+		result.push({ noteTitle, file });
+	}
+
+	return result;
+}

package/src/utils/paths.ts

@@ -0,0 +1,246 @@
+import { execFile } from "child_process";
+import { Platform } from "obsidian";
+import { access, stat } from "fs/promises";
+import { constants } from "fs";
+import { join } from "path";
+import { buildWslShellWrapper, getLoginShell } from "./platform";
+
+/**
+ * Check whether a path string is an absolute path (Unix or Windows).
+ */
+export function isAbsolutePath(path: string): boolean {
+	return path.startsWith("/") || /^[A-Za-z]:[\\/]/.test(path);
+}
+
+/**
+ * Best-effort fallback for when `which` returns nothing — e.g. macOS GUI-launched
+ * apps (Finder/Dock) inherit a reduced PATH that excludes /opt/homebrew/bin, so
+ * `which` can fail even when the command is installed. Probes common install
+ * directories directly (PATH-independent), returning only an executable regular
+ * file so the result matches what `which` would have returned.
+ *
+ * Best-effort and intentionally narrow: version-manager installs
+ * (nvm/fnm/asdf/volta) and ~/.local/bin live in per-version directories a static
+ * list cannot enumerate and are out of scope — those users get an honest
+ * "Not found". (Windows solves the same reduced-PATH problem authoritatively via
+ * the registry; see getFullWindowsPath in platform.ts. macOS has no such
+ * side-channel, so this static last-resort list is a deliberate trade-off.)
+ *
+ * @param command - Bare command name (e.g. "node", "codex-acp")
+ * @returns Absolute path to an executable file, or null if not found
+ */
+async function findInKnownPaths(command: string): Promise<string | null> {
+	// Only resolve bare names within the listed dirs; never let a separator
+	// escape via join() (defensive — current callers pass hardcoded names).
+	if (command.includes("/") || command.includes("\\")) return null;
+
+	const dirs = Platform.isMacOS
+		? ["/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin"]
+		: ["/usr/local/bin", "/usr/bin", "/bin"];
+
+	for (const dir of dirs) {
+		const candidate = join(dir, command);
+		try {
+			const st = await stat(candidate); // follows symlinks
+			if (!st.isFile()) continue; // reject directories/sockets
+			await access(candidate, constants.X_OK); // must be executable
+			return candidate;
+		} catch {
+			// missing / not a runnable file / dangling symlink → keep scanning
+		}
+	}
+
+	return null;
+}
+
+/**
+ * Resolve the absolute path of a command using `which` (macOS/Linux) or `where` (Windows).
+ * If the command is already an absolute path, returns it as-is.
+ * Runs asynchronously to avoid blocking the Electron main thread.
+ *
+ * @param command - Command name (e.g. "node", "claude") or absolute path
+ * @returns Absolute path string, or null if not found
+ */
+export function resolveCommandPath(command: string): Promise<string | null> {
+	if (!command || command.trim().length === 0) return Promise.resolve(null);
+
+	const trimmed = command.trim();
+
+	if (isAbsolutePath(trimmed)) {
+		return Promise.resolve(trimmed);
+	}
+
+	return new Promise((resolve) => {
+		if (Platform.isWin) {
+			execFile(
+				"where",
+				[trimmed],
+				{ timeout: 5000, windowsHide: true },
+				(err, stdout) => {
+					if (err) {
+						resolve(null);
+						return;
+					}
+					const resolved = stdout.split("\n")[0].trim();
+					resolve(resolved.length > 0 ? resolved : null);
+				},
+			);
+		} else {
+			const shell = getLoginShell();
+			const escaped = trimmed.replace(/'/g, "'\\''");
+			execFile(
+				shell,
+				["-l", "-c", `which '${escaped}'`],
+				{ timeout: 5000 },
+				(err, stdout) => {
+					const fallback = () => {
+						findInKnownPaths(trimmed).then(resolve, () =>
+							resolve(null),
+						);
+					};
+					if (err) {
+						fallback();
+						return;
+					}
+					const resolved = stdout.split("\n")[0].trim();
+					if (resolved.length > 0) {
+						resolve(resolved);
+					} else {
+						fallback();
+					}
+				},
+			);
+		}
+	});
+}
+
+/**
+ * Resolve the absolute path of a command inside WSL.
+ * Uses the WSL shell wrapper (buildWslShellWrapper) to resolve within the Linux environment.
+ *
+ * @param command - Command name (e.g. "node", "claude")
+ * @param distribution - Optional WSL distribution name
+ * @returns Linux absolute path string, or null if not found
+ */
+export function resolveCommandPathInWsl(
+	command: string,
+	distribution?: string,
+): Promise<string | null> {
+	if (!command || command.trim().length === 0) return Promise.resolve(null);
+
+	const trimmed = command.trim();
+
+	if (isAbsolutePath(trimmed)) {
+		return Promise.resolve(trimmed);
+	}
+
+	return new Promise((resolve) => {
+		const escaped = trimmed.replace(/'/g, "'\\''");
+		const args: string[] = [];
+		if (distribution) {
+			args.push("-d", distribution);
+		}
+		const innerCommand = `which '${escaped}'`;
+		args.push("sh", "-c", buildWslShellWrapper(innerCommand));
+		execFile(
+			"C:\\Windows\\System32\\wsl.exe",
+			args,
+			{ timeout: 5000 },
+			(err, stdout) => {
+				if (err) {
+					// No known-paths fallback here on purpose: a host-side
+					// existsSync would check the Windows filesystem, not the
+					// Linux FS inside WSL. The wrapper already runs a login
+					// shell (-l, sources ~/.profile), so the reduced-PATH
+					// problem is milder here than on a GUI-launched macOS app.
+					resolve(null);
+					return;
+				}
+				const resolved = stdout.split("\n")[0].trim();
+				resolve(resolved.length > 0 ? resolved : null);
+			},
+		);
+	});
+}
+
+/**
+ * Extract the directory containing a command (for PATH adjustments).
+ * Example: /usr/local/bin/node → /usr/local/bin
+ *
+ * @param command - Full path to a command
+ * @returns Directory path, or null if cannot be determined
+ */
+export function resolveCommandDirectory(command: string): string | null {
+	if (!command) {
+		return null;
+	}
+	const lastSlash = Math.max(
+		command.lastIndexOf("/"),
+		command.lastIndexOf("\\"),
+	);
+	if (lastSlash <= 0) {
+		return null;
+	}
+	return command.slice(0, lastSlash);
+}
+
+/**
+ * Resolve the Node.js directory from the plugin's nodePath setting.
+ * Returns the directory only when nodePath is an absolute path.
+ * When nodePath is empty or a bare command name, returns undefined
+ * (the login shell handles PATH resolution).
+ *
+ * @param nodePathSetting - The raw nodePath setting value
+ * @returns Directory path, or undefined
+ */
+export function resolveNodeDirectory(
+	nodePathSetting: string | undefined,
+): string | undefined {
+	if (!nodePathSetting) return undefined;
+	const trimmed = nodePathSetting.trim();
+	if (!isAbsolutePath(trimmed)) return undefined;
+	return resolveCommandDirectory(trimmed) || undefined;
+}
+
+/**
+ * Convert absolute path to relative path if it's under basePath.
+ * Otherwise return the absolute path as-is.
+ *
+ * @param absolutePath - The absolute path to convert
+ * @param basePath - The base path (e.g., vault path)
+ * @returns Relative path if under basePath, otherwise absolute path
+ */
+export function toRelativePath(absolutePath: string, basePath: string): string {
+	// Normalize paths (remove trailing slashes)
+	const normalizedBase = basePath.replace(/\/+$/, "");
+	const normalizedPath = absolutePath.replace(/\/+$/, "");
+
+	if (normalizedPath.startsWith(normalizedBase + "/")) {
+		return normalizedPath.slice(normalizedBase.length + 1);
+	}
+	return absolutePath;
+}
+
+/**
+ * Build a file URI from an absolute path.
+ * Handles both Windows and Unix paths.
+ *
+ * @param absolutePath - Absolute file path
+ * @returns file:// URI
+ *
+ * @example
+ * buildFileUri("/Users/user/note.md") // "file:///Users/user/note.md"
+ * buildFileUri("C:\\Users\\user\\note.md") // "file:///C:/Users/user/note.md"
+ */
+export function buildFileUri(absolutePath: string): string {
+	// Normalize backslashes to forward slashes
+	const normalizedPath = absolutePath.replace(/\\/g, "/");
+
+	// Windows path (e.g., C:/Users/...)
+	if (/^[A-Za-z]:/.test(normalizedPath)) {
+		return `file:///${normalizedPath}`;
+	}
+
+	// Unix path (e.g., /Users/...)
+	return `file://${normalizedPath}`;
+}