Rhema Documentation

Welcome to the comprehensive Rhema documentation! This guide will help you get started with Rhema and explore its powerful features for AI-driven development workflows.

🚀 Quick Start

If you’re new to Rhema, start here:

Quick Start Guide - Complete beginner’s guide to Rhema
Workspace Quick Start - Setting up Rhema in a workspace environment
Refactoring to Workspace - Migration guide for existing projects

📚 Documentation Sections

👤 User Guide

Comprehensive guides for using Rhema’s features and capabilities.

Complete Getting Started Guide - Comprehensive beginner’s guide with step-by-step examples
CLI Command Reference - Complete command-line interface documentation
Configuration Management - Managing Rhema configuration files
Batch Operations - Performing operations on multiple items
Interactive Mode - Using Rhema’s interactive interface
Enhanced Dependencies Command - Advanced dependency management
Enhanced Validation Command - Comprehensive validation features
Lock File Health Checks - Monitoring lock file integrity
Conflict Resolution - Resolving conflicts in Rhema
Performance Monitoring - Monitoring and optimizing Rhema performance

🏗️ Core Features

Detailed documentation of Rhema’s core functionality.

Core Features Overview - Introduction to all core features
Scope Management - Organizing projects into logical scopes
Context Query Language (CQL) - Powerful querying across all context data
Validation System - Ensuring data integrity and consistency
Todo Management - Tracking tasks and work items
Insight Recording - Capturing learnings and observations
Pattern Recognition - Identifying and documenting patterns
Decision Tracking - Recording architectural and design decisions
Dependency Management - Understanding scope relationships
Impact Analysis - Assessing change effects
Knowledge Synchronization - Keeping context in sync
Context Injection - Providing AI with relevant context
Prompt Management - Managing and optimizing prompts
Workflow Automation - Automating repetitive tasks
Agent Coordination - Multi-agent collaboration
Performance Monitoring - System and user experience tracking
Health Checks - Ensuring system integrity
Usage Analytics - Understanding feature adoption
Lock File System - Ensuring reproducible builds
Git Integration - Version control integration
MCP Protocol - Model Context Protocol support
Action Protocol - Safe agent-assisted modifications

📖 Reference

Technical reference materials and specifications.

Complete API Reference - Comprehensive API documentation with examples and error codes
API Reference - Complete API documentation and specifications
Global Config Reference - Complete configuration schema reference
Specification Schema Examples - Example schemas and specifications
YAML Schema Reference - All YAML file schemas
JSON Schema Definitions - JSON schema specifications
CLI API Reference - Command-line interface specifications
Library API Reference - Rust library API documentation
Query Language Reference - CQL syntax and semantics
Plugin API Reference - Plugin development interfaces
MCP Protocol Reference - Model Context Protocol implementation
Action Protocol Reference - Action protocol specifications
gRPC API Reference - gRPC service definitions
REST API Reference - REST API endpoints
Security Model - Security architecture and model
Authentication Reference - Authentication mechanisms
Authorization Reference - Authorization and permissions
Encryption Reference - Data encryption specifications
Data Model Reference - Core data structures
Context Model Reference - Context data models
Knowledge Model Reference - Knowledge representation
Agent Model Reference - Agent coordination models

🛠️ Development Setup

Guides for developers contributing to Rhema.

Development Overview - Comprehensive development information
Local Setup - Setting up a local development environment
Rust Setup - Rust-specific development setup
Git Setup - Git configuration for development
Editor Setup - IDE and editor configuration guides
VS Code - VS Code integration setup
IntelliJ IDEA - IntelliJ IDEA integration setup
Vim/Neovim - Vim/Neovim integration setup
Sublime Text - Sublime Text integration setup
Cursor - Cursor integration setup
CI/CD - Continuous integration and deployment guides

🚨 Troubleshooting

Help and support for common issues and problems.

Common Issues & Solutions - Comprehensive troubleshooting guide
Debugging Guide - Advanced debugging techniques
Recovery Procedures - Data recovery and system repair
Performance Optimization - Performance tuning and optimization

🏗️ Architecture

Architectural documentation and design decisions.

Architecture Overview - System architecture and design principles
Proposals - RFC-style proposals for new features and changes
MCP Documentation - Model Context Protocol implementation details

📝 Examples

Practical examples and use cases.

Examples Overview - Introduction to all examples
Quick Start Commands - Essential commands for beginners
Advanced Usage - Complex usage scenarios
CQL Queries - Context Query Language examples
E-commerce Epic Orchestration - Real-world orchestration example
Enhanced Context Injection - Advanced context management
Implicit to Explicit Knowledge - Knowledge transformation patterns
Prompt Chain Persistence - Managing prompt workflows
Prompt Effectiveness Tracking - Measuring prompt performance
Prompt Versioning - Version control for prompts
Query Provenance - Tracking query origins and history
Template Management - Managing prompt templates
Lock File Operations - Managing dependency locks

For New Users

Start with the Getting Started section, particularly the Quick Start Guide.

For Regular Users

Browse the User Guide for detailed feature documentation and the Examples for practical use cases.

For Power Users

Explore Core Features for advanced functionality and Reference for technical specifications.

For Developers

Check out Development Setup for environment setup and Architecture for design decisions.

For Contributors

Review Proposals for upcoming changes and Architecture for design decisions.

🔍 Search and Discovery

Find What You Need

By Feature: Use the navigation sections above
By Use Case: Check the Examples section
By Command: Use the CLI Command Reference
By Technical Detail: Use the Reference section

Common Tasks

Getting Started: Quick Start Guide
Configuration: Configuration Management
Queries: Context Query Language
Validation: Validation System
AI Integration: Context Injection
Development: Development Setup

📋 Documentation Standards

All documentation should be written in Markdown format
Use clear, concise language with practical examples
Include code snippets where appropriate
Maintain consistent formatting and structure
Update documentation when features change

🤝 Contributing to Documentation

When contributing to Rhema, please also update relevant documentation:

Update user guides for new features
Add examples for new functionality
Update reference materials for API changes
Create proposals for significant architectural changes

For questions about documentation organization or content, please open an issue in the repository.

🔗 External Resources

GitHub Repository: fugue-ai/rhema
Issues: GitHub Issues
Discussions: GitHub Discussions
Releases: GitHub Releases

📊 Documentation Status

✅ Completed Sections

🔄 In Progress

Advanced Configuration Examples
Performance Tuning Guide
Troubleshooting Guide
Migration Guides

📋 Planned

Video Tutorials
Interactive Tutorials
Community Showcase
Best Practices Guide

Need Help? If you can’t find what you’re looking for, please:

Check the Quick Start Guide for basic usage
Search the CLI Command Reference for specific commands
Browse the Examples for practical use cases
Open an issue in the repository for documentation requests