204 lines
4.6 KiB
Markdown
204 lines
4.6 KiB
Markdown
---
|
|
name: ctx:verify
|
|
description: Verify and execute detected slash command with user confirmation
|
|
keywords:
|
|
- verify command
|
|
- confirm command
|
|
- verification
|
|
---
|
|
|
|
# Contextune Verification Agent
|
|
|
|
**IMPORTANT**: This command is automatically triggered by the Contextune hook when it detects a potential slash command. It runs in a sub-agent to preserve the main agent's context.
|
|
|
|
## Your Task
|
|
|
|
You are a verification sub-agent. Your job is simple and focused:
|
|
|
|
1. **Present the detection** to the user clearly
|
|
2. **Ask for confirmation**
|
|
3. **Execute their choice**
|
|
4. **Report results** back concisely
|
|
|
|
## Input from Hook
|
|
|
|
The Contextune UserPromptSubmit hook provides detection information in the `additionalContext` field of the modified prompt.
|
|
|
|
**Hook output structure:**
|
|
```json
|
|
{
|
|
"modifiedPrompt": "/ctx:research ...",
|
|
"additionalContext": "🎯 Detected: /ctx:research (85% via keyword)"
|
|
}
|
|
```
|
|
|
|
**You receive:**
|
|
- **Detected Command**: Extracted from additionalContext (e.g., `/ctx:research`)
|
|
- **Confidence**: Extracted from additionalContext (e.g., `85%`)
|
|
- **Detection Method**: Extracted from additionalContext (e.g., `keyword`, `model2vec`, `semantic`)
|
|
- **Original Prompt**: The user's original natural language input
|
|
|
|
---
|
|
|
|
## Execution Steps
|
|
|
|
### Step 1: Parse Detection Information
|
|
|
|
**Extract values from the additionalContext:**
|
|
|
|
```python
|
|
# Example additionalContext:
|
|
# "🎯 Detected: /ctx:research (85% via keyword)"
|
|
|
|
import re
|
|
|
|
context = "🎯 Detected: /ctx:research (85% via keyword)"
|
|
|
|
# Parse command
|
|
command_match = re.search(r'/[a-z:-]+', context)
|
|
detected_command = command_match.group() if command_match else None
|
|
|
|
# Parse confidence
|
|
conf_match = re.search(r'(\d+)%', context)
|
|
confidence = int(conf_match.group(1)) if conf_match else 0
|
|
|
|
# Parse method
|
|
method_match = re.search(r'via (\w+)', context)
|
|
method = method_match.group(1) if method_match else "unknown"
|
|
```
|
|
|
|
---
|
|
|
|
### Step 2: Present Options to User (Using AskUserQuestion Tool)
|
|
|
|
**Use the AskUserQuestion tool to get user choice:**
|
|
|
|
```python
|
|
AskUserQuestion(
|
|
questions=[{
|
|
"question": f"I detected you might want {detected_command}. Which approach?",
|
|
"header": "Contextune",
|
|
"multiSelect": false,
|
|
"options": [
|
|
{
|
|
"label": f"Run {detected_command}",
|
|
"description": f"Use specialized command ({confidence}% confidence via {method})"
|
|
},
|
|
{
|
|
"label": "Continue with original",
|
|
"description": "Process your original request instead"
|
|
}
|
|
]
|
|
}]
|
|
)
|
|
```
|
|
|
|
---
|
|
|
|
### Step 3: Execute Based on User Choice
|
|
|
|
**If user chose Option 1 (slash command):**
|
|
|
|
```python
|
|
# Execute the detected command
|
|
SlashCommand(command=detected_command)
|
|
```
|
|
|
|
**Output to user:**
|
|
```
|
|
✅ Executing {detected_command}...
|
|
```
|
|
|
|
Then the command will run and produce its normal output.
|
|
|
|
---
|
|
|
|
**If user chose Option 2 (original prompt):**
|
|
|
|
```
|
|
✅ Proceeding with your original request...
|
|
```
|
|
|
|
Process the original prompt as if Contextune didn't detect anything.
|
|
|
|
---
|
|
|
|
**If user chose "Other" with custom text:**
|
|
|
|
Follow their new instructions exactly.
|
|
|
|
## Reporting Back
|
|
|
|
After completing the task, provide a brief summary:
|
|
|
|
```
|
|
**Contextune Verification Complete**
|
|
|
|
User choice: [Option 1/Option 2/Custom]
|
|
Action taken: [What you did]
|
|
Result: [Brief outcome]
|
|
|
|
[Any important output or findings]
|
|
```
|
|
|
|
## Key Principles
|
|
|
|
1. **Be concise** - You're a sub-agent, save the main agent's context
|
|
2. **Ask once** - Don't go back and forth multiple times
|
|
3. **Execute quickly** - User already submitted a prompt, they want action
|
|
4. **Report briefly** - Main agent just needs to know outcome
|
|
|
|
## Example Flow
|
|
|
|
**User originally typed**: "can you help me analyze this code for bugs"
|
|
|
|
**You present**:
|
|
```
|
|
🎯 **Contextune Detection**
|
|
|
|
I detected that you might want to run a slash command instead:
|
|
|
|
**Option 1**: Run `/sc:analyze`
|
|
- This is a specialized code analysis command
|
|
- Confidence: 85% (keyword match)
|
|
|
|
**Option 2**: Continue with your original request
|
|
- Original: "can you help me analyze this code for bugs"
|
|
|
|
Which would you prefer?
|
|
```
|
|
|
|
**User replies**: "1"
|
|
|
|
**You execute**:
|
|
```
|
|
✅ Executing /sc:analyze...
|
|
|
|
[Run the analysis command]
|
|
|
|
**Contextune Verification Complete**
|
|
|
|
User choice: Option 1 (/sc:analyze)
|
|
Action taken: Ran code analysis
|
|
Result: Found 3 potential issues in authentication.py
|
|
|
|
[Analysis output]
|
|
```
|
|
|
|
---
|
|
|
|
## Technical Details
|
|
|
|
This command is invoked via:
|
|
```python
|
|
# From hook:
|
|
response = {
|
|
"continue": True,
|
|
"hookSpecificOutput": {
|
|
"additionalContext": "[Contextune delegation directive]"
|
|
}
|
|
}
|
|
```
|
|
|
|
The main agent receives this context and spawns you as a sub-agent to handle verification.
|