ExoMind

KO | EN

gitlite — search

#javascript #typescript #go #golang #deep-learning #docker #nodejs #awesome #cli #kubernetes #vue #pytorch #security #ios

(★ 21)

Highly skilled voice-based assistant with intimate knowledge of your preferences, interests, worldview who can synthesize random thoughts from curated info sources, and act on your behalf.

ExoMind 최신버젼 다운로드

최종 버전 다운로드 (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# ExoMind

> AI-powered cognitive architecture combining SPARC methodology, swarm intelligence, and personal knowledge management for enhanced productivity and decision-making.

## 🚀 Overview

ExoMind is an advanced development environment that integrates:

- **SPARC Methodology** - Systematic Test-Driven Development (Specification, Pseudocode, Architecture, Refinement, Completion)
- **Claude Flow** - Multi-agent swarm orchestration with 54+ specialized agents
- **Superpowers** - Enhanced Claude Code skills and capabilities
- **Anthropic Skills** - Official example and document skills (PDF, DOCX, PPTX, XLSX)
- **Knowledge Management** - Personal OS and productivity tools
- **Google Workspace Integration** - Gmail and Calendar access via MCP

## ✨ Features

- 🧠 **54+ Specialized AI Agents** - From backend development to consensus algorithms
- ⚡ **Parallel Execution** - 2.8-4.4x speed improvement with concurrent agent coordination
- 🎯 **84.8% SWE-Bench Solve Rate** - Proven effectiveness in software engineering tasks
- 💾 **Cross-Session Memory** - Persistent context and learning across sessions
- 🔗 **GitHub Integration** - Automated PR management, code review, and release coordination
- 📊 **Performance Analytics** - Real-time metrics and bottleneck detection
- 🌐 **Google Workspace** - Email and calendar management through Claude Code

## 📋 Prerequisites

- [Node.js](https://nodejs.org/) (v18 or higher)
- [Claude Desktop](https://claude.ai/download) or [Claude Code CLI](https://docs.claude.com/en/docs/claude-code)
- Git (for submodules)

## 🔧 Installation

### 1. Clone the Repository with Submodules

```bash
# Clone with all submodules in one command
git clone --recurse-submodules https://github.com/natea/ExoMind.git
cd ExoMind

# Or clone first, then initialize submodules
git clone https://github.com/natea/ExoMind.git
cd ExoMind
git submodule update --init --recursive
```

**Included Submodules:**
- `modules/superpowers` - Enhanced skills for TDD, brainstorming, debugging
- `modules/anthropic-claude-skills` - Official Anthropic skills (documents, creative, dev)
- `modules/ar-claude-skills` - Professional skills for C-level advisors, marketing, and product teams
- `modules/claude-code-by-agents` - Multi-agent workspace with web UI for coordination
- `modules/mcp-getgather` - Context gathering and web scraping
- `modules/Skill_Seekers` - Auto-generate skills from documentation
- `modules/life-os` - Personal productivity and life management

### 2. Initialize Claude Flow

Claude Flow provides the core multi-agent orchestration framework:

```bash
# Initialize Claude Flow in your project
npx claude-flow@alpha init

# Verify installation
npx claude-flow@alpha --version
```

### 3. Configure MCP Servers in Claude Code

MCP (Model Context Protocol) servers extend Claude Code with specialized capabilities.

#### Core MCP Servers (Required)

```bash
# Add Claude Flow MCP server (required for swarm coordination)
claude mcp add claude-flow npx claude-flow@alpha mcp start

# Verify MCP server is running
claude mcp list
```

#### Optional MCP Servers

```bash
# Enhanced swarm coordination with WASM acceleration
claude mcp add ruv-swarm npx ruv-swarm mcp start

# Cloud-based orchestration with 70+ advanced features
claude mcp add flow-nexus npx flow-nexus@latest mcp start

# Flow-Nexus requires registration:
# npx flow-nexus@latest register
# npx flow-nexus@latest login
```

### 4. Add Google Workspace Integration (Gmail & Calendar)

There are two options for Google Workspace integration:

#### Option A: Composio MCP (Recommended - Easiest Setup)

[Composio](https://composio.dev/) provides a unified authentication layer for multiple services including Google Workspace:

```bash
# Install Composio MCP
npm install -g composio-core

# Add Composio MCP to Claude Code
claude mcp add composio npx composio-core mcp

# Authenticate with Google Workspace
composio add googleworkspace

# This will open a browser for OAuth authentication
# Grant access to Gmail and Google Calendar
```

**Composio Configuration:**

Add to your Claude Code MCP settings (`~/.config/claude/mcp_settings.json`):

```json
{
  "mcpServers": {
    "composio": {
      "command": "npx",
      "args": ["composio-core", "mcp"],
      "env": {
        "COMPOSIO_API_KEY": "your-composio-api-key"
      }
    }
  }
}
```

**Get your Composio API key:**
1. Sign up at [Composio Dashboard](https://app.composio.dev/)
2. Navigate to Settings → API Keys
3. Copy your API key

**Available Composio Actions:**
- `gmail_send_email` - Send emails via Gmail
- `gmail_search` - Search email messages
- `gmail_read_message` - Read specific emails
- `calendar_list_events` - List calendar events
- `calendar_create_event` - Create new events
- `calendar_update_event` - Update existing events

#### Option B: Direct Google Workspace MCP

For more control, use the direct Google Workspace MCP:

```bash
# Install the Google Workspace MCP
npm install -g @modelcontextprotocol/server-google-workspace

# Add to Claude Code
claude mcp add google-workspace npx @modelcontextprotocol/server-google-workspace
```

**Google Cloud Setup:**
1. Create a project in [Google Cloud Console](https://console.cloud.google.com/)
2. Enable Gmail API and Google Calendar API
3. Create OAuth 2.0 credentials (Desktop application)
4. Download credentials as `credentials.json`

**Configuration:**

Add to your MCP settings:

```json
{
  "mcpServers": {
    "google-workspace": {
      "command": "npx",
      "args": ["@modelcontextprotocol/server-google-workspace"],
      "env": {
        "GOOGLE_CREDENTIALS_PATH": "/path/to/credentials.json",
        "GOOGLE_TOKEN_PATH": "/path/to/token.json"
      }
    }
  }
}
```

**First-time Authentication:**
```bash
# Run authentication flow
npx @modelcontextprotocol/server-google-workspace auth

# This will:
# 1. Open your browser for Google OAuth
# 2. Request permissions for Gmail and Calendar
# 3. Save the token to GOOGLE_TOKEN_PATH
```

### 5. Add Superpowers Plugin (Enhanced Skills)

Superpowers provides systematic development workflows, brainstorming, TDD, and debugging skills:

```bash
# Add Superpowers from marketplace
/plugin marketplace add obra/superpowers-marketplace

# Install the plugin
/plugin install superpowers@superpowers-marketplace
```

**What You Get:**
- 🧠 **Brainstorming** - Interactive design refinement using Socratic method
- 🧪 **Test-Driven Development** - RED-GREEN-REFACTOR workflows
- 🐛 **Systematic Debugging** - Root cause tracing and pattern analysis
- ✅ **Code Review** - Verification and validation frameworks
- 📝 **Planning & Execution** - Writing and executing implementation plans

**Usage in Claude Code:**
```
"Use the brainstorming skill to refine this API design"
"Apply TDD workflow to implement user authentication"
"Use systematic debugging to find the root cause of this error"
```

### 6. Add MCP GetGather (Context Gathering)

GetGather enables intelligent web content extraction and research automation:

```bash
# Start GetGather MCP server (runs on port 23456)
cd modules/mcp-getgather
python server.py
```

**Configuration:**

Add to your MCP settings (`~/.config/claude/mcp_settings.json`):

```json
{
  "mcpServers": {
    "getgather": {
      "url": "http://127.0.0.1:23456/mcp"
    }
  }
}
```

**What You Get:**
- 🌐 **Web Scraping** - Extract content from any website
- 📄 **Document Processing** - Parse and analyze documents
- 🔍 **Research Automation** - Gather information across multiple sources
- 📊 **Context Aggregation** - Synthesize information from various sources

**Usage in Claude Code:**
```
"Use getgather to extract all API documentation from https://docs.example.com"
"Gather context from these 5 research papers"
"Scrape and summarize the latest release notes"
```

### 7. Add Skill Seekers (Auto-Generate Claude Skills)

Skill Seekers automatically converts any documentation website into a Claude Code skill:

**Key Capabilities:**
- 🚀 **Auto-Generate Skills** - Convert any docs site into a Claude skill in minutes
- 📚 **Documentation Learning** - Scrape and organize documentation automatically
- 🧠 **AI Enhancement** - Use Claude to create comprehensive skill guides
- 📦 **One-Click Packaging** - Package skills ready for upload to Claude

**Quick Setup:**

```bash
cd modules/Skill_Seekers

# Install dependencies
pip3 install requests beautifulsoup4

# Generate a skill from any documentation site
python3 cli/doc_scraper.py --config configs/react.json --enhance-local

# Package the skill
python3 cli/package_skill.py output/react/

# Upload to Claude Code (output/react.zip)
```

**Example: Create a React Skill**

```bash
# Scrape React documentation and create a skill (20-30 minutes)
python3 cli/doc_scraper.py \
  --name react \
  --url https://react.dev/ \
  --description "React framework for building UIs" \
  --enhance-local

# Package the skill
python3 cli/package_skill.py output/react/

# Upload output/react.zip to Claude
```

**Using MCP Server (Easiest):**

```bash
# One-time setup
cd modules/Skill_Seekers
./setup_mcp.sh

# Then in Claude Code, use natural language:
"Generate a skill from https://tailwindcss.com/docs"
"List all available skill configs"
"Package the React skill"
```

**What Skill Seekers Creates:**
- ✅ **SKILL.md** - Comprehensive guide with real code examples
- ✅ **References/** - Organized documentation by category
- ✅ **Code Examples** - Extracted from actual documentation
- ✅ **Quick Reference** - Common patterns and best practices

**Pre-built Configs:**
- `react.json` - React framework
- `vue.json` - Vue.js
- `django.json` - Django web framework
- `fastapi.json` - FastAPI
- `godot.json` - Godot game engine

**For Large Documentation (10K+ pages):**

```bash
# Estimate page count first
python3 cli/estimate_pages.py configs/godot.json

# Auto-split into focused sub-skills
python3 cli/split_config.py configs/godot.json --strategy router

# Scrape in parallel (much faster!)
for config in configs/godot-*.json; do
  python3 cli/doc_scraper.py --config $config &
done
```

See [modules/Skill_Seekers/README.md](modules/Skill_Seekers/README.md) for full documentation.

### 8. Add VoiceMode (Voice Conversations)

VoiceMode enables natural voice conversations with Claude, supporting both local STT/TTS services and OpenAI fallback:

```bash
# Install VoiceMode MCP python package and dependencies
curl -LsSf https://astral.sh/uv/install.sh | sh
uvx voice-mode-install

# Optional: Set OpenAI API key (backup if local services unavailable)
export OPENAI_API_KEY=your-openai-key

# Add VoiceMode to Claude
claude mcp add --scope user voicemode -- uvx --refresh voice-mode

# Start a voice conversation
claude converse
```

**What You Get:**
- 🎤 **Voice Input** - Speak naturally to Claude instead of typing
- 🔊 **Voice Output** - Hear Claude's responses in natural speech
- 🏠 **Local Processing** - Uses Whisper (STT) and Kokoro (TTS) for privacy
- ☁️ **OpenAI Fallback** - Automatic fallback when local services unavailable
- 🎯 **Low Latency** - Fast response times with optimized processing

**Service Management:**

VoiceMode provides a unified service management tool:

```bash
# Check service status
uvx voice-mode service whisper status
uvx voice-mode service kokoro status

# Start/stop services
uvx voice-mode service whisper start
uvx voice-mode service kokoro start

# View logs
uvx voice-mode service whisper logs
uvx voice-mode service kokoro logs

# Enable auto-start on boot
uvx voice-mode service whisper enable
uvx voice-mode service kokoro enable
```

**Documentation & Resources:**
- Website: [getvoicemode.com](https://getvoicemode.com)
- MCP Resources: Access via `voicemode://docs/*`
  - `voicemode://docs/quickstart` - Basic usage guide
  - `voicemode://docs/parameters` - Complete parameter reference
  - `voicemode://docs/languages` - Non-English language support
  - `voicemode://docs/troubleshooting` - Audio and connectivity issues

### 9. Verify Setup

```bash
# List all configured MCP servers
claude mcp list

# Test Claude Flow
npx claude-flow@alpha sparc modes

# Test Composio (if installed)
composio apps

# Check Google Workspace connection
# Open Claude Code and try: "Check my Gmail inbox"

# Test GetGather (if running)
# In Claude Code: "Use getgather to fetch https://example.com"

# Check Superpowers
# In Claude Code: "List all available superpowers skills"

# Test VoiceMode (if installed)
uvx voice-mode service whisper status
uvx voice-mode service kokoro status
# Try: claude converse
```

## 📚 Included Submodules

ExoMind includes six specialized modules in the `modules/` directory:

### [Superpowers](https://github.com/natea/superpowers)
Enhanced Claude Code skills for systematic development workflows.

**Installation:** `/plugin install superpowers@superpowers-marketplace`

**Key Features:**
- Brainstorming and design refinement using Socratic method
- Test-driven development with RED-GREEN-REFACTOR cycles
- Systematic debugging with root cause tracing
- Code review and validation frameworks
- Implementation plan writing and execution

**Skills Include:**
- `brainstorming` - Interactive design refinement
- `test-driven-development` - TDD workflows
- `systematic-debugging` - Debug with structure
- `requesting-code-review` - Request reviews properly
- `receiving-code-review` - Handle feedback effectively
- `verification-before-completion` - Never skip verification

### [MCP GetGather](https://github.com/natea/mcp-getgather)
MCP server for intelligent context gathering and information synthesis.

**Installation:** Add to MCP settings with `http://127.0.0.1:23456/mcp`

**Key Features:**
- Web content extraction from any URL
- Document processing and parsing
- Context aggregation across sources
- Research automation workflows

**Use Cases:**
- Extract API documentation from websites
- Gather research from multiple sources
- Scrape and summarize release notes
- Collect examples and code snippets

### [Skill Seekers](https://github.com/natea/Skill_Seekers)
Automatically convert documentation websites into Claude Code skills.

**Key Features:**
- **Universal Documentation Scraper** - Works with ANY docs site
- **AI-Powered Enhancement** - Creates comprehensive guides with examples
- **MCP Server Integration** - Use from Claude Code with natural language
- **Large Documentation Support** - Handle 10K-40K+ page sites
- **Router/Hub Skills** - Intelligent routing to specialized sub-skills
- **8 Pre-built Configs** - React, Vue, Django, FastAPI, Godot, and more

**Quick Start:**
```bash
cd modules/Skill_Seekers
python3 cli/doc_scraper.py --config configs/react.json --enhance-local
python3 cli/package_skill.py output/react/
# Upload output/react.zip to Claude
```

**What Gets Created:**
- Comprehensive SKILL.md with real examples
- Categorized reference documentation
- Code patterns and best practices
- Quick reference guides

### [Life OS](https://github.com/natea/life-os)
Personal operating system for productivity and life management with 20+ integrated skills.

**Complete Implementation (Weeks 1-11):**
- ✅ **20+ Skills** - Full GTD workflow, reviews, goal tracking, integrations
- ✅ **100+ Source Files** - TypeScript codebase with configuration management
- ✅ **600+ Tests** - Comprehensive test coverage
- ✅ **10K+ Lines of Docs** - Complete user guides and API documentation

**Core Skills:**
- `conducting-life-assessment` - 10 life areas quarterly evaluation
- `daily-planning` - Morning/evening routines with energy management
- `weekly-review` - Complete GTD methodology
- `monthly-review` - Intelligent aggregation and pattern detection
- `quarterly-review` - OKR scoring and 90-day retrospectives
- `goal-setting` - SMART goals + OKR framework
- `processing-inbox` - GTD inbox processing workflow

**Integration Skills:**
- `processing-email-inbox` - Email-to-task conversion via Google Workspace MCP
- `analyzing-schedule` - Calendar analysis and optimization
- `scheduling-tasks` - Smart time blocking
- `whatsapp-message-management` - Mobile briefings and quick capture
- `resolving-sync-conflicts` - Todoist conflict resolution

**Advanced Skills:**
- `detecting-patterns` - 6 pattern types across productivity data
- `smart-recommendations` - AI-powered insights
- `tracking-habits` - Streak management and consistency analysis
- `coordinating-life-os` - System orchestration and health checks

**Life Management:**
- `meal-planning` - Weekly meal planning with dietary preferences
- `recipe-finding` - Recipe search and scaling
- `grocery-shopping` - Automated shopping list generation

**Quick Start:**
```bash
# Install dependencies
npm install

# Test the skills in Claude Code
./scripts/sync-claude-skills.sh

# Run validation
npm run validate:all
npm test
```

See [docs/user/getting-started.md](docs/user/getting-started.md) for complete setup guide.

### [Anthropic Claude Skills](https://github.com/natea/anthropic-claude-skills)
Official example skills from Anthropic demonstrating Claude's skills system capabilities.

**Installation:** `/plugin install example-skills@anthropic-agent-skills` or `/plugin install document-skills@anthropic-agent-skills`

**Key Features:**
- **Document Skills** - Create and edit DOCX, PDF, PPTX, XLSX files
- **Creative Skills** - Algorithmic art, canvas design, Slack GIF creation
- **Development Skills** - MCP server creation, webapp testing, artifact building
- **Enterprise Skills** - Brand guidelines, internal communications, theme factory
- **Meta Skills** - Skill creator and template for building custom skills

**Example Skills Include:**
- `algorithmic-art` - Generative art with p5.js
- `canvas-design` - Visual art in PNG/PDF formats
- `artifacts-builder` - Complex HTML artifacts with React/Tailwind
- `mcp-server` - Guide for creating MCP servers
- `webapp-testing` - Test web apps with Playwright
- `brand-guidelines` - Apply consistent branding
- `skill-creator` - Create effective custom skills

**Document Skills Include:**
- `docx` - Word documents with tracked changes and formatting
- `pdf` - PDF manipulation, extraction, and creation
- `pptx` - PowerPoint presentations with layouts and charts
- `xlsx` - Excel spreadsheets with formulas and visualization

**Quick Start:**
```bash
# Register the marketplace
/plugin marketplace add anthropics/skills

# Install example skills
/plugin install example-skills@anthropic-agent-skills

# Install document skills
/plugin install document-skills@anthropic-agent-skills

# Use a skill
"Use the PDF skill to extract text from document.pdf"
"Create an algorithmic art piece using p5.js"
"Build a React artifact for a task management app"
```

See [modules/anthropic-claude-skills/README.md](modules/anthropic-claude-skills/README.md) for full documentation.

### [AR Claude Skills](https://github.com/natea/ar-claude-skills)
Professional skills for C-level leadership, marketing teams, and product development.

**Key Features:**
- **C-Level Advisors** - Strategic guidance for CEOs and CTOs
- **Marketing Skills** - Content creation, strategy, and demand generation
- **Product Team** - Agile practices, PM frameworks, UX research, design systems
- **Automated Symlinking** - Safe script for integrating skills into Claude Code

**10 Professional Skills:**

**C-Level Leadership:**
- `ceo-advisor` - Strategic business leadership and decision-making
- `cto-advisor` - Technical leadership and architecture guidance

**Marketing:**
- `content-creator` - Content strategy and creation workflows
- `marketing-strategy-pmm` - Product marketing management frameworks
- `marketing-demand-acquisition` - Demand generation and customer acquisition

**Product Team:**
- `agile-product-owner` - Agile methodologies and PO best practices
- `product-manager-toolkit` - PM frameworks, prioritization, roadmapping
- `product-strategist` - Product strategy and vision development
- `ux-researcher-designer` - UX research methodologies and design
- `ui-design-system` - Design system creation and maintenance

**Quick Start:**
```bash
# Symlink skills into Claude Code
./scripts/symlink-ar-skills.sh --dry-run  # Preview
./scripts/symlink-ar-skills.sh            # Execute

# Verify installation
ls -la .claude/skills/ | grep "ar-claude-skills"

# Use in Claude Code
"Use the ceo-advisor skill to help with strategic planning"
"Apply product-strategist skill to develop product roadmap"
```

**Script Features:**
- ✅ Non-destructive: Never overwrites existing skills
- ✅ Dry-run mode for safe testing
- ✅ Relative symlink paths for portability
- ✅ Color-coded status output

See [scripts/README-symlink-ar-skills.md](scripts/README-symlink-ar-skills.md) for detailed documentation.

### [Claude Code by Agents](https://github.com/natea/claude-code-by-agents)
Multi-agent workspace with Electron desktop app for collaborative development and task coordination.

**Key Features:**
- **Electron Desktop App** - Native app for Windows, macOS, and Linux
- **Multi-Agent Orchestration** - Coordinate multiple specialized agents
- **@agent-name Mentions** - Direct task routing to specific agents
- **Local & Remote Agents** - Mix local and cloud-based agent instances
- **No API Keys Required** - Uses your Claude CLI authentication
- **Beautiful Web UI** - Agent hub, detail views, and orchestrator chat
- **Session Continuity** - Maintains conversation context per agent
- **Agent Isolation** - Separate working directories and contexts per agent

**Architecture:**
- **Agent Hub Page** - Grid view of all configured agents with status
- **Agent Detail View** - Individual chat sessions (Current Chat + History tabs)
- **Orchestrator Chat** - Multi-agent planning and coordination
- **Remote Agent Support** - Connect agents running on different machines
- **File-Based Coordination** - Automatic dependency management

**Quick Start:**

```bash
cd modules/claude-code-by-agents

# Option 1: Download pre-built desktop app
# Windows: claude-code-webui-windows-x64.exe
# macOS Intel: claude-code-webui-macos-x64
# macOS ARM: claude-code-webui-macos-arm64
# Linux: claude-code-webui-linux-{x64,arm64}

# Start backend service (required for desktop app)
cd backend && deno task dev  # Runs on localhost:8080

# Option 2: Run from source
npm install
cd backend && deno task dev        # Terminal 1: Backend
cd frontend && npm run dev         # Terminal 2: Frontend

# Option 3: Build desktop app
npm run dist:mac    # macOS DMG
npm run dist:win    # Windows installer
npm run dist:linux  # Linux AppImage
```

**Usage Examples:**

```bash
# Single agent - direct execution, no orchestration overhead
@api-agent add user authentication

# Multi-agent - orchestrator coordinates automatically
"Create full auth system with frontend and backend"

# Remote agent on different machine
@mac-mini-agent run browser tests on Safari

# Mix local and remote agents
"@backend-agent create API, @frontend-agent build UI, @test-agent verify"
```

**Configure Agents in Web UI:**

1. **Click "Add Agent"** in Agent Hub
2. **Enter agent details:**
   - Name: `Backend API Agent`
   - Description: `Handles backend API development`
   - Working Directory: `/path/to/backend`
   - API Endpoint: `http://localhost:8081` (local) or `http://remote-host:8081`
3. **Save and use** with @mentions in messages

**Authentication & Billing:**
- Uses Claude CLI authentication (`claude auth login`)
- No API keys needed - OAuth tokens managed securely
- All requests billed to your Claude subscription (Pro/Team/Enterprise)
- Same billing model as using Claude Code directly

**Use Cases:**
- **Full-stack projects**: Separate agents for frontend, backend, database
- **Microservices**: One agent per service with isolated working directories
- **Cross-platform**: Mac agent for iOS, Linux agent for Android
- **Team coordination**: Remote agents on team members' machines
- **Specialized agents**: API development, testing, documentation, etc.

**Benefits:**
- Visual workspace for managing multiple agent conversations
- Specialized agents with focused expertise and codebases
- Mix local development with remote cloud instances
- Simple @mention routing instead of complex orchestration
- Beautiful UI for tracking progress across agents

See [modules/claude-code-by-agents/README.md](modules/claude-code-by-agents/README.md) for full documentation.

## 🧪 Testing Life OS Skills in Claude Code

ExoMind includes 20+ Life OS skills for personal productivity. To test them in Claude Code:

### Option 1: Symlinks (Recommended)

Use symlinks to keep skills synchronized automatically:

```bash
# Create symlinks from /skills/ to /.claude/skills/
./scripts/sync-claude-skills.sh

# Verify symlinks were created
ls -la .claude/skills/
# Should show: skill-name -> ../../skills/skill-name

# Test a skill in Claude Code
"Use the daily-planning skill to plan my day"
```

**Benefits:**
- ✅ Single source of truth in `skills/`
- ✅ Changes in either location reflect everywhere
- ✅ No manual syncing needed
- ✅ Git tracks only the original files

### Option 2: Manual Copying (Not Recommended)

Copy files manually (requires re-sync after each change):

```bash
# Copy all skills to .claude/skills
cp -r skills/* .claude/skills/

# Remember: Must re-run after ANY skill modification!
```

⚠️ **Warning:** Easy to forget, files will diverge, requires manual syncing.

### Available Skills

All 20+ Life OS skills are available in `.claude/skills/`:
- **Planning**: daily-planning, weekly-review, monthly-review, quarterly-review
- **Goals**: conducting-life-assessment, goal-setting
- **GTD**: processing-inbox, processing-email-inbox
- **Calendar**: analyzing-schedule, scheduling-tasks
- **Advanced**: detecting-patterns, smart-recommendations, tracking-habits
- **Integration**: whatsapp-message-management, resolving-sync-conflicts
- **System**: coordinating-life-os, using-life-os
- **Life**: meal-planning, recipe-finding, grocery-shopping

See [.claude/skills/README.md](.claude/skills/README.md) for complete documentation.

## 🎯 Quick Start

### Run Your First SPARC Workflow

```bash
# List available SPARC modes
npx claude-flow@alpha sparc modes

# Run a complete TDD workflow
npx claude-flow@alpha sparc tdd "Create a REST API endpoint for user authentication"

# Run specific SPARC phases
npx claude-flow@alpha sparc run spec-pseudocode "Design a caching system"
npx claude-flow@alpha sparc run architect "Build microservices architecture"
```

### Initialize a Multi-Agent Swarm

```bash
# Initialize swarm with mesh topology (peer-to-peer)
npx claude-flow@alpha swarm init --topology mesh

# Spawn specialized agents
npx claude-flow@alpha swarm spawn --type researcher --name "api-researcher"
npx claude-flow@alpha swarm spawn --type coder --name "backend-dev"
npx claude-flow@alpha swarm spawn --type tester --name "qa-engineer"

# Check swarm status
npx claude-flow@alpha swarm status
```

### Use Google Workspace Features

With Composio or Google Workspace MCP configured, you can use natural language commands in Claude Code:

```
"Check my Gmail for messages from today"
"Send an email to team@example.com with subject 'Project Update'"
"What's on my calendar for tomorrow?"
"Schedule a meeting for next Monday at 2pm"
"Find all emails about the ExoMind project"
"Create a calendar event: Team standup, daily at 9am"
```

## 🏗️ Project Structure

```
ExoMind/
├── modules/                    # Git submodules
│   ├── superpowers/           # Enhanced Claude Code skills
│   ├── mcp-getgather/         # Context gathering MCP
│   ├── Skill_Seekers/         # Skill management system
│   └── life-os/               # Personal productivity OS
├── .claude/                   # Claude Code configuration
│   ├── agents/                # 54+ specialized agent definitions
│   ├── commands/              # Slash commands and workflows
│   ├── helpers/               # Automation scripts
│   └── settings.json          # Claude Code settings
├── src/                       # Source code (when generated)
├── tests/                     # Test files
├── docs/                      # Documentation
│   └── SUBMODULES.md         # Submodule management guide
├── config/                    # Configuration files
├── scripts/                   # Utility scripts
├── CLAUDE.md                  # Project instructions for Claude
└── README.md                  # This file
```

## 🤖 Available Agents

ExoMind provides 54 specialized AI agents across multiple categories:

### Core Development
- `coder` - Implementation specialist
- `reviewer` - Code review and quality assurance
- `tester` - Comprehensive testing and QA
- `planner` - Strategic planning and task orchestration
- `researcher` - Deep research and information gathering

### SPARC Methodology
- `specification` - Requirements analysis
- `pseudocode` - Algorithm design
- `architecture` - System design
- `refinement` - TDD implementation
- `sparc-coder` - Transform specs into code

### Swarm Coordination
- `hierarchical-coordinator` - Tree-based coordination
- `mesh-coordinator` - Peer-to-peer mesh network
- `adaptive-coordinator` - Dynamic topology switching
- `collective-intelligence-coordinator` - Distributed cognition
- `swarm-memory-manager` - Shared memory management

### GitHub Integration
- `pr-manager` - Pull request management and automation
- `code-review-swarm` - Multi-agent code review
- `issue-tracker` - Intelligent issue management
- `release-manager` - Automated release coordination
- `workflow-automation` - CI/CD pipeline creation

### Specialized Development
- `backend-dev` - REST and GraphQL API development
- `mobile-dev` - React Native cross-platform apps
- `ml-developer` - Machine learning model development
- `cicd-engineer` - CI/CD pipeline specialist
- `api-docs` - OpenAPI/Swagger documentation

### Consensus & Distributed Systems
- `byzantine-coordinator` - Byzantine fault tolerance
- `raft-manager` - Raft consensus algorithm
- `gossip-coordinator` - Gossip-based consensus
- `crdt-synchronizer` - Conflict-free replicated data types

### Performance & Optimization
- `perf-analyzer` - Performance bottleneck analysis
- `performance-benchmarker` - Comprehensive benchmarking
- `resource-allocator` - Adaptive resource allocation
- `topology-optimizer` - Dynamic topology optimization

[View all 54 agents →](.claude/agents/)

## 📖 Documentation

### Core Documentation
- [Submodule Management](docs/SUBMODULES.md) - Working with git submodules
- [Claude Code Configuration](CLAUDE.md) - Project instructions and workflows
- [Agent Directory](.claude/agents/) - All available agent definitions
- [Command Reference](.claude/commands/) - Slash commands and workflows

### External Resources
- [Claude Flow Documentation](https://github.com/ruvnet/claude-flow)
- [Claude Code Docs](https://docs.claude.com/en/docs/claude-code)
- [MCP Protocol Specification](https://modelcontextprotocol.io/)
- [Composio Documentation](https://docs.composio.dev/)

## 🔬 Advanced Usage

### Parallel Agent Execution

ExoMind is optimized for concurrent operations. Always batch related operations in a single message:

```javascript
// ✅ CORRECT: Single message with parallel agent execution
Task("Research agent", "Analyze API patterns", "researcher")
Task("Coder agent", "Implement REST endpoints", "coder")
Task("Tester agent", "Create test suite", "tester")
Task("Reviewer agent", "Review code quality", "reviewer")

TodoWrite { todos: [...8-10 todos...] }

Write "src/api/server.js"
Write "tests/api.test.js"
Write "docs/API.md"
```

### Memory Management

Agents can store and retrieve context across sessions:

```bash
# Store context in memory
npx claude-flow@alpha hooks post-edit --memory-key "project/context" --value "API design decisions"

# Retrieve context
npx claude-flow@alpha hooks session-restore --session-id "swarm-12345"
```

### GitHub Automation

```bash
# Analyze repository
npx claude-flow@alpha github repo-analyze natea/ExoMind

# Automated PR review
npx claude-flow@alpha github pr-review 42

# Release coordination
npx claude-flow@alpha github release-coord --version v1.0.0
```

### Neural Training

Train agents from successful patterns:

```bash
# Train from completed tasks
npx claude-flow@alpha neural-train --pattern coordination

# Analyze cognitive patterns
npx claude-flow@alpha neural-patterns --action analyze
```

## 🧪 Testing

```bash
# Run all tests
npm test

# Run specific test suite
npm test -- --grep "API"

# Run with coverage
npm run test:coverage

# Type checking
npm run typecheck

# Linting
npm run lint
```

## 📊 Performance Metrics

ExoMind achieves impressive performance through swarm coordination:

- **84.8% SWE-Bench solve rate** - Outperforms individual agents
- **32.3% token reduction** - Efficient context management
- **2.8-4.4x speed improvement** - Parallel execution
- **27+ neural models** - Specialized learning patterns
- **54 specialized agents** - Comprehensive coverage

## 🛠️ Troubleshooting

### MCP Servers Not Working

```bash
# Restart Claude Desktop/Code
# Verify MCP configuration
cat ~/.config/claude/mcp_settings.json

# Check MCP server logs
claude mcp logs claude-flow

# Re-add MCP server
claude mcp remove claude-flow
claude mcp add claude-flow npx claude-flow@alpha mcp start
```

### Google Workspace Authentication Issues

```bash
# For Composio:
composio logout
composio add googleworkspace

# For direct Google Workspace MCP:
rm /path/to/token.json
npx @modelcontextprotocol/server-google-workspace auth
```

### Submodule Issues

```bash
# Update all submodules
git submodule update --remote --recursive

# Reset submodule to tracked commit
git submodule update --init --recursive

# Clean and reinitialize
git submodule deinit -f modules/superpowers
git submodule update --init modules/superpowers
```

### Claude Flow Not Found

```bash
# Reinstall Claude Flow
npm install -g claude-flow@alpha

# Or use npx without installation
npx claude-flow@alpha init
```

## 🤝 Contributing

Contributions are welcome! Please follow these guidelines:

1. Fork the repository
2. Create a feature branch (`git checkout -b feature/amazing-feature`)
3. Follow the SPARC methodology for implementation
4. Write tests for new functionality
5. Update documentation
6. Submit a pull request

## 📄 License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

## 🙏 Acknowledgments

- [Claude Code](https://claude.ai/code) - AI-powered development environment
- [Claude Flow](https://github.com/ruvnet/claude-flow) - Multi-agent orchestration framework
- [Composio](https://composio.dev/) - Unified API authentication
- [MCP Protocol](https://modelcontextprotocol.io/) - Model Context Protocol specification
- All contributors to the included submodules

## 📞 Support

- **Issues**: [GitHub Issues](https://github.com/natea/ExoMind/issues)
- **Discussions**: [GitHub Discussions](https://github.com/natea/ExoMind/discussions)
- **Claude Flow**: [Claude Flow Issues](https://github.com/ruvnet/claude-flow/issues)
- **Flow-Nexus**: [Flow-Nexus Platform](https://flow-nexus.ruv.io)

## 🗺️ Roadmap

- [ ] Web-based dashboard for swarm monitoring
- [ ] VS Code extension for enhanced integration
- [ ] Additional MCP servers for popular services (Slack, Notion, etc.)
- [ ] Mobile app for on-the-go access
- [ ] Advanced neural pattern libraries
- [ ] Marketplace for custom agents and workflows
- [ ] Enterprise features (SSO, audit logs, compliance)

---

**Built with ❤️ using Claude Code, SPARC methodology, and swarm intelligence.**

**Remember**: Claude Flow coordinates, Claude Code creates!

ExoMind

ExoMind 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

ExoMind

ExoMind 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

Download README