luna-agents 2.0.1

package/commands/ll-multi-agent.md

@@ -0,0 +1,170 @@
+---
+name: ll-multi-agent
+displayName: Luna Multi-Agent
+description: Run multiple AI agents in parallel on isolated git worktrees — race or consensus strategies, inspired by Agent of Empires
+version: 1.0.0
+category: orchestration
+agent: luna-task-executor
+parameters:
+  - name: task
+    type: string
+    description: The task to distribute across parallel agents
+    required: true
+    prompt: true
+  - name: agents
+    type: number
+    description: "Number of parallel agents to spawn (default: 3)"
+    required: false
+    default: 3
+  - name: strategy
+    type: string
+    description: "Strategy: race (first wins), consensus (merge best parts) (default: race)"
+    required: false
+    default: race
+mcp_servers:
+  - memory
+  - git
+  - sequential-thinking
+prerequisites:
+  - name: git-worktree
+    check: "git worktree list"
+    install: "Requires git 2.15+ with worktree support"
+    optional: false
+  - name: tmux
+    check: "which tmux"
+    install: "brew install tmux (macOS) or apt install tmux (Linux)"
+    optional: true
+---
+
+# /multi-agent — Parallel AI Agents on Isolated Branches
+
+Run multiple AI agents simultaneously on different git worktrees, each tackling the same task independently. Pick the best result (race) or merge the best parts (consensus). Inspired by Agent of Empires.
+
+## What It Does
+
+```
+/multi-agent "Implement user authentication" --agents 3
+    │
+    ├── SETUP: Create isolated environments
+    │   ├── git worktree add .worktrees/agent-1 -b agent/auth-1
+    │   ├── git worktree add .worktrees/agent-2 -b agent/auth-2
+    │   └── git worktree add .worktrees/agent-3 -b agent/auth-3
+    │
+    ├── EXECUTE: Run agents in parallel
+    │   ├── Agent 1: Working in .worktrees/agent-1 ...
+    │   ├── Agent 2: Working in .worktrees/agent-2 ...
+    │   └── Agent 3: Working in .worktrees/agent-3 ...
+    │   (tmux sessions for real-time monitoring)
+    │
+    ├── EVALUATE: Compare results
+    │   ├── Run tests in each worktree
+    │   ├── Score: test pass rate, code quality, coverage
+    │   ├── Compare approaches and trade-offs
+    │   └── Select winner or merge best parts
+    │
+    └── MERGE
+        ├── race:      Cherry-pick winner to main branch
+        └── consensus: Merge best files from each agent
+```
+
+## Strategies
+
+### Race (default)
+All agents work independently. The first one that passes all tests wins. Others are discarded.
+
+```
+Agent 1: ████████████ PASS ← Winner!
+Agent 2: ██████████░░ FAIL
+Agent 3: ████████░░░░ (still running, cancelled)
+```
+
+### Consensus
+All agents complete their work. An evaluator agent reviews all solutions and merges the best parts from each.
+
+```
+Agent 1: Auth middleware (best)    → KEEP
+Agent 2: Token refresh (best)     → KEEP
+Agent 3: Test coverage (best)     → KEEP
+Result:  Combined best of all three
+```
+
+## How It Works
+
+1. **Git worktrees**: Each agent gets an isolated working directory on its own branch
+2. **Parallel execution**: Agents run concurrently via tmux or background processes
+3. **Isolation**: No agent can see or interfere with another's work
+4. **Evaluation**: Tests + code quality scoring determine the winner
+5. **Cleanup**: Worktrees and branches are removed after merge
+
+## Usage
+
+```bash
+/multi-agent "Implement OAuth2 login"                         # 3 agents, race
+/multi-agent "Build dashboard" --agents 5                     # 5 agents
+/multi-agent "Refactor auth module" --strategy consensus      # Merge best parts
+/multi-agent "Write API tests" --agents 2 --strategy race    # 2 agents race
+```
+
+## Use Cases
+
+| Use Case | Why |
+|----------|-----|
+| Parallel feature development | 3 approaches, pick the best |
+| A/B code generation | Compare different architectures |
+| Multi-approach problem solving | Consensus merges best of each |
+| Competitive coding | Race to the best solution |
+| Explore trade-offs | See how different agents solve it |
+
+## Session Management
+
+```bash
+# Monitor running agents (tmux)
+tmux attach -t luna-multi-agent          # View all agent sessions
+tmux select-window -t agent-1           # Focus on agent 1
+
+# Manual control
+/multi-agent status                      # Check progress
+/multi-agent cancel                      # Stop all agents
+/multi-agent results                     # View comparison
+```
+
+## Output Structure
+
+```
+.worktrees/
+├── agent-1/          # Isolated worktree (cleaned up after merge)
+├── agent-2/
+└── agent-3/
+
+multi-agent-results/
+├── comparison.md     # Side-by-side analysis
+├── scores.json       # Per-agent scores
+│   {
+│     "agents": [
+│       { "id": 1, "tests_passed": 42, "coverage": "94%", "score": 0.92 },
+│       { "id": 2, "tests_passed": 38, "coverage": "87%", "score": 0.81 },
+│       { "id": 3, "tests_passed": 40, "coverage": "91%", "score": 0.88 }
+│     ],
+│     "winner": 1,
+│     "strategy": "race"
+│   }
+└── diffs/
+    ├── agent-1.diff  # Each agent's changes
+    ├── agent-2.diff
+    └── agent-3.diff
+```
+
+## In Pipes
+
+```bash
+/pipe multi-agent "build feature" >> test >> ship
+/pipe idea "my app" >> multi-agent "implement" --agents 5 >> rev >> ship
+/pipe multi-agent "fix bug #42" --strategy consensus >> test >> pr
+/pipe plan >> multi-agent "implement phase 1" >> flaky "npm test" >> ship
+```
+
+## Reference
+
+- Inspired by: https://github.com/njbrake/agent-of-empires
+- Git worktrees: `git worktree add <path> -b <branch>`
+- tmux: Session management for parallel monitoring

package/commands/ll-native.md

@@ -0,0 +1,93 @@
+---
+name: ll-native
+displayName: Luna Native
+description: Generate native mobile (iOS/Android) or desktop (macOS/Windows/Linux) apps from web code or description
+version: 1.0.0
+category: creation
+agent: luna-design-architect
+parameters:
+  - name: source
+    type: string
+    description: Web app path, URL, or plain English description
+    required: true
+    prompt: true
+  - name: platform
+    type: string
+    description: "Platform: ios, android, macos, windows, linux, all"
+    required: true
+    prompt: true
+  - name: framework
+    type: string
+    description: "Framework: react-native (default), expo, flutter, swift-ui, kotlin-compose, electron, tauri"
+    required: false
+    default: react-native
+mcp_servers:
+  - zai-mcp-server
+  - playwright
+  - fetch
+  - sequential-thinking
+  - ruflo
+  - memory
+---
+
+# /native — Web to Native in One Command
+
+Transform your web app into a native mobile or desktop experience. Or describe what you want and Luna builds it from scratch.
+
+## From Web to Native
+
+```
+/native ./my-next-app --platform ios --framework expo
+              │
+              ▼
+      ANALYZE web app
+      ├── Routes → Screens
+      ├── Components → Native equivalents
+      ├── State management → preserved
+      ├── API calls → shared service layer
+      ├── Auth flow → native auth (FaceID, biometrics)
+      └── Design → platform-native UI patterns
+              │
+              ▼
+      TRANSFORM
+      ├── React components → React Native components
+      ├── CSS/Tailwind → StyleSheet / NativeWind
+      ├── Next.js router → React Navigation
+      ├── Web storage → AsyncStorage / SecureStore
+      ├── Web push → Push notifications (APNs/FCM)
+      └── Web camera/GPS → native APIs
+              │
+              ▼
+      ENHANCE for native
+      ├── Haptic feedback on interactions
+      ├── Native gestures (swipe, long press, pinch)
+      ├── Offline mode with local cache
+      ├── App icon and splash screen
+      ├── Deep linking configuration
+      └── Platform-specific UX (iOS vs Android)
+```
+
+## Desktop Apps
+
+```bash
+/native ./web-app --platform macos --framework tauri     # Lightweight native wrapper
+/native ./web-app --platform all --framework electron     # Cross-platform desktop
+/native "A Notion-like editor for local markdown files" --platform macos --framework swift-ui
+```
+
+## Mobile Apps
+
+```bash
+/native ./dashboard --platform ios --framework expo       # iOS from web dashboard
+/native ./dashboard --platform android                    # Android
+/native "Fitness tracker with Apple Watch" --platform ios --framework swift-ui
+/native "Delivery driver app with GPS tracking" --platform all --framework flutter
+```
+
+## In Pipes
+
+```bash
+/pipe native ./web-app ios >> hig >> test >> launch "App Store"
+/pipe clone https://app.com >> native ios >> brand >> test >> ship
+/pipe idea "my app" >> api >> go *5 >> native all >> test >> launch
+```

package/commands/ll-nexa.md

@@ -0,0 +1,79 @@
+---
+name: ll-nexa
+displayName: Luna Nexa AI
+description: Nexa-powered semantic code analysis — AI review, bug detection, architecture recommendations
+version: 1.0.0
+category: ai
+agent: luna-rag-enhanced
+parameters:
+  - name: action
+    type: string
+    description: Action (review, bugs, explain, recommend, chat, debt)
+    required: true
+    prompt: true
+  - name: target
+    type: string
+    description: File path, directory, or question
+    required: true
+    prompt: true
+workflow:
+  - connect_nexa_rag_server
+  - index_codebase_embeddings
+  - execute_ai_action
+  - generate_nexa_report
+output:
+  - .luna/{current-project}/nexa-report.md
+prerequisites: []
+---
+
+# Luna Nexa AI
+
+Semantic code intelligence powered by Nexa embeddings + ChromaDB + LangChain.
+
+## What This Command Does
+
+Connects to the Nexa RAG MCP server for AI-powered code analysis using vector embeddings and LangChain chains.
+
+## Actions
+
+| Action | What It Does |
+|--------|-------------|
+| `review` | AI code review with semantic understanding of patterns |
+| `bugs` | Bug detection — finds potential issues across codebase |
+| `explain` | Explain code in natural language with context |
+| `recommend` | Architecture recommendations based on codebase analysis |
+| `chat` | Conversational codebase Q&A with memory |
+| `debt` | Tech debt detection and prioritized cleanup plan |
+| `test-gen` | Auto-generate tests from code analysis |
+| `doc-gen` | Auto-generate documentation from code |
+
+## Usage
+
+```
+/nexa review src/services/           # AI code review
+/nexa bugs src/                      # Find potential bugs
+/nexa explain src/auth/middleware.ts  # Explain code
+/nexa recommend                      # Architecture recommendations
+/nexa chat "how does billing work?"  # Codebase Q&A
+/nexa debt                           # Tech debt analysis
+/nexa test-gen src/services/auth.ts  # Generate tests
+/nexa doc-gen src/routes/            # Generate docs
+```
+
+## Architecture
+
+```
+Your code -> Nexa Embeddings (bge-base-en-v1.5)
+  -> ChromaDB vector store
+  -> LangChain semantic search
+  -> AI analysis chain
+  -> Structured report
+```
+
+## Features
+
+- Semantic code search (not just text matching)
+- Cross-file relationship understanding
+- Conversation memory for follow-up questions
+- Supports 15+ AI tools via MCP protocol
+- Indexes up to 1,000 files (free) / unlimited (pro)

package/commands/ll-onboarding.md

@@ -0,0 +1,84 @@
+---
+name: ll-onboarding
+displayName: Luna Onboarding Guide Builder
+description: Generate an onboarding guide — setup steps, first-use walkthrough, progressive disclosure, role-based paths
+version: 1.0.0
+category: documentation
+agent: luna-onboarding-builder
+parameters:
+  - name: scope
+    type: string
+    description: Project or audience scope for onboarding guide
+    required: true
+    prompt: true
+workflow:
+  - analyse_setup_requirements
+  - trace_first_use_experience
+  - define_progressive_disclosure_path
+  - identify_common_gotchas
+  - generate_onboarding_document
+output:
+  - .luna/{current-project}/onboarding.md
+prerequisites:
+  - source_code
+  - .luna/{current-project}/requirements.md (optional)
+---
+
+# Luna Onboarding Guide Builder
+
+Generates a comprehensive onboarding guide from your codebase covering setup, first-use walkthrough, feature discovery, and role-based paths.
+
+## What This Command Does
+
+This command analyses your project's installation requirements, initial configuration, key features, and common pitfalls, then produces role-based onboarding guides with step-by-step instructions.
+
+## Prerequisites
+
+Requires in your current project:
+- Source code
+
+Optional for richer output:
+- `.luna/{current-project}/requirements.md`
+- `.luna/{current-project}/design.md`
+
+## Usage Instructions
+
+When you run this command, you'll be prompted for the scope:
+- Press **ENTER** for full-project onboarding
+- Type **developer** / **admin** / **user** for role-specific guides
+
+## Execution Steps
+
+1. **Setup Analysis**: Identifies tools, env vars, dependencies, and services needed
+2. **First-Use Trace**: Maps the initial user experience step-by-step
+3. **Progressive Disclosure**: Defines feature discovery order by importance
+4. **Gotcha Detection**: Finds common first-time mistakes from the codebase
+5. **Guide Generation**: Produces `onboarding.md` with checklists and paths
+
+## Output Files
+
+Creates in your current project:
+- `.luna/{current-project}/onboarding.md`
+
+Includes:
+- Quick Start Guide (zero-to-running)
+- Environment setup checklist
+- First-use walkthrough with screenshot placeholders
+- Feature discovery path (progressive disclosure)
+- Common gotchas and solutions
+- Role-based guides (developer / admin / end-user)
+- Interactive onboarding checklist
+
+## Next Steps in Workflow
+
+After onboarding guide:
+```
+/luna-docs         # Full project documentation
+/luna-flowdocs     # Detailed flow documentation
+```
+
+## Tips
+
+- Onboarding guides reduce support burden and improve adoption
+- Include the guide in your repo's CONTRIBUTING.md or docs/ directory
+- Test the guide with a fresh environment to verify completeness

package/commands/ll-openhands.md

@@ -0,0 +1,78 @@
+---
+name: ll-openhands
+displayName: Luna OpenHands
+description: Autonomous AI coding agent — delegate complex tasks to OpenHands for autonomous implementation
+version: 1.0.0
+category: ai
+agent: luna-task-executor
+parameters:
+  - name: task
+    type: string
+    description: Task description for OpenHands to execute autonomously
+    required: true
+    prompt: true
+  - name: mode
+    type: string
+    description: Execution mode (autonomous, supervised, plan-only)
+    required: false
+    prompt: true
+workflow:
+  - analyze_task_complexity
+  - prepare_openhands_context
+  - launch_openhands_agent
+  - monitor_execution
+  - review_changes
+  - validate_output
+  - generate_openhands_report
+output:
+  - .luna/{current-project}/openhands-report.md
+prerequisites: []
+---
+
+# Luna OpenHands
+
+Delegate complex coding tasks to the OpenHands autonomous AI agent.
+
+## What This Command Does
+
+1. **Analyze** — evaluates task complexity and prepares context
+2. **Context** — sends relevant codebase context to OpenHands
+3. **Launch** — starts OpenHands agent via REST API
+4. **Monitor** — streams execution progress via WebSocket/SSE
+5. **Review** — validates generated code against project rules
+6. **Validate** — runs tests and lint on OpenHands output
+7. **Report** — documents what was changed and why
+
+## Execution Modes
+
+| Mode | Behavior |
+|------|----------|
+| `autonomous` | OpenHands works independently, reports when done |
+| `supervised` | Pauses at each step for your approval |
+| `plan-only` | Returns execution plan without implementing |
+
+## Usage
+
+```
+/openhands "implement user settings page with profile edit"
+/openhands "refactor the billing service to use LemonSqueezy webhooks" supervised
+/openhands "add WebSocket support to the run logs endpoint" plan-only
+```
+
+## Integration Points
+
+```
+Luna CLI -> OpenHands REST API -> Agent Execution
+     ↓                                ↓
+  RAG context (Nexa)          Code generation
+     ↓                                ↓
+  Project rules              Validation & tests
+```
+
+## Safety
+
+- All OpenHands output is validated against project rules
+- 100-line file cap enforced on generated code
+- Tests must pass before accepting changes
+- Code review runs automatically on output
+- Supervised mode for high-risk changes