@probelabs/probe 0.6.0-rc56

package/src/query.js

@@ -0,0 +1,112 @@
+/**
+ * Query functionality for the probe package
+ * @module query
+ */
+
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { getBinaryPath, buildCliArgs, escapeString } from './utils.js';
+
+const execAsync = promisify(exec);
+
+/**
+ * Flag mapping for query options
+ * Maps option keys to command-line flags
+ */
+const QUERY_FLAG_MAP = {
+	language: '--language',
+	ignore: '--ignore',
+	allowTests: '--allow-tests',
+	maxResults: '--max-results',
+	format: '--format'
+};
+
+/**
+ * Query code in a specified directory using tree-sitter patterns
+ * 
+ * @param {Object} options - Query options
+ * @param {string} options.path - Path to search in
+ * @param {string} options.pattern - The ast-grep pattern to search for
+ * @param {string} [options.language] - Programming language to search in
+ * @param {string[]} [options.ignore] - Patterns to ignore
+ * @param {boolean} [options.allowTests] - Include test files
+ * @param {number} [options.maxResults] - Maximum number of results
+ * @param {string} [options.format] - Output format ('markdown', 'plain', 'json', 'color')
+ * @param {Object} [options.binaryOptions] - Options for getting the binary
+ * @param {boolean} [options.binaryOptions.forceDownload] - Force download even if binary exists
+ * @param {string} [options.binaryOptions.version] - Specific version to download
+ * @param {boolean} [options.json] - Return results as parsed JSON instead of string
+ * @returns {Promise<string|Object>} - Query results as string or parsed JSON
+ * @throws {Error} If the query fails
+ */
+export async function query(options) {
+	if (!options || !options.path) {
+		throw new Error('Path is required');
+	}
+
+	if (!options.pattern) {
+		throw new Error('Pattern is required');
+	}
+
+	// Get the binary path
+	const binaryPath = await getBinaryPath(options.binaryOptions || {});
+
+	// Build CLI arguments from options
+	const cliArgs = buildCliArgs(options, QUERY_FLAG_MAP);
+
+	// If json option is true, override format to json
+	if (options.json && !options.format) {
+		cliArgs.push('--format', 'json');
+	}
+
+	// Add pattern and path as positional arguments
+	cliArgs.push(escapeString(options.pattern), escapeString(options.path));
+
+	// Create a single log record with all query parameters
+	let logMessage = `Query: pattern="${options.pattern}" path="${options.path}"`;
+	if (options.language) logMessage += ` language=${options.language}`;
+	if (options.maxResults) logMessage += ` maxResults=${options.maxResults}`;
+	if (options.allowTests) logMessage += " allowTests=true";
+	console.error(logMessage);
+
+	// Execute command
+	const command = `${binaryPath} query ${cliArgs.join(' ')}`;
+
+	try {
+		const { stdout, stderr } = await execAsync(command);
+
+		if (stderr) {
+			console.error(`stderr: ${stderr}`);
+		}
+
+		// Count results
+		let resultCount = 0;
+
+		// Try to count results from stdout
+		const lines = stdout.split('\n');
+		for (const line of lines) {
+			if (line.startsWith('```') && !line.includes('```language')) {
+				resultCount++;
+			}
+		}
+
+		// Log the results count
+		console.error(`Query results: ${resultCount} matches`);
+
+		// Parse JSON if requested or if format is json
+		if (options.json || options.format === 'json') {
+			try {
+				return JSON.parse(stdout);
+			} catch (error) {
+				console.error('Error parsing JSON output:', error);
+				return stdout; // Fall back to string output
+			}
+		}
+
+		return stdout;
+	} catch (error) {
+		// Enhance error message with command details
+		const errorMessage = `Error executing query command: ${error.message}\nCommand: ${command}`;
+		throw new Error(errorMessage);
+	}
+}

package/src/search.js

@@ -0,0 +1,235 @@
+/**
+ * Search functionality for the probe package
+ * @module search
+ */
+
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { getBinaryPath, buildCliArgs, escapeString } from './utils.js';
+
+const execAsync = promisify(exec);
+
+/**
+ * Flag mapping for search options
+ * Maps option keys to command-line flags
+ */
+const SEARCH_FLAG_MAP = {
+	filesOnly: '--files-only',
+	ignore: '--ignore',
+	excludeFilenames: '--exclude-filenames',
+	reranker: '--reranker',
+	frequencySearch: '--frequency',
+	exact: '--exact',
+	maxResults: '--max-results',
+	maxBytes: '--max-bytes',
+	maxTokens: '--max-tokens',
+	allowTests: '--allow-tests',
+	noMerge: '--no-merge',
+	mergeThreshold: '--merge-threshold',
+	session: '--session',
+	timeout: '--timeout',
+	language: '--language'
+};
+
+/**
+ * Search code in a specified directory
+ *
+ * @param {Object} options - Search options
+ * @param {string} options.path - Path to search in
+ * @param {string|string[]} options.query - Search query or queries
+ * @param {boolean} [options.filesOnly] - Only output file paths
+ * @param {string[]} [options.ignore] - Patterns to ignore
+ * @param {boolean} [options.excludeFilenames] - Exclude filenames from search
+ * @param {string} [options.reranker] - Reranking method ('hybrid', 'hybrid2', 'bm25', 'tfidf')
+ * @param {boolean} [options.frequencySearch] - Use frequency-based search
+ * @param {boolean} [options.exact] - Perform exact search without tokenization (case-insensitive)
+ * @param {number} [options.maxResults] - Maximum number of results
+ * @param {number} [options.maxBytes] - Maximum bytes to return
+ * @param {number} [options.maxTokens] - Maximum tokens to return
+ * @param {boolean} [options.allowTests] - Include test files
+ * @param {boolean} [options.noMerge] - Don't merge adjacent blocks
+ * @param {number} [options.mergeThreshold] - Merge threshold
+ * @param {string} [options.session] - Session ID for caching results
+ * @param {number} [options.timeout] - Timeout in seconds (default: 30)
+ * @param {string} [options.language] - Limit search to files of a specific programming language
+ * @param {Object} [options.binaryOptions] - Options for getting the binary
+ * @param {boolean} [options.binaryOptions.forceDownload] - Force download even if binary exists
+ * @param {string} [options.binaryOptions.version] - Specific version to download
+ * @param {boolean} [options.json] - Return results as parsed JSON instead of string
+ * @returns {Promise<string|Object>} - Search results as string or parsed JSON
+ * @throws {Error} If the search fails
+ */
+export async function search(options) {
+	if (!options || !options.path) {
+		throw new Error('Path is required');
+	}
+
+	if (!options.query) {
+		throw new Error('Query is required');
+	}
+
+	// Get the binary path
+	const binaryPath = await getBinaryPath(options.binaryOptions || {});
+
+	// Build CLI arguments from options
+	const cliArgs = buildCliArgs(options, SEARCH_FLAG_MAP);
+
+	// Add JSON format if requested
+	if (options.json) {
+		cliArgs.push('--format', 'json');
+	}
+
+	// Set default maxTokens if not provided
+	if (!options.maxTokens) {
+		options.maxTokens = 10000;
+		cliArgs.push('--max-tokens', '10000');
+	}
+
+	// Set default timeout if not provided
+	if (!options.timeout) {
+		options.timeout = 30;
+		cliArgs.push('--timeout', '30');
+	}
+
+	// Ensure language is properly passed if provided
+	if (options.language) {
+		// Ensure language flag is in cliArgs
+		if (!cliArgs.includes('--language')) {
+			cliArgs.push('--language', options.language);
+		}
+	}
+
+	// Ensure exact search is properly passed if enabled
+	if (options.exact) {
+		// Ensure exact flag is in cliArgs
+		if (!cliArgs.includes('--exact')) {
+			cliArgs.push('--exact');
+		}
+	}
+
+	// Add session ID from environment variable if not provided in options
+	if (!options.session && process.env.PROBE_SESSION_ID) {
+		options.session = process.env.PROBE_SESSION_ID;
+	}
+
+	// Add query and path as positional arguments
+	const queries = Array.isArray(options.query) ? options.query : [options.query];
+
+	// Create a single log record with all search parameters (commented out for less verbose output)
+	let logMessage = `\nSearch: query="${queries[0]}" path="${options.path}"`;
+	if (options.maxResults) logMessage += ` maxResults=${options.maxResults}`;
+	logMessage += ` maxTokens=${options.maxTokens}`;
+	logMessage += ` timeout=${options.timeout}`;
+	if (options.allowTests) logMessage += " allowTests=true";
+	if (options.language) logMessage += ` language=${options.language}`;
+	if (options.exact) logMessage += " exact=true";
+	if (options.session) logMessage += ` session=${options.session}`;
+	console.error(logMessage);
+	// Create positional arguments array separate from flags
+	const positionalArgs = [];
+
+	if (queries.length > 0) {
+		// Escape the query to handle special characters
+		positionalArgs.push(escapeString(queries[0]));
+	}
+
+	// Escape the path to handle spaces and special characters
+	positionalArgs.push(escapeString(options.path));
+	// Don't add the path to cliArgs, it should only be a positional argument
+
+	// Execute command with flags first, then positional arguments
+	const command = `${binaryPath} search ${cliArgs.join(' ')} ${positionalArgs.join(' ')}`;
+
+	// Debug logs to see the actual command with quotes and the path
+	// console.error(`Executing command: ${command}`);
+	// console.error(`Path being used: "${options.path}"`);
+	// console.error(`Escaped path: ${escapeString(options.path)}`);
+	// console.error(`Command flags: ${cliArgs.join(' ')}`);
+	// console.error(`Positional arguments: ${positionalArgs.join(' ')}`);
+
+	try {
+		// Log before executing
+		// console.error(`About to execute command: ${command}`);
+
+		// Execute the command with options to preserve quotes and apply timeout
+		const { stdout, stderr } = await execAsync(command, {
+			shell: true,
+			timeout: options.timeout * 1000 // Convert seconds to milliseconds
+		});
+
+		// Log after executing
+		// console.error(`Command executed successfully`);
+
+		if (stderr && process.env.DEBUG) {
+			console.error(`stderr: ${stderr}`);
+		}
+
+		// Count results, tokens, and bytes
+		let resultCount = 0;
+		let tokenCount = 0;
+		let bytesCount = 0;
+
+		// Try to count results from stdout
+		const lines = stdout.split('\n');
+		for (const line of lines) {
+			if (line.startsWith('```') && !line.includes('```language')) {
+				resultCount++;
+			}
+		}
+
+		// Look for the specific "Total bytes returned: X" line in the output
+		const totalBytesMatch = stdout.match(/Total bytes returned:\s*(\d+)/i);
+		if (totalBytesMatch && totalBytesMatch[1]) {
+			bytesCount = parseInt(totalBytesMatch[1], 10);
+		}
+
+		// Look for the specific "Total tokens returned: X" line in the output
+		const totalTokensMatch = stdout.match(/Total tokens returned:\s*(\d+)/i);
+		if (totalTokensMatch && totalTokensMatch[1]) {
+			tokenCount = parseInt(totalTokensMatch[1], 10);
+		} else {
+			// Try other patterns if the specific format isn't found
+			const tokenMatch = stdout.match(/Tokens:?\s*(\d+)/i) ||
+				stdout.match(/(\d+)\s*tokens/i) ||
+				stdout.match(/token count:?\s*(\d+)/i);
+
+			if (tokenMatch && tokenMatch[1]) {
+				tokenCount = parseInt(tokenMatch[1], 10);
+			} else {
+				// If we still can't find the token count, use the default maxTokens value
+				// This is a fallback, but the command should be returning the actual count
+				tokenCount = options.maxTokens;
+			}
+		}
+
+		// Log the results count, token count, and bytes count (commented out for less verbose output)
+		let resultsMessage = `\nSearch results: ${resultCount} matches, ${tokenCount} tokens`;
+		if (bytesCount > 0) {
+			resultsMessage += `, ${bytesCount} bytes`;
+		}
+		console.error(resultsMessage);
+
+		// Parse JSON if requested
+		if (options.json) {
+			try {
+				return JSON.parse(stdout);
+			} catch (error) {
+				console.error('Error parsing JSON output:', error);
+				return stdout; // Fall back to string output
+			}
+		}
+
+		return stdout;
+	} catch (error) {
+		// Check if the error is a timeout
+		if (error.code === 'ETIMEDOUT' || error.killed) {
+			const timeoutMessage = `Search operation timed out after ${options.timeout} seconds.\nCommand: ${command}`;
+			console.error(timeoutMessage);
+			throw new Error(timeoutMessage);
+		}
+
+		// Enhance error message with command details
+		const errorMessage = `Error executing search command: ${error.message}\nCommand: ${command}`;
+		throw new Error(errorMessage);
+	}
+}

package/src/tools/common.js

@@ -0,0 +1,224 @@
+/**
+ * Common schemas and definitions for AI tools
+ * @module tools/common
+ */
+
+import { z } from 'zod';
+
+// Common schemas for tool parameters (used for internal execution after XML parsing)
+export const searchSchema = z.object({
+	query: z.string().describe('Search query with Elasticsearch syntax. Use + for important terms.'),
+	path: z.string().optional().default('.').describe('Path to search in. For dependencies use "go:github.com/owner/repo", "js:package_name", or "rust:cargo_name" etc.'),
+	allow_tests: z.boolean().optional().default(false).describe('Allow test files in search results'),
+	exact: z.boolean().optional().default(false).describe('Perform exact search without tokenization (case-insensitive)'),
+	maxResults: z.number().optional().describe('Maximum number of results to return'),
+	maxTokens: z.number().optional().default(10000).describe('Maximum number of tokens to return'),
+	language: z.string().optional().describe('Limit search to files of a specific programming language')
+});
+
+export const querySchema = z.object({
+	pattern: z.string().describe('AST pattern to search for. Use $NAME for variable names, $$$PARAMS for parameter lists, etc.'),
+	path: z.string().optional().default('.').describe('Path to search in'),
+	language: z.string().optional().default('rust').describe('Programming language to use for parsing'),
+	allow_tests: z.boolean().optional().default(false).describe('Allow test files in search results')
+});
+
+export const extractSchema = z.object({
+	file_path: z.string().optional().describe('Path to the file to extract from. Can include line numbers or symbol names'),
+	input_content: z.string().optional().describe('Text content to extract file paths from'),
+	line: z.number().optional().describe('Start line number to extract a specific code block'),
+	end_line: z.number().optional().describe('End line number for extracting a range of lines'),
+	allow_tests: z.boolean().optional().default(false).describe('Allow test files and test code blocks'),
+	context_lines: z.number().optional().default(10).describe('Number of context lines to include'),
+	format: z.string().optional().default('plain').describe('Output format (plain, markdown, json, color)')
+});
+
+// Schema for the new attempt_completion tool
+export const attemptCompletionSchema = z.object({
+	result: z.string().describe('The final result of the task. Formulate this result in a way that is final and does not require further input from the user. Do not end your result with questions or offers for further assistance.'),
+	command: z.string().optional().describe('A CLI command to execute to show a live demo of the result to the user (e.g., `open index.html`). Do not use commands like `echo` or `cat` that merely print text.')
+});
+
+
+// Tool descriptions for the system prompt (using XML format)
+
+export const searchToolDefinition = `
+## search
+Description: Search code in the repository using Elasticsearch query syntax (except field based queries, e.g. "filename:..." NOT supported).
+
+You need to focus on main keywords when constructing the query, and always use elastic search syntax like OR AND and brackets to group keywords.
+Parameters:
+- query: (required) Search query with Elasticsearch syntax. You can use + for important terms, and - for negation.
+- path: (required) Path to search in. All dependencies located in /dep folder, under language sub folders, like this: "/dep/go/github.com/owner/repo", "/dep/js/package_name", or "/dep/rust/cargo_name" etc. YOU SHOULD ALWAYS provide FULL PATH when searching dependencies, including depency name.
+- allow_tests: (optional, default: false) Allow test files in search results (true/false).
+- exact: (optional, default: false) Perform exact pricise search. Use it when you already know function or struct name, or some other code block, and want exact match.
+- maxResults: (optional) Maximum number of results to return (number).
+- maxTokens: (optional, default: 10000) Maximum number of tokens to return (number).
+- language: (optional) Limit search to files of a specific programming language (e.g., 'rust', 'js', 'python', 'go' etc.).
+
+
+Usage Example:
+
+<examples>
+
+User: How to calculate the total amount in the payments module?
+<search>
+<query>calculate AND payment</query>
+<path>src/utils</path>
+<allow_tests>false</allow_tests>
+</search>
+
+User: How do the user authentication and authorization work?
+<search>
+<query>+user and (authentification OR authroization OR authz)</query>
+<path>.</path>
+<allow_tests>true</allow_tests>
+<language>go</language>
+</search>
+
+User: Find all react imports in the project.
+<search>
+<query>import { react }</query>
+<path>.</path>
+<exact>true</exact>
+<language>js</language>
+</search>
+
+
+User: Find how decompoud library works?
+<search>
+<query>import { react }</query>
+<path>/dep/rust/decompound</path>
+<language>rust</language>
+</search>
+
+</examples>
+`;
+
+export const queryToolDefinition = `
+## query
+Description: Search code using ast-grep structural pattern matching. Use this tool to find specific code structures like functions, classes, or methods.
+Parameters:
+- pattern: (required) AST pattern to search for. Use $NAME for variable names, $$$PARAMS for parameter lists, etc.
+- path: (optional, default: '.') Path to search in.
+- language: (optional, default: 'rust') Programming language to use for parsing.
+- allow_tests: (optional, default: false) Allow test files in search results (true/false).
+Usage Example:
+
+<examples>
+
+<query>
+<pattern>function $FUNC($$$PARAMS) { $$$BODY }</pattern>
+<path>src/parser</path>
+<language>js</language>
+</query>
+
+</examples>
+`;
+
+export const extractToolDefinition = `
+## extract
+Description: Extract code blocks from files based on file paths and optional line numbers. Use this tool to see complete context after finding relevant files. It can be used to read full files as well. 
+Full file extraction should be the LAST RESORT! Always prefer search.
+
+Parameters:
+- file_path: (required) Path to the file to extract from. Can include line numbers or symbol names (e.g., 'src/main.rs:10-20', 'src/utils.js#myFunction').
+- line: (optional) Start line number to extract a specific code block. Use with end_line for ranges.
+- end_line: (optional) End line number for extracting a range of lines.
+- allow_tests: (optional, default: false) Allow test files and test code blocks (true/false).
+Usage Example:
+
+<examples>
+
+User: How RankManager works
+<extract>
+<file_path>src/search/ranking.rs#RankManager</file_path>
+</extract>
+
+User: Lets read the whole file
+<extract>
+<file_path>src/search/ranking.rs</file_path>
+</extract>
+
+User: Read the first 10 lines of the file
+<extract>
+<file_path>src/search/ranking.rs</file_path>
+<line>1</line>
+<end_line>10</end_line>
+</extract>
+
+User: Read file inside the dependency
+<extract>
+<file_path>/dep/go/github.com/gorilla/mux/router.go</file_path>
+</extract>
+
+
+</examples>
+`;
+
+export const attemptCompletionToolDefinition = `
+## attempt_completion
+Description: Use this tool ONLY when the task is fully complete and you have received confirmation of success for all previous tool uses. Presents the final result to the user.
+Parameters:
+- result: (required) The final result of the task. Formulate this result concisely and definitively. Do not end with questions or offers for further assistance. Ensure that answer fully addresses the user's request, and a clear and detailed maneer.
+- command: (optional) A CLI command to demonstrate the result (e.g., 'open index.html'). Avoid simple print commands like 'echo'.
+Usage Example:
+<attempt_completion>
+<result>I have refactored the search module according to the requirements and verified the tests pass.</result>
+<command>cargo test --lib</command>
+</attempt_completion>
+`;
+
+export const searchDescription = 'Search code in the repository using Elasticsearch-like query syntax. Use this tool first for any code-related questions.';
+export const queryDescription = 'Search code using ast-grep structural pattern matching. Use this tool to find specific code structures like functions, classes, or methods.';
+export const extractDescription = 'Extract code blocks from files based on file paths and optional line numbers. Use this tool to see complete context after finding relevant files.';
+
+// Simple XML parser helper
+export function parseXmlToolCall(xmlString) {
+	const toolMatch = xmlString.match(/<([a-zA-Z0-9_]+)>([\s\S]*?)<\/\1>/);
+	if (!toolMatch) {
+		return null;
+	}
+
+	const toolName = toolMatch[1];
+	const innerContent = toolMatch[2];
+	const params = {};
+
+	const paramRegex = /<([a-zA-Z0-9_]+)>([\s\S]*?)<\/\1>/g;
+	let paramMatch;
+	while ((paramMatch = paramRegex.exec(innerContent)) !== null) {
+		const paramName = paramMatch[1];
+		let paramValue = paramMatch[2].trim();
+
+		// Basic type inference (can be improved)
+		if (paramValue.toLowerCase() === 'true') {
+			paramValue = true;
+		} else if (paramValue.toLowerCase() === 'false') {
+			paramValue = false;
+		} else if (!isNaN(paramValue) && paramValue.trim() !== '') {
+			// Check if it's potentially a number (handle integers and floats)
+			const num = Number(paramValue);
+			if (Number.isFinite(num)) { // Use Number.isFinite to avoid Infinity/NaN
+				paramValue = num;
+			}
+			// Keep as string if not a valid finite number
+		}
+
+		params[paramName] = paramValue;
+	}
+
+	// Special handling for attempt_completion where result might contain nested XML/code
+	if (toolName === 'attempt_completion') {
+		const resultMatch = innerContent.match(/<result>([\s\S]*?)<\/result>/);
+		if (resultMatch) {
+			params['result'] = resultMatch[1].trim(); // Keep result content as is
+		}
+		const commandMatch = innerContent.match(/<command>([\s\S]*?)<\/command>/);
+		if (commandMatch) {
+			params['command'] = commandMatch[1].trim();
+		}
+	}
+
+
+	return { toolName, params };
+}

package/src/tools/index.js

@@ -0,0 +1,36 @@
+/**
+ * Main tools module
+ * @module tools
+ */
+
+// Export Vercel AI SDK tool generators
+export { searchTool, queryTool, extractTool } from './vercel.js';
+
+// Export LangChain tools
+export { createSearchTool, createQueryTool, createExtractTool } from './langchain.js';
+
+// Export common schemas
+export {
+	searchSchema,
+	querySchema,
+	extractSchema,
+	attemptCompletionSchema,
+	attemptCompletionToolDefinition
+} from './common.js';
+
+// Export system message
+export { DEFAULT_SYSTEM_MESSAGE } from './system-message.js';
+
+// For backward compatibility, create and export pre-configured tools
+import { searchTool as searchToolGenerator, queryTool as queryToolGenerator, extractTool as extractToolGenerator } from './vercel.js';
+import { DEFAULT_SYSTEM_MESSAGE } from './system-message.js';
+
+// Create default tool instances (for backward compatibility)
+const tools = {
+	searchTool: searchToolGenerator(),
+	queryTool: queryToolGenerator(),
+	extractTool: extractToolGenerator(),
+	DEFAULT_SYSTEM_MESSAGE
+};
+
+export { tools };

package/src/tools/langchain.js

@@ -0,0 +1,88 @@
+/**
+ * Tools for LangChain
+ * @module tools/langchain
+ */
+
+import { search } from '../search.js';
+import { query } from '../query.js';
+import { extract } from '../extract.js';
+import { searchSchema, querySchema, extractSchema, searchDescription, queryDescription, extractDescription } from './common.js';
+
+// LangChain tool for searching code
+export function createSearchTool() {
+	return {
+		name: 'search',
+		description: searchDescription,
+		schema: searchSchema,
+		func: async ({ query: searchQuery, path, allow_tests, exact, maxResults, maxTokens = 10000, language }) => {
+			try {
+				const results = await search({
+					query: searchQuery,
+					path,
+					allow_tests,
+					exact,
+					json: false,
+					maxResults,
+					maxTokens,
+					language
+				});
+
+				return results;
+			} catch (error) {
+				console.error('Error executing search command:', error);
+				return `Error executing search command: ${error.message}`;
+			}
+		}
+	};
+}
+
+// LangChain tool for querying code
+export function createQueryTool() {
+	return {
+		name: 'query',
+		description: queryDescription,
+		schema: querySchema,
+		func: async ({ pattern, path, language, allow_tests }) => {
+			try {
+				const results = await query({
+					pattern,
+					path,
+					language,
+					allow_tests,
+					json: false
+				});
+
+				return results;
+			} catch (error) {
+				console.error('Error executing query command:', error);
+				return `Error executing query command: ${error.message}`;
+			}
+		}
+	};
+}
+
+// LangChain tool for extracting code
+export function createExtractTool() {
+	return {
+		name: 'extract',
+		description: extractDescription,
+		schema: extractSchema,
+		func: async ({ file_path, line, end_line, allow_tests, context_lines, format }) => {
+			try {
+				const files = [file_path];
+
+				const results = await extract({
+					files,
+					allowTests: allow_tests,
+					contextLines: context_lines,
+					format
+				});
+
+				return results;
+			} catch (error) {
+				console.error('Error executing extract command:', error);
+				return `Error executing extract command: ${error.message}`;
+			}
+		}
+	};
+}