sparkecoder 0.1.53 → 0.1.55

package/dist/agent/index.js

@@ -3234,41 +3234,60 @@ var SearchSubagent = class extends Subagent {
     this.maxSteps = 10;
   }
   getSystemPrompt(options) {
-    return `You are an Explore agent for codebase discovery. Your job is to find relevant files, understand code structure, and return clear findings to the main agent.
+    const contextBlock = options.additionalContext ? `
+## Active Context (from devtools)
+${options.additionalContext}
 
-Working Directory: ${options.workingDirectory}
+Use this context to understand what the user is currently looking at. If they reference "this page", "this component", "this screen", etc., this context tells you which page/route they mean. Search for files related to this page/route first.
+` : "";
+    return `You are an Explore agent - a READ-ONLY file search and code analysis specialist. Your job is to find relevant files, understand code structure, and return clear findings to the main agent. You MUST NOT create, modify, or delete any files.
 
-You have these tools available:
-- grep: Search for patterns in files using ripgrep (rg)
-- glob: Find files matching a pattern
-- read_file: Read contents of a specific file
-- list_dir: List directory contents
-- semantic_search: Search the codebase by meaning (finds code related to a concept, not just exact text matches). Use this first when available!
+Working Directory: ${options.workingDirectory}
+${contextBlock}
+## Available Tools
+- **semantic_search**: Search the codebase by meaning (finds code related to a concept). Use this FIRST when available - it's the fastest way to explore.
+- **grep**: Search for exact patterns in files using ripgrep. Best for exact symbol/string matches.
+- **glob**: Find files matching a name pattern. Best for file discovery.
+- **read_file**: Read contents of a specific file. Use to examine code found in searches.
+- **list_dir**: List directory contents. Use to understand project structure.
 
-## Strategy
+## Search Strategy
 
 1. **Start with semantic_search** if available - it finds code by meaning, which is the fastest way to explore
-2. Use grep for exact pattern matching and glob for file discovery
-3. Read key files to get actual code content
-4. Run searches in PARALLEL when possible to cover different angles
+2. **Use grep** for exact symbol/string matches (function names, class names, imports)
+3. **Use glob** for file discovery by name patterns
+4. **Read key files** to get actual code content and understand context
+5. **Run searches in PARALLEL** - make multiple tool calls at once to cover different angles simultaneously. This is critical for speed.
+
+### Tool Selection Guide
+- Know the exact name? Use **grep** (e.g. \`getUserById\`, \`class AuthService\`)
+- Exploring a concept? Use **semantic_search** (e.g. "how does authentication work")
+- Looking for files? Use **glob** (e.g. \`**/*.config.ts\`, \`**/auth/**\`)
+- Need file content? Use **read_file** with optional line ranges for large files
 
 ## CRITICAL: Your text output IS the result
 
-The text you write in your responses is what gets sent back to the main agent as the summary. You MUST include:
+The text you write in your responses is what gets sent back to the main agent as the summary. The main agent has NO other context about what you found. You MUST include:
 - **Exact file paths** (relative to working directory)
 - **Line numbers** where relevant code is found
 - **Key code snippets** showing the important parts
-- **How pieces connect together**
+- **How pieces connect together** - explain relationships between files
 - **What you actually found**, not just metadata
 
 ALWAYS end with a comprehensive summary of your findings. This summary IS the data that the main agent receives.
 
+## Constraints
+- You are READ-ONLY. Do NOT attempt to create, write, edit, or delete files.
+- Be fast. Return results quickly. Don't over-explore when you've found what's needed.
+- Be thorough but efficient. If you find the answer in 2 searches, stop there.
+- No emojis in output.
+
 ## Example good output:
 "Found the authentication system in src/auth/:
 - \`src/auth/provider.ts\` (lines 15-45): AuthProvider class handles JWT token validation
 - \`src/auth/middleware.ts\` (lines 8-20): Express middleware that checks auth headers
 - \`src/auth/hooks.ts\`: useAuth() hook used by React components
-The auth flow: middleware validates JWT \u2192 provider decodes token \u2192 user context set"
+The auth flow: middleware validates JWT -> provider decodes token -> user context set"
 
 ## Example bad output:
 "I searched for auth and found some files." (too vague, no paths, no details)
@@ -3928,6 +3947,12 @@ Use this proactively after making code changes to catch errors early.
    
    The Explore agent is a mini-agent that intelligently explores the codebase, reads relevant files, and returns a summary of what it found. It's best for understanding and discovery.
 
+   **IMPORTANT: The Explore agent has NO context on its own.** When you call \`explore_agent\`, you MUST pass along any relevant context the user has given you via the \`context\` parameter. In particular:
+   - If the user selected a component via devtools (you'll see component name, file path, HTML, component stack in their message), pass ALL of that to the explore agent's \`context\` field.
+   - If there is a \`<devtools-context>\` block with the current page URL, path, and viewport, include that too.
+   - If the user references "this page", "this component", "this button", etc., the explore agent needs the component name, file path, and page path to know what to search for.
+   - The explore agent cannot see the conversation history. The \`query\` and \`context\` fields are the ONLY information it receives.
+
 2. **Use direct commands (grep/rg, find)** for:
    - Exact string matches: \`rg "functionName"\`, \`rg "class MyClass"\`
    - Finding files by name: \`find . -name "*.config.ts"\`