@probelabs/probe 0.6.0-rc279 → 0.6.0-rc280

package/build/downloader.js

@@ -95,9 +95,7 @@ async function acquireFileLock(lockPath, version) {
 	try {
 		// Try to create lock file atomically (fails if already exists)
 		await fs.writeFile(lockPath, JSON.stringify(lockData), { flag: 'wx' });
-		if (process.env.DEBUG === '1' || process.env.VERBOSE === '1') {
-			console.log(`Acquired file lock: ${lockPath}`);
-		}
+		console.log(`Acquired file lock: ${lockPath}`);
 		return true;
     } catch (error) {
 		if (error.code === 'EEXIST') {
@@ -108,17 +106,13 @@ async function acquireFileLock(lockPath, version) {
 
 				if (lockAge > LOCK_TIMEOUT_MS) {
 					// Lock is stale, remove it
-					if (process.env.DEBUG === '1' || process.env.VERBOSE === '1') {
-						console.log(`Removing stale lock file (age: ${Math.round(lockAge / 1000)}s, pid: ${existingLock.pid})`);
-					}
+					console.log(`Removing stale lock file (age: ${Math.round(lockAge / 1000)}s, pid: ${existingLock.pid})`);
 					await fs.remove(lockPath);
 					return false; // Caller should retry
 				}
 
 				// Lock is fresh, another process is downloading
-				if (process.env.DEBUG === '1' || process.env.VERBOSE === '1') {
-					console.log(`Download in progress by process ${existingLock.pid}, waiting...`);
-				}
+				console.log(`Download in progress by process ${existingLock.pid}, waiting...`);
 				return false;
 			} catch (readError) {
 				// Can't read lock file, might be corrupted - remove it
@@ -180,23 +174,23 @@ async function releaseFileLock(lockPath) {
  */
 async function waitForFileLock(lockPath, binaryPath) {
 	const startTime = Date.now();
+	let lastStatusTime = startTime;
+
+	console.log(`Waiting for file lock to clear: ${lockPath}`);
 
 	// Poll in a loop until binary appears, lock expires, or we timeout
 	while (Date.now() - startTime < MAX_LOCK_WAIT_MS) {
 		// Check #1: Is the binary now available?
 		if (await fs.pathExists(binaryPath)) {
-			if (process.env.DEBUG === '1' || process.env.VERBOSE === '1') {
-				console.log(`Binary now available at ${binaryPath}, download completed by another process`);
-			}
+			const waitedSeconds = Math.round((Date.now() - startTime) / 1000);
+			console.log(`Binary now available at ${binaryPath}, download completed by another process (waited ${waitedSeconds}s)`);
 			return true;
 		}
 
 		// Check #2: Is the lock file gone? (download finished or failed)
 		const lockExists = await fs.pathExists(lockPath);
 		if (!lockExists) {
-			if (process.env.DEBUG === '1' || process.env.VERBOSE === '1') {
-				console.log(`Lock file removed but binary not found - download may have failed`);
-			}
+			console.log(`Lock file removed but binary not found - download may have failed`);
 			return false;
 		}
 
@@ -205,22 +199,24 @@ async function waitForFileLock(lockPath, binaryPath) {
 			const lockData = JSON.parse(await fs.readFile(lockPath, 'utf-8'));
 			const lockAge = Date.now() - lockData.timestamp;
 			if (lockAge > LOCK_TIMEOUT_MS) {
-				if (process.env.DEBUG === '1' || process.env.VERBOSE === '1') {
-					console.log(`Lock expired (age: ${Math.round(lockAge / 1000)}s), will retry download`);
-				}
+				console.log(`Lock expired (age: ${Math.round(lockAge / 1000)}s), will retry download`);
 				return false;
 			}
 		} catch {
 			// Ignore errors reading lock file - will retry on next poll
 		}
 
+		if (Date.now() - lastStatusTime >= 15000) {
+			const elapsedSeconds = Math.round((Date.now() - startTime) / 1000);
+			console.log(`Still waiting for file lock (${elapsedSeconds}s/${MAX_LOCK_WAIT_MS / 1000}s max)`);
+			lastStatusTime = Date.now();
+		}
+
 		// Wait 1 second before checking again
 		await new Promise(resolve => setTimeout(resolve, LOCK_POLL_INTERVAL_MS));
 	}
 
-	if (process.env.DEBUG === '1' || process.env.VERBOSE === '1') {
-		console.log(`Timeout waiting for file lock`);
-	}
+	console.log(`Timeout waiting for file lock after ${MAX_LOCK_WAIT_MS / 1000}s`);
 	return false;
 }
 
@@ -247,9 +243,7 @@ async function withDownloadLock(version, downloadFn) {
 			}
 			downloadLocks.delete(lockKey);
 		} else {
-			if (process.env.DEBUG === '1' || process.env.VERBOSE === '1') {
-				console.log(`Download already in progress in this process for version ${lockKey}, waiting...`);
-			}
+			console.log(`Download already in progress in this process for version ${lockKey}, waiting...`);
 			try {
 				return await lock.promise;
 			} catch (error) {
@@ -262,10 +256,16 @@ async function withDownloadLock(version, downloadFn) {
 	}
 
 	// Create new download promise with timeout protection
+	let timeoutId = null;
 	const downloadPromise = Promise.race([
 		downloadFn(),
 		new Promise((_, reject) =>
-			setTimeout(() => reject(new Error(`Download timeout after ${LOCK_TIMEOUT_MS / 1000}s`)), LOCK_TIMEOUT_MS)
+			{
+				timeoutId = setTimeout(() => reject(new Error(`Download timeout after ${LOCK_TIMEOUT_MS / 1000}s`)), LOCK_TIMEOUT_MS);
+				if (timeoutId.unref) {
+					timeoutId.unref();
+				}
+			}
 		)
 	]);
 
@@ -278,6 +278,9 @@ async function withDownloadLock(version, downloadFn) {
 		const result = await downloadPromise;
 		return result;
 	} finally {
+		if (timeoutId) {
+			clearTimeout(timeoutId);
+		}
 		// Clean up lock after download completes (success or failure)
 		downloadLocks.delete(lockKey);
 	}

package/build/tools/analyzeAll.js

@@ -227,18 +227,14 @@ async function processChunksParallel(chunks, extractionPrompt, maxWorkers, optio
 
 			active.add(promise);
 
-			if (options.debug) {
-				console.error(`[analyze_all] Started processing chunk ${chunk.id}/${chunk.total}`);
-			}
+			console.error(`[analyze_all] Started processing chunk ${chunk.id}/${chunk.total}`);
 		}
 
 		if (active.size > 0) {
 			const result = await Promise.race(active);
 			results.push(result);
 
-			if (options.debug) {
-				console.error(`[analyze_all] Completed chunk ${result.chunk.id}/${result.chunk.total}`);
-			}
+			console.error(`[analyze_all] Completed chunk ${result.chunk.id}/${result.chunk.total}`);
 		}
 	}
 

package/build/tools/common.js

@@ -8,7 +8,7 @@ import { resolve, isAbsolute } from 'path';
 
 // 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 quotes for exact matches, AND/OR for boolean logic, - for negation.'),
+	query: z.string().describe('Search query — natural language questions or Elasticsearch-style keywords both work. For keywords: use quotes for exact phrases, AND/OR for boolean logic, - for negation. Probe handles stemming and camelCase/snake_case splitting automatically, so do NOT try case or style variations of the same keyword.'),
 	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.'),
 	exact: z.boolean().optional().default(false).describe('Default (false) enables stemming and keyword splitting for exploratory search - "getUserData" matches "get", "user", "data", etc. Set true for precise symbol lookup where "getUserData" matches only "getUserData". Use true when you know the exact symbol name.'),
 	maxTokens: z.number().nullable().optional().describe('Maximum tokens to return. Default is 20000. Set to null for unlimited results.'),
@@ -17,7 +17,7 @@ export const searchSchema = z.object({
 });
 
 export const searchAllSchema = z.object({
-	query: z.string().describe('Search query with Elasticsearch syntax. Use quotes for exact matches, AND/OR for boolean logic, - for negation.'),
+	query: z.string().describe('Search query — natural language questions or Elasticsearch-style keywords both work. For keywords: use quotes for exact phrases, AND/OR for boolean logic, - for negation. Probe handles stemming and camelCase/snake_case splitting automatically, so do NOT try case or style variations of the same keyword.'),
 	path: z.string().optional().default('.').describe('Path to search in.'),
 	exact: z.boolean().optional().default(false).describe('Use exact matching instead of stemming.'),
 	maxTokensPerPage: z.number().optional().default(20000).describe('Tokens per page when paginating. Default 20000.'),
@@ -149,7 +149,8 @@ export const attemptCompletionSchema = {
 
 // Tool descriptions (used by Vercel tool() definitions)
 
-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 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. NOTE: By default, search handles stemming, case-insensitive matching, and camelCase/snake_case splitting automatically — do NOT manually try keyword variations like "getAllUsers" then "get_all_users" then "GetAllUsers". One search covers all variations.';
+export const searchDelegateDescription = 'Search code in the repository by asking a question. Accepts natural language questions (e.g., "How does authentication work?", "Where is the user validation logic?"). A specialized subagent breaks down your question into targeted keyword searches and returns extracted code blocks. Do NOT formulate keyword queries yourself — just ask the question naturally.';
 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. Line numbers from output can be used with edit start_line/end_line for precise editing.';
 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.';

package/build/tools/vercel.js

@@ -9,7 +9,7 @@ import { query } from '../query.js';
 import { extract } from '../extract.js';
 import { delegate } from '../delegate.js';
 import { analyzeAll } from './analyzeAll.js';
-import { searchSchema, querySchema, extractSchema, delegateSchema, analyzeAllSchema, searchDescription, queryDescription, extractDescription, delegateDescription, analyzeAllDescription, parseTargets, parseAndResolvePaths, resolveTargetPath } from './common.js';
+import { searchSchema, querySchema, extractSchema, delegateSchema, analyzeAllSchema, searchDescription, searchDelegateDescription, queryDescription, extractDescription, delegateDescription, analyzeAllDescription, parseTargets, parseAndResolvePaths, resolveTargetPath } from './common.js';
 import { existsSync } from 'fs';
 import { formatErrorForAI } from '../utils/error-types.js';
 import { annotateOutputWithHashes } from './hashline.js';
@@ -143,11 +143,41 @@ function buildSearchDelegateTask({ searchQuery, searchPath, exact, language, all
 		'- extract: Verify code snippets to ensure targets are actually relevant before including them.',
 		'- listFiles: Understand directory structure to find where relevant code might live.',
 		'',
-		'Strategy for complex queries:',
+		'CRITICAL - How probe search works (do NOT ignore):',
+		'- By default (exact=false), probe ALREADY handles stemming, case-insensitive matching, and camelCase/snake_case splitting.',
+		'- Searching "allowed_ips" ALREADY matches "AllowedIPs", "allowedIps", "allowed_ips", etc. Do NOT manually try case/style variations.',
+		'- Searching "getUserData" ALREADY matches "get", "user", "data" and their variations.',
+		'- NEVER repeat the same search query — you will get the same results.',
+		'- NEVER search trivial variations of the same keyword (e.g., AllowedIPs then allowedIps then allowed_ips). This is wasteful — probe handles it.',
+		'- If a search returns no results, the term likely does not exist in that path. Try a genuinely DIFFERENT keyword or concept, not a variation.',
+		'- If 2-3 consecutive searches return no results for a concept, STOP searching for it and move on.',
+		'',
+		'GOOD search strategy (do this):',
+		'  Query: "How does authentication work and how are sessions managed?"',
+		'  → search "authentication" → search "session management" (two different concepts)',
+		'  Query: "Find the IP allowlist middleware"',
+		'  → search "allowlist middleware" (one search, probe handles IP/ip/Ip variations)',
+		'  Query: "How does BM25 scoring work with SIMD optimization?"',
+		'  → search "BM25 scoring" → search "SIMD optimization" (two different concepts)',
+		'',
+		'BAD search strategy (never do this):',
+		'  → search "AllowedIPs" → search "allowedIps" → search "allowed_ips" (WRONG: these are trivial case variations, probe handles them)',
+		'  → search "CIDR" → search "cidr" → search "Cidr" → search "*cidr*" (WRONG: same keyword repeated with variations)',
+		'  → search "error handling" → search "error handling" → search "error handling" (WRONG: repeating exact same query)',
+		'',
+		'Keyword tips:',
+		'- Common programming keywords are filtered as stopwords when unquoted: function, class, return, new, struct, impl, var, let, const, etc.',
+		'- Avoid searching for these alone — combine with a specific term (e.g., "middleware function" is fine, "function" alone is too generic).',
+		'- To bypass stopword filtering: wrap terms in quotes ("return", "struct") or set exact=true. Both disable stemming and splitting too.',
+		'- Multiple words without operators use OR logic: foo bar = foo OR bar. Use AND explicitly if you need both: foo AND bar.',
+		'- camelCase terms are split: getUserData becomes "get", "user", "data" — so one search covers all naming styles.',
+		'',
+		'Strategy:',
 		'1. Analyze the query - identify key concepts, entities, and relationships',
-		'2. Run focused searches for each independent concept (e.g., for "how do payments work and how are emails sent", search "payments" and "emails" separately since they are unrelated)',
-		'3. Use extract to verify relevance of promising results',
-		'4. Combine all relevant targets in your final response',
+		'2. Run ONE focused search per concept with the most natural keyword. Trust probe to handle variations.',
+		'3. If a search returns results, use extract to verify relevance',
+		'4. Only try a different keyword if the first one returned irrelevant results (not if it returned no results — that means the concept is absent)',
+		'5. Combine all relevant targets in your final response',
 		'',
 		`Query: ${searchQuery}`,
 		`Search path(s): ${searchPath}`,
@@ -186,10 +216,16 @@ export const searchTool = (options = {}) => {
 		return result;
 	};
 
+	// Track previous non-paginated searches to detect and block duplicates
+	const previousSearches = new Set();
+	// Track pagination counts per query to cap runaway pagination
+	const paginationCounts = new Map();
+	const MAX_PAGES_PER_QUERY = 3;
+
 	return tool({
 		name: 'search',
 		description: searchDelegate
-			? `${searchDescription} (delegates code search to a subagent and returns extracted code blocks)`
+			? searchDelegateDescription
 			: searchDescription,
 		inputSchema: searchSchema,
 		execute: async ({ query: searchQuery, path, allow_tests, exact, maxTokens: paramMaxTokens, language, session, nextPage }) => {
@@ -236,6 +272,29 @@ export const searchTool = (options = {}) => {
 			};
 
 			if (!searchDelegate) {
+				// Block duplicate non-paginated searches (models sometimes repeat the exact same call)
+				// Allow pagination: only nextPage=true is a legitimate repeat of the same query
+				const searchKey = `${searchQuery}::${searchPath}::${exact || false}`;
+				if (!nextPage) {
+					if (previousSearches.has(searchKey)) {
+						if (debug) {
+							console.error(`[DEDUP] Blocked duplicate search: "${searchQuery}" in "${searchPath}"`);
+						}
+						return 'DUPLICATE SEARCH BLOCKED: You already searched for this exact query in this path. Do NOT repeat the same search. If you need more results, set nextPage=true with the session ID from the previous search. Otherwise, try a genuinely different keyword, use extract to examine results you already found, or use attempt_completion if you have enough information.';
+					}
+					previousSearches.add(searchKey);
+					paginationCounts.set(searchKey, 0);
+				} else {
+					// Cap pagination to prevent runaway page-through of broad queries
+					const pageCount = (paginationCounts.get(searchKey) || 0) + 1;
+					paginationCounts.set(searchKey, pageCount);
+					if (pageCount > MAX_PAGES_PER_QUERY) {
+						if (debug) {
+							console.error(`[DEDUP] Blocked excessive pagination (page ${pageCount}/${MAX_PAGES_PER_QUERY}): "${searchQuery}" in "${searchPath}"`);
+						}
+						return `PAGINATION LIMIT REACHED: You have already retrieved ${MAX_PAGES_PER_QUERY} pages of results for this query. You have enough results — use extract to examine specific files, or use attempt_completion to return your findings.`;
+					}
+				}
 				try {
 					const result = maybeAnnotate(await runRawSearch());
 					// Track files found in search results for staleness detection