kairo-code 0.1.0__py3-none-any.whl

kairo_code/agents/base.py

@@ -0,0 +1,463 @@
+"""Base agent class with robust tool loop execution"""
+
+import hashlib
+import time
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from typing import Generator, Callable
+from enum import Enum
+
+from ..llm import LLM
+from ..config import Config
+from ..tools.base import (
+    ToolRegistry, parse_tool_calls, ToolResult,
+    format_tool_error, ToolParseResult, ParsedToolCall
+)
+from ..logging_config import get_agent_logger, log_tool_call
+
+logger = get_agent_logger()
+
+
+class AgentStatus(Enum):
+    RUNNING = "running"
+    COMPLETED = "completed"
+    ERROR = "error"
+    MAX_ITERATIONS = "max_iterations"
+
+
+@dataclass
+class AgentEvent:
+    """Structured event from agent execution."""
+    type: str  # "thinking", "tool_start", "tool_result", "text", "error", "done"
+    content: str = ""
+    tool_name: str | None = None
+    tool_params: dict | None = None
+    success: bool = True
+
+
+@dataclass
+class AgentMessage:
+    """A message in the agent's conversation."""
+    role: str  # "user", "assistant", "tool", "error"
+    content: str
+    tool_name: str | None = None
+    tool_result: ToolResult | None = None
+    thinking: str | None = None
+
+
+@dataclass
+class AgentState:
+    """Current state of an agent execution."""
+    messages: list[AgentMessage] = field(default_factory=list)
+    tool_calls_made: int = 0
+    failed_parses: int = 0
+    retries: int = 0
+    status: AgentStatus = AgentStatus.RUNNING
+    final_response: str = ""
+    thinking_log: list[str] = field(default_factory=list)
+
+    # Context tracking (approximate)
+    estimated_tokens: int = 0
+
+    # Track recent tool calls to prevent loops: (tool_name, key_param) -> success
+    recent_tool_calls: dict[tuple[str, str], bool] = field(default_factory=dict)
+
+    # Track recent file writes to detect identical content loops
+    recent_file_hashes: dict[str, str] = field(default_factory=dict)  # path -> content_hash
+
+
+class Agent(ABC):
+    """
+    Base agent class that can execute multi-step tasks using tools.
+
+    Features:
+    - Robust tool parsing with multiple format support
+    - Retry mechanism with error feedback
+    - Thinking/scratchpad extraction
+    - Context window tracking
+    - Configurable confirmation for destructive actions
+    """
+
+    name: str = "base_agent"
+    description: str = "Base agent"
+    max_iterations: int = 10
+    max_retries: int = 3  # Retries per malformed tool call
+    max_context_tokens: int = 6000  # Conservative limit for 7B models
+
+    # Override in subclasses
+    require_confirmation: list[str] = ["write_file", "bash"]
+
+    def __init__(
+        self,
+        llm: LLM,
+        tools: ToolRegistry,
+        on_confirm: Callable[[str], bool] | None = None
+    ):
+        self.llm = llm
+        self.tools = tools
+        self.on_confirm = on_confirm  # Callback for confirmation prompts
+        self.state = AgentState()
+        self.config = Config()  # Load config for safety settings
+
+    @abstractmethod
+    def get_system_prompt(self) -> str:
+        """Get the system prompt for this agent."""
+        pass
+
+    def get_tool_examples(self) -> str:
+        """Get few-shot examples of tool usage. Override in subclasses."""
+        return ""
+
+    def run_events(self, task: str) -> Generator[AgentEvent, None, None]:
+        """
+        Run the agent and yield structured events.
+
+        This is the preferred method for UI rendering - it yields clean events
+        instead of raw LLM chunks.
+        """
+        logger.info(f"=== Agent '{self.name}' starting task ===")
+        logger.info(f"Task: {task[:200]}...")
+
+        self.state = AgentState()
+        self.state.messages.append(AgentMessage(role="user", content=task))
+        self._update_token_estimate()
+
+        consecutive_failures = 0
+        max_iter = self.config.max_iterations or self.max_iterations
+        accumulated_text = []
+
+        iteration = 0
+        while iteration < max_iter:
+            iteration += 1
+            logger.info(f"--- Iteration {iteration}/{max_iter} ---")
+
+            # Check context limits
+            if self.state.estimated_tokens > self.max_context_tokens:
+                logger.warning(f"Context limit approaching: {self.state.estimated_tokens} tokens")
+                self._summarize_history()
+
+            # Build messages for LLM
+            messages = self._build_messages()
+
+            # Notify UI that we're waiting for LLM
+            yield AgentEvent(type="thinking", content=f"Thinking... (iteration {iteration})")
+
+            # Get LLM response (don't stream to UI - collect it)
+            response_chunks = []
+            llm_start = time.time()
+            try:
+                for chunk in self.llm.chat(messages, stream=True):
+                    response_chunks.append(chunk)
+                llm_elapsed = time.time() - llm_start
+                logger.info(f"LLM response received in {llm_elapsed:.2f}s")
+            except Exception as e:
+                logger.error(f"LLM Error: {e}")
+                yield AgentEvent(type="error", content=str(e))
+                self.state.status = AgentStatus.ERROR
+                break
+
+            full_response = "".join(response_chunks)
+
+            # Parse the response for tool calls and thinking
+            parse_result = parse_tool_calls(full_response)
+
+            # Add assistant message to state
+            self.state.messages.append(
+                AgentMessage(
+                    role="assistant",
+                    content=full_response,
+                    thinking=parse_result.thinking_content if parse_result.has_thinking else None
+                )
+            )
+
+            # Handle parse errors
+            if parse_result.parse_errors and not parse_result.calls:
+                consecutive_failures += 1
+                if consecutive_failures >= self.max_retries:
+                    yield AgentEvent(type="error", content="Max retries reached")
+                    self.state.status = AgentStatus.ERROR
+                    break
+                error_msg = format_tool_error(f"Failed to parse: {parse_result.parse_errors}")
+                self.state.messages.append(AgentMessage(role="error", content=error_msg))
+                continue
+
+            # No tool calls - agent is done
+            if not parse_result.calls:
+                # Clean the response and yield as final text
+                cleaned = self._clean_response_text(full_response)
+                yield AgentEvent(type="text", content=cleaned)
+                self.state.status = AgentStatus.COMPLETED
+                self.state.final_response = full_response
+                break
+
+            # Reset failures on successful parse
+            consecutive_failures = 0
+
+            # Execute tool calls
+            for call in parse_result.calls:
+                # Yield tool start event
+                yield AgentEvent(
+                    type="tool_start",
+                    tool_name=call.tool_name,
+                    tool_params=call.params
+                )
+
+                result = self._execute_tool_call(call)
+
+                if result is None:
+                    yield AgentEvent(type="error", content="Action cancelled by user")
+                    continue
+
+                # Yield tool result event
+                yield AgentEvent(
+                    type="tool_result",
+                    tool_name=call.tool_name,
+                    content=result.output[:500] if result.output else "",
+                    success=result.success
+                )
+
+                # Add result to messages
+                if result.success:
+                    content = result.output
+                else:
+                    content = f"Error: {result.error}"
+                    if result.output:
+                        content += f"\n\nOutput:\n{result.output}"
+
+                self.state.messages.append(
+                    AgentMessage(
+                        role="tool",
+                        content=content,
+                        tool_name=call.tool_name,
+                        tool_result=result,
+                    )
+                )
+
+            self._update_token_estimate()
+
+        # Check if we hit max iterations
+        if iteration >= max_iter and self.state.status == AgentStatus.RUNNING:
+            self.state.status = AgentStatus.MAX_ITERATIONS
+            yield AgentEvent(type="error", content="Max iterations reached")
+
+        yield AgentEvent(type="done")
+
+    def _clean_response_text(self, text: str) -> str:
+        """Remove tool calls and thinking from response text."""
+        import re
+        # Remove thinking blocks
+        text = re.sub(r'<thinking>.*?</thinking>', '', text, flags=re.DOTALL)
+        # Remove tool calls
+        text = re.sub(r'<tool>.*?</tool>\s*<params>.*?</params>', '', text, flags=re.DOTALL)
+        # Clean up extra whitespace
+        text = re.sub(r'\n{3,}', '\n\n', text)
+        return text.strip()
+
+    def _execute_tool_call(self, call: ParsedToolCall) -> ToolResult | None:
+        """Execute a single tool call with optional confirmation."""
+        logger.info(f"Executing tool: {call.tool_name}")
+        logger.debug(f"Tool params: {call.params}")
+
+        # Check for duplicate tool calls (especially web_search loops)
+        key_param = self._get_tool_key_param(call)
+        call_signature = (call.tool_name, key_param)
+
+        # Check if this is a duplicate
+        if call_signature in self.state.recent_tool_calls:
+            prev_success = self.state.recent_tool_calls[call_signature]
+
+            # For web_search: always block duplicates (main source of loops)
+            # For bash: allow retry if previous attempt failed/timed out
+            if call.tool_name == "web_search" or prev_success:
+                logger.warning(f"Duplicate tool call detected: {call.tool_name}({key_param})")
+                return ToolResult(
+                    success=True,
+                    output=f"[Already executed {call.tool_name} with similar parameters. Move on to the next step - output your results or plan.]",
+                    error=None
+                )
+            else:
+                logger.info(f"Allowing retry of failed {call.tool_name}({key_param})")
+
+        tool = self.tools.get(call.tool_name)
+
+        if not tool:
+            # Try to suggest correct tool name
+            available = self.tools.get_tool_names()
+            suggestion = f"Available tools: {', '.join(available)}"
+            logger.error(f"Unknown tool: {call.tool_name}")
+            return ToolResult(
+                success=False,
+                output="",
+                error=f"Unknown tool '{call.tool_name}'. {suggestion}"
+            )
+
+        # Safety check for bash commands
+        if call.tool_name == "bash":
+            command = call.params.get("command", "")
+            allowed, reason = self.config.is_command_allowed(command)
+            if not allowed:
+                logger.warning(f"Blocked bash command: {command} - {reason}")
+                return ToolResult(
+                    success=False,
+                    output="",
+                    error=f"Command blocked: {reason}"
+                )
+
+        # Check for identical file content (writing same thing repeatedly)
+        if call.tool_name == "write_file":
+            path = call.params.get("path", "")
+            content = call.params.get("content", "")
+            content_hash = hashlib.md5(content.encode()).hexdigest()
+
+            if path in self.state.recent_file_hashes:
+                if self.state.recent_file_hashes[path] == content_hash:
+                    logger.warning(f"Identical content write detected for {path}")
+                    return ToolResult(
+                        success=True,
+                        output=f"[File {path} already has this exact content. Make DIFFERENT changes or move to the next step.]",
+                        error=None
+                    )
+
+            # Track the content hash
+            self.state.recent_file_hashes[path] = content_hash
+
+        # Check if confirmation is required (respecting auto_approve settings)
+        needs_confirm = tool.name in self.require_confirmation
+        auto_approved = self.config.should_auto_approve(tool.name)
+
+        if self.on_confirm and needs_confirm and not auto_approved:
+            params_preview = str(call.params)[:100]
+            logger.debug(f"Requesting user confirmation for {tool.name}")
+            if not self.on_confirm(f"Execute {tool.name}({params_preview})?"):
+                logger.info(f"User denied execution of {tool.name}")
+                return None
+
+        # Execute the tool
+        try:
+            self.state.tool_calls_made += 1
+            start_time = time.time()
+            logger.debug(f"Starting tool execution: {tool.name}")
+            result = tool.execute(**call.params)
+            elapsed = time.time() - start_time
+            logger.info(f"Tool {tool.name} completed in {elapsed:.2f}s (success={result.success})")
+            log_tool_call(tool.name, call.params, result)
+
+            # Track success for duplicate detection (allows retry on failure)
+            self.state.recent_tool_calls[call_signature] = result.success
+            return result
+        except TypeError as e:
+            # Wrong parameters
+            logger.error(f"Invalid parameters for {tool.name}: {e}")
+            self.state.recent_tool_calls[call_signature] = False
+            return ToolResult(
+                success=False,
+                output="",
+                error=f"Invalid parameters for {tool.name}: {e}"
+            )
+        except Exception as e:
+            logger.error(f"Tool execution failed: {e}")
+            self.state.recent_tool_calls[call_signature] = False
+            return ToolResult(
+                success=False,
+                output="",
+                error=f"Tool execution failed: {e}"
+            )
+
+    def _get_tool_key_param(self, call: ParsedToolCall) -> str:
+        """Extract the key parameter for duplicate detection.
+
+        Only dedupe tools that cause loops when repeated:
+        - web_search: same query is definitely a loop
+        - bash: same command might be intentional retry, but limit it
+
+        Don't dedupe:
+        - write_file: updating same file with different content is normal
+        - read_file: re-reading files is often needed
+        """
+        params = call.params
+
+        # Only dedupe web_search (the main source of loops)
+        if call.tool_name == "web_search":
+            query = params.get("query", "")
+            return query.lower().strip()
+
+        # For bash, only dedupe exact same command
+        if call.tool_name == "bash":
+            cmd = params.get("command", "")
+            return cmd.strip()
+
+        # Don't dedupe other tools - return unique value each time
+        import time
+        return f"{call.tool_name}_{time.time()}"
+
+    def _build_messages(self) -> list[dict]:
+        """Build message list for LLM with system prompt and examples."""
+        system_content = self.get_system_prompt()
+
+        # Add tool examples if available
+        examples = self.get_tool_examples()
+        if examples:
+            system_content += f"\n\n## Examples\n{examples}"
+
+        messages = [{"role": "system", "content": system_content}]
+
+        # Critical instruction reminder to prepend to first user message
+        # (Some models ignore system prompts, so repeat key rules here)
+        instruction_reminder = """[INSTRUCTION: You MUST use tools. Do NOT write code in markdown blocks.
+Use this format: <tool>tool_name</tool><params>{"key": "value"}</params>
+Do ONE web_search at most, then immediately start writing code with write_file.]
+
+"""
+
+        for i, msg in enumerate(self.state.messages):
+            if msg.role == "tool":
+                # Format tool results clearly
+                content = f"[Tool Result: {msg.tool_name}]\n{msg.content}"
+                messages.append({"role": "user", "content": content})
+            elif msg.role == "error":
+                # Error feedback
+                messages.append({"role": "user", "content": msg.content})
+            elif msg.role == "user" and i == 0:
+                # Prepend instruction reminder to first user message
+                messages.append({"role": "user", "content": instruction_reminder + msg.content})
+            else:
+                messages.append({"role": msg.role, "content": msg.content})
+
+        return messages
+
+    def _update_token_estimate(self) -> None:
+        """Estimate current context size (rough approximation)."""
+        total_chars = sum(len(msg.content) for msg in self.state.messages)
+        # Rough estimate: 4 chars per token
+        self.state.estimated_tokens = total_chars // 4
+
+    def _summarize_history(self) -> None:
+        """Summarize older messages to reduce context size."""
+        if len(self.state.messages) <= 4:
+            return
+
+        # Keep first message (original task) and last 3 messages
+        # Summarize the middle
+        to_summarize = self.state.messages[1:-3]
+
+        if not to_summarize:
+            return
+
+        # Create a summary
+        summary_parts = []
+        for msg in to_summarize:
+            if msg.role == "tool":
+                summary_parts.append(f"- Used {msg.tool_name}")
+            elif msg.role == "assistant" and msg.thinking:
+                summary_parts.append(f"- Thought: {msg.thinking[:100]}...")
+
+        summary = "[Previous actions summary]\n" + "\n".join(summary_parts)
+
+        # Replace middle messages with summary
+        self.state.messages = (
+            [self.state.messages[0]]
+            + [AgentMessage(role="user", content=summary)]
+            + self.state.messages[-3:]
+        )
+
+        self._update_token_estimate()

kairo_code/agents/coder.py

@@ -0,0 +1,155 @@
+"""Coder agent for writing and modifying code.
+
+Prompt design based on research:
+- Concise > verbose (reduces hallucination)
+- Clear role + constraints + fallback
+- Key rules at start AND end
+- No lengthy examples (dilutes core directive)
+"""
+
+from .base import Agent
+
+
+class CoderAgent(Agent):
+    """
+    Agent specialized for writing and modifying code.
+
+    Features:
+    - Creates new files
+    - Modifies existing code with targeted edits
+    - Fixes bugs
+    - Implements features
+    """
+
+    name = "coder"
+    description = "Writes, modifies, and improves code"
+    max_iterations = 12  # Reduced from 20 to prevent looping
+    require_confirmation = ["write_file", "bash"]
+
+    def get_system_prompt(self) -> str:
+        tools_desc = self.tools.format_for_prompt()
+
+        # Check Python availability for dynamic prompt
+        import os
+        import shutil
+        python_cmd = os.environ.get("KAIRO_PYTHON_CMD")
+        if not python_cmd:
+            for cmd in ["python3", "python"]:
+                if shutil.which(cmd):
+                    python_cmd = cmd
+                    break
+
+        # Build Python-specific guidance
+        if python_cmd:
+            python_note = f"- Use {python_cmd} to run scripts (not 'python' directly)"
+        else:
+            python_note = """- Python is NOT installed on this system
+- If the task requires Python, inform the user they need to install it first
+- Suggest: sudo apt-get install python3 (or appropriate command for their system)
+- You can still write Python files, but cannot execute them until Python is installed"""
+
+        # Autonomous agent prompt - research, plan, then execute
+        return f"""You are an autonomous coding agent. You research, plan, then write code.
+
+CRITICAL RULES:
+- NEVER use input() - it causes timeouts! Use hardcoded test values instead.
+- NEVER output your thinking/reasoning - just execute tools and give brief status updates
+- Keep text output SHORT - just say what you're doing, not why
+
+{tools_desc}
+
+## YOUR PROCESS (follow in order)
+
+### STEP 1: RESEARCH (required for new projects)
+- web_search to find relevant API docs or libraries
+- web_fetch to READ the actual documentation URL (get the real endpoints!)
+- Understand the API structure before writing any code
+- NEVER guess API endpoints - always verify from docs
+
+### STEP 2: PLAN (state your plan clearly)
+Before writing code, output a brief plan:
+- What files you'll create
+- What the architecture looks like
+- What dependencies are needed
+
+### STEP 3: IMPLEMENT
+- write_file to create each file
+- Keep files under 50 lines - split into modules if needed
+- Use hardcoded test values (NEVER input())
+- For GUIs: use ttk widgets (not plain tk) for modern look
+- Add padding/margins (padx=10, pady=5) for clean layout
+- Always add error handling for API calls (try/except, check response)
+
+### STEP 4: TEST & FIX
+- bash to run and test
+- If errors occur, READ THE ERROR MESSAGE CAREFULLY:
+  - ModuleNotFoundError: Install the missing module with pip install
+  - SyntaxError: Fix the syntax in the specific file/line mentioned
+  - ImportError: Check the import path is correct
+  - FileNotFoundError: Create the missing file or fix the path
+- If the SAME error keeps happening after 2 attempts, try a DIFFERENT approach
+- Do NOT retry the exact same command more than twice
+- Do NOT strip down code - fix the real problem
+
+## TOOL FORMAT
+Standard format:
+<tool>tool_name</tool>
+<params>{{"key": "value"}}</params>
+
+For write_file (RECOMMENDED - no JSON escaping needed):
+<write_file path="filename.py">
+your code here
+multiple lines ok
+</write_file>
+
+For edit_file:
+<tool>edit_file</tool>
+<params>{{"path": "file.py", "old_string": "old code", "new_string": "new code"}}</params>
+
+## CRITICAL RULES
+- NEVER show code in ```python blocks - ONLY use write_file
+- NEVER use input() - causes timeouts. Use: sport = "Soccer"
+- ALWAYS web_fetch API docs before using an API
+- When fixing errors: analyze and fix, don't simplify
+- NEVER write the SAME file with identical content twice - if content didn't change, move on
+- If pip install fails repeatedly, the package may not exist or have a different name
+- tkinter is a SYSTEM package on Linux - install with: sudo apt-get install python3-tk
+
+## PYTHON VIRTUAL ENVIRONMENT (for externally-managed-environment errors)
+If you see "externally-managed-environment" error, use a venv:
+1. Create venv: python3 -m venv venv
+2. Install packages: venv/bin/pip install requests  (NOT pip install!)
+3. Run scripts: venv/bin/python app.py  (NOT python app.py!)
+IMPORTANT: Do NOT use "source venv/bin/activate" - it doesn't work. Use venv/bin/pip and venv/bin/python directly.
+
+## SUDO AND SYSTEM PACKAGES
+- You CAN use sudo apt-get install for system packages
+- The -y flag is added automatically to prevent hangs
+- For tkinter: sudo apt-get install python3-tk
+- For other packages: use pip or apt-get as appropriate
+
+## FILE SIZE LIMITS
+- Keep each file UNDER 100 lines
+- Split larger code into multiple module files
+- Write ONE file at a time, verify it works before writing the next
+
+## CODE QUALITY
+- GUIs must look professional: use ttk, proper spacing, readable fonts
+- API calls must have error handling: check status codes, handle missing data
+- Test with real data before declaring done
+- If something doesn't work, FIX IT - don't leave broken code
+{python_note}
+
+## EXAMPLE WORKFLOW
+1. User asks for sports schedule app
+2. You: web_search "TheSportsDB API documentation"
+3. You: web_fetch the documentation URL
+4. You: State plan - "I'll create app.py with Flask backend..."
+5. You: write_file for each file
+6. You: bash to test
+7. You: Fix any errors by analyzing the actual problem"""
+
+    def get_tool_examples(self) -> str:
+        # Removed verbose examples - research shows they dilute core directive
+        # The system prompt now contains minimal inline examples
+        return ""

kairo_code/agents/database.py

@@ -0,0 +1,77 @@
+"""Database specialist agent — schema design, query optimization, migrations.
+
+Mirrors the database-specialist Claude Code agent.
+"""
+
+from .base import Agent
+
+
+class DatabaseAgent(Agent):
+    name = "database"
+    description = "Database design, query optimization, migrations, and troubleshooting"
+    max_iterations = 15
+    require_confirmation = ["write_file", "bash"]
+
+    def get_system_prompt(self) -> str:
+        tools_desc = self.tools.format_for_prompt()
+
+        return f"""You are the Database Specialist Agent, a senior-level expert functioning as a database architect, query optimizer, and troubleshooting specialist. You have deep expertise across SQL, NoSQL, distributed systems, and cloud-native data platforms.
+
+{tools_desc}
+
+## Core Responsibilities
+- Diagnose and fix database issues with systematic root-cause analysis
+- Design schemas, migrations, and indexing strategies that are production-ready
+- Optimize queries for performance, cost, and scalability
+- Explain tradeoffs between SQL and NoSQL with concrete reasoning
+- Guide replication, sharding, partitioning, and clustering configurations
+- Assist with cloud DB services (AWS RDS, Aurora, DynamoDB, etc.)
+- Ensure security, compliance, and data-integrity best practices
+
+## Technical Expertise
+- **SQL**: PostgreSQL, MySQL, MariaDB, SQL Server, Oracle
+- **NoSQL**: MongoDB, DynamoDB, Cassandra, Redis, Neo4j
+- **Distributed**: Kafka, ClickHouse, Snowflake, BigQuery, Redshift
+- **Indexing**: EXPLAIN plans, cost-based optimizers, join strategies
+- **Transactions**: ACID, MVCC, isolation levels, locking, deadlock resolution
+- **Data Modeling**: ERDs, normalization (1NF-BCNF), star/snowflake schemas
+- **Scalability**: Sharding, partitioning, read replicas, caching layers
+- **Security**: Encryption at rest/transit, least-privilege, audit logging, injection prevention
+- **Migrations**: Version-controlled, rollback strategies, zero-downtime
+
+## TOOL FORMAT
+<tool>tool_name</tool>
+<params>{{"key": "value"}}</params>
+
+## Methodology
+
+### Diagnosing Issues:
+1. Identify symptoms and gather context
+2. Form hypotheses based on common root causes
+3. Ask targeted clarifying questions
+4. Provide systematic diagnosis with evidence
+5. Offer primary recommendation and alternatives
+
+### Designing Schemas:
+1. Clarify access patterns and query requirements
+2. Consider current scale and anticipated growth
+3. Present design with rationale for each decision
+4. Highlight tradeoffs (consistency vs. availability, normalization vs. read performance)
+5. Include indexing strategy and migration plan
+
+### Optimizing Queries:
+1. Analyze query structure and identify bottlenecks
+2. Request/analyze EXPLAIN output
+3. Propose optimizations by impact (indexing > query rewrite > schema change > infrastructure)
+4. Before/after comparisons when possible
+5. Warn about edge cases (data skew, NULL handling, implicit casts)
+
+## Output Standards
+- All SQL must be correct, optimized, and production-ready
+- Include comments in complex queries
+- Provide step-by-step reasoning
+- Offer multiple solution paths with pros/cons
+- Proactively warn about anti-patterns (N+1, missing FK indexes, over-indexing)"""
+
+    def get_tool_examples(self) -> str:
+        return ""