@bike4mind/cli 0.2.64-worktree-refactor-extract-search-query-builders.21815 → 0.2.64

package/dist/deleteFile-DKHfnyny-G3b1Kj2T.mjs

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+import { t as assertPathAllowed } from "./pathValidation-Cgjh5WQO-DiCZTcq6.mjs";
+import { existsSync, promises, statSync } from "fs";
+import path from "path";
+//#region ../../b4m-core/packages/services/dist/deleteFile-DKHfnyny.mjs
+async function deleteFile(params, allowedDirectories) {
+	const { path: filePath, recursive = false } = params;
+	const resolvedPath = assertPathAllowed(filePath, allowedDirectories, "delete");
+	if (!existsSync(resolvedPath)) throw new Error(`File or directory not found: ${filePath}`);
+	const stats = statSync(resolvedPath);
+	const isDirectory = stats.isDirectory();
+	const size = stats.size;
+	if (isDirectory && !recursive) throw new Error(`Path is a directory: ${filePath}. Use recursive=true to delete directories and their contents.`);
+	if (isDirectory) {
+		await promises.rm(resolvedPath, {
+			recursive: true,
+			force: true
+		});
+		return `Directory deleted successfully: ${filePath}`;
+	} else {
+		await promises.unlink(resolvedPath);
+		return `File deleted successfully: ${filePath}\nSize: ${size} bytes`;
+	}
+}
+const deleteFileTool = {
+	name: "delete_file",
+	implementation: (context) => ({
+		toolFn: async (value) => {
+			const params = value;
+			const resolvedPath = path.resolve(process.cwd(), path.normalize(params.path));
+			const isDirectory = existsSync(resolvedPath) && statSync(resolvedPath).isDirectory();
+			context.logger.info(`🗑️  DeleteFile: Deleting ${isDirectory ? "directory" : "file"}`, {
+				path: params.path,
+				recursive: params.recursive
+			});
+			try {
+				const result = await deleteFile(params, context.allowedDirectories);
+				context.logger.info("✅ DeleteFile: Success", { path: params.path });
+				return result;
+			} catch (error) {
+				context.logger.error("❌ DeleteFile: Failed", error);
+				throw error;
+			}
+		},
+		toolSchema: {
+			name: "delete_file",
+			description: "Delete a file or directory. For directories, recursive option must be enabled. Restricted to current working directory for security. Always prompts user for confirmation before deletion.",
+			parameters: {
+				type: "object",
+				properties: {
+					path: {
+						type: "string",
+						description: "Path to the file or directory to delete (relative to current working directory)"
+					},
+					recursive: {
+						type: "boolean",
+						description: "Required to delete directories and their contents (default: false). Use with caution as this will delete all files and subdirectories."
+					}
+				},
+				required: ["path"]
+			}
+		}
+	})
+};
+//#endregion
+export { deleteFileTool };

package/dist/globFiles-D1en6joM-8jekiXdX.mjs

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+import { n as isPathAllowed } from "./pathValidation-Cgjh5WQO-DiCZTcq6.mjs";
+import path from "path";
+import { stat } from "fs/promises";
+import { glob } from "glob";
+//#region ../../b4m-core/packages/services/dist/globFiles-D1en6joM.mjs
+const DEFAULT_IGNORE_PATTERNS = [
+	"**/node_modules/**",
+	"**/.git/**",
+	"**/dist/**",
+	"**/build/**",
+	"**/.next/**",
+	"**/coverage/**",
+	"**/.turbo/**",
+	"**/.sst/**",
+	"**/*.min.js",
+	"**/*.min.css"
+];
+async function findFiles(params, allowedDirectories) {
+	const { pattern, dir_path, case_sensitive = true, respect_git_ignore = true } = params;
+	const baseCwd = process.cwd();
+	const targetDir = dir_path ? path.resolve(baseCwd, path.normalize(dir_path)) : baseCwd;
+	if (!isPathAllowed(targetDir, allowedDirectories).allowed) {
+		const dirsMsg = allowedDirectories && allowedDirectories.length > 0 ? `Allowed directories: ${[baseCwd, ...allowedDirectories].join(", ")}` : `Working directory: ${baseCwd}`;
+		throw new Error(`Access denied: Cannot search outside allowed directories. ${dirsMsg}`);
+	}
+	const matches = await glob(pattern, {
+		cwd: targetDir,
+		dot: false,
+		ignore: respect_git_ignore ? DEFAULT_IGNORE_PATTERNS : [],
+		absolute: true,
+		nodir: true,
+		nocase: !case_sensitive,
+		maxDepth: 20
+	});
+	if (matches.length === 0) return `No files found matching pattern: ${pattern}${dir_path ? ` in ${dir_path}` : ""}`;
+	const filesWithStats = [];
+	for (const filePath of matches) try {
+		const stats = await stat(filePath);
+		filesWithStats.push({
+			path: filePath,
+			mtime: stats.mtimeMs
+		});
+	} catch {
+		continue;
+	}
+	filesWithStats.sort((a, b) => b.mtime - a.mtime);
+	const MAX_RESULTS = 500;
+	const truncated = filesWithStats.length > MAX_RESULTS;
+	const results = truncated ? filesWithStats.slice(0, MAX_RESULTS) : filesWithStats;
+	return `${`Found ${filesWithStats.length} file(s)${truncated ? ` (showing first ${MAX_RESULTS})` : ""} matching: ${pattern}`}${dir_path ? `\nDirectory: ${dir_path}` : ""}\n\n${results.map((file) => path.relative(baseCwd, file.path)).join("\n")}`;
+}
+const globFilesTool = {
+	name: "glob_files",
+	implementation: (context) => ({
+		toolFn: async (value) => {
+			const params = value;
+			context.logger.info("🔍 GlobFiles: Finding files", {
+				pattern: params.pattern,
+				dir_path: params.dir_path || "."
+			});
+			try {
+				const result = await findFiles(params, context.allowedDirectories);
+				context.logger.info("✅ GlobFiles: Success");
+				return result;
+			} catch (error) {
+				context.logger.error("❌ GlobFiles: Failed", error);
+				throw error;
+			}
+		},
+		toolSchema: {
+			name: "glob_files",
+			description: "Efficiently finds files matching specific glob patterns (e.g., `src/**/*.ts`, `**/*.md`), returning absolute paths sorted by modification time (newest first). Use this to locate files by name or extension when you need to discover or explore files in a project.",
+			parameters: {
+				type: "object",
+				properties: {
+					pattern: {
+						type: "string",
+						description: "The glob pattern to match against file paths. Supports wildcards (*, **), character ranges ([abc]), and brace expansion ({ts,tsx}). Examples: \"*.ts\" for TypeScript files in current dir, \"src/**/*.tsx\" for all TSX files in src tree, \"**/*.{js,ts}\" for all JS/TS files."
+					},
+					dir_path: {
+						type: "string",
+						description: "Optional: The absolute path to the directory to search in. If not specified, uses the current working directory. Must be within the current working directory."
+					},
+					case_sensitive: {
+						type: "boolean",
+						description: "Optional: Whether the pattern matching should be case-sensitive. Defaults to true. Set to false for case-insensitive matching on case-sensitive file systems."
+					},
+					respect_git_ignore: {
+						type: "boolean",
+						description: "Optional: Whether to respect common ignore patterns (node_modules, .git, dist, build, etc.). Defaults to true. Set to false to include all files."
+					}
+				},
+				required: ["pattern"]
+			}
+		}
+	})
+};
+//#endregion
+export { globFilesTool };

package/dist/grepSearch-aMamoBn_-DCJcY8JS.mjs

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+import { n as isPathAllowed } from "./pathValidation-Cgjh5WQO-DiCZTcq6.mjs";
+import { execFile, execFileSync } from "child_process";
+import { existsSync } from "fs";
+import path from "path";
+import { stat } from "fs/promises";
+import { promisify } from "util";
+import { createRequire } from "module";
+//#region ../../b4m-core/packages/services/dist/grepSearch-aMamoBn_.mjs
+const execFileAsync = promisify(execFile);
+const require = createRequire(import.meta.url);
+/** Cached ripgrep binary path after first resolution */
+let cachedRgPath = null;
+/**
+* Get ripgrep binary path
+* This is an optional dependency (CLI-only), so we load it lazily.
+* If the binary is missing (postinstall was skipped), auto-downloads it.
+*/
+function getRipgrepPath() {
+	if (cachedRgPath) return cachedRgPath;
+	try {
+		const ripgrepPath = require.resolve("@vscode/ripgrep");
+		const ripgrepDir = path.dirname(ripgrepPath);
+		const rgBinary = path.join(ripgrepDir, "..", "bin", "rg" + (process.platform === "win32" ? ".exe" : ""));
+		if (!existsSync(rgBinary)) {
+			const postinstallScript = path.join(ripgrepDir, "..", "lib", "postinstall.js");
+			if (existsSync(postinstallScript)) execFileSync(process.execPath, [postinstallScript], {
+				cwd: path.join(ripgrepDir, ".."),
+				stdio: "pipe",
+				timeout: 3e4
+			});
+			if (!existsSync(rgBinary)) throw new Error(`ripgrep binary not found at ${rgBinary}. The postinstall download may have failed. Try running: cd ${path.join(ripgrepDir, "..")} && node lib/postinstall.js`);
+		}
+		cachedRgPath = rgBinary;
+		return rgBinary;
+	} catch (error) {
+		if (error instanceof Error && error.message.includes("ripgrep binary not found")) throw error;
+		throw new Error("ripgrep is not available. Please install @vscode/ripgrep: pnpm add @vscode/ripgrep --filter @bike4mind/services");
+	}
+}
+/**
+* Converts a glob pattern to ripgrep glob patterns
+* Handles common cases like *.ts, *.{ts,tsx}, src/**, etc.
+*/
+function convertGlobToRipgrepGlobs(globPattern) {
+	if (!globPattern || globPattern === "**/*") return [];
+	const braceMatch = globPattern.match(/\*\.{([^}]+)}/);
+	if (braceMatch) return braceMatch[1].split(",").map((ext) => `*.${ext.trim()}`);
+	return [globPattern];
+}
+async function searchFiles(params, allowedDirectories) {
+	const { pattern, dir_path, include } = params;
+	const baseCwd = process.cwd();
+	const targetDir = dir_path ? path.resolve(baseCwd, dir_path) : baseCwd;
+	if (!isPathAllowed(targetDir, allowedDirectories).allowed) {
+		const dirsMsg = allowedDirectories && allowedDirectories.length > 0 ? `Allowed directories: ${[baseCwd, ...allowedDirectories].join(", ")}` : `Working directory: ${baseCwd}`;
+		throw new Error(`Path validation failed: "${dir_path}" resolves outside allowed directories. ${dirsMsg}`);
+	}
+	try {
+		if (!(await stat(targetDir)).isDirectory()) throw new Error(`Path is not a directory: ${dir_path}`);
+	} catch (error) {
+		if (error.code === "ENOENT") throw new Error(`Path does not exist: ${dir_path}`);
+		throw error;
+	}
+	const rgPath = getRipgrepPath();
+	const rgArgs = [
+		"--json",
+		"--max-count",
+		"500",
+		"--ignore-case",
+		"--max-filesize",
+		"10M"
+	];
+	const globs = convertGlobToRipgrepGlobs(include || "");
+	if (globs.length > 0) globs.forEach((glob) => {
+		rgArgs.push("--glob", glob);
+	});
+	rgArgs.push(pattern, targetDir);
+	let stdout;
+	try {
+		stdout = (await execFileAsync(rgPath, rgArgs, { maxBuffer: 50 * 1024 * 1024 })).stdout;
+	} catch (error) {
+		const execError = error;
+		if (execError.code === 1 && execError.stdout) stdout = execError.stdout;
+		else if (execError.code === 2) {
+			const errorMsg = execError.stderr || "Unknown ripgrep error";
+			throw new Error(`Ripgrep error: ${errorMsg}`);
+		} else throw error;
+	}
+	const lines = stdout.split("\n").filter(Boolean);
+	const allMatches = [];
+	let filesSearched = 0;
+	for (const line of lines) try {
+		const item = JSON.parse(line);
+		if (item.type === "match") {
+			const match = item;
+			allMatches.push({
+				filePath: path.relative(targetDir, match.data.path.text) || path.basename(match.data.path.text),
+				lineNumber: match.data.line_number,
+				line: match.data.lines.text.trimEnd()
+			});
+		} else if (item.type === "summary") filesSearched = item.data.stats.searches || 0;
+	} catch {
+		continue;
+	}
+	const searchDirDisplay = dir_path || ".";
+	const filterInfo = include ? ` (filter: "${include}")` : "";
+	const maxMatches = 500;
+	if (allMatches.length === 0) return `No matches found for pattern "${pattern}" in "${searchDirDisplay}"${filterInfo}.\nSearched ${filesSearched} file(s).`;
+	const matchesByFile = allMatches.reduce((acc, match) => {
+		if (!acc[match.filePath]) acc[match.filePath] = [];
+		acc[match.filePath].push(match);
+		return acc;
+	}, {});
+	const matchCount = allMatches.length;
+	let result = `Found ${matchCount} ${matchCount === 1 ? "match" : "matches"}${matchCount >= maxMatches ? " (truncated)" : ""} for pattern "${pattern}" in "${searchDirDisplay}"${filterInfo}:\n`;
+	result += `Searched ${filesSearched} file(s)\n---\n`;
+	for (const filePath in matchesByFile) {
+		result += `File: ${filePath}\n`;
+		matchesByFile[filePath].forEach((match) => {
+			const trimmedLine = match.line.trim();
+			const displayLine = trimmedLine.length > 200 ? trimmedLine.slice(0, 200) + "..." : trimmedLine;
+			result += `L${match.lineNumber}: ${displayLine}\n`;
+		});
+		result += "---\n";
+	}
+	return result.trim();
+}
+const grepSearchTool = {
+	name: "grep_search",
+	implementation: (context) => ({
+		toolFn: async (value) => {
+			const params = value;
+			context.logger.info("🔍 GrepSearch: Searching files", {
+				pattern: params.pattern,
+				dir_path: params.dir_path || ".",
+				include: params.include || "**/*"
+			});
+			try {
+				const result = await searchFiles(params, context.allowedDirectories);
+				context.logger.info("✅ GrepSearch: Success");
+				return result;
+			} catch (error) {
+				context.logger.error("❌ GrepSearch: Failed", error);
+				throw error;
+			}
+		},
+		toolSchema: {
+			name: "grep_search",
+			description: "Searches for a regular expression pattern within the content of files in a specified directory (or current working directory). Can filter files by a glob pattern. Returns the lines containing matches, along with their file paths and line numbers.",
+			parameters: {
+				type: "object",
+				properties: {
+					pattern: {
+						type: "string",
+						description: "The regular expression (regex) pattern to search for within file contents (e.g., 'function\\s+myFunction', 'import\\s+\\{.*\\}\\s+from\\s+.*')."
+					},
+					dir_path: {
+						type: "string",
+						description: "Optional: The absolute path to the directory to search within. If omitted, searches the current working directory."
+					},
+					include: {
+						type: "string",
+						description: "Optional: A glob pattern to filter which files are searched (e.g., '*.js', '*.{ts,tsx}', 'src/**'). If omitted, searches all files (respecting potential global ignores)."
+					}
+				},
+				required: ["pattern"]
+			}
+		}
+	})
+};
+//#endregion
+export { grepSearchTool };