@within-7/minto 0.0.5-dev.1

package/README.md

@@ -0,0 +1,1097 @@
+# Minto - AI Strategic Research & Planning Assistant
+
+**Private Repository - within-7**
+
+<p align="center">
+  <strong>A powerful AI assistant for strategic thinking and research planning</strong>
+</p>
+
+<p align="center">
+  🤖 Multi-Model Support | 🎯 Strategic Planning | 🔌 Extensible Plugin System<br>
+  📦 MCP Integration | 🧠 Intelligent Agents | 🎨 Beautiful Terminal UI
+</p>
+
+<p align="right">
+  <strong>English</strong> | <a href="./README.zh-CN.md">简体中文</a>
+</p>
+
+---
+
+## Table of Contents
+
+- [Overview](#overview)
+- [Features](#features)
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Core Concepts](#core-concepts)
+  - [Agents (Subagents)](#agents-subagents)
+  - [Plugin System](#plugin-system)
+  - [MCP Integration](#mcp-integration)
+- [Configuration](#configuration)
+- [Usage Guide](#usage-guide)
+  - [Basic Commands](#basic-commands)
+  - [Working with Agents](#working-with-agents)
+  - [Using Plugins](#using-plugins)
+  - [MCP Servers](#mcp-servers)
+- [Advanced Topics](#advanced-topics)
+- [Documentation](#documentation)
+- [Development](#development)
+- [Attribution & License](#attribution--license)
+
+---
+
+## Overview
+
+Minto is a powerful AI-powered strategic research and planning assistant. It facilitates strategic thinking, coordinates research initiatives, and orchestrates planning workflows through intelligent conversation and specialized agents.
+
+> **⚠️ Security Notice**: Minto runs in YOLO mode by default (bypassing permission checks for maximum productivity). For sensitive strategic projects, use `minto --safe` to enable manual approval for all operations.
+
+---
+
+## Features
+
+### 🤖 **Multi-Model AI Support**
+- **20+ AI Models**: Claude (Sonnet, Opus, Haiku), GPT-4, GPT-3.5, Gemini, DeepSeek, and more
+- **Model Switching**: Change models mid-conversation without losing context
+- **Model Profiles**: Optimized configurations for different tasks (coding, reasoning, quick responses)
+
+### 🎯 **Intelligent Agent System**
+- **Dynamic Agents**: Specialized AI agents for different tasks (strategic analysis, research coordination, planning, etc.)
+- **Agent Orchestration**: Agents can call other agents to solve complex strategic challenges
+- **Custom Agents**: Create your own agents with simple Markdown files
+- **5-Tier Priority**: Built-in → User global → Project local → Plugin-bundled
+
+### 🔌 **Extensible Plugin System**
+- **Plugin Marketplace**: Install community plugins with one command
+- **Plugin Components**: Agents, Commands, Skills, Hooks, and MCP servers
+- **Claude Code Compatible**: Works with Claude Code plugin ecosystem
+- **Easy Development**: Create plugins with simple configuration files
+
+### 📦 **MCP (Model Context Protocol) Integration**
+- **4 Transport Types**: stdio, SSE, WebSocket, HTTP
+- **Built-in Servers**: Filesystem, Git, Database, Search, and more
+- **Custom Servers**: Connect to any MCP-compatible service
+- **Tool Auto-discovery**: Automatically expose MCP tools to AI models
+
+### 💼 **Dual-Mode Compression**
+- **Business Mode**: 9-section compression for strategic consulting and analysis
+- **Research Mode**: 8-section compression optimized for research planning
+- **Smart Auto-compact**: Intelligently manages context window
+
+### 🎨 **Beautiful Terminal UI**
+- **Interactive Interface**: Built with React Ink
+- **Real-time Streaming**: See AI responses as they're generated
+- **Syntax Highlighting**: Code blocks with language-specific highlighting
+- **Rich Formatting**: Tables, lists, and formatted output
+
+---
+
+## Installation
+
+### Prerequisites
+
+- **Node.js** >= 20.18.1
+- **Bun** (recommended) or npm/yarn
+- API keys for your chosen AI models
+
+### Install from Source
+
+```bash
+# Clone the repository
+git clone <repository-url>
+cd minto
+
+# Install dependencies
+bun install
+
+# Build the CLI
+bun run build
+
+# Link globally
+bun link
+
+# Verify installation
+minto --version
+```
+
+### Quick Install (for team members)
+
+```bash
+# Extract package
+tar -xzf minto-team-*.tar.gz
+cd minto-team-*
+
+# Run installer
+./install.sh
+
+# Start using
+minto
+```
+
+---
+
+## Quick Start
+
+### 1. Configure API Keys
+
+Create `~/.minto.json`:
+
+```json
+{
+  "mainModel": "claude-sonnet-4",
+  "models": {
+    "claude-sonnet-4": {
+      "provider": "anthropic",
+      "model": "claude-sonnet-4-20250514",
+      "apiKey": "your-anthropic-api-key"
+    }
+  }
+}
+```
+
+**Or** set environment variables:
+
+```bash
+export ANTHROPIC_API_KEY="your-key-here"
+export OPENAI_API_KEY="your-key-here"
+```
+
+### 2. Start Minto
+
+```bash
+# Start in current directory
+minto
+
+# Or with safe mode
+minto --safe
+
+# With specific model
+minto --model gpt-4-turbo
+```
+
+### 3. Try Basic Commands
+
+```bash
+# In Minto session:
+> "Analyze the structure of this project"
+> "Create a new React component called UserProfile"
+> "Write unit tests for src/utils/helper.ts"
+> "Explain what this function does" (in a code file)
+```
+
+---
+
+## Core Concepts
+
+### Agents (Subagents)
+
+**Agents are specialized AI assistants** that excel at specific tasks. Each agent has:
+- Focused expertise and knowledge
+- Custom system prompts
+- Limited tool access for security
+- Optional preferred AI model
+
+#### Agent Directory Structure
+
+Minto uses a **priority-based directory system** where `.minto` directories have higher priority:
+
+```
+# Directory Priority (low to high):
+~/.claude/agents/          # Claude Code compatibility (compatible)
+~/.minto/agents/           # User-level agents (primary)
+./.claude/agents/          # Project-level (compatible)
+./.minto/agents/           # Project-level agents (highest priority)
+plugins/*/agents/          # Plugin-bundled agents
+```
+
+**Key Points**:
+- ✅ New agents are created in `.minto/agents/` by default
+- ✅ Agents in `.minto/` override same-named agents in `.claude/`
+- ✅ Full compatibility with Claude Code `.claude/` directories
+
+#### Creating an Agent
+
+Create `~/.minto/agents/code-reviewer.md`:
+
+```markdown
+---
+name: code-reviewer
+description: Expert code reviewer specializing in best practices, security, and performance
+tools: ["FileRead", "Grep", "Glob"]
+model: claude-sonnet-4
+---
+
+You are an expert code reviewer. When analyzing code:
+
+1. Check for security vulnerabilities
+2. Identify performance issues
+3. Suggest improvements for readability
+4. Verify best practices
+5. Look for potential bugs
+
+Always provide specific, actionable feedback with code examples.
+```
+
+#### Using Agents
+
+```bash
+# Method 1: Direct invocation
+/task code-reviewer "Review src/auth.ts"
+
+# Method 2: Natural language
+"Use the code-reviewer agent to analyze my authentication code"
+
+# Method 3: List available agents
+/agents
+```
+
+#### Agent Configuration
+
+In `.minto.json`:
+
+```json
+{
+  "// Agent Directories": "Priority: last to first (.minto > .claude)",
+  "agentDirectories": [
+    "~/.claude/agents",    // Compatible: Claude Code user directory
+    "~/.minto/agents",     // Primary: Minto user directory (higher priority)
+    "./.claude/agents",    // Compatible: Claude Code project directory
+    "./.minto/agents"      // Primary: Minto project directory (highest priority)
+  ],
+  "agentOverrides": {
+    "code-reviewer": {
+      "model": "claude-sonnet-4",
+      "temperature": 0.3,
+      "tools": ["FileRead", "Grep", "Glob", "WebSearch"]
+    }
+  }
+}
+```
+
+---
+
+### Plugin System
+
+**Plugins extend Minto's capabilities** with reusable components.
+
+#### Plugin Components
+
+1. **Agents**: Specialized AI assistants
+2. **Commands**: Slash commands (`/review`, `/test`)
+3. **Skills**: Reusable knowledge modules
+4. **Hooks**: Lifecycle event handlers
+5. **MCP Servers**: Extended tools and capabilities
+
+#### Plugin Directory Structure
+
+Minto uses a **priority-based directory system** where `.minto` directories have higher priority:
+
+```
+# Directory Priority (low to high):
+~/.claude/plugins/         # Claude Code compatibility (compatible)
+~/.minto/plugins/          # User-level plugins (primary)
+./.claude/plugins/         # Project-level (compatible)
+./.minto/plugins/          # Project-level plugins (highest priority)
+```
+
+**Key Points**:
+- ✅ New plugins are installed in `.minto/plugins/` by default
+- ✅ Plugins in `.minto/` override same-named plugins in `.claude/`
+- ✅ Full compatibility with Claude Code `.claude/` directories
+
+#### Installing Plugins
+
+##### From Marketplace
+
+```bash
+# Add marketplace
+minto marketplace add wshobson/agents
+
+# Search plugins
+minto marketplace search "python"
+
+# Install plugin
+minto plugin install python-development@wshobson
+
+# List installed plugins
+minto plugin list
+```
+
+##### From Git Repository
+
+```bash
+minto plugin install https://github.com/user/minto-plugin.git
+```
+
+##### From Local Directory
+
+```bash
+minto plugin install ./my-plugin --link
+```
+
+#### Creating a Plugin
+
+##### 1. Create Plugin Structure
+
+```bash
+mkdir my-plugin
+cd my-plugin
+```
+
+##### 2. Create `plugin.json`
+
+```json
+{
+  "name": "my-plugin",
+  "version": "1.0.0",
+  "description": "My custom Minto plugin",
+  "author": "Your Name",
+  "agents": ["agents/my-agent.md"],
+  "commands": ["commands/my-command.md"],
+  "skills": ["skills/my-skill.md"]
+}
+```
+
+##### 3. Add Components
+
+**Agent** (`agents/my-agent.md`):
+
+```markdown
+---
+name: my-agent
+description: Custom agent for specific tasks
+tools: ["*"]
+---
+
+Agent system prompt here...
+```
+
+**Command** (`commands/my-command.md`):
+
+```markdown
+---
+name: my-command
+description: Execute custom command
+argNames: ["input"]
+---
+
+Process {input} and perform the custom action.
+```
+
+**Skill** (`skills/my-skill.md`):
+
+```markdown
+---
+name: my-skill
+description: Reusable knowledge about X
+---
+
+# My Skill Knowledge
+
+Detailed instructions and examples...
+```
+
+##### 4. Install Plugin
+
+```bash
+# From plugin directory
+minto plugin install . --link
+
+# Or from parent directory
+minto plugin install ./my-plugin
+```
+
+#### Plugin Configuration
+
+In `.minto.json`:
+
+```json
+{
+  "// Plugin Directories": "Priority: last to first (.minto > .claude)",
+  "pluginDirectories": [
+    "~/.claude/plugins",   // Compatible: Claude Code user directory
+    "~/.minto/plugins",    // Primary: Minto user directory (higher priority)
+    "./.claude/plugins",   // Compatible: Claude Code project directory
+    "./.minto/plugins"     // Primary: Minto project directory (highest priority)
+  ],
+  "enabledPlugins": [
+    "python-development",
+    "code-reviewer",
+    "my-plugin"
+  ],
+  "pluginConfig": {
+    "my-plugin": {
+      "customSetting": "value"
+    }
+  }
+}
+```
+
+---
+
+### MCP Integration
+
+**MCP (Model Context Protocol)** allows AI models to access external tools and data sources.
+
+#### MCP Server Types
+
+1. **stdio**: Local command-line tools
+2. **SSE**: Server-Sent Events (streaming)
+3. **WebSocket**: Bidirectional real-time communication
+4. **HTTP**: Request-response pattern
+
+#### Configuring MCP Servers
+
+In `.minto.json`:
+
+```json
+{
+  "mcpServers": {
+    "filesystem": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/allowed/files"],
+      "enabled": true
+    },
+
+    "brave-search": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
+      "enabled": true,
+      "env": {
+        "BRAVE_API_KEY": "${BRAVE_API_KEY}"
+      }
+    },
+
+    "github": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-github"],
+      "enabled": true,
+      "env": {
+        "GITHUB_TOKEN": "${GITHUB_TOKEN}"
+      }
+    },
+
+    "postgres": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-postgres"],
+      "enabled": false,
+      "env": {
+        "DATABASE_URL": "${DATABASE_URL}"
+      }
+    },
+
+    "custom-websocket": {
+      "type": "websocket",
+      "url": "wss://mcp.example.com",
+      "enabled": false,
+      "headers": {
+        "Authorization": "Bearer ${TOKEN}"
+      }
+    }
+  }
+}
+```
+
+#### Available MCP Servers
+
+| Server | Type | Purpose | Package |
+|--------|------|---------|---------|
+| Filesystem | stdio | File operations | `@modelcontextprotocol/server-filesystem` |
+| Git | stdio | Git operations | `@modelcontextprotocol/server-git` |
+| GitHub | stdio | GitHub API | `@modelcontextprotocol/server-github` |
+| GitLab | stdio | GitLab API | `@modelcontextprotocol/server-gitlab` |
+| Google Drive | stdio | Google Drive | `@modelcontextprotocol/server-google-drive` |
+| Slack | stdio | Slack API | `@modelcontextprotocol/server-slack` |
+| PostgreSQL | stdio | Database | `@modelcontextprotocol/server-postgres` |
+| Puppeteer | stdio | Browser automation | `@modelcontextprotocol/server-puppeteer` |
+| Brave Search | stdio | Web search | `@modelcontextprotocol/server-brave-search` |
+
+#### Using MCP Tools
+
+MCP tools are automatically available to AI models:
+
+```bash
+# MCP tools are used automatically
+> "Search for recent news about AI"  # Uses brave-search MCP
+> "Read the contents of /home/user/data.json"  # Uses filesystem MCP
+> "Get my latest GitHub issues"  # Uses github MCP
+```
+
+#### Creating Custom MCP Servers
+
+See [MCP Implementation Guide](./docs/guides/MCP_IMPLEMENTATION_GUIDE.md) for detailed instructions on creating custom MCP servers.
+
+---
+
+## Configuration
+
+### Configuration File Locations
+
+Minto uses hierarchical configuration:
+
+1. **Global**: `~/.minto.json` (user-wide settings)
+2. **Project**: `./.minto.json` (project-specific settings)
+3. **Environment**: `.env` files and environment variables
+4. **CLI Args**: Command-line overrides
+
+**Priority**: CLI Args > Project > Global > Defaults
+
+### Environment Variables
+
+Minto supports the following environment variables:
+
+#### Primary Configuration
+- `MINTO_CONFIG_DIR` - Custom configuration directory (highest priority)
+- `CLAUDE_CONFIG_DIR` - Claude Code compatible directory (for compatibility)
+
+#### API Keys
+- `ANTHROPIC_API_KEY` - Anthropic API key for Claude models
+- `OPENAI_API_KEY` - OpenAI API key
+- Other provider-specific API keys
+
+#### Advanced Options
+- `MINTO_SESSION_ID` - Custom session identifier
+- `MINTO_BASH` - Custom bash executable path (Windows)
+- `MINTO_DEBUG_AGENTS` - Enable agent debugging output
+
+**Note**: `.minto` directories always have higher priority than `.claude` directories for configuration, agents, and plugins.
+
+### Complete Configuration Example
+
+See [`.minto.json.example`](./.minto.json.example) for a fully documented configuration file with all available options.
+
+### Key Configuration Sections
+
+#### Models
+
+```json
+{
+  "mainModel": "claude-sonnet-4",
+  "taskModel": "claude-sonnet-3-7",
+  "models": {
+    "claude-sonnet-4": {
+      "provider": "anthropic",
+      "model": "claude-sonnet-4-20250514",
+      "apiKey": "${ANTHROPIC_API_KEY}",
+      "maxTokens": 8192,
+      "temperature": 0.7
+    },
+    "gpt-4-turbo": {
+      "provider": "openai",
+      "model": "gpt-4-turbo-preview",
+      "apiKey": "${OPENAI_API_KEY}"
+    }
+  }
+}
+```
+
+#### Compression & Context
+
+```json
+{
+  "compressionMode": "code",
+  "autoCompact": {
+    "enabled": true,
+    "threshold": 0.8
+  },
+  "contextWindow": {
+    "maxTokens": 200000,
+    "reserveTokens": 4000
+  }
+}
+```
+
+#### Permissions
+
+```json
+{
+  "permissionMode": "safe",
+  "permissions": {
+    "fileWrite": {
+      "enabled": true,
+      "requireConfirmation": true,
+      "allowedPaths": ["./**", "!node_modules/**"]
+    },
+    "bashExecution": {
+      "enabled": true,
+      "requireConfirmation": true,
+      "blockedCommands": ["rm -rf", "sudo"]
+    }
+  }
+}
+```
+
+---
+
+## Usage Guide
+
+### Basic Commands
+
+#### Starting Minto
+
+```bash
+# Basic start
+minto
+
+# Safe mode (permissions required)
+minto --safe
+
+# With specific model
+minto --model gpt-4-turbo
+
+# Verbose output
+minto --verbose
+
+# In specific directory
+minto --cwd /path/to/project
+```
+
+#### In-Session Commands
+
+```bash
+# Model management
+/model                    # Show current model
+/model gpt-4-turbo       # Switch model
+
+# Agent management
+/agents                  # List available agents
+/task <agent> <prompt>   # Use specific agent
+
+# Plugin management
+/plugins                 # List installed plugins
+/plugin install <name>   # Install plugin
+
+# Context management
+/compact                 # Manually compact context
+/compression             # Switch compression mode
+/clear                   # Clear conversation
+
+# Help and info
+/help                    # Show help
+/commands                # List all commands
+/quit                    # Exit with summary
+```
+
+---
+
+### Working with Agents
+
+#### Listing Agents
+
+```bash
+# In Minto session
+/agents
+
+# Output:
+# Available Agents:
+# - code-reviewer: Expert code review
+# - python-pro: Python development expert
+# - researcher: Web research specialist
+```
+
+#### Using Agents Explicitly
+
+```bash
+# Method 1: /task command
+/task code-reviewer "Review src/auth.ts for security issues"
+
+# Method 2: Natural language
+"Use the code-reviewer agent to analyze my code"
+
+# Method 3: Multi-agent workflow
+"Have the researcher agent find best practices, then code-reviewer agent apply them"
+```
+
+#### Creating Custom Agents
+
+1. **Create agent file**: `~/.minto/agents/my-agent.md`
+
+```markdown
+---
+name: my-agent
+description: Specialized agent for X task
+tools: ["FileRead", "FileWrite", "Bash"]
+model: claude-sonnet-4
+temperature: 0.5
+---
+
+# My Custom Agent
+
+You are an expert in X. When asked to perform Y:
+
+1. First, analyze the requirements
+2. Then, create a detailed plan
+3. Finally, execute the plan step by step
+
+Always provide explanations for your decisions.
+```
+
+2. **Test the agent**:
+
+```bash
+minto
+> /agents
+> /task my-agent "Perform task X"
+```
+
+#### Agent Best Practices
+
+✅ **DO**:
+- Provide clear, specific descriptions
+- Limit tool access to what's needed
+- Include examples in the prompt
+- Test agents before sharing
+
+❌ **DON'T**:
+- Give agents unlimited tools (`"*"`) unless necessary
+- Use overly broad descriptions
+- Forget to specify the model if it's task-specific
+
+---
+
+### Using Plugins
+
+#### Installing from Marketplace
+
+```bash
+# Add marketplace
+minto marketplace add wshobson/agents
+
+# List marketplaces
+minto marketplace list
+
+# Search for plugins
+minto marketplace search "python"
+
+# Install plugin
+minto plugin install python-development@wshobson
+
+# Install specific version
+minto plugin install python-development@wshobson --version 2.1.0
+```
+
+#### Managing Installed Plugins
+
+```bash
+# List installed plugins
+minto plugin list
+
+# Show plugin details
+minto plugin info python-development
+
+# Enable/disable plugin
+minto plugin enable python-development
+minto plugin disable python-development
+
+# Update plugin
+minto plugin update python-development
+
+# Uninstall plugin
+minto plugin uninstall python-development
+```
+
+#### Developing Plugins
+
+See the comprehensive guides:
+- [Plugin Quick Start](./docs/getting-started/PLUGIN_QUICKSTART.md)
+- [Plugin System Guide](./docs/guides/PLUGIN_SYSTEM_GUIDE.md)
+- [Plugin Implementation Guide](./docs/guides/PLUGIN_IMPLEMENTATION_GUIDE.md)
+
+**Basic structure**:
+
+```
+my-plugin/
+├── plugin.json          # Plugin manifest
+├── agents/              # AI agents
+│   └── my-agent.md
+├── commands/            # Slash commands
+│   └── my-cmd.md
+├── skills/              # Reusable knowledge
+│   └── my-skill.md
+└── README.md            # Documentation
+```
+
+---
+
+### MCP Servers
+
+#### Starting with MCP Servers
+
+1. **Install MCP server packages**:
+
+```bash
+npm install -g @modelcontextprotocol/server-filesystem
+npm install -g @modelcontextprotocol/server-brave-search
+```
+
+2. **Configure in `.minto.json`**:
+
+```json
+{
+  "mcpServers": {
+    "filesystem": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/allowed/path"],
+      "enabled": true
+    },
+    "brave-search": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
+      "enabled": true,
+      "env": {
+        "BRAVE_API_KEY": "your-api-key"
+      }
+    }
+  }
+}
+```
+
+3. **Use in Minto**:
+
+```bash
+minto
+
+# MCP tools are automatically available
+> "Search for latest TypeScript features"
+> "Read the package.json file"
+```
+
+#### MCP Server Configuration Options
+
+```json
+{
+  "server-name": {
+    "type": "stdio|sse|websocket|http",
+    "command": "executable",           // For stdio
+    "args": ["arg1", "arg2"],          // For stdio
+    "url": "ws://...",                 // For websocket/http
+    "baseUrl": "http://...",           // For http
+    "enabled": true|false,
+    "env": {                           // Environment variables
+      "VAR_NAME": "${ENV_VAR}"
+    },
+    "headers": {                       // For websocket/http
+      "Authorization": "Bearer ${TOKEN}"
+    },
+    "reconnect": true,                 // For websocket
+    "timeout": 30000                   // For http (ms)
+  }
+}
+```
+
+---
+
+## Advanced Topics
+
+### Multi-Model Workflows
+
+```bash
+# Use different models for different tasks
+minto --model claude-sonnet-4
+
+> "Use GPT-4 to generate creative ideas"  # Auto-switches
+> /model gpt-4-turbo
+> "Now analyze these ideas"
+> /model claude-sonnet-4
+> "Implement the best idea"
+```
+
+### Custom Compression Modes
+
+```bash
+# Switch compression mode
+/compression
+
+# Choose: business | code
+
+# Business mode: 9 sections (background, objectives, findings, etc.)
+# Code mode: 8 sections (project structure, key files, changes, etc.)
+```
+
+### Hooks and Automation
+
+In `.minto.json`:
+
+```json
+{
+  "hooks": {
+    "beforeCommand": "echo 'Starting command...'",
+    "afterCommand": "echo 'Command complete!'",
+    "beforeFileWrite": "./scripts/pre-write-check.sh",
+    "afterFileWrite": "git add ."
+  }
+}
+```
+
+### Memory System
+
+```bash
+# Save information to memory
+> "Remember that our API endpoint is https://api.company.com"
+
+# Recall information
+> "What's our API endpoint?"
+
+# Memory persists across sessions
+```
+
+### CI/CD Integration
+
+```yaml
+# .github/workflows/ai-code-review.yml
+name: AI Code Review
+
+on: [pull_request]
+
+jobs:
+  review:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Install Minto
+        run: npm install -g @within-7/minto
+      - name: Run AI Review
+        env:
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+        run: |
+          minto --non-interactive \
+            "/task code-reviewer 'Review this PR'" \
+            > review.md
+      - name: Comment PR
+        uses: actions/github-script@v6
+        with:
+          script: |
+            const fs = require('fs');
+            const review = fs.readFileSync('review.md', 'utf8');
+            github.rest.issues.createComment({
+              issue_number: context.issue.number,
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              body: review
+            });
+```
+
+---
+
+## Documentation
+
+📚 **[Complete Documentation Center](./docs/README.md)**
+
+### Quick Start Guides
+- [Getting Started](./docs/getting-started/START_HERE.md)
+- [Compression Guide](./docs/getting-started/COMPRESSION_QUICK_GUIDE.md)
+- [Plugin Quick Start](./docs/getting-started/PLUGIN_QUICKSTART.md)
+- [Plugin Agents](./docs/getting-started/PLUGIN_AGENTS_QUICK_START.md)
+
+### Complete Guides
+- [Plugin System Guide](./docs/guides/PLUGIN_SYSTEM_GUIDE.md)
+- [Subagents Implementation](./docs/guides/SUBAGENTS_IMPLEMENTATION_GUIDE.md)
+- [MCP Implementation](./docs/guides/MCP_IMPLEMENTATION_GUIDE.md)
+- [Package & Publish](./docs/guides/PACKAGE_AND_PUBLISH_GUIDE.md)
+
+### Reference
+- [Quick Reference](./docs/reference/QUICK_REFERENCE.md)
+- [Plugin CLI Reference](./docs/reference/PLUGIN_CLI_REFERENCE.md)
+- [Subagents Templates](./docs/reference/SUBAGENTS_TEMPLATES.md)
+
+### Architecture
+- [CLI Architecture](./docs/architecture/CLAUDE_CODE_CLI_ARCHITECTURE.md)
+- [Plugin System Design](./docs/architecture/PLUGIN_SYSTEM_DESIGN.md)
+- [Skills System Design](./docs/architecture/SKILLS_SYSTEM_DESIGN.md)
+
+---
+
+## Development
+
+### Build from Source
+
+```bash
+# Install dependencies
+bun install
+
+# Run in development mode
+bun run dev
+
+# Build for production
+bun run build
+
+# Run tests
+bun test
+
+# Type checking
+bun run typecheck
+
+# Format code
+bun run format
+```
+
+### Project Structure
+
+```
+minto/
+├── src/
+│   ├── entrypoints/       # CLI entry points
+│   ├── screens/           # UI screens (REPL, etc.)
+│   ├── tools/             # Tool implementations
+│   ├── services/          # AI service integrations
+│   ├── utils/             # Utilities (config, agents, etc.)
+│   ├── commands/          # Built-in commands
+│   └── types/             # TypeScript definitions
+├── docs/                  # Documentation
+├── scripts/               # Build and utility scripts
+└── cli.js                 # CLI wrapper
+```
+
+### Contributing
+
+See [CONTRIBUTING.md](./CONTRIBUTING.md) for guidelines.
+
+---
+
+## Attribution & License
+
+### Attribution
+
+Minto is a derivative work based on [Kode-cli](https://github.com/shareAI-lab/Kode-cli), which is licensed under the Apache License, Version 2.0.
+
+**Original Project**: Kode-cli
+**Original Copyright**: Copyright 2024 ShareAI Lab
+**Original License**: Apache License, Version 2.0
+
+This derivative work includes significant modifications and enhancements made by within-7.
+
+For detailed attribution information, see [ATTRIBUTION.md](./docs/legal/ATTRIBUTION.md).
+
+### License
+
+This software is licensed under the Apache License, Version 2.0 (inherited from Kode-cli).
+
+**For private use within the within-7 organization only.**
+
+See [LICENSE](./LICENSE) for the complete license text and [NOTICE](./NOTICE) for attribution and modification details.
+
+### Disclaimer
+
+THIS SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---
+
+## Support
+
+- **Documentation**: [./docs](./docs)
+- **Issues**: Internal issue tracker
+- **Contact**: within-7 team
+
+---
+
+**Author**: Lib - within-7
+**Version**: 1.0.0
+
+© 2025 within-7. All rights reserved.
+Based on Kode-cli © 2024 ShareAI Lab.