Setup and configure oh-my-droid (the ONLY command you need to learn)
npx skills add https://github.com/MeroZemory/oh-my-droid --skill omd-setupCopiez et collez cette commande dans Claude Code pour installer le skill
Expand a product idea into a spec, plan implementation with critic validation, execute code across parallel agents, run iterative QA cycles, and perform multi-reviewer validation. Use when the user provides a feature description or project idea and wants end-to-end autonomous implementation without manual phase transitions.
Coordinate multi-agent task execution by delegating to specialist subagents, managing parallel workflows, and verifying completion through architect review. Handles investigation-to-PR cycles, codebase assessment, todo-driven progress tracking, and failure recovery. Use when a task requires breaking work across multiple agents, delegating frontend/backend/research to specialists, or managing a full GitHub issue-to-PR workflow.
Exhaustive multi-strategy codebase search using grep, ripgrep, find, and AST-aware tracing to locate implementations, references, dependencies, and usage patterns for a given symbol, pattern, or concept. Use when you need to find every occurrence of a function, type, config key, or concept across a project — especially when simple text search misses indirect references, re-exports, or dynamic usage.
Enforce strict Test-Driven Development (TDD) using the red-green-refactor cycle. Use when writing unit tests, practicing test-first development, applying TDD discipline, or implementing features via red-green-refactor workflows.
Decompose multi-step tasks into parallel sub-agent workloads, route each sub-task to the cheapest capable model tier (Haiku/Sonnet/Opus), run long-running commands in the background, and verify all deliverables before stopping. Use when the user asks to 'go fast', 'parallelize', 'ultrawork', or when a request contains 3+ independent sub-tasks that benefit from concurrent execution.
Strategic planning with optional interview workflow
| name | omd-setup |
| description | Setup and configure oh-my-droid (the ONLY command you need to learn) |
This skill is a setup wizard. Ignore unrelated context (open files, pending code changes, git/commits, etc.).
When you need to ask the user anything, use the AskUser tool and ONLY ask the wizard questions below.
This is the only command you need to learn. After running this, everything else is automatic.
IMPORTANT: This setup process saves progress after each step. If interrupted (Ctrl+C or connection loss), the setup can resume from where it left off.
.omd/state/setup-state.json - Tracks completed stepsBefore starting any step, check for existing state:
# Check for existing setup state
STATE_FILE=".omd/state/setup-state.json"
# Cross-platform ISO date to epoch conversion
iso_to_epoch() {
local iso_date="$1"
local epoch=""
# Try GNU date first (Linux)
epoch=$(date -d "$iso_date" +%s 2>/dev/null)
if [ $? -eq 0 ] && [ -n "$epoch" ]; then
echo "$epoch"
return 0
fi
# Try BSD/macOS date
local clean_date=$(echo "$iso_date" | sed 's/[+-][0-9][0-9]:[0-9][0-9]$//' | sed 's/Z$//' | sed 's/T/ /')
epoch=$(date -j -f "%Y-%m-%d %H:%M:%S" "$clean_date" +%s 2>/dev/null)
if [ $? -eq 0 ] && [ -n "$epoch" ]; then
echo "$epoch"
return 0
fi
echo "0"
}
if [ -f "$STATE_FILE" ]; then
# Check if state is stale (older than 24 hours)
TIMESTAMP_RAW=$(jq -r '.timestamp // empty' "$STATE_FILE" 2>/dev/null)
if [ -n "$TIMESTAMP_RAW" ]; then
TIMESTAMP_EPOCH=$(iso_to_epoch "$TIMESTAMP_RAW")
NOW_EPOCH=$(date +%s)
STATE_AGE=$((NOW_EPOCH - TIMESTAMP_EPOCH))
else
STATE_AGE=999999 # Force fresh start if no timestamp
fi
if [ "$STATE_AGE" -gt 86400 ]; then
echo "Previous setup state is more than 24 hours old. Starting fresh."
rm -f "$STATE_FILE"
else
LAST_STEP=$(jq -r ".lastCompletedStep // 0" "$STATE_FILE" 2>/dev/null || echo "0")
TIMESTAMP=$(jq -r .timestamp "$STATE_FILE" 2>/dev/null || echo "unknown")
echo "Found previous setup session (Step $LAST_STEP completed at $TIMESTAMP)"
fi
fi
If state exists, use AskUser to prompt exactly:
If user chooses "Start fresh":
rm -f ".omd/state/setup-state.json"
echo "Previous state cleared. Starting fresh setup."
MANDATORY: Regardless of whether the user resumes or starts fresh, you MUST ask for maxBackgroundTasks in this run.
If resuming, try to infer the scope from the state file:
# Optional: infer scope from state file
CONFIG_TYPE=$(jq -r '.configType // empty' ".omd/state/setup-state.json" 2>/dev/null || true)
Interpretation:
CONFIG_TYPE starts with local → scope = Local (this project)CONFIG_TYPE starts with global → scope = Global (all projects)After completing each major step, save progress:
# Save setup progress (call after each step)
# Usage: save_setup_progress STEP_NUMBER
save_setup_progress() {
mkdir -p .omd/state
cat > ".omd/state/setup-state.json" << EOF
{
"lastCompletedStep": $1,
"timestamp": "$(date -Iseconds)",
"configType": "${CONFIG_TYPE:-unknown}"
}
EOF
}
After successful setup completion (Step 7/8), remove the state file:
rm -f ".omd/state/setup-state.json"
echo "Setup completed successfully. State cleared."
This skill handles three scenarios:
--local): Configure project-specific settings (.factory/FACTORY.md)--global): Configure global settings (~/.factory/FACTORY.md)Check for flags in the user's invocation:
--local flag present → Skip to Local Configuration (Step 2A)--global flag present → Skip to Global Configuration (Step 2B)IMPORTANT: Always run Step 1.1 (parallelism) even when --local or --global is used.
Note: If resuming and lastCompletedStep >= 1, skip to the appropriate step based on configType.
Immediately use AskUser to prompt exactly:
IMPORTANT: Always run this step (even if maxBackgroundTasks is already set, and even when resuming).
Use AskUser to prompt:
If the user chooses Keep current, skip updating settings.
Otherwise, update BOTH:
~/.factory/settings.json → top-level maxBackgroundTasks./.factory/droid.jsonc → permissions.maxBackgroundTasks${XDG_CONFIG_HOME:-~/.config}/oh-my-droid/config.jsonc → permissions.maxBackgroundTasksRules:
python3 - <<'PY'
import json
import os
import re
from pathlib import Path
MIN_V = 1
MAX_V = 20
DEFAULT_V = 5
def strip_jsonc(text: str) -> str:
out: list[str] = []
i = 0
in_str = False
str_ch = ''
while i < len(text):
c = text[i]
if in_str:
out.append(c)
if c == '\\' and i + 1 < len(text):
i += 1
out.append(text[i])
elif c == str_ch:
in_str = False
i += 1
continue
if c in ('"', "'"):
in_str = True
str_ch = c
out.append(c)
i += 1
continue
if c == '/' and i + 1 < len(text) and text[i + 1] == '/':
i += 2
while i < len(text) and text[i] not in ('\n', '\r'):
i += 1
continue
if c == '/' and i + 1 < len(text) and text[i + 1] == '*':
i += 2
while i + 1 < len(text) and not (text[i] == '*' and text[i + 1] == '/'):
i += 1
i += 2
continue
out.append(c)
i += 1
return ''.join(out)
def parse_jsonc_file(path: Path) -> dict:
if not path.exists():
return {}
raw = path.read_text('utf-8')
cleaned = strip_jsonc(raw)
cleaned = re.sub(r',\s*([}\]])', r'\1', cleaned)
cleaned_s = cleaned.strip()
if not cleaned_s:
return {}
return json.loads(cleaned_s)
factory_settings_path = Path.home() / '.factory' / 'settings.json'
factory_settings_path.parent.mkdir(parents=True, exist_ok=True)
try:
factory_data = json.loads(factory_settings_path.read_text('utf-8')) if factory_settings_path.exists() else {}
except Exception:
factory_data = {}
current = int(factory_data.get('maxBackgroundTasks', DEFAULT_V) or DEFAULT_V)
raw = "USER_CHOICE" # replace with chosen value (or user's custom answer)
scope = "SCOPE_CHOICE" # replace with: "Local (this project)" | "Global (all projects)" (or flags)
raw_s = str(raw).strip().lower()
if raw_s.startswith('keep'):
v = current
else:
try:
v = int(raw_s)
except Exception:
v = current
if v < MIN_V:
v = MIN_V
if v > MAX_V:
v = MAX_V
# 1) Factory Droid settings (global)
factory_data['maxBackgroundTasks'] = v
factory_settings_path.write_text(json.dumps(factory_data, indent=2) + '\n', encoding='utf-8')
print('Set Factory maxBackgroundTasks to', v, 'in', factory_settings_path)
# 2) OMD config (local or global)
scope_s = str(scope).strip().lower()
if scope_s.startswith('local'):
omd_config_path = Path.cwd() / '.factory' / 'droid.jsonc'
else:
xdg = Path(os.environ.get('XDG_CONFIG_HOME') or (Path.home() / '.config'))
omd_config_path = xdg / 'oh-my-droid' / 'config.jsonc'
omd_config_path.parent.mkdir(parents=True, exist_ok=True)
try:
omd_data = parse_jsonc_file(omd_config_path)
except Exception as e:
print('Warning: could not parse OMD config; skipping update:', omd_config_path, '-', e)
omd_data = None
if isinstance(omd_data, dict):
perms = omd_data.get('permissions')
if not isinstance(perms, dict):
perms = {}
perms['maxBackgroundTasks'] = v
omd_data['permissions'] = perms
omd_config_path.write_text(json.dumps(omd_data, indent=2) + '\n', encoding='utf-8')
print('Set OMD permissions.maxBackgroundTasks to', v, 'in', omd_config_path)
PY
CRITICAL: This ALWAYS downloads fresh FACTORY.md from GitHub to the local project. DO NOT use the Write tool - use bash curl exclusively.
# Create .factory directory in current project
mkdir -p .factory && echo ".factory directory ready"
# Extract old version before download
OLD_VERSION=$(grep -m1 "^# oh-my-droid" .factory/FACTORY.md 2>/dev/null | grep -oE 'v[0-9]+\.[0-9]+\.[0-9]+' || echo "none")
# Backup existing FACTORY.md before overwriting (if it exists)
if [ -f ".factory/FACTORY.md" ]; then
BACKUP_DATE=$(date +%Y-%m-%d)
BACKUP_PATH=".factory/FACTORY.md.backup.${BACKUP_DATE}"
cp .factory/FACTORY.md "$BACKUP_PATH"
echo "Backed up existing FACTORY.md to $BACKUP_PATH"
fi
# Download fresh FACTORY.md from GitHub
curl -fsSL "https://raw.githubusercontent.com/MeroZemory/oh-my-droid/main/docs/FACTORY.md" -o .factory/FACTORY.md && \
echo "Downloaded FACTORY.md to .factory/FACTORY.md"
# Extract new version and report
NEW_VERSION=$(grep -m1 "^# oh-my-droid" .factory/FACTORY.md 2>/dev/null | grep -oE 'v[0-9]+\.[0-9]+\.[0-9]+' || echo "unknown")
if [ "$OLD_VERSION" = "none" ]; then
echo "Installed FACTORY.md: $NEW_VERSION"
elif [ "$OLD_VERSION" = "$NEW_VERSION" ]; then
echo "FACTORY.md unchanged: $NEW_VERSION"
else
echo "Updated FACTORY.md: $OLD_VERSION -> $NEW_VERSION"
fi
Note: The downloaded FACTORY.md includes Context Persistence instructions with <remember> tags for surviving conversation compaction.
Note: If an existing FACTORY.md is found, it will be backed up to .factory/FACTORY.md.backup.YYYY-MM-DD before downloading the new version.
MANDATORY: Always run this command. Do NOT skip. Do NOT use Write tool.
FALLBACK if curl fails: Tell user to manually download from: https://raw.githubusercontent.com/MeroZemory/oh-my-droid/main/docs/FACTORY.md
grep -q "oh-my-droid" ~/.factory/settings.json && echo "Plugin verified" || echo "Plugin NOT found - run: droid /plugin install oh-my-droid@oh-my-droid"
After completing local configuration, save progress and report:
# Save progress - Step 2 complete (Local config)
mkdir -p .omd/state
cat > ".omd/state/setup-state.json" << EOF
{
"lastCompletedStep": 2,
"timestamp": "$(date -Iseconds)",
"configType": "local"
}
EOF
OMC Project Configuration Complete
.factory/FACTORY.md.backup.YYYY-MM-DD (if existed)Note: This configuration is project-specific and won't affect other projects or global settings.
If --local flag was used, clear state and STOP HERE:
rm -f ".omd/state/setup-state.json"
Do not continue to HUD setup or other steps.
CRITICAL: This ALWAYS downloads fresh FACTORY.md from GitHub to global config. DO NOT use the Write tool - use bash curl exclusively.
# Extract old version before download
OLD_VERSION=$(grep -m1 "^# oh-my-droid" ~/.factory/FACTORY.md 2>/dev/null | grep -oE 'v[0-9]+\.[0-9]+\.[0-9]+' || echo "none")
# Backup existing FACTORY.md before overwriting (if it exists)
if [ -f "$HOME/.factory/FACTORY.md" ]; then
BACKUP_DATE=$(date +%Y-%m-%d)
BACKUP_PATH="$HOME/.factory/FACTORY.md.backup.${BACKUP_DATE}"
cp "$HOME/.factory/FACTORY.md" "$BACKUP_PATH"
echo "Backed up existing FACTORY.md to $BACKUP_PATH"
fi
# Download fresh FACTORY.md to global config
curl -fsSL "https://raw.githubusercontent.com/MeroZemory/oh-my-droid/main/docs/FACTORY.md" -o ~/.factory/FACTORY.md && \
echo "Downloaded FACTORY.md to ~/.factory/FACTORY.md"
# Extract new version and report
NEW_VERSION=$(grep -m1 "^# oh-my-droid" ~/.factory/FACTORY.md 2>/dev/null | grep -oE 'v[0-9]+\.[0-9]+\.[0-9]+' || echo "unknown")
if [ "$OLD_VERSION" = "none" ]; then
echo "Installed FACTORY.md: $NEW_VERSION"
elif [ "$OLD_VERSION" = "$NEW_VERSION" ]; then
echo "FACTORY.md unchanged: $NEW_VERSION"
else
echo "Updated FACTORY.md: $OLD_VERSION -> $NEW_VERSION"
fi
Note: If an existing FACTORY.md is found, it will be backed up to ~/.factory/FACTORY.md.backup.YYYY-MM-DD before downloading the new version.
Check if old manual hooks exist and remove them to prevent duplicates:
# Remove legacy bash hook scripts (now handled by plugin system)
rm -f ~/.factory/hooks/keyword-detector.sh
rm -f ~/.factory/hooks/stop-continuation.sh
rm -f ~/.factory/hooks/persistent-mode.sh
rm -f ~/.factory/hooks/session-start.sh
echo "Legacy hooks cleaned"
Check ~/.factory/settings.json for manual hook entries. If the "hooks" key exists with UserPromptSubmit, Stop, or SessionStart entries pointing to bash scripts, inform the user:
Note: Found legacy hooks in settings.json. These should be removed since the plugin now provides hooks automatically. Remove the "hooks" section from ~/.factory/settings.json to prevent duplicate hook execution.
grep -q "oh-my-droid" ~/.factory/settings.json && echo "Plugin verified" || echo "Plugin NOT found - run: droid /plugin install oh-my-droid@oh-my-droid"
After completing global configuration, save progress and report:
# Save progress - Step 2 complete (Global config)
mkdir -p .omd/state
cat > ".omd/state/setup-state.json" << EOF
{
"lastCompletedStep": 2,
"timestamp": "$(date -Iseconds)",
"configType": "global"
}
EOF
OMC Global Configuration Complete
~/.factory/FACTORY.md.backup.YYYY-MM-DD (if existed)Note: Hooks are now managed by the plugin system automatically. No manual hook installation required.
If --global flag was used, clear state and STOP HERE:
rm -f ".omd/state/setup-state.json"
Do not continue to HUD setup or other steps.
Note: If resuming and lastCompletedStep >= 3, skip to Step 3.5.
The HUD shows real-time status in Factory Droid's status bar. Invoke the hud skill to set up and configure:
Use the Skill tool to invoke: hud with args: setup
This will:
~/.factory/hud/omd-hud.mjsstatusLine in ~/.factory/settings.jsonAfter HUD setup completes, save progress:
# Save progress - Step 3 complete (HUD setup)
mkdir -p .omd/state
CONFIG_TYPE=$(cat ".omd/state/setup-state.json" 2>/dev/null | grep -oE '"configType":\s*"[^"]+"' | cut -d'"' -f4 || echo "unknown")
cat > ".omd/state/setup-state.json" << EOF
{
"lastCompletedStep": 3,
"timestamp": "$(date -Iseconds)",
"configType": "$CONFIG_TYPE"
}
EOF
Clear old cached plugin versions to avoid conflicts:
# Clear stale plugin cache versions
CACHE_DIR="$HOME/.factory/plugins/cache/oh-my-droid/oh-my-droid"
if [ -d "$CACHE_DIR" ]; then
LATEST=$(ls -1 "$CACHE_DIR" | sort -V | tail -1)
CLEARED=0
for dir in "$CACHE_DIR"/*; do
if [ "$(basename "$dir")" != "$LATEST" ]; then
rm -rf "$dir"
CLEARED=$((CLEARED + 1))
fi
done
[ $CLEARED -gt 0 ] && echo "Cleared $CLEARED stale cache version(s)" || echo "Cache is clean"
else
echo "No cache directory found (normal for new installs)"
fi
Notify user if a newer version is available:
# Detect installed version
INSTALLED_VERSION=""
# Try cache directory first
if [ -d "$HOME/.factory/plugins/cache/oh-my-droid/oh-my-droid" ]; then
INSTALLED_VERSION=$(ls -1 "$HOME/.factory/plugins/cache/oh-my-droid/oh-my-droid" | sort -V | tail -1)
fi
# Try .omd-version.json second
if [ -z "$INSTALLED_VERSION" ] && [ -f ".omd-version.json" ]; then
INSTALLED_VERSION=$(grep -oE '"version":\s*"[^"]+' .omd-version.json | cut -d'"' -f4)
fi
# Try FACTORY.md header third (local first, then global)
if [ -z "$INSTALLED_VERSION" ]; then
if [ -f ".factory/FACTORY.md" ]; then
INSTALLED_VERSION=$(grep -m1 "^# oh-my-droid" .factory/FACTORY.md 2>/dev/null | grep -oE 'v[0-9]+\.[0-9]+\.[0-9]+' | sed 's/^v//')
elif [ -f "$HOME/.factory/FACTORY.md" ]; then
INSTALLED_VERSION=$(grep -m1 "^# oh-my-droid" "$HOME/.factory/FACTORY.md" 2>/dev/null | grep -oE 'v[0-9]+\.[0-9]+\.[0-9]+' | sed 's/^v//')
fi
fi
# Check npm for latest version
LATEST_VERSION=$(npm view oh-my-droid version 2>/dev/null)
if [ -n "$INSTALLED_VERSION" ] && [ -n "$LATEST_VERSION" ]; then
# Simple version comparison (assumes semantic versioning)
if [ "$INSTALLED_VERSION" != "$LATEST_VERSION" ]; then
echo ""
echo "UPDATE AVAILABLE:"
echo " Installed: v$INSTALLED_VERSION"
echo " Latest: v$LATEST_VERSION"
echo ""
echo "To update, run: droid /plugin install oh-my-droid@oh-my-droid"
else
echo "You're on the latest version: v$INSTALLED_VERSION"
fi
elif [ -n "$LATEST_VERSION" ]; then
echo "Latest version available: v$LATEST_VERSION"
fi
Background processes are required for true parallel shell execution (e.g., running multiple long Execute commands concurrently).
This must be set globally in ~/.factory/settings.json (there is no per-project equivalent).
python3 - <<'PY'
import json
from pathlib import Path
settings_path = Path.home() / '.factory' / 'settings.json'
settings_path.parent.mkdir(parents=True, exist_ok=True)
try:
data = json.loads(settings_path.read_text('utf-8')) if settings_path.exists() else {}
except Exception:
data = {}
data['allowBackgroundProcesses'] = True
settings_path.write_text(json.dumps(data, indent=2) + '\n', encoding='utf-8')
print('Enabled allowBackgroundProcesses in', settings_path)
print('NOTE: You may need to restart Droid (or start with --allow-background-processes) for it to take effect.')
PY
If the user wants to use background processes immediately in the current session and it still reports "Fire and forget is disabled", instruct them to restart Droid.
Use AskUser to prompt:
Store the preference in ~/.factory/.omd-config.json:
# Read existing config or create empty object
CONFIG_FILE="$HOME/.factory/.omd-config.json"
mkdir -p "$(dirname "$CONFIG_FILE")"
if [ -f "$CONFIG_FILE" ]; then
EXISTING=$(cat "$CONFIG_FILE")
else
EXISTING='{}'
fi
# Set defaultExecutionMode (replace USER_CHOICE with "ultrawork" or "ecomode")
echo "$EXISTING" | jq --arg mode "USER_CHOICE" '. + {defaultExecutionMode: $mode, configuredAt: (now | todate)}' > "$CONFIG_FILE"
echo "Default execution mode set to: USER_CHOICE"
Note: This preference ONLY affects generic keywords ("fast", "parallel"). Explicit keywords ("ulw", "eco") always override this preference.
The OMD CLI provides standalone token analytics commands (omd stats, omd agents, omd tui).
Ask user: "Would you like to install the OMD CLI for standalone analytics? (Recommended for tracking token usage and costs)"
Options:
omd stats, omd agents, etc.The CLI (omc command) is no longer supported via npm/bun global install.
All functionality is available through the plugin system:
/help for guidance/doctor for diagnosticsSkip this step - the plugin provides all features.
grep -q "oh-my-droid" ~/.factory/settings.json && echo "Plugin verified" || echo "Plugin NOT found - run: droid /plugin install oh-my-droid@oh-my-droid"
MCP servers extend Factory Droid with additional tools (web search, GitHub, etc.).
Ask user: "Would you like to configure MCP servers for enhanced capabilities? (Context7, Exa search, GitHub, etc.)"
If yes, invoke the mcp-setup skill:
/mcp-setup
If no, skip to next step.
Check if user has existing configuration:
# Check for existing 2.x artifacts
ls ~/.factory/commands/ralph-loop.md 2>/dev/null || ls ~/.factory/commands/ultrawork.md 2>/dev/null
If found, this is an upgrade from 2.x.
OMD Setup Complete!
You don't need to learn any commands. I now have intelligent behaviors that activate automatically.
WHAT HAPPENS AUTOMATICALLY:
- Complex tasks -> I parallelize and delegate to specialists
- "plan this" -> I start a planning interview
- "don't stop until done" -> I persist until verified complete
- "stop" or "cancel" -> I intelligently stop current operation
MAGIC KEYWORDS (optional power-user shortcuts):
Just include these words naturally in your request:
| Keyword | Effect | Example |
|---------|--------|---------|
| ralph | Persistence mode | "ralph: fix the auth bug" |
| ralplan | Iterative planning | "ralplan this feature" |
| ulw | Max parallelism | "ulw refactor the API" |
| eco | Token-efficient mode | "eco refactor the API" |
| plan | Planning interview | "plan the new endpoints" |
**ralph includes ultrawork:** When you activate ralph mode, it automatically includes ultrawork's parallel execution. No need to combine keywords.
MCP SERVERS:
Run /mcp-setup to add tools like web search, GitHub, etc.
HUD STATUSLINE:
The status bar now shows OMD state. Restart Factory Droid to see it.
CLI ANALYTICS (if installed):
- omc - Full dashboard (stats + agents + cost)
- omd stats - View token usage and costs
- omd agents - See agent breakdown by cost
- omd tui - Launch interactive TUI dashboard
That's it! Just use Factory Droid normally.
OMD Setup Complete! (Upgraded from 2.x)
GOOD NEWS: Your existing commands still work!
- /ralph, /ultrawork, /plan, etc. all still function
WHAT'S NEW in 3.0:
You no longer NEED those commands. Everything is automatic now:
- Just say "don't stop until done" instead of /ralph
- Just say "fast" or "parallel" instead of /ultrawork
- Just say "plan this" instead of /plan
- Just say "stop" instead of /cancel
MAGIC KEYWORDS (power-user shortcuts):
| Keyword | Same as old... | Example |
|---------|----------------|---------|
| ralph | /ralph | "ralph: fix the bug" |
| ralplan | /ralplan | "ralplan this feature" |
| ulw | /ultrawork | "ulw refactor API" |
| eco | (new!) | "eco fix all errors" |
| plan | /plan | "plan the endpoints" |
HUD STATUSLINE:
The status bar now shows OMD state. Restart Factory Droid to see it.
CLI ANALYTICS (if installed):
- omc - Full dashboard (stats + agents + cost)
- omd stats - View token usage and costs
- omd agents - See agent breakdown by cost
- omd tui - Launch interactive TUI dashboard
Your workflow won't break - it just got easier!
First, check if gh CLI is available and authenticated:
gh auth status &>/dev/null
Use AskUser to prompt:
If user chooses "Yes, star it!":
gh api -X PUT /user/starred/MeroZemory/oh-my-droid 2>/dev/null && echo "Thanks for starring! ⭐" || true
Note: Fail silently if the API call doesn't work - never block setup completion.
echo ""
echo "If you enjoy oh-my-droid, consider starring the repo:"
echo " https://github.com/MeroZemory/oh-my-droid"
echo ""
After Step 8 completes (regardless of star choice), clear the setup state:
# Setup complete - clear state file
rm -f ".omd/state/setup-state.json"
echo "Setup completed successfully!"
After installing oh-my-droid updates (via npm or plugin update), run:
/omd-setup --local to update project config/omd-setup --global to update global configThis ensures you have the newest features and agent configurations.
When user runs /omd-setup --help or just --help, display:
OMD Setup - Configure oh-my-droid
USAGE:
/omd-setup Run initial setup wizard
/omd-setup --local Configure local project (.factory/FACTORY.md)
/omd-setup --global Configure global settings (~/.factory/FACTORY.md)
/omd-setup --help Show this help
MODES:
Initial Setup (no flags)
- Interactive wizard for first-time setup
- Configures FACTORY.md (local or global)
- Sets up HUD statusline
- Checks for updates
- Offers MCP server configuration
Local Configuration (--local)
- Downloads fresh FACTORY.md to ./.factory/
- Backs up existing FACTORY.md to .factory/FACTORY.md.backup.YYYY-MM-DD
- Project-specific settings
- Use this to update project config after OMC upgrades
Global Configuration (--global)
- Downloads fresh FACTORY.md to ~/.factory/
- Backs up existing FACTORY.md to ~/.factory/FACTORY.md.backup.YYYY-MM-DD
- Applies to all Factory Droid sessions
- Cleans up legacy hooks
- Use this to update global config after OMC upgrades
EXAMPLES:
/omd-setup # First time setup
/omd-setup --local # Update this project
/omd-setup --global # Update all projects
For more info: https://github.com/MeroZemory/oh-my-droid