enya-agent 0.1.0

package/docs/content/installation/_index.md

@@ -0,0 +1,186 @@
++++
+title = "Installation"
+weight = 1
+sort_by = "weight"
++++
+
+# Installation
+
+Enact can be installed via multiple methods. Choose the one that works best for you.
+
+## Status
+
+| Installation Method | Status |
+|---------------------|--------|
+| Build from Source | ✅ Available |
+| Cargo (crates.io) | ✅ Available |
+| npm | ✅ Available |
+| Homebrew | 🚧 Future |
+| Docker | 🚧 Future |
+| Install Script | 🚧 Future |
+
+## Quick Install
+
+Choose your preferred package manager:
+
+```bash
+# Using Cargo (recommended for Rust users)
+cargo install enact
+
+# Using npm (recommended for Node.js users)
+npm install -g enact
+
+# Using Homebrew (macOS/Linux)
+brew install enact
+```
+
+## Cargo (crates.io)
+
+Install from crates.io:
+
+```bash
+cargo install enact
+```
+
+This downloads pre-built binaries. To build from source instead:
+
+```bash
+cargo install enact --force --git https://github.com/adl-tan-theta/enactai
+```
+
+## npm
+
+Install pre-built binaries via npm:
+
+```bash
+# Global installation
+npm install -g enact
+
+# Verify installation
+enact --version
+```
+
+The npm package includes binaries for:
+- macOS (Intel & Apple Silicon)
+- Linux (x64 & ARM64)
+- Windows
+
+## Build from Source
+
+If you need the latest development version or want to contribute:
+
+### Prerequisites
+
+- **Rust**: 1.75+ (install via [rustup](https://rustup.rs))
+- **Git**: For cloning the repository
+
+### Steps
+
+```bash
+# 1. Clone the repository
+git clone https://github.com/adl-tan-theta/enactai.git
+cd enya/enact-agent
+
+# 2. Build all crates
+cargo build --release
+
+# 3. (Optional) Run tests
+cargo test
+```
+
+### Development Build
+
+For faster iteration during development:
+
+```bash
+# Build with debug symbols
+cargo build
+
+# Run a specific crate
+cargo run -p enact-runner
+```
+
+### Verify Build
+
+```bash
+# Check that crates compile
+cargo check --workspace
+
+# Run tests
+cargo test --workspace
+```
+
+## Requirements
+
+### System Requirements
+
+- **OS**: macOS 12+, Linux (glibc 2.31+), Windows 10+
+- **Memory**: 256MB minimum, 512MB recommended
+- **Disk**: ~500MB for build artifacts (source build only)
+
+### Runtime Dependencies
+
+- **API Keys**: At least one LLM provider (OpenAI, Anthropic, Azure, etc.)
+- **Network**: Outbound HTTPS for API calls (unless using Ollama locally)
+
+## Using as a Library
+
+Since Enact is a workspace of crates, you can use individual crates as dependencies:
+
+```toml
+# Cargo.toml
+[dependencies]
+enact-core = "0.0.1"
+enact-providers = "0.0.1"
+enact-channels = "0.0.1"
+enact-config = "0.0.1"
+```
+
+Or with git:
+
+```toml
+[dependencies]
+enact-core = { git = "https://github.com/adl-tan-theta/enactai", package = "enact-core" }
+```
+
+## Next Steps
+
+- [Quick Start](/getting-started/) - Configure and run your first agent
+- [Configuration](/configuration/) - Set up API keys and channels
+- [YAML Schema](/yaml-schema/) - Learn the agent definition format
+
+---
+
+## Future Installation Methods (🚧 Planned)
+
+### Homebrew (macOS)
+
+```bash
+brew install enact
+```
+
+### Docker
+
+```bash
+# Pull the image
+docker pull ghcr.io/adl-tan-theta/enya/enact:latest
+
+# Run with config mounted
+docker run -d \
+  --name enact \
+  -v ~/.enact:/root/.enact \
+  -p 18789:18789 \
+  ghcr.io/adl-tan-theta/enya/enact:latest serve
+```
+
+### Binary Downloads
+
+Pre-built binaries from GitHub Releases:
+
+| Platform | Architecture | Download |
+|----------|--------------|----------|
+| macOS | Apple Silicon (M1/M2) | `enact-aarch64-apple-darwin.tar.gz` |
+| macOS | Intel | `enact-x86_64-apple-darwin.tar.gz` |
+| Linux | x64 | `enact-x86_64-unknown-linux-gnu.tar.gz` |
+| Linux | ARM64 | `enact-aarch64-unknown-linux-gnu.tar.gz` |
+| Windows | x64 | `enact-x86_64-pc-windows-msvc.exe` |

package/docs/content/installation/uninstall.md

@@ -0,0 +1,101 @@
++++
+title = "Uninstalling"
+weight = 3
++++
+
+# Uninstalling Enact
+
+Since Enact is currently built from source, uninstalling means removing the source directory and any build artifacts.
+
+## Remove Source Directory
+
+```bash
+# Remove the cloned repository
+rm -rf /path/to/enact-agent
+```
+
+## Remove Cargo Artifacts
+
+If you installed any crates globally:
+
+```bash
+# List installed binaries (if any)
+ls ~/.cargo/bin/ | grep enact
+
+# Remove if present
+rm ~/.cargo/bin/enact
+```
+
+## Remove Configuration
+
+If you created any configuration files:
+
+```bash
+# Remove .env files in your project directories
+rm /path/to/your-project/.env
+
+# Remove any Enact-specific config (future)
+rm -rf ~/.config/enact/
+rm -rf ~/.enact/
+```
+
+## Clean Cargo Cache
+
+To free up disk space from cached dependencies:
+
+```bash
+# Remove cached crates used by Enact
+cargo cache -r  # requires cargo-cache
+# or
+rm -rf ~/.cargo/registry/cache/*/enact*
+rm -rf ~/.cargo/git/checkouts/*enact*
+```
+
+## Revoke Channel Access
+
+If you configured messaging channels, you may want to revoke access:
+
+### Telegram
+1. Open [@BotFather](https://t.me/botfather)
+2. Send `/deletebot`
+3. Select your bot
+
+### Teams
+1. Go to Azure Portal > App registrations
+2. Delete the app registration
+
+### WhatsApp
+1. Go to Meta Business Suite
+2. Remove the WhatsApp business account
+
+---
+
+## Future Uninstall Methods (🚧 Planned)
+
+When official installation methods are available:
+
+### Cargo (🚧 Future)
+
+```bash
+cargo uninstall enact
+```
+
+### Homebrew (🚧 Future)
+
+```bash
+brew uninstall enact
+```
+
+### npm (🚧 Future)
+
+```bash
+npm uninstall -g @enact/cli
+```
+
+### Docker (🚧 Future)
+
+```bash
+docker stop enact
+docker rm enact
+docker rmi ghcr.io/your-org/enact:latest
+```

package/docs/content/installation/updating.md

@@ -0,0 +1,120 @@
++++
+title = "Updating"
+weight = 2
++++
+
+# Updating Enact
+
+Keep Enact up to date by pulling the latest source code.
+
+## Check Current Version
+
+Since Enact is currently built from source, check your git commit:
+
+```bash
+cd enact-agent
+git log -1 --oneline
+# e.g., abc1234 Add WhatsApp channel support
+```
+
+## Update from Source
+
+```bash
+cd enact-agent
+
+# Fetch latest changes
+git fetch origin
+
+# Pull latest main branch
+git pull origin main
+
+# Rebuild
+cargo build --release
+```
+
+## Handling Conflicts
+
+If you have local changes:
+
+```bash
+# Option 1: Stash your changes
+git stash
+git pull origin main
+git stash pop
+
+# Option 2: Create a branch for your changes
+git checkout -b my-changes
+git checkout main
+git pull origin main
+```
+
+## Clean Rebuild
+
+If you encounter build issues after updating:
+
+```bash
+# Clean build artifacts
+cargo clean
+
+# Rebuild everything
+cargo build --release
+```
+
+---
+
+## Future Update Methods (🚧 Planned)
+
+### Self-Update Command (🚧 Future)
+
+When the CLI is fully implemented:
+
+```bash
+# Check for updates
+enact update --check
+
+# Update to latest
+enact update
+
+# Update to specific version
+enact update --version 0.1.0
+```
+
+### Cargo (🚧 Future)
+
+When published to crates.io:
+
+```bash
+cargo install enact --force
+```
+
+### Homebrew (🚧 Future)
+
+```bash
+brew upgrade enact
+```
+
+### npm (🚧 Future)
+
+```bash
+npm update -g @enact/cli
+```
+
+### Docker (🚧 Future)
+
+```bash
+docker pull ghcr.io/your-org/enact:latest
+docker-compose up -d
+```
+
+## Changelog
+
+See the [Changelog](https://github.com/your-org/enact-agent/blob/main/CHANGELOG.md) for what's new in each release.
+
+## Migration Notes
+
+When updating, check for:
+- Changes to YAML schema format
+- New required configuration options
+- API changes in library code
+
+The project is still in early development, so breaking changes may occur between versions.

package/docs/content/mcp/_index.md

@@ -0,0 +1,215 @@
++++
+title = "MCP Client"
+weight = 8
+sort_by = "weight"
++++
+
+# MCP Client
+
+The Model Context Protocol (MCP) client allows Enact to connect to MCP servers and use their tools.
+
+## Status
+
+| Feature | Status |
+|---------|--------|
+| Stdio transport support | ✅ Complete |
+| JSON-RPC protocol | ✅ Complete |
+| Tool listing | ✅ Complete |
+| Tool calling | ✅ Complete |
+| Async/await support | ✅ Complete |
+
+## What is MCP?
+
+The [Model Context Protocol](https://modelcontextprotocol.io/) is a standard for connecting AI models to external tools and data sources. It enables:
+
+- **Tool discovery**: Dynamically discover available tools from servers
+- **Tool execution**: Call tools with structured arguments
+- **Standardized communication**: JSON-RPC 2.0 over various transports
+
+## Quick Start
+
+### Connect to an MCP Server
+
+```rust
+use enact_mcp::McpStdioClient;
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    // Connect to an MCP server via stdio
+    let mut client = McpStdioClient::new(
+        "npx",
+        &["-y", "@modelcontextprotocol/server-filesystem", "/tmp"]
+    ).await?;
+
+    // List available tools
+    let tools = client.list_tools().await?;
+    for tool in &tools {
+        println!("{}: {}", tool.name, tool.description);
+    }
+
+    // Call a tool
+    let result = client.call_tool(
+        "read_file",
+        serde_json::json!({"path": "/tmp/test.txt"})
+    ).await?;
+
+    println!("Result: {}", result);
+    Ok(())
+}
+```
+
+## Stdio Transport
+
+The MCP client uses stdio transport to communicate with servers:
+
+1. **Spawns subprocess**: The MCP server runs as a child process
+2. **Stdin/Stdout**: Communication via standard input/output
+3. **JSON-RPC**: Messages are JSON-RPC 2.0 formatted
+4. **Automatic cleanup**: Process is killed when client is dropped
+
+## API Reference
+
+### McpStdioClient
+
+```rust
+pub struct McpStdioClient {
+    // Internal fields
+}
+
+impl McpStdioClient {
+    /// Create a new MCP client connected to a command via stdio
+    pub async fn new(command: &str, args: &[&str]) -> Result<Self>;
+
+    /// List available tools from the MCP server
+    pub async fn list_tools(&mut self) -> Result<Vec<McpTool>>;
+
+    /// Call a tool on the MCP server
+    pub async fn call_tool(
+        &mut self,
+        name: &str,
+        arguments: serde_json::Value
+    ) -> Result<String>;
+}
+```
+
+### McpTool
+
+```rust
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct McpTool {
+    pub name: String,
+    pub description: String,
+    pub parameters: serde_json::Value,
+}
+```
+
+## JSON-RPC Protocol
+
+The client uses JSON-RPC 2.0 for communication:
+
+### Initialize
+
+```json
+{
+    "jsonrpc": "2.0",
+    "id": 1,
+    "method": "initialize",
+    "params": {
+        "protocolVersion": "2024-11-05",
+        "capabilities": {},
+        "clientInfo": {
+            "name": "enact-mcp",
+            "version": "0.1.0"
+        }
+    }
+}
+```
+
+### List Tools
+
+```json
+{
+    "jsonrpc": "2.0",
+    "id": 2,
+    "method": "tools/list"
+}
+```
+
+### Call Tool
+
+```json
+{
+    "jsonrpc": "2.0",
+    "id": 3,
+    "method": "tools/call",
+    "params": {
+        "name": "tool_name",
+        "arguments": { "arg1": "value1" }
+    }
+}
+```
+
+## Example MCP Servers
+
+### Filesystem Server
+
+```rust
+let mut client = McpStdioClient::new(
+    "npx",
+    &["-y", "@modelcontextprotocol/server-filesystem", "/path/to/dir"]
+).await?;
+```
+
+### Custom Server
+
+```rust
+let mut client = McpStdioClient::new(
+    "./my-mcp-server",
+    &["--config", "config.json"]
+).await?;
+```
+
+## Error Handling
+
+```rust
+let result = client.call_tool("tool_name", args).await;
+
+match result {
+    Ok(output) => println!("Success: {}", output),
+    Err(e) => eprintln!("Tool error: {}", e),
+}
+```
+
+Tool errors from the MCP server are returned as `anyhow::Error` with the error message from the server.
+
+## Integration with Enact
+
+The MCP client can be used with Enact's agent system:
+
+```rust
+use enact_mcp::McpStdioClient;
+use enact_core::callable::LlmCallable;
+
+// Create MCP client
+let mut mcp = McpStdioClient::new("mcp-server", &[]).await?;
+
+// Get available tools
+let tools = mcp.list_tools().await?;
+
+// Tools can be exposed to the LLM as functions
+// (integration with tool-use coming in future releases)
+```
+
+## Lifecycle
+
+1. **Create client**: `McpStdioClient::new()` spawns the server process
+2. **Initialize**: Automatic handshake with the server
+3. **Use tools**: `list_tools()` and `call_tool()`
+4. **Cleanup**: Server process is killed when client is dropped
+
+```rust
+{
+    let mut client = McpStdioClient::new("server", &[]).await?;
+    // Use client...
+} // Client dropped here, server process killed
+```