| description | Comprehensive ReactorPro documentation covering installation, features, agent mode, configuration, skills, MCP servers, and all capabilities. Use this skill when answering questions about ReactorPro features, configuration, troubleshooting, or best practices. |
| name | reactorpro-doc |
ReactorPro Documentation Skill
This skill provides comprehensive documentation for ReactorPro, enabling you to answer questions about its features, configuration, and usage.
Introduction
ReactorPro supercharges your coding workflow by combining the power of aider with an intuitive desktop interface, enabling seamless AI-assisted code generation, modification, and project management.
Installation
- Download the latest version for your operating system from the Releases page
- Install the application:
- Windows: Run the
.exe installer
- macOS: Open the
.dmg and drag ReactorPro to Applications
- Linux: Extract the
.AppImage and make it executable (chmod +x)
First Launch Experience
When you first open ReactorPro:
- The app will automatically set up required Python dependencies
- Create default configuration files in
~/.reactorpro
- Open the main interface with a welcome screen
Key Features
- AI-Powered Coding: Generate new code from natural language, modify existing code with precise edits, get explanations for complex code
- Project Context Management: Manual or automatic file inclusion, IDE plugins for VSCode and IntelliJ, read-only mode for reference files
- Workflow Tools: Session persistence, cost tracking per project, multiple AI provider support, built-in diff viewer with side-by-side comparison
Chat Modes
ReactorPro offers several chat modes to tailor the AI's behavior to your specific needs:
Code Mode (/code)
The default mode for direct interaction with Aider to request code changes. Best for specific, well-defined tasks.
Agent Mode (/agent)
Activates the autonomous agent. Use for high-level, complex tasks that may require multiple steps, reasoning, and tool use.
Ask Mode (/ask)
Ask questions about your codebase without the AI attempting to make any changes.
Architect Mode (/architect)
A specialized mode for planning and executing large-scale changes affecting multiple files. The AI creates a plan first, then uses an "editor" model to apply changes.
Context Mode (/context)
Aider will automatically analyze your prompt and try to identify and add the most relevant files to the context.
Model Library
The Model Library is ReactorPro's advanced provider and model management system.
Features
- Multiple Provider Profiles: Create multiple profiles for the same provider with different configurations
- Custom Model Management: Add models that aren't automatically discovered
- Cost and Token Configuration: Set custom pricing and token limits
- Model Organization: Hide irrelevant models and organize by provider profiles
- Dynamic Model Loading: Automatically discover available models for most providers
Accessing the Model Library
- Top Bar Icon: Click the Model Library icon in the top bar
- Model Selector: Cog icon right from model selector
- Onboarding: During initial setup
Built-in Commands
Core Commands
/add <files>: Adds files to the chat context/drop <files>: Removes files from the context/read-only <files>: Adds files in read-only mode/run <command>: Executes a shell command/test: Runs the predefined test command
Chat & Context Management
/clear: Clears the entire chat history and drops all files/clear-logs: Removes only log messages/compact: Summarizes the conversation to reduce token usage/copy-context: Copies context to clipboard in markdown format/tokens: Reports token usage
Mode Switching
/code: Switch to Code Mode/agent: Switch to Agent Mode/ask: Switch to Ask Mode/architect: Switch to Architect Mode/context: Switch to Context Mode
Model & Aider Control
/model <name>: Changes the AI model/reasoning-effort <level>: Sets reasoning effort (low, medium, high)/think-tokens <budget>: Sets thinking token budget/undo: Undoes the last git commit/redo: Re-runs the last prompt/edit-last: Edit and re-submit last message
Other Utilities
/web <url>: Scrapes URL content and adds to chat/map: Prints the repository map/map-refresh: Forces refresh of repository map/commit: Commits unstaged changes/resolve-conflicts: Resolves merge conflicts using AI/init: Initializes AGENTS.md rule file/handoff <focus>: Extract context and create new focused task
IDE Integration
Visual Studio Code
IntelliJ IDEA (and other JetBrains IDEs)
Task Management
Tasks are containers for all the context, conversations, and decisions related to a specific piece of work.
Task Organization
Tasks are stored in .reactorpro/tasks/{taskId}/ with:
settings.json: Task metadata and configurationcontext.json: Messages and files contexttodos.json: Todo items for the task
Working Modes
- Local Mode: Work directly in main project directory
- Worktree Mode: Create isolated Git worktree for safe experimentation
Subtasks
Break down complex work into hierarchical structures. Subtasks inherit parent's worktree path.
Smart Task States
- TODO: Task hasn't been started yet
- IN PROGRESS: Task is currently being worked on
- INTERRUPTED: Task was stopped before completion
- MORE INFO NEEDED: Agent needs clarification
- READY FOR IMPLEMENTATION: Agent has a clear plan
- READY FOR REVIEW: Agent completed work, ready for human review
- DONE: Task marked as completed
Task Operations
- Rename: Change task name
- Duplicate: Create complete copy
- Delete: Remove permanently
- Archive: Hide from main view
- Pin: Pin to top of list
- Export: Export as Markdown or PNG
Git Worktrees
Git worktrees enable isolated development environments for each task.
Integration Options
- Standard Merge: Preserves all individual commits
- Squash & Merge: Creates one clean commit
- Only Uncommitted Changes: Transfers work-in-progress without commits
Features
- AI-assisted conflict resolution
- Visual status indicators (ahead commits, uncommitted files)
- Rebase operations with conflict handling
- Revert operations for safety
Custom Commands
Create custom commands in Markdown files with YAML front matter.
Locations
- Global:
~/.reactorpro/commands/
- Project-specific:
.reactorpro/commands/
Format
---
description: A brief description of what the command does.
arguments:
- description: Description for the first argument.
required: true
---
Template content using {{1}}, {{2}}, or {{ARGUMENTS}} placeholders.
Lines starting with ! are executed as shell commands.
Memory
ReactorPro Memory lets the agent store and retrieve durable, project-scoped knowledge across tasks.
Prerequisites
- Enable Memory in Settings:
Settings → Memory → Enabled
- Enable Memory tools for agent profile:
Settings → Agent → Use Memory Tools
Memory Tools
retrieve_memory: Search for relevant memoriesstore_memory: Save a new memorylist_memories: List stored memoriesdelete_memory: Delete a specific memory
What to Store
- User preferences (formatting, frameworks, naming)
- Architectural decisions
- Reusable codebase patterns
What NOT to Store
- One-off task status updates
- Temporary debugging notes
- Long logs/stack traces
- Secrets, tokens, credentials, or personal data
Skills
Skills let you extend the agent with reusable, on-demand expertise. A skill is a folder containing instructions (and optionally scripts and reference materials).
Where Skills Live
- Home-level skills:
~/.reactorpro/skills/
- Project-level skills:
.reactorpro/skills/
Skill Structure
{skills-root}/
{skill-name}/
SKILL.md
references/
scripts/
...
Prerequisites
Skills only work when Skills Tools are enabled for the active agent profile:
Settings → Agent → Use Skills Tools- Or via
AgentSelector → Use skills tools
Skills Tools
- Discover installed skills (using skill metadata)
- Activate a skill when relevant by loading its SKILL.md
Hooks
Hooks allow you to extend ReactorPro's behavior by executing custom JavaScript code.
Locations
- Global:
~/.reactorpro/hooks/
- Project-specific:
.reactorpro/hooks/
Format
module.exports = {
onTaskCreated: async (event, context) => {
context.addInfoMessage(`Task "${event.task.name}" was created!`);
},
onPromptStarted: async (event, context) => {
if (event.prompt.includes('secret')) {
return false;
}
}
};
Available Events
onTaskCreated, onTaskInitialized, onTaskClosedonPromptSubmitted, onPromptStarted, onPromptFinishedonAgentStarted, onAgentFinished, onAgentStepFinishedonToolCalled, onToolFinishedonFileAdded, onFileDroppedonCommandExecutedonAiderPromptStarted, onAiderPromptFinishedonQuestionAsked, onQuestionAnsweredonHandleApprovalonSubagentStarted, onSubagentFinishedonResponseMessageProcessed
Web Scraping
Use the /web command to pull content from any URL into your chat context.
Usage
/web https://react.dev/reference/react/useState
How It Works
- Launches internal browser using Electron
- Navigates and extracts raw HTML
- Cleans and converts to markdown-like text
- Saves to
.reactorpro/tmp as read-only context file
Voice Control
Voice Control allows speech-to-text functionality to dictate prompts.
Supported Providers
- OpenAI: Uses OpenAI's real-time speech-to-text API
- Google Gemini: Uses Gemini's live audio input capabilities
Setup
- Configure provider profile with API key in Model Library
- Enable Voice Control in Model Library provider settings
- Configure voice options in
Settings → Voice
Handoff Command
The /handoff command extracts relevant context from your current conversation and moves it into a new, focused task.
Usage
/handoff [your focus here]
Examples
/handoff implement this for teams as well, not just individual users
/handoff execute phase one of the created plan
/handoff check the rest of the codebase and find other places that need this fix
Handoff vs Compaction
- Handoff: Creates new focused task, preserves original conversation
- Compact: Summarizes and replaces current thread
Compact Conversation
The /compact command summarizes your conversation history to reduce token usage.
What It Does
- Generates structured summary including:
- Primary request and overall intent
- Key technical concepts
- Chronological list of user messages
- Files and code sections read/created/modified
- Errors encountered and resolutions
- Current work and next steps
Usage Dashboard
Track usage patterns, token consumption, and costs across projects.
Key Features
- Activity Analysis: Monitor development activity over time
- Token Visualization: Track consumption trends
- Cost Breakdown: By project and model
- Interactive Patterns: Filter by date, project, model
View Modes
- Table View: Structured tabular format
- Charts View: Interactive visualizations
ReactorPro as MCP Server
ReactorPro includes a built-in MCP server for other MCP-compatible clients.
Available Tools via MCP
add_context_file: Add file to contextdrop_context_file: Remove file from contextget_context_files: List files in contextget_addable_files: List available project filesrun_prompt: Execute a promptclear_context: Clear the context
Agent Mode
Agent Mode transforms ReactorPro into a powerful, autonomous assistant.
Key Capabilities
- Autonomous Task Execution: Break down high-level requests into concrete steps
- Tool Utilization: Power Tools, Aider Tools, MCP Servers
- Configurable Profiles: Tailor behavior for different tasks
- Transparent Operation: Observe thought process and tool choices
Switching to Agent Mode
- Click mode selector below prompt field and choose "Agent"
- Or type
/agent in the prompt field
Agent Profiles
Agent Profiles configure the agent's behavior. Create multiple profiles for different workflows.
File-Based Storage
- Global Profiles:
~/.reactorpro/agents/
- Project-Level Profiles:
$projectDir/.reactorpro/agents/
Profile Structure
profile-name/
├── config.json # Profile configuration
└── rules/ # Additional rule files
├── coding-standards.md
├── architecture.md
└── custom-instructions.md
Pre-defined Profiles
- Power Tools: Direct file system access for analysis and modification
- Aider: Leverages Aider's code generation capabilities
- Aider with Power Search: Combines search capabilities with Aider
Configuration Options
- Parameters: Temperature, Max Iterations, Max Tokens, Min Time Between Tool Calls
- Context Settings: Include Context Files, Include Repository Map
- Tool Groups: Power Tools, Aider Tools, Todo Tools
- Rules & Instructions: Custom instructions and rule files
- MCP Servers: External tool connections
- Tool Approvals: Ask, Always, Never
Subagents
Subagents are specialized AI assistants that can be delegated specific tasks.
Key Benefits
- Context Preservation: Focused context without polluting main conversation
- Specialized Expertise: Domain-specific system prompts
- Reusability: Use across different projects
- Flexible Permissions: Different tool access levels
- Cost Optimization: Strategic model selection per task type
Configuration
- Enable as Subagent: Toggle in agent profile
- System Prompt: Define behavior and expertise
- Invocation Mode: Automatic or On-demand
- Color: Visual identifier
- Description: When the subagent should be used
Aider Tools
When Agent Mode is active, the agent can interact with Aider:
get_context_files: List files in Aider's contextadd_context_files: Add files to contextdrop_context_files: Remove files from contextrun_prompt: Delegate a coding task to Aider
Power Tools
Power tools provide direct file system interaction and development operations.
File Operations
power---file_read: Read file contentpower---file_write: Create/modify files (overwrite, append, create_only modes)power---file_edit: Targeted find-and-replace changes
Search and Discovery
power---semantic_search: Natural language code searchpower---glob: Find files using glob patternspower---grep: Search content with regex
System Operations
power---bash: Execute shell commandspower---agent: Delegate to specialized sub-agents
Tool Approval States
- Ask: Prompt for approval each time
- Always: Auto-approve without prompting
- Never: Disable the tool completely
Task Tools
Task tools enable agents to interact with the task management system.
Available Tools
tasks---list_tasks: List all tasks in current projecttasks---get_task: Get comprehensive task detailstasks---get_task_message: Retrieve specific message from task historytasks---create_task: Create new task or subtasktasks---delete_task: Permanently delete a tasktasks---search_task: Semantic search within a tasktasks---search_parent_task: Search parent task content (for subtasks)
MCP Servers
Extend Agent Mode with external tools through the Model Context Protocol.
Configuration Format
{
"mcpServers": {
"server-name": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-puppeteer"]
}
}
}
Directory Placeholders
${projectDir}: Project root directory${taskDir}: Current task's working directory
AGENTS.md with /init
The /init command analyzes your codebase and generates an AGENTS.md file.
What It Does
- Identifies project purpose and architecture
- Documents programming languages and frameworks
- Lists core dependencies and libraries
- Records coding conventions and patterns
- Documents build and testing procedures
Usage
- Switch to Agent Mode
- Type
/init and press Enter
- Add generated file to Aider's read-only context when prompted
Todo Management
The agent can track and complete multi-step tasks.
Todo Tools
set_items: Creates or overwrites the todo listget_items: Reads current todo stateupdate_item_completion: Marks items complete/incompleteclear_items: Clears all items
Configuration
Settings Overview
Access settings via the gear icon in the top-right corner.
General Tab
- Appearance (language, zoom, theme)
- Start Up behavior
- Notifications
- Prompt Behavior
Providers Tab
Manage API keys and connections for LLM providers.
Aider Tab
- Options: Command-line arguments for Aider
- Environment Variables: For Aider process
- Context: Control automatic rule file inclusion
Agent Tab
- Agent Profiles
- MCP Servers
- Tool Approvals
Memory Tab
- Enable/disable Memory
- Embedding model selection
- View and delete stored memories
Providers Configuration
Supported providers:
- Anthropic: Claude models
- OpenAI: GPT models
- Azure: Azure OpenAI (requires manual model addition)
- Gemini: Google Gemini models
- Vertex AI: Google Cloud enterprise AI
- GPUStack: OpenAI-compatible GPU inference
- Deepseek: Coding-optimized models
- Groq: Ultra-fast inference
- Bedrock: AWS foundation models
- Claude Agent SDK: For Claude Code Pro/Max subscriptions
- OpenAI Compatible: Custom endpoints
- Ollama: Local open-source models
- LM Studio: Local models with GUI
- OpenRouter: Multiple providers via single API
- Requesty: Optimized routing and caching
Aider Configuration
Priority Order
- ReactorPro UI settings
- Command-line options in settings
.env in project directory.aider.conf.yml in project directory.env in home directory.aider.conf.yml in home directory- System environment variables
Aider Options
Pass command-line arguments in Settings > Aider > Options.
Environment Variables
Set in Settings > Aider > Environment Variables.
Project-Specific Rules
Rule File Locations
- Project-Level:
.reactorpro/rules/
- Agent-Specific:
.reactorpro/agents/{profile}/rules/
- Global:
~/.reactorpro/agents/{profile}/rules/
Rule Precedence
- Global agent rules
- Project-level rules
- Project agent rules
What to Include
- Architecture overview
- Coding conventions
- Technology stack
- Do's and Don'ts
- Agent behavior guidelines
- Tool usage preferences
Custom Prompts
ReactorPro uses Handlebars templates for AI agent behavior.
Available Templates
system-prompt.hbs: Main system promptinit-project.hbs: Project initializationworkflow.hbs: Agent workflow guidancecompact-conversation.hbs: Conversation summarizationcommit-message.hbs: Git commit messagestask-name.hbs: Task name generationupdate-task-state.hbs: Task state determinationconflict-resolution-system.hbs: Conflict resolution system promptconflict-resolution.hbs: Conflict resolution instructionshandoff.hbs: Handoff prompt generation
Template Override System
- Project-Specific (highest):
$PROJECT_DIR/.reactorpro/prompts/
- Global (medium):
~/.reactorpro/prompts/
- Default (lowest): Bundled with ReactorPro
Handlebars Helpers
{{equals value1 value2}}: Check equality{{not value}}: Logical NOT{{assign varName value}}: Assign variable{{increment varName}}: Increment variable{{indent text spaces}}: Indent text{{cdata text}}: Wrap in CDATA
Troubleshooting
Common Issues
Microphone Not Working (Voice Control)
- Check microphone connection
- Verify permissions
- Select specific microphone in Settings
- Ensure no other app is using it
Power tools not available
- Check "Use Power Tools" is enabled
- Verify agent profile configuration
- Restart ReactorPro
Skills not loading
- Verify Skills Tools are enabled for agent profile
- Check skill is in correct directory
- Ensure SKILL.md exists with proper frontmatter
Memory not working
- Enable Memory in Settings
- Enable Memory Tools for agent profile
- Check embedding model is configured
Best Practices
Task Management
- Use descriptive task names
- Keep tasks focused on single features/bugs
- Archive completed tasks
- Use subtasks for large features
Agent Profiles
- Create specialized profiles for different task types
- Use conservative approval settings initially
- Start with predefined profiles and customize
- Document custom configurations
Skills
- Keep skill descriptions specific and action-oriented
- Prefer small, composable skills
- Move rarely-needed details to references/ directory
- Only install skills from trusted sources
Memory
- Retrieve memories at task start
- Store reusable preferences and patterns
- Don't store task-specific or sensitive information
Resources
