@probelabs/probe 0.6.0-rc200 → 0.6.0-rc202

package/build/delegate.js

@@ -173,11 +173,18 @@ const delegationManager = new DelegationManager();
  * @param {number} [options.maxIterations=30] - Maximum tool iterations allowed
  * @param {string} [options.parentSessionId=null] - Parent session ID for tracking
  * @param {string} [options.path] - Search directory path (inherited from parent)
+ * @param {string[]} [options.allowedFolders] - Allowed folders (inherited from parent)
  * @param {string} [options.provider] - AI provider (inherited from parent)
  * @param {string} [options.model] - AI model (inherited from parent)
  * @param {Object} [options.tracer=null] - Telemetry tracer instance
  * @param {boolean} [options.enableBash=false] - Enable bash tool (inherited from parent)
  * @param {Object} [options.bashConfig] - Bash configuration (inherited from parent)
+ * @param {string} [options.architectureFileName] - Architecture context filename to embed from repo root
+ * @param {string} [options.promptType='code-researcher'] - Prompt type for the subagent
+ * @param {Array<string>|null} [options.allowedTools] - Allowed tools for the subagent (null = default)
+ * @param {boolean} [options.disableTools=false] - Disable all tools for the subagent
+ * @param {boolean} [options.searchDelegate] - Use delegated search in the subagent
+ * @param {Object|string} [options.schema] - Optional JSON schema to enforce response format
  * @returns {Promise<string>} The response from the delegate agent
  */
 export async function delegate({
@@ -189,10 +196,17 @@ export async function delegate({
 	tracer = null,
 	parentSessionId = null,
 	path = null,
+	allowedFolders = null,
 	provider = null,
 	model = null,
 	enableBash = false,
-	bashConfig = null
+	bashConfig = null,
+	architectureFileName = null,
+	promptType = 'code-researcher',
+	allowedTools = null,
+	disableTools = false,
+	searchDelegate = undefined,
+	schema = null
 }) {
 	if (!task || typeof task !== 'string') {
 		throw new Error('Task parameter is required and must be a string');
@@ -226,7 +240,7 @@ export async function delegate({
 			console.error(`[DELEGATE] Remaining iterations for subagent: ${remainingIterations}`);
 			console.error(`[DELEGATE] Timeout configured: ${timeout} seconds`);
 			console.error(`[DELEGATE] Global active delegations: ${stats.globalActive}/${stats.maxConcurrent}`);
-			console.error(`[DELEGATE] Using ProbeAgent SDK with code-researcher prompt`);
+			console.error(`[DELEGATE] Using ProbeAgent SDK with ${promptType} prompt`);
 		}
 		// Create a new ProbeAgent instance for the delegated task
 		// IMPORTANT: We pass both path and cwd set to the same value (workspace root)
@@ -234,24 +248,29 @@ export async function delegate({
 		// affect the subagent's path resolution - subagents always work from workspace root.
 		const subagent = new ProbeAgent({
 			sessionId,
-			promptType: 'code-researcher',  // Clean prompt, not inherited from parent
-			enableDelegate: false,           // Explicitly disable delegation to prevent recursion
+			promptType,               // Clean prompt, not inherited from parent
+			enableDelegate: false,     // Explicitly disable delegation to prevent recursion
 			disableMermaidValidation: true,  // Faster processing
 			disableJsonValidation: true,     // Simpler responses
 			maxIterations: remainingIterations,
 			debug,
 			tracer,
 			path,       // Workspace root (from delegateTool)
+			allowedFolders, // Inherit allowed folders to keep architecture context root consistent
 			cwd: path,  // Explicitly set cwd to workspace root to prevent path doubling
 			provider,   // Inherit from parent
 			model,      // Inherit from parent
 			enableBash, // Inherit from parent
-			bashConfig  // Inherit from parent
+			bashConfig, // Inherit from parent
+			architectureFileName,
+			allowedTools,
+			disableTools,
+			searchDelegate
 		});
 
 		if (debug) {
 			console.error(`[DELEGATE] Created subagent with session ${sessionId}`);
-			console.error(`[DELEGATE] Subagent config: promptType=code-researcher, enableDelegate=false, maxIterations=${remainingIterations}`);
+			console.error(`[DELEGATE] Subagent config: promptType=${promptType}, enableDelegate=false, maxIterations=${remainingIterations}`);
 		}
 
 		// Set up timeout with proper cleanup
@@ -269,7 +288,8 @@ export async function delegate({
 		});
 
 		// Execute the task with timeout
-		const answerPromise = subagent.answer(task);
+		const answerOptions = schema ? { schema } : undefined;
+		const answerPromise = answerOptions ? subagent.answer(task, [], answerOptions) : subagent.answer(task);
 		const response = await Promise.race([answerPromise, timeoutPromise]);
 
 		// Clear timeout immediately after race completes to prevent memory leak

package/build/tools/common.js

@@ -30,6 +30,14 @@ export const delegateSchema = z.object({
 	task: z.string().describe('The task to delegate to a subagent. Be specific about what needs to be accomplished.')
 });
 
+export const listSkillsSchema = z.object({
+	filter: z.string().optional().describe('Optional substring filter to match skill names or descriptions.')
+});
+
+export const useSkillSchema = z.object({
+	name: z.string().describe('Skill name to load and activate.')
+});
+
 export const bashSchema = z.object({
 	command: z.string().describe('The bash command to execute'),
 	workingDirectory: z.string().optional().describe('Directory to execute the command in (optional)'),
@@ -103,7 +111,8 @@ export const attemptCompletionSchema = {
 
 export const searchToolDefinition = `
 ## search
-Description: Search code in the repository using Elasticsearch query syntax (except field based queries, e.g. "filename:..." NOT supported).
+Description: Search code in the repository. You may provide a free-form question about the code or a concise Elasticsearch-style keyword query (field based queries, e.g. "filename:..." NOT supported).
+Note: This tool may internally use a dedicated search subagent when search delegation is enabled. This is separate from the "delegate" tool and does not require an explicit delegate call.
 
 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.
 
@@ -113,7 +122,7 @@ You need to focus on main keywords when constructing the query, and always use e
 - Once data is returned, it's cached and won't return on next runs (this is expected behavior)
 
 Parameters:
-- query: (required) Search query with Elasticsearch syntax. Use quotes for exact matches ("functionName"), AND/OR for boolean logic, - for negation, + for important terms.
+- query: (required) Search query. Free-form questions are accepted, but for best results prefer Elasticsearch-style syntax with quotes for exact matches ("functionName"), AND/OR for boolean logic, - for negation, + for important terms.
 - path: (optional, default: '.') 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.
 
 **Workflow:** Always start with search, then use extract for detailed context when needed.
@@ -319,7 +328,7 @@ User: Check system info
 </examples>
 `;
 
-export const searchDescription = 'Search code in the repository using Elasticsearch-like query syntax. Use this tool first for any code-related questions.';
+export const searchDescription = 'Search code in the repository. Free-form questions are accepted, but Elasticsearch-style keyword queries work best. 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.';
 export const delegateDescription = 'Automatically delegate big distinct tasks to specialized probe subagents within the agentic loop. Used by AI agents to break down complex requests into focused, parallel tasks.';
@@ -332,6 +341,8 @@ export const DEFAULT_VALID_TOOLS = [
 	'query',
 	'extract',
 	'delegate',
+	'listSkills',
+	'useSkill',
 	'listFiles',
 	'searchFiles',
 	'implement',
@@ -366,6 +377,8 @@ function getValidParamsForTool(toolName) {
 		query: querySchema,
 		extract: extractSchema,
 		delegate: delegateSchema,
+		listSkills: listSkillsSchema,
+		useSkill: useSkillSchema,
 		bash: bashSchema,
 		attempt_completion: attemptCompletionSchema,
 		edit: editSchema,
@@ -628,4 +641,4 @@ export function resolveTargetPath(target, cwd) {
 	}
 
 	return filePart + suffix;
-}
+}

package/build/tools/system-message.js

@@ -11,7 +11,7 @@ You are Probe, a specialized code intelligence assistant. Your objective is to a
 1.  **Tool-First Always:** Immediately use tools for any code-related query. Do not guess or use general knowledge.
 2.  **Mandatory Path:** ALL tool calls (\`search\`, \`query\`, \`extract\`) MUST include the \`path\` argument. Use \`"."\` for the whole project, specific directories/files (e.g., \`"src/api"\`, \`"pkg/utils/helpers.py"\`), or dependency syntax (e.g., \`"go:github.com/gin-gonic/gin"\`, \`"js:@ai-sdk/anthropic"\`, \`"rust:serde"\`).
 3.  **Start with \`search\`:**
-    *   **Keywords are Key:** Formulate queries like you would in Elasticsearch. Use specific keywords, boolean operators (\`AND\`, \`OR\`, \`NOT\`), and exact phrases (\`""\`). This is NOT a simple text search.
+    *   **Free-form is OK, keywords are better:** You may ask a free-form question about the code, but for best results use Elasticsearch-style keywords, boolean operators (\`AND\`, \`OR\`, \`NOT\`), and exact phrases (\`""\`).
     *   **Iterate if Needed:** If initial results are too broad or insufficient, **repeat the exact same \`search\` query** to get the next page of results (pagination). Reuse the \`sessionID\` if provided by the previous identical search. If results are irrelevant, refine the keywords (add terms, use \`NOT\`, try synonyms).
 4.  **Analyze & Refine:** Review \`search\` results (snippets, file paths).
     *   Use \`query\` if you need code based on *structure* (AST patterns) within specific files/directories identified by \`search\`.
@@ -23,8 +23,8 @@ You are Probe, a specialized code intelligence assistant. Your objective is to a
 
 *   \`search\`
     *   **Purpose:** Find relevant code snippets/files using keyword-based search (like Elasticsearch). Locate named symbols. Search project code or dependencies.
-    *   **Syntax:** \`query\` (Elasticsearch-like string: keywords, \`AND\`, \`OR\`, \`NOT\`, \`""\` exact phrases), \`path\` (Mandatory: \`"."\`, \`"path/to/dir"\`, \`"path/to/file.ext"\`, \`"go:pkg"\`, \`"js:npm_module"\`, \`"rust:crate"\`), \`exact\` (Optional: Set to \`true\` for case-insensitive exact matching without tokenization).
-    *   **Features:** Returns snippets/paths. Supports pagination (repeat query). Caching via \`sessionID\` (reuse if returned). Use \`exact\` flag when you need precise matching of terms.
+    *   **Syntax:** \`query\` (free-form question or Elasticsearch-like keywords: \`AND\`, \`OR\`, \`NOT\`, \`""\` exact phrases), \`path\` (Mandatory: \`"."\`, \`"path/to/dir"\`, \`"path/to/file.ext"\`, \`"go:pkg"\`, \`"js:npm_module"\`, \`"rust:crate"\`), \`exact\` (Optional: Set to \`true\` for case-insensitive exact matching without tokenization).
+    *   **Features:** Returns snippets/paths. Supports pagination (repeat query). Caching via \`sessionID\` (reuse if returned). Use \`exact\` flag when you need precise matching of terms. This tool may internally delegate code discovery when configured; this is not the same as the \`delegate\` tool and requires no explicit call.
 *   \`query\`
     *   **Purpose:** Find code by its *structure* (AST patterns) within specific files/directories, typically after \`search\`.
     *   **Syntax:** \`pattern\` (ast-grep pattern), \`language\` (e.g., "go", "python").
@@ -124,4 +124,4 @@ For GitHub-compatible mermaid diagrams, avoid single quotes and parentheses in n
 - **requirement**: system requirements, traceability
 - **packet**: network protocols, data packets
 - **zenuml**: UML sequence diagrams
-</mermaid-instructions>`
+</mermaid-instructions>`

package/build/tools/vercel.js

@@ -10,6 +10,125 @@ import { extract } from '../extract.js';
 import { delegate } from '../delegate.js';
 import { searchSchema, querySchema, extractSchema, delegateSchema, searchDescription, queryDescription, extractDescription, delegateDescription, parseTargets, parseAndResolvePaths, resolveTargetPath } from './common.js';
 
+const CODE_SEARCH_SCHEMA = {
+	type: 'object',
+	properties: {
+		targets: {
+			type: 'array',
+			items: { type: 'string' },
+			description: 'List of file targets like "path/to/file.ext#Symbol" or "path/to/file.ext:line" or "path/to/file.ext:start-end".'
+		}
+	},
+	required: ['targets'],
+	additionalProperties: false
+};
+
+function normalizeTargets(targets) {
+	if (!Array.isArray(targets)) return [];
+	const seen = new Set();
+	const normalized = [];
+
+	for (const target of targets) {
+		if (typeof target !== 'string') continue;
+		const trimmed = target.trim();
+		if (!trimmed || seen.has(trimmed)) continue;
+		seen.add(trimmed);
+		normalized.push(trimmed);
+	}
+
+	return normalized;
+}
+
+function extractJsonSnippet(text) {
+	const jsonBlockMatch = text.match(/```json\s*([\s\S]*?)```/i);
+	if (jsonBlockMatch) {
+		return jsonBlockMatch[1].trim();
+	}
+
+	const anyBlockMatch = text.match(/```\s*([\s\S]*?)```/);
+	if (anyBlockMatch) {
+		return anyBlockMatch[1].trim();
+	}
+
+	const firstBrace = text.indexOf('{');
+	const lastBrace = text.lastIndexOf('}');
+	if (firstBrace !== -1 && lastBrace > firstBrace) {
+		return text.slice(firstBrace, lastBrace + 1);
+	}
+
+	const firstBracket = text.indexOf('[');
+	const lastBracket = text.lastIndexOf(']');
+	if (firstBracket !== -1 && lastBracket > firstBracket) {
+		return text.slice(firstBracket, lastBracket + 1);
+	}
+
+	return null;
+}
+
+function fallbackTargetsFromText(text) {
+	const candidates = [];
+	const lines = text.split(/\r?\n/);
+
+	for (const line of lines) {
+		let cleaned = line.trim();
+		if (!cleaned) continue;
+		cleaned = cleaned.replace(/^[-*•\d.)\s]+/, '').trim();
+		if (!cleaned) continue;
+		const token = cleaned.split(/\s+/)[0];
+		if (/[#:]|[/\\]|\\./.test(token)) {
+			candidates.push(token);
+		}
+	}
+
+	return candidates;
+}
+
+function parseDelegatedTargets(rawResponse) {
+	if (!rawResponse || typeof rawResponse !== 'string') return [];
+	const trimmed = rawResponse.trim();
+
+	const tryParse = (text) => {
+		try {
+			return JSON.parse(text);
+		} catch {
+			return null;
+		}
+	};
+
+	let parsed = tryParse(trimmed);
+	if (!parsed) {
+		const snippet = extractJsonSnippet(trimmed);
+		if (snippet) {
+			parsed = tryParse(snippet);
+		}
+	}
+
+	if (parsed) {
+		if (Array.isArray(parsed)) {
+			return normalizeTargets(parsed);
+		}
+		if (Array.isArray(parsed.targets)) {
+			return normalizeTargets(parsed.targets);
+		}
+	}
+
+	return normalizeTargets(fallbackTargetsFromText(trimmed));
+}
+
+function buildSearchDelegateTask({ searchQuery, searchPath, exact, language, allowTests }) {
+	return [
+		'You are a code-search subagent. Your ONLY job is to return ALL relevant code locations.',
+		'Use ONLY the search tool. Do NOT answer the question or explain anything.',
+		'Return ONLY valid JSON with this shape: {"targets": ["path/to/file.ext#Symbol", "path/to/file.ext:line", "path/to/file.ext:start-end"]}.',
+		'Prefer #Symbol when a function/class name is clear; otherwise use line numbers.',
+		`Search query: ${searchQuery}`,
+		`Search path(s): ${searchPath}`,
+		`Options: exact=${exact ? 'true' : 'false'}, language=${language || 'auto'}, allow_tests=${allowTests ? 'true' : 'false'}.`,
+		'Run additional searches only if needed to capture all relevant locations.',
+		'Deduplicate targets.'
+	].join('\n');
+}
+
 /**
  * Search tool generator
  * 
@@ -20,58 +139,138 @@ import { searchSchema, querySchema, extractSchema, delegateSchema, searchDescrip
  * @returns {Object} Configured search tool
  */
 export const searchTool = (options = {}) => {
-	const { sessionId, maxTokens = 10000, debug = false, outline = false } = options;
+	const {
+		sessionId,
+		maxTokens = 10000,
+		debug = false,
+		outline = false,
+		searchDelegate = false
+	} = options;
 
 	return tool({
 		name: 'search',
-		description: searchDescription,
+		description: searchDelegate
+			? `${searchDescription} (delegates code search to a subagent and returns extracted code blocks)`
+			: searchDescription,
 		inputSchema: searchSchema,
 		execute: async ({ query: searchQuery, path, allow_tests, exact, maxTokens: paramMaxTokens, language }) => {
-			try {
-				// Use parameter maxTokens if provided, otherwise use the default
-				const effectiveMaxTokens = paramMaxTokens || maxTokens;
+			// Use parameter maxTokens if provided, otherwise use the default
+			const effectiveMaxTokens = paramMaxTokens || maxTokens;
 
-				// Parse and resolve paths (supports comma-separated and relative paths)
-				let searchPaths;
-				if (path) {
-					searchPaths = parseAndResolvePaths(path, options.cwd);
-				}
+			// Parse and resolve paths (supports comma-separated and relative paths)
+			let searchPaths;
+			if (path) {
+				searchPaths = parseAndResolvePaths(path, options.cwd);
+			}
 
-				// Default to cwd or '.' if no paths provided
-				if (!searchPaths || searchPaths.length === 0) {
-					searchPaths = [options.cwd || '.'];
-				}
+			// Default to cwd or '.' if no paths provided
+			if (!searchPaths || searchPaths.length === 0) {
+				searchPaths = [options.cwd || '.'];
+			}
 
-				// Join paths with space for CLI (probe search supports multiple paths)
-				const searchPath = searchPaths.join(' ');
+			// Join paths with space for CLI (probe search supports multiple paths)
+			const searchPath = searchPaths.join(' ');
+
+			const searchOptions = {
+				query: searchQuery,
+				path: searchPath,
+				cwd: options.cwd, // Working directory for resolving relative paths
+				allowTests: allow_tests ?? true,
+				exact,
+				json: false,
+				maxTokens: effectiveMaxTokens,
+				session: sessionId, // Pass session ID if provided
+				language // Pass language parameter if provided
+			};
+
+			// Add outline format if enabled
+			if (outline) {
+				searchOptions.format = 'outline-xml';
+			}
 
+			const runRawSearch = async () => {
 				if (debug) {
 					console.error(`Executing search with query: "${searchQuery}", path: "${searchPath}", exact: ${exact ? 'true' : 'false'}, language: ${language || 'all'}, session: ${sessionId || 'none'}`);
 				}
+				return await search(searchOptions);
+			};
+
+			if (!searchDelegate) {
+				try {
+					return await runRawSearch();
+				} catch (error) {
+					console.error('Error executing search command:', error);
+					return `Error executing search command: ${error.message}`;
+				}
+			}
 
-				const searchOptions = {
-					query: searchQuery,
-					path: searchPath,
-					cwd: options.cwd, // Working directory for resolving relative paths
-					allowTests: allow_tests ?? true,
+			try {
+				if (debug) {
+					console.error(`Delegating search with query: "${searchQuery}", path: "${searchPath}"`);
+				}
+
+				const delegateTask = buildSearchDelegateTask({
+					searchQuery,
+					searchPath,
 					exact,
-					json: false,
-					maxTokens: effectiveMaxTokens,
-					session: sessionId, // Pass session ID if provided
-					language // Pass language parameter if provided
+					language,
+					allowTests: allow_tests ?? true
+				});
+
+				const runDelegation = () => delegate({
+					task: delegateTask,
+					debug,
+					parentSessionId: sessionId,
+					path: options.allowedFolders?.[0] || options.cwd || '.',
+					allowedFolders: options.allowedFolders,
+					provider: options.provider || null,
+					model: options.model || null,
+					tracer: options.tracer || null,
+					enableBash: false,
+					bashConfig: null,
+					architectureFileName: options.architectureFileName || null,
+					promptType: 'code-searcher',
+					allowedTools: ['search', 'attempt_completion'],
+					searchDelegate: false,
+					schema: CODE_SEARCH_SCHEMA
+				});
+
+				const delegateResult = options.tracer?.withSpan
+					? await options.tracer.withSpan('search.delegate', runDelegation, {
+						'search.query': searchQuery,
+						'search.path': searchPath
+					})
+					: await runDelegation();
+
+				const targets = parseDelegatedTargets(delegateResult);
+				if (!targets.length) {
+					if (debug) {
+						console.error('Delegated search returned no targets; falling back to raw search');
+					}
+					return await runRawSearch();
+				}
+
+				const effectiveCwd = options.cwd || '.';
+				const resolvedTargets = targets.map(target => resolveTargetPath(target, effectiveCwd));
+				const extractOptions = {
+					files: resolvedTargets,
+					cwd: effectiveCwd,
+					allowTests: allow_tests ?? true
 				};
 
-				// Add outline format if enabled
 				if (outline) {
-					searchOptions.format = 'outline-xml';
+					extractOptions.format = 'xml';
 				}
 
-				const results = await search(searchOptions);
-
-				return results;
+				return await extract(extractOptions);
 			} catch (error) {
-				console.error('Error executing search command:', error);
-				return `Error executing search command: ${error.message}`;
+				console.error('Delegated search failed, falling back to raw search:', error);
+				try {
+					return await runRawSearch();
+				} catch (fallbackError) {
+					console.error('Error executing search command:', fallbackError);
+					return `Error executing search command: ${fallbackError.message}`;
+				}
 			}
 		}
 	});
@@ -250,16 +449,17 @@ export const extractTool = (options = {}) => {
  * @param {string[]} [options.allowedFolders] - Allowed folders for workspace isolation
  * @param {boolean} [options.enableBash=false] - Enable bash tool for sub-agents
  * @param {Object} [options.bashConfig] - Bash configuration (allow/deny patterns)
+ * @param {string} [options.architectureFileName] - Architecture context filename to embed from repo root
  * @returns {Object} Configured delegate tool
  */
 export const delegateTool = (options = {}) => {
-	const { debug = false, timeout = 300, cwd, allowedFolders, enableBash = false, bashConfig } = options;
+	const { debug = false, timeout = 300, cwd, allowedFolders, enableBash = false, bashConfig, architectureFileName } = options;
 
 	return tool({
 		name: 'delegate',
 		description: delegateDescription,
 		inputSchema: delegateSchema,
-		execute: async ({ task, currentIteration, maxIterations, parentSessionId, path, provider, model, tracer }) => {
+		execute: async ({ task, currentIteration, maxIterations, parentSessionId, path, provider, model, tracer, searchDelegate }) => {
 			// Validate required parameters - throw errors for consistency
 			if (!task || typeof task !== 'string') {
 				throw new Error('Task parameter is required and must be a non-empty string');
@@ -295,6 +495,10 @@ export const delegateTool = (options = {}) => {
 				throw new TypeError('model must be a string, null, or undefined');
 			}
 
+			if (searchDelegate !== undefined && typeof searchDelegate !== 'boolean') {
+				throw new TypeError('searchDelegate must be a boolean if provided');
+			}
+
 			// Determine the path to pass to the subagent
 			// NOTE: Delegation intentionally uses DIFFERENT priority than other tools.
 			//
@@ -331,14 +535,17 @@ export const delegateTool = (options = {}) => {
 				maxIterations: maxIterations || 30,
 				parentSessionId,
 				path: effectivePath,
+				allowedFolders,
 				provider,
 				model,
 				tracer,
 				enableBash,
-				bashConfig
+				bashConfig,
+				architectureFileName,
+				searchDelegate
 			});
 
 			return result;
 		}
 	});
-};
+};