564 lines
14 KiB
Markdown
564 lines
14 KiB
Markdown
---
|
|
description: Answer questions about code or technical topics without creating artifacts
|
|
argument-hint: "<question>"
|
|
allowed-tools: Read, Glob, Grep, Bash, Task
|
|
---
|
|
|
|
# Question Command: Intelligent Q&A System
|
|
|
|
Answer questions about your codebase or general technical topics with zero artifacts.
|
|
|
|
## Core Philosophy
|
|
|
|
**Ask anything, get answers, create nothing.**
|
|
|
|
This command is for Q&A ONLY - no file creation, no documentation generation, no code changes.
|
|
|
|
## Usage Examples
|
|
|
|
```bash
|
|
# Codebase questions
|
|
/lazy question "where is user authentication handled?"
|
|
/lazy question "how does the payment processor work?"
|
|
/lazy question "what files implement the REST API?"
|
|
|
|
# General technical questions
|
|
/lazy question "what is the difference between REST and GraphQL?"
|
|
/lazy question "how to implement OAuth2 in Python?"
|
|
/lazy question "best practices for API versioning?"
|
|
```
|
|
|
|
## When to Use
|
|
|
|
**Use this command when:**
|
|
- You need to understand how something works in the codebase
|
|
- You want to locate specific functionality
|
|
- You have general technical questions
|
|
- You need quick documentation lookups
|
|
|
|
**Do NOT use for:**
|
|
- Creating documentation files
|
|
- Modifying code
|
|
- Generating new files
|
|
- Planning features (use `/lazy plan` instead)
|
|
|
|
## Requirements
|
|
|
|
**Input:**
|
|
- Single question string (clear and specific)
|
|
- Can be about codebase OR general knowledge
|
|
|
|
**Critical:**
|
|
- **NO file creation** - answers only
|
|
- **NO .md files** - inline responses only
|
|
- **NO code generation** - explanation only
|
|
- **NO documentation updates** - read-only operation
|
|
|
|
## Question Type Detection
|
|
|
|
### Decision Logic
|
|
|
|
```python
|
|
def should_use_codebase(question: str) -> bool:
|
|
"""Decide if question is about codebase or general knowledge."""
|
|
|
|
codebase_indicators = [
|
|
"in this", "this codebase", "this project", "this repo",
|
|
"where is", "how does", "why does", "what does",
|
|
"in our", "our codebase", "our project",
|
|
"file", "function", "class", "module",
|
|
"implemented", "defined", "located",
|
|
"show me", "find", "which file"
|
|
]
|
|
|
|
question_lower = question.lower()
|
|
|
|
# If question mentions codebase-specific terms → use codebase
|
|
if any(ind in question_lower for ind in codebase_indicators):
|
|
return True
|
|
|
|
# If question is general knowledge → use research agent
|
|
general_indicators = [
|
|
"what is", "how to", "difference between",
|
|
"best practice", "tutorial", "documentation",
|
|
"learn", "explain", "guide", "introduction"
|
|
]
|
|
|
|
if any(ind in question_lower for ind in general_indicators):
|
|
return False
|
|
|
|
# Default: assume codebase question
|
|
return True
|
|
```
|
|
|
|
### Examples by Type
|
|
|
|
**Codebase Questions (searches project):**
|
|
- "where is user authentication handled?"
|
|
- "how does this project structure payments?"
|
|
- "what files implement the API endpoints?"
|
|
- "in our codebase, how is logging configured?"
|
|
- "show me where database migrations are defined"
|
|
- "which function handles token validation?"
|
|
|
|
**General Questions (uses research agent):**
|
|
- "what is the difference between JWT and session tokens?"
|
|
- "how to implement OAuth2 in Python?"
|
|
- "best practices for API versioning?"
|
|
- "explain what GraphQL is"
|
|
- "tutorial on writing pytest fixtures"
|
|
|
|
## Execution Workflow
|
|
|
|
### Phase 1: Analyze Question
|
|
|
|
```python
|
|
question = "$ARGUMENTS".strip()
|
|
|
|
# Determine question type
|
|
is_codebase_question = should_use_codebase(question)
|
|
|
|
if is_codebase_question:
|
|
approach = "codebase_search"
|
|
tools = ["Grep", "Glob", "Read"]
|
|
else:
|
|
approach = "research_agent"
|
|
tools = ["Task (research agent)"]
|
|
```
|
|
|
|
### Phase 2a: Codebase Question Path
|
|
|
|
**If question is about the codebase:**
|
|
|
|
```python
|
|
# 1. Extract search terms from question
|
|
search_terms = extract_keywords(question)
|
|
# Example: "where is authentication handled?" → ["authentication", "auth", "login"]
|
|
|
|
# 2. Search codebase with Grep
|
|
for term in search_terms:
|
|
# Search for term in code
|
|
matches = grep(pattern=term, output_mode="files_with_matches")
|
|
|
|
# Search for term in comments/docstrings
|
|
doc_matches = grep(pattern=f"(#|//|\"\"\"|\"\"\").*{term}", output_mode="content", -n=True)
|
|
|
|
# 3. Prioritize results
|
|
relevant_files = prioritize_by_relevance(matches, question)
|
|
# Priority: src/ > tests/ > docs/
|
|
|
|
# 4. Read top relevant files
|
|
for file in relevant_files[:5]: # Top 5 most relevant
|
|
content = Read(file_path=file)
|
|
# Extract relevant sections based on search terms
|
|
|
|
# 5. Analyze and answer
|
|
answer = """
|
|
Based on codebase analysis:
|
|
|
|
{synthesized answer from code}
|
|
|
|
**References:**
|
|
- {file1}:{line1}
|
|
- {file2}:{line2}
|
|
"""
|
|
```
|
|
|
|
**Search Strategy:**
|
|
|
|
```python
|
|
# Identify search terms based on question type
|
|
if "where" in question or "which file" in question:
|
|
# Location question - find files
|
|
search_mode = "files_with_matches"
|
|
search_scope = "filenames and content"
|
|
|
|
elif "how does" in question or "how is" in question:
|
|
# Implementation question - show code
|
|
search_mode = "content"
|
|
search_scope = "function definitions and logic"
|
|
context_lines = 10 # Use -C flag
|
|
|
|
elif "what is" in question and is_codebase_question:
|
|
# Definition question - find docstrings/comments
|
|
search_mode = "content"
|
|
search_scope = "docstrings, comments, README"
|
|
```
|
|
|
|
### Phase 2b: General Question Path
|
|
|
|
**If question is general knowledge:**
|
|
|
|
```python
|
|
Task(
|
|
prompt=f"""
|
|
You are the Research Agent for LAZY-DEV-FRAMEWORK.
|
|
|
|
## Question to Answer
|
|
|
|
{question}
|
|
|
|
## Instructions
|
|
|
|
1. This is a GENERAL technical question (not codebase-specific)
|
|
2. Answer based on:
|
|
- Your training knowledge
|
|
- Industry best practices
|
|
- Official documentation (if available)
|
|
- Common patterns and conventions
|
|
|
|
3. Provide a clear, concise answer with:
|
|
- Direct answer to the question
|
|
- Key concepts explained
|
|
- Code examples if relevant (generic, not project-specific)
|
|
- Links to official docs/resources
|
|
|
|
4. Structure answer for readability:
|
|
- Use bullet points for lists
|
|
- Use code blocks for examples
|
|
- Use clear section headers
|
|
|
|
## Output Format
|
|
|
|
**Answer:**
|
|
{direct answer}
|
|
|
|
**Key Concepts:**
|
|
- {concept 1}
|
|
- {concept 2}
|
|
|
|
**Example (if applicable):**
|
|
```language
|
|
{generic code example}
|
|
```
|
|
|
|
**Further Reading:**
|
|
- {resource 1}
|
|
- {resource 2}
|
|
|
|
**Critical Reminder:**
|
|
- Do NOT create any files
|
|
- Do NOT search the codebase
|
|
- Do NOT reference project-specific code
|
|
- This is general knowledge only
|
|
"""
|
|
)
|
|
```
|
|
|
|
## Output Format
|
|
|
|
### For Codebase Questions
|
|
|
|
```markdown
|
|
## Answer
|
|
|
|
Based on codebase analysis:
|
|
|
|
{synthesized answer from code analysis}
|
|
|
|
**Key Files:**
|
|
- `{file1}` - {purpose}
|
|
- `{file2}` - {purpose}
|
|
|
|
**Code References:**
|
|
- {file1}:{line1} - {what happens here}
|
|
- {file2}:{line2} - {what happens here}
|
|
|
|
**Flow:**
|
|
{if applicable, explain the flow through multiple files}
|
|
```
|
|
|
|
### For General Questions
|
|
|
|
```markdown
|
|
## Answer
|
|
|
|
{direct answer to question}
|
|
|
|
**Key Concepts:**
|
|
- {concept 1 with explanation}
|
|
- {concept 2 with explanation}
|
|
|
|
**Example:**
|
|
```language
|
|
{generic code example if relevant}
|
|
```
|
|
|
|
**Further Reading:**
|
|
- {official documentation link}
|
|
- {tutorial or guide link}
|
|
```
|
|
|
|
## Validation
|
|
|
|
**Success criteria:**
|
|
- Question answered clearly and accurately
|
|
- References provided (for codebase questions)
|
|
- No files created or modified
|
|
- No commits made
|
|
- Response is conversational, not a file
|
|
|
|
**Anti-patterns (MUST AVOID):**
|
|
- Creating documentation files
|
|
- Generating .md files
|
|
- Writing code to files
|
|
- Running git commands
|
|
- Creating pull requests
|
|
|
|
## Examples in Action
|
|
|
|
### Example 1: Codebase Location Question
|
|
|
|
```bash
|
|
$ /lazy question "where is user authentication handled?"
|
|
|
|
## Answer
|
|
|
|
Based on codebase analysis:
|
|
|
|
User authentication is handled primarily in the `src/auth/` module:
|
|
|
|
**Key Files:**
|
|
- `src/auth/login.py` - Main login endpoint and session management
|
|
- `src/auth/middleware.py` - Authentication middleware for protected routes
|
|
- `src/auth/jwt_handler.py` - JWT token generation and validation
|
|
|
|
**Code References:**
|
|
- src/auth/login.py:45 - `authenticate_user()` validates credentials
|
|
- src/auth/middleware.py:23 - `require_auth()` decorator protects endpoints
|
|
- src/auth/jwt_handler.py:67 - `generate_token()` creates JWT tokens
|
|
|
|
**Authentication Flow:**
|
|
1. User submits credentials → `login.py:authenticate_user()`
|
|
2. Credentials validated against database
|
|
3. JWT token generated → `jwt_handler.py:generate_token()`
|
|
4. Token returned to client
|
|
5. Protected routes checked by → `middleware.py:require_auth()`
|
|
```
|
|
|
|
### Example 2: Codebase Implementation Question
|
|
|
|
```bash
|
|
$ /lazy question "how does the payment processor work?"
|
|
|
|
## Answer
|
|
|
|
Based on codebase analysis:
|
|
|
|
The payment processor uses a strategy pattern with multiple payment providers:
|
|
|
|
**Key Files:**
|
|
- `src/payment/processor.py` - Main processor coordinator
|
|
- `src/payment/providers/stripe.py` - Stripe integration
|
|
- `src/payment/providers/paypal.py` - PayPal integration
|
|
|
|
**Processing Flow:**
|
|
1. Client initiates payment → `processor.py:process_payment()`
|
|
2. Processor selects provider based on payment method
|
|
3. Provider-specific handler called (Stripe/PayPal)
|
|
4. Payment validated and processed
|
|
5. Result logged and webhook sent
|
|
|
|
**Code References:**
|
|
- src/payment/processor.py:89 - Main `process_payment()` entry point
|
|
- src/payment/processor.py:145 - Provider selection logic
|
|
- src/payment/providers/stripe.py:34 - Stripe charge creation
|
|
- src/payment/webhook.py:23 - Payment confirmation webhook
|
|
|
|
**Error Handling:**
|
|
- Retries configured in processor.py:67 (3 attempts, exponential backoff)
|
|
- Failed payments logged to `payment_failures` table
|
|
- Customer notified via email on failure
|
|
```
|
|
|
|
### Example 3: General Technical Question
|
|
|
|
```bash
|
|
$ /lazy question "what is the difference between REST and GraphQL?"
|
|
|
|
## Answer
|
|
|
|
REST and GraphQL are both API architectural patterns, but they differ in how clients request and receive data:
|
|
|
|
**Key Differences:**
|
|
|
|
1. **Data Fetching:**
|
|
- REST: Multiple endpoints, each returns fixed data structure
|
|
- GraphQL: Single endpoint, client specifies exact data needed
|
|
|
|
2. **Over/Under-fetching:**
|
|
- REST: Often returns too much or too little data
|
|
- GraphQL: Client gets exactly what they request
|
|
|
|
3. **Versioning:**
|
|
- REST: Typically requires version in URL (v1, v2)
|
|
- GraphQL: Schema evolution without versions
|
|
|
|
4. **Request Structure:**
|
|
- REST: HTTP methods (GET, POST, PUT, DELETE)
|
|
- GraphQL: All requests are POST with query body
|
|
|
|
**Example:**
|
|
|
|
REST - Multiple requests needed:
|
|
```bash
|
|
GET /api/users/123 # Get user
|
|
GET /api/users/123/posts # Get user's posts
|
|
GET /api/posts/456/comments # Get post comments
|
|
```
|
|
|
|
GraphQL - Single request:
|
|
```graphql
|
|
query {
|
|
user(id: 123) {
|
|
name
|
|
email
|
|
posts {
|
|
title
|
|
comments {
|
|
text
|
|
author
|
|
}
|
|
}
|
|
}
|
|
}
|
|
```
|
|
|
|
**Further Reading:**
|
|
- [GraphQL Official Docs](https://graphql.org/learn/)
|
|
- [REST API Best Practices](https://restfulapi.net/)
|
|
```
|
|
|
|
### Example 4: Edge Case - Ambiguous Question
|
|
|
|
```bash
|
|
$ /lazy question "how does authentication work?"
|
|
|
|
# Decision: Too ambiguous - clarify first
|
|
|
|
## Clarification Needed
|
|
|
|
Your question "how does authentication work?" could mean:
|
|
|
|
1. **Codebase-specific:** "How does authentication work in THIS project?"
|
|
- Run: `/lazy question "how does authentication work in this codebase?"`
|
|
|
|
2. **General concept:** "How does authentication work as a concept?"
|
|
- Run: `/lazy question "explain authentication concepts and best practices"`
|
|
|
|
Please rephrase your question to be more specific.
|
|
```
|
|
|
|
## Decision Tree
|
|
|
|
```
|
|
Parse question
|
|
↓
|
|
Contains codebase indicators? ──Yes──→ Codebase Search Path
|
|
│ ↓
|
|
No Extract keywords
|
|
↓ ↓
|
|
Contains general indicators? ──Yes──→ Grep/Glob codebase
|
|
│ ↓
|
|
No Read relevant files
|
|
↓ ↓
|
|
Ambiguous Synthesize answer
|
|
↓ ↓
|
|
Ask for clarification Format with references
|
|
↓
|
|
Return answer
|
|
(NO FILES CREATED)
|
|
|
|
Research Agent Path:
|
|
↓
|
|
Delegate to research agent
|
|
↓
|
|
Agent uses training knowledge
|
|
↓
|
|
Format answer with examples
|
|
↓
|
|
Return answer
|
|
(NO FILES CREATED)
|
|
```
|
|
|
|
## Key Principles
|
|
|
|
1. **Read-Only Operation**: Never create, modify, or delete files
|
|
2. **Zero Artifacts**: No .md files, no commits, no PRs
|
|
3. **Smart Detection**: Auto-determine codebase vs general question
|
|
4. **Cite Sources**: Always reference file:line for codebase answers
|
|
5. **Conversational**: Return inline answers, not documentation
|
|
6. **Focused Search**: Top 5 most relevant files only
|
|
7. **Context-Aware**: Use -C flag for code context when needed
|
|
|
|
## Integration Points
|
|
|
|
**With other commands:**
|
|
```bash
|
|
# Learn about codebase before implementing
|
|
/lazy question "where is user validation implemented?"
|
|
/lazy code "add email validation to user signup"
|
|
|
|
# Understand before documenting
|
|
/lazy question "how does the API rate limiting work?"
|
|
/lazy docs src/api/rate_limiter.py
|
|
|
|
# Research before planning
|
|
/lazy question "best practices for OAuth2 implementation"
|
|
/lazy plan "add OAuth2 authentication"
|
|
```
|
|
|
|
## Environment Variables
|
|
|
|
None required - this is a pure Q&A command.
|
|
|
|
## Troubleshooting
|
|
|
|
**Issue: "No results found"**
|
|
```
|
|
Try rephrasing your question:
|
|
- Use different keywords
|
|
- Be more specific about file types or modules
|
|
- Check if functionality exists in project
|
|
```
|
|
|
|
**Issue: "Too many results"**
|
|
```
|
|
Narrow your question:
|
|
- Specify module or component
|
|
- Add context about feature area
|
|
- Ask about specific file/function
|
|
```
|
|
|
|
**Issue: "Wrong type detected"**
|
|
```
|
|
Force codebase search:
|
|
- Add "in this codebase" to question
|
|
|
|
Force general search:
|
|
- Add "explain" or "what is" to question
|
|
```
|
|
|
|
## Anti-Patterns to Avoid
|
|
|
|
**DO NOT:**
|
|
- Create documentation files from answers
|
|
- Generate code files based on research
|
|
- Write .md files with Q&A content
|
|
- Make commits or PRs
|
|
- Modify existing files
|
|
- Create new directories
|
|
|
|
**DO:**
|
|
- Answer questions inline
|
|
- Provide file references
|
|
- Show code snippets in response
|
|
- Explain concepts clearly
|
|
- Link to external resources
|
|
|
|
---
|
|
|
|
**Version:** 2.2.0
|
|
**Status:** Production-Ready
|
|
**Philosophy:** Ask anything, get answers, create nothing.
|