AI DevOps Framework

aidevops.sh — Unleash your AI assistant's true potential with specialist DevOps agents, designed to manage all your infrastructure and services with security and reliability guidance on every decision.

"List all my servers and websites, and check each for theme and plugin update needs, SEO and page loading performance scores, and give me a list of recommended priorities" - One conversation, complete infrastructure management.

The Philosophy

Sane vibe-coding through git workflow best practices. aidevops brings structure to AI-assisted development:

• Git-first workflow - Protected branches, PR reviews, quality gates before merge
• Parallel agents - Multiple AI sessions running full Ralph loops on separate branches via git worktrees
• Progressive discovery - /slash commands and @subagent mentions load knowledge into context only when needed
• Guided development - Build your AI team incrementally, with specialists for every online need

The result: AI agents that work with your development process, not around it.

Built on proven patterns: aidevops implements industry-standard agent design patterns validated across Claude Code, Manus, and Cursor - including multi-layer action spaces, context isolation, and iterative execution loops.

aidevops knows what you need to know.

Why This Framework?

Beyond Single-Repo Limitations: VS Code and Web UIs work on one repo at a time. CLI AI assistants can manage your entire infrastructure when given the right tools, access, and guidance.

DevOps Superpowers for AI:

• Multi-Service Management: 30+ APIs (hosting, Git, security, monitoring, deployment)
• Real-Time Operations: SSH, domain management, database operations
• Cross-Service Intelligence: Connect patterns across your entire ecosystem
• Unlimited Scope: Full access to your development infrastructure for bug fixes and feature development

Quick Reference

• Purpose: AI-assisted DevOps automation framework
• Install: npm install -g aidevops && aidevops update
• Entry: aidevops CLI, ~/.aidevops/agents/AGENTS.md
• Stack: Bash scripts, TypeScript (Bun), MCP servers

Key Commands

• aidevops init - Initialize in any project
• aidevops update - Update framework
• /onboarding - Interactive setup wizard (in AI assistant)

Agent Structure

• ~15 main agents (Plan+, Build+, SEO, WordPress, etc.)
• 200+ subagent markdown files organized by domain
• 100+ helper scripts in .agent/scripts/

Enterprise-Grade Quality & Security

Comprehensive DevOps framework with tried & tested services integrations, popular and trusted MCP servers, and enterprise-grade infrastructure quality assurance code monitoring and recommendations.

Security Notice

This framework provides agentic AI assistants with powerful infrastructure access. Use responsibly.

Capabilities: Execute commands, access credentials, modify infrastructure, interact with APIs Your responsibility: Use trusted AI providers, rotate credentials regularly, monitor activity

Quick Start

Installation Options

npm (recommended - verified provenance):

npm install -g aidevops && aidevops update

Note: npm suppresses postinstall output. The && aidevops update deploys agents to ~/.aidevops/agents/. The CLI will remind you if agents need updating.

Bun (fast alternative):

bun install -g aidevops && aidevops update

Homebrew (macOS/Linux):

brew install marcusquinn/tap/aidevops && aidevops update

Direct from source (aidevops.sh):

bash <(curl -fsSL https://aidevops.sh/install)

Manual (git clone):

git clone https://github.com/marcusquinn/aidevops.git ~/Git/aidevops
~/Git/aidevops/setup.sh

That's it! The setup script will:

• Clone/update the repo to ~/Git/aidevops
• Deploy agents to ~/.aidevops/agents/
• Install the aidevops CLI command
• Configure your AI assistants automatically
• Guide you through recommended tools (Tabby, Zed, Git CLIs)

New users: Start OpenCode and type /onboarding to configure your services interactively. The onboarding wizard will:

• Explain what aidevops can do
• Ask about your work to give personalized recommendations
• Show which services are configured vs need setup
• Guide you through setting up each service with links and commands

After installation, use the CLI:

aidevops status           # Check what's installed
aidevops update           # Update framework + check registered projects
aidevops init             # Initialize aidevops in any project
aidevops features         # List available features
aidevops repos            # List/add/remove registered projects
aidevops detect           # Scan for unregistered aidevops projects
aidevops upgrade-planning # Upgrade TODO.md/PLANS.md to latest templates
aidevops update-tools     # Check and update installed tools
aidevops uninstall        # Remove aidevops

Project tracking: When you run aidevops init, the project is automatically registered in ~/.config/aidevops/repos.json. Running aidevops update checks all registered projects for version updates.

Use aidevops in Any Project

Initialize aidevops features in any git repository:

cd ~/your-project
aidevops init                         # Enable all features
aidevops init planning                # Enable only planning
aidevops init planning,time-tracking  # Enable specific features

This creates:

• .aidevops.json - Configuration with enabled features
• .agent symlink → ~/.aidevops/agents/
• TODO.md - Quick task tracking with time estimates
• todo/PLANS.md - Complex execution plans
• .beads/ - Task graph database (if beads enabled)

Available features: planning, git-workflow, code-quality, time-tracking, beads

Upgrade Planning Files

When aidevops templates evolve, upgrade existing projects to the latest format:

aidevops upgrade-planning           # Interactive upgrade with backup
aidevops upgrade-planning --dry-run # Preview changes without modifying
aidevops upgrade-planning --force   # Skip confirmation prompt

This preserves your existing tasks while adding TOON-enhanced parsing, dependency tracking, and better structure.

Task Graph Visualization with Beads

Beads provides task dependency tracking and graph visualization:

aidevops init beads              # Enable beads (includes planning)

Task Dependencies:

- [ ] t001 First task
- [ ] t002 Second task blocked-by:t001
- [ ] t001.1 Subtask of t001

Commands:

Architecture: aidevops markdown files (TODO.md, PLANS.md) are the source of truth. Beads syncs from them for visualization.

Optional Viewers: Beyond the bd CLI, there are community viewers for richer visualization:

• beads_viewer (Python TUI) - PageRank, critical path analysis
• beads-ui (Web) - Live updates in browser
• bdui (React/Ink TUI) - Modern terminal UI
• perles (Rust TUI) - BQL query language

See .agent/tools/task-management/beads.md for complete documentation and installation commands.

Your AI assistant now has agentic access to 30+ service integrations.

OpenCode Antigravity OAuth Plugin

The setup automatically installs the opencode-antigravity-auth plugin, enabling Google OAuth authentication for OpenCode. This gives you access to Antigravity rate limits and premium models.

After setup, authenticate:

opencode auth login
# Select: Google → OAuth with Google (Antigravity)
# Press Enter to skip Project ID prompt

Available models via Antigravity:

• gemini-3-pro-high / gemini-3-pro-low / gemini-3-flash
• claude-sonnet-4-5 / claude-sonnet-4-5-thinking / claude-opus-4-5-thinking
• gpt-oss-120b-medium

Multi-account load balancing: Add multiple Google accounts for automatic rate limit distribution and failover. See the plugin documentation for model configuration.

OpenCode Anthropic OAuth Plugin

The setup automatically installs the opencode-anthropic-auth plugin, enabling OAuth authentication for Claude Pro/Max accounts. This allows Claude subscribers to use OpenCode with zero API costs.

After setup, authenticate:

opencode auth login
# Select: Anthropic → Claude Pro/Max
# Follow OAuth flow in browser

Benefits:

• Zero cost for Claude Pro/Max subscribers (covered by subscription)
• Automatic token refresh - No manual re-authentication needed
• Beta features enabled - Extended thinking modes and latest features
• Three authentication methods:
  • Claude Pro/Max OAuth (recommended for subscribers)
  • Create API Key via OAuth
  • Manual API key entry

Available models:

All Anthropic models available to Pro/Max subscribers, including:

• claude-sonnet-4-20250514
• claude-opus-4-5
• Extended thinking modes

See the plugin documentation and .agent/tools/opencode/opencode-anthropic-auth.md for complete setup and troubleshooting.

Oh-My-OpenCode Plugin (Optional)

The setup offers to install oh-my-opencode - a complementary plugin that adds coding productivity features:

How they complement each other:

• aidevops provides DevOps infrastructure (30+ services: hosting, DNS, WordPress, SEO, code quality)
• oh-my-opencode provides coding productivity (LSP, AST, background agents, hooks)

Usage after installation:

# Trigger maximum performance mode
> ultrawork implement the authentication system

# Use curated agents
> @oracle review this architecture
> @librarian find examples of this pattern on GitHub
> @explore search for authentication handling

See .agent/tools/opencode/oh-my-opencode.md for the full compatibility guide.

GitHub AI Agent Integration

Enable AI-powered issue resolution directly from GitHub. Comment /oc fix this on any issue and the AI creates a branch, implements the fix, and opens a PR.

Security-first design - The workflow includes:

• Trusted users only (OWNER/MEMBER/COLLABORATOR)
• ai-approved label required on issues before AI processing
• Prompt injection pattern detection
• Audit logging of all invocations
• 15-minute timeout and rate limiting

Quick setup:

# 1. Install the OpenCode GitHub App
# Visit: https://github.com/apps/opencode-agent

# 2. Add API key secret
# Repository → Settings → Secrets → ANTHROPIC_API_KEY

# 3. Create required labels
gh label create "ai-approved" --color "0E8A16" --description "Issue approved for AI agent"
gh label create "security-review" --color "D93F0B" --description "Requires security review"

The secure workflow is included at .github/workflows/opencode-agent.yml.

Usage:

See .agent/tools/git/opencode-github-security.md for the full security documentation.

Supported AI Assistants: (OpenCode & Zed are our daily drivers and preferred tools, so will have the most continual testing. All 18 assistants below have MCP configuration support.)

Preferred:

• Tabby - Modern terminal with colour-coded Profiles. Use different profile colours per project/repo to visually distinguish which codebase you're working in. Auto-syncs tab title with git repo/branch.
• OpenCode - Primary choice. Powerful agentic TUI/CLI with native MCP support, Tab-based agent switching, and excellent DX.
• Zed - High-performance editor with AI (Preferred, with the OpenCode Agent Extension)

Terminal Tab Title Sync

Your terminal tab/window title automatically shows repo/branch context when working in git repositories. This helps identify which codebase and branch you're working on across multiple terminal sessions.

Supported terminals: Tabby, iTerm2, Windows Terminal, Kitty, Alacritty, WezTerm, Hyper, and most xterm-compatible terminals.

How it works: The pre-edit-check.sh script's primary role is enforcing git workflow protection (blocking edits on main/master branches). As a secondary, non-blocking action, it updates the terminal title via escape sequences. No configuration needed - it's automatic.

Example format: {repo}/{branch-type}/{description}

See .agent/tools/terminal/terminal-title.md for customization options.

IDE-Based:

• Cursor - AI-first IDE with MCP support
• Windsurf - Codeium's AI IDE
• Continue.dev - VS Code/JetBrains extension
• Cody - Sourcegraph's AI assistant

Claude Family:

• Claude Code - CLI version with claude mcp add
• Claude Desktop - GUI with MCP config

Enterprise & Professional:

• Factory AI Droid - Enterprise-grade agentic AI
• Augment Code - Deep codebase indexing
• GitHub Copilot - Agent mode for MCP

Specialized:

• Kilo Code - VS Code extension
• Kiro - AWS's AI assistant
• AntiGravity - AI coding tool
• Gemini CLI - Google's CLI

Terminal & CLI:

• Aider - CLI pair programmer with native MCP
• Warp AI - Terminal with AI (no native MCP, use OpenCode/Claude in Warp)
• Qwen - Alibaba's CLI (MCP support experimental)

Core Capabilities

AI-First Infrastructure Management:

• SSH server access, remote command execution, API integrations
• DNS management, application deployment, email monitoring
• Git platform management, domain purchasing, setup automation
• WordPress management, credential security, code auditing

Unified Interface:

• Standardized commands across all providers
• Automated SSH configuration and multi-account support for all services
• Security-first design with comprehensive logging, code quality reviews, and continual feedback-based improvement

Quality Control & Monitoring:

• Multi-Platform Analysis: SonarCloud, CodeFactor, Codacy, CodeRabbit, Qlty, Gemini Code Assist, Snyk
• Performance Auditing: PageSpeed Insights and Lighthouse integration
• Uptime Monitoring: Updown.io integration for website and SSL monitoring

Agent Design Patterns

aidevops implements proven agent design patterns identified by Lance Martin (LangChain) and validated across successful agents like Claude Code, Manus, and Cursor.

Key insight: Context is a finite resource with diminishing returns. aidevops treats every token as precious - loading only what's needed, when it's needed.

See .agent/aidevops/architecture.md for detailed implementation notes and references.

Requirements

# Install dependencies (auto-detected by setup.sh)
brew install sshpass jq curl mkcert dnsmasq fd ripgrep  # macOS
sudo apt-get install sshpass jq curl dnsmasq fd-find ripgrep  # Ubuntu/Debian

# Generate SSH key
ssh-keygen -t ed25519 -C "your-email@domain.com"

File Discovery Tools

AI agents use fast file discovery tools for efficient codebase navigation:

Both tools respect .gitignore by default and are written in Rust for maximum performance.

Preference order for file discovery:

1. git ls-files '*.md' - Instant, git-tracked files only
2. fd -e md - Fast, respects .gitignore
3. rg --files -g '*.md' - Fast, respects .gitignore
4. Built-in glob tools - Fallback when bash unavailable

The setup script offers to install these tools automatically.

Comprehensive Service Coverage

Infrastructure & Hosting

• Hostinger: Shared hosting, domains, email
• Hetzner Cloud: VPS servers, networking, load balancers
• Closte: Managed hosting, application deployment
• Coolify Enhanced with CLI: Self-hosted PaaS with CLI integration
• Cloudron: Server and app management platform
• Vercel Enhanced with CLI: Modern web deployment platform with CLI integration
• AWS: Cloud infrastructure support via standard protocols
• DigitalOcean: Cloud infrastructure support via standard protocols

Domain & DNS

• Cloudflare: DNS, CDN, security services
• Spaceship: Domain registration and management
• 101domains: Domain purchasing and DNS
• AWS Route 53: AWS DNS management
• Namecheap: Domain and DNS services

Development & Git Platforms with CLI Integration

• GitHub Enhanced with CLI: Repository management, actions, API, GitHub CLI (gh) integration
• GitLab Enhanced with CLI: Self-hosted and cloud Git platform with GitLab CLI (glab) integration
• Gitea Enhanced with CLI: Lightweight Git service with Gitea CLI (tea) integration
• Agno: Local AI agent operating system for DevOps automation
• Pandoc: Document conversion to markdown for AI processing

AI Orchestration Frameworks

• Langflow: Visual drag-and-drop builder for AI workflows (MIT, localhost:7860)
• CrewAI: Multi-agent teams with role-based orchestration (MIT, localhost:8501)
• AutoGen: Microsoft's agentic AI framework with MCP support (MIT, localhost:8081)

WordPress Development

• LocalWP: WordPress development environment with MCP database access
• MainWP: WordPress site management dashboard

Git CLI Enhancement Features:

• .agent/scripts/github-cli-helper.sh: Advanced GitHub repository, issue, PR, and branch management
• .agent/scripts/gitlab-cli-helper.sh: Complete GitLab project, issue, MR, and branch management
• .agent/scripts/gitea-cli-helper.sh: Full Gitea repository, issue, PR, and branch management

Security & Code Quality

• Vaultwarden: Password and secrets management
• SonarCloud: Security and quality analysis (A-grade ratings)
• CodeFactor: Code quality metrics (A+ score)
• Codacy: Multi-tool analysis (0 findings)
• CodeRabbit: AI-powered code reviews
• Snyk: Security vulnerability scanning
• Qlty: Universal code quality platform (70+ linters, auto-fixes)
• Gemini Code Assist: Google's AI-powered code completion and review

AI Prompt Optimization

• Augment Context Engine: Semantic codebase retrieval with deep code understanding
• Repomix: Pack codebases into AI-friendly context (80% token reduction with compress mode)
• DSPy: Framework for programming with language models
• DSPyGround: Interactive playground for prompt optimization
• TOON Format: Token-Oriented Object Notation - 20-60% token reduction for LLM prompts

Communications

• Twilio: SMS, voice calls, WhatsApp, phone verification (Verify API), call recording & transcription
• Telfon: Twilio-powered cloud phone system with iOS/Android/Chrome apps for end-user calling interface

Performance & Monitoring

• PageSpeed Insights: Website performance auditing
• Lighthouse: Comprehensive web app analysis
• Updown.io: Website uptime and SSL monitoring

AI & Documentation

• Context7: Real-time documentation access for libraries and frameworks

MCP Integrations

Model Context Protocol servers for real-time AI assistant integration. The framework helps configure these MCPs for 18 AI assistants including OpenCode (preferred), Cursor, Claude Code/Desktop, Windsurf, Continue.dev, Cody, Zed, GitHub Copilot, Kilo Code, Kiro, AntiGravity, Gemini CLI, Droid, Warp AI, Aider, and Qwen.

All Supported MCPs

By Category

Context & Codebase:

• Augment Context Engine - Semantic codebase retrieval with deep code understanding
• llm-tldr - Semantic code analysis with 95% token savings (tree, structure, CFG, DFG, impact analysis)
• osgrep - Local semantic search (100% private, no cloud)
• Context7 - Real-time documentation access for thousands of libraries
• Repomix - Pack codebases into AI-friendly context

Browser Automation:

• Stagehand (JavaScript) - AI-powered browser automation with natural language
• Stagehand (Python) - Python version with Pydantic validation
• Chrome DevTools - Browser automation, performance analysis, debugging
• Playwright - Cross-browser testing and automation
• Crawl4AI - Async web crawler optimized for AI
• Cloudflare Browser Rendering - Server-side web scraping

SEO & Research:

• Ahrefs - SEO analysis, backlink research, keyword data
• DataForSEO - Comprehensive SEO data APIs (SERP, keywords, backlinks, on-page)
• Serper - Google Search API (web, images, news, places, shopping)
• Google Search Console - Search performance insights
• Perplexity - AI-powered web search and research
• Grep by Vercel - Search code snippets across GitHub repositories
• Keyword Research - Strategic keyword research with SERP weakness detection (via DataForSEO + Serper + Ahrefs)
• Site Crawler - Screaming Frog-like SEO auditing: broken links, redirects, meta issues, structured data
• Domain Research - DNS intelligence via THC (4.51B records) and Reconeer APIs: rDNS, subdomains, CNAMEs

Data Extraction:

• Outscraper - Google Maps, business data, reviews extraction

Performance & Security:

• PageSpeed Insights - Website performance auditing
• Snyk - Security vulnerability scanning

WordPress & Development:

• LocalWP - Direct WordPress database access
• Next.js DevTools - React/Next.js development assistance

UI Components:

• shadcn/ui - Browse, search, and install shadcn/ui components directly via MCP

Quick Setup

# Install all MCP integrations
bash .agent/scripts/setup-mcp-integrations.sh all

# Install specific integration
bash .agent/scripts/setup-mcp-integrations.sh stagehand          # JavaScript version
bash .agent/scripts/setup-mcp-integrations.sh stagehand-python   # Python version
bash .agent/scripts/setup-mcp-integrations.sh stagehand-both     # Both versions
bash .agent/scripts/setup-mcp-integrations.sh chrome-devtools

Repomix - AI Context Generation

Repomix packages your codebase into AI-friendly formats for sharing with AI assistants. This framework includes optimized Repomix configuration for consistent context generation.

Why Repomix?

Quick Usage

# Pack current repo with configured defaults
npx repomix

# Compress mode (~80% smaller, structure only)
npx repomix --compress

# Or use the helper script
.agent/scripts/context-builder-helper.sh pack      # Full context
.agent/scripts/context-builder-helper.sh compress  # Compressed

Configuration Files

Key Design Decisions

• No pre-generated files: Outputs are generated on-demand to avoid staleness
• Inherits .gitignore: Security patterns automatically respected
• Secretlint enabled: Scans for exposed credentials before output
• Symlinks excluded: Avoids duplicating .agent/ content

MCP Integration

Repomix runs as an MCP server for direct AI assistant integration:

{
  "repomix": {
    "type": "local",
    "command": ["npx", "-y", "repomix@latest", "--mcp"],
    "enabled": true
  }
}

See .agent/tools/context/context-builder.md for complete documentation.

Augment Context Engine - Semantic Codebase Search

Augment Context Engine provides semantic codebase retrieval - understanding your code at a deeper level than simple text search. It's the recommended tool for real-time interactive coding sessions.

Why Augment Context Engine?

Use it to:

• Find related code across your entire codebase
• Understand project architecture quickly
• Discover patterns and implementations
• Get context-aware code suggestions

Quick Setup

# 1. Install Auggie CLI (requires Node.js 22+)
npm install -g @augmentcode/auggie@prerelease

# 2. Authenticate (opens browser)
auggie login

# 3. Verify installation
auggie token print

MCP Integration

Add to your AI assistant's MCP configuration:

OpenCode (~/.config/opencode/opencode.json):

{
  "mcp": {
    "augment-context-engine": {
      "type": "local",
      "command": ["auggie", "--mcp"],
      "enabled": true
    }
  }
}

Claude Code:

claude mcp add-json auggie-mcp --scope user '{"type":"stdio","command":"auggie","args":["--mcp"]}'

Cursor: Settings → Tools & MCP → New MCP Server:

{
  "mcpServers": {
    "augment-context-engine": {
      "command": "bash",
      "args": ["-c", "auggie --mcp -m default -w \"${WORKSPACE_FOLDER_PATHS%%,*}\""]
    }
  }
}

Verification

Test with this prompt:

What is this project? Please use codebase retrieval tool to get the answer.

The AI should provide a semantic understanding of your project architecture.

Repomix vs Augment Context Engine

See .agent/tools/context/augment-context-engine.md for complete documentation including configurations for Zed, GitHub Copilot, Kilo Code, Kiro, AntiGravity, Gemini CLI, and Factory.AI Droid.

osgrep - Local Alternative (Experimental)

osgrep provides 100% local semantic search with no cloud dependency:

npm install -g osgrep && osgrep setup
osgrep "where is authentication handled?"

See .agent/tools/context/osgrep.md for complete documentation and AI tool configurations.

llm-tldr - Semantic Code Analysis

llm-tldr extracts code structure and semantics, saving ~95% tokens compared to raw code. From the Continuous-Claude project.

# Install
pip install llm-tldr

# CLI usage
tldr tree ./src                    # File structure with line counts
tldr structure src/auth.py         # Code skeleton (classes, functions)
tldr context src/auth.py           # Full semantic analysis
tldr search "authentication" ./src # Semantic code search
tldr impact src/auth.py validate   # What would change affect?

MCP Integration:

{
  "llm-tldr": {
    "command": "tldr-mcp",
    "args": ["--project", "${workspaceFolder}"]
  }
}

See .agent/tools/context/llm-tldr.md for complete documentation.

Cross-Tool Compatibility

Agent Skills Standard

aidevops implements the Agent Skills standard for cross-tool compatibility. Skills are auto-discovered by compatible AI assistants.

Generated SKILL.md files in ~/.aidevops/agents/ provide skill metadata for:

• Cursor
• Claude Code
• VS Code (GitHub Copilot)
• Other Agent Skills-compatible tools

Claude Code Plugin Marketplace

aidevops is registered as a Claude Code plugin marketplace. Install with two commands:

/plugin marketplace add marcusquinn/aidevops
/plugin install aidevops@aidevops

This installs the complete framework: ~15 domain agents, 80+ subagents, and 100+ helper scripts.

AI Agents & Subagents

Agents are specialized AI personas with focused knowledge and tool access. Instead of giving your AI assistant access to everything at once (which wastes context tokens), agents provide targeted capabilities for specific tasks.

Call them in your AI assistant conversation with a simple @mention

How Agents Work

Main Agents

Ordered as they appear in OpenCode Tab selector and other AI assistants (14 total):

Example Subagents with MCP Integration

These are examples of subagents that have supporting MCPs enabled. See .agent/ for the full list of 80+ subagents organized by domain.

Setup for OpenCode

# Install aidevops agents for OpenCode
.agent/scripts/generate-opencode-agents.sh

# Check status
.agent/scripts/generate-opencode-agents.sh  # Shows status after generation

Setup for Other AI Assistants

Claude Code (recommended):

/plugin marketplace add marcusquinn/aidevops
/plugin install aidevops-all@aidevops

Agent Skills-compatible tools (Cursor, VS Code, etc.): Skills are auto-discovered from ~/.aidevops/agents/ via SKILL.md files after running setup.sh.

Manual configuration (other tools): Add to your AI assistant's system prompt:

Before any DevOps operations, read ~/git/aidevops/AGENTS.md for authoritative guidance.

When working with specific services, read the corresponding .agent/[service].md file
for focused guidance. Available services: hostinger, hetzner, wordpress, seo,
code-quality, browser-automation, git-platforms.

Continuous Improvement with @agent-review

End every session by calling @agent-review to analyze what worked and what didn't:

@agent-review analyze this session and suggest improvements to the agents used

The review agent will:

1. Identify which agents were used
2. Evaluate missing, incorrect, or excessive information
3. Suggest specific improvements to agent files
4. Generate ready-to-apply edits
5. Optionally compose a PR to contribute improvements back to aidevops

This creates a feedback loop:

Session → @agent-review → Improvements → Better Agents → Better Sessions
                ↓
         PR to aidevops repo (optional)

Contributing improvements:

@agent-review create a PR for improvement #2

The agent will create a branch, apply changes, and submit a PR to marcusquinn/aidevops with a structured description. Your real-world usage helps improve the framework for everyone.

Code quality learning loop:

The @code-quality agent also learns from issues. After fixing violations from SonarCloud, Codacy, ShellCheck, etc., it analyzes patterns and updates framework guidance to prevent recurrence:

Quality Issue → Fix Applied → Pattern Identified → Framework Updated → Issue Prevented

Slash Commands (OpenCode)

Slash commands provide quick access to common workflows directly from the OpenCode prompt. Type / to see available commands.

Available Commands

Planning & Task Management:

Plans are tracked in TODO.md (all tasks) and todo/PLANS.md (complex execution plans). Task dependencies are visualized with Beads.

/list-todo options:

Time Tracking: Tasks support time estimates and actuals with the format ~4h (ai:2h test:1h) started:2025-01-15T10:30Z. Configure per-repo via .aidevops.json.

Development Workflow (typical order):

Content Workflow:

SEO Workflow:

Release Workflow (in order):

Meta/Improvement:

Ralph Loop - Iterative AI Development

The Ralph Loop (named after Ralph Wiggum's persistent optimism) enables autonomous iterative development. The AI keeps working on a task until it's complete, automatically resolving issues that arise.

How it works:

Task → Implement → Check → Fix Issues → Re-check → ... → Complete
         ↑                    ↓
         └────────────────────┘ (loop until done)

Usage:

# Run quality checks iteratively until all pass
.agent/scripts/quality-loop-helper.sh preflight --auto-fix --max-iterations <MAX_ITERATIONS>

# Or use the slash command
/preflight-loop --auto-fix --max-iterations <MAX_ITERATIONS>

Note: Store any API credentials securely via environment variables or .env files (never commit credentials to version control).

Key features:

• Automatic issue detection and resolution
• Configurable max iterations (prevents infinite loops)
• Works with any quality check (linting, tests, builds)
• Detailed logging of each iteration

See .agent/workflows/ralph-loop.md for the full workflow guide.

Full Loop - End-to-End Development Automation

The Full Loop chains all development phases into a single automated workflow:

Task Development → Preflight → PR Create → PR Review → Postflight → Deploy

Usage:

# Start a full development loop
/full-loop "Implement feature X with tests"

# With options
/full-loop "Fix bug Y" --max-task-iterations 30 --skip-postflight

Options:

The loop pauses for human input at merge approval, rollback decisions, and scope changes.

See .agent/scripts/commands/full-loop.md for complete documentation.

Git Worktrees - Parallel Branch Development

Work on multiple branches simultaneously without stashing or switching. Each branch gets its own directory.

Recommended: Worktrunk (wt) - Git worktree management with shell integration, CI status, and PR links:

# Install (macOS/Linux)
brew install max-sixty/worktrunk/wt && wt config shell install
# Restart your shell for shell integration to take effect

# Create worktree + cd into it
wt switch -c feature/my-feature

# Create worktree + start any AI CLI (-x runs command after switch)
wt switch -c -x claude feature/ai-task

# List worktrees with CI status and PR links
wt list

# Merge + cleanup (squash/rebase options)
wt merge

Fallback (no dependencies):

~/.aidevops/agents/scripts/worktree-helper.sh add feature/my-feature
# Creates: ~/Git/{repo}-feature-my-feature/ (cd there manually)
~/.aidevops/agents/scripts/worktree-helper.sh list
~/.aidevops/agents/scripts/worktree-helper.sh clean

Benefits:

• Run tests on one branch while coding on another
• Compare implementations side-by-side
• No context switching or stash management
• Each AI session can work on a different branch

Worktree-first workflow: The pre-edit check now enforces worktrees as the default when creating branches, keeping your main directory on main. This prevents uncommitted changes from blocking branch switches and ensures parallel sessions don't inherit wrong branch state.

See .agent/workflows/worktree.md for the complete guide and .agent/tools/git/worktrunk.md for Worktrunk documentation.

Session Management - Parallel AI Sessions

Spawn new AI sessions for parallel work or fresh context. The framework detects natural session completion points and suggests next steps.

Completion signals:

Spawning options:

# Background session (same terminal)
opencode --non-interactive --prompt "Continue with feature X" &

# New terminal tab (macOS)
osascript -e 'tell application "Terminal" to do script "cd ~/Git/project && opencode"'

# Worktree-based (isolated branch) - recommended
wt switch -c -x opencode feature/next-feature  # Worktrunk: create + start AI CLI
# Or fallback:
# ~/.aidevops/agents/scripts/worktree-helper.sh add feature/next-feature
# cd ~/Git/{repo}-feature-next-feature && opencode

Session handoff pattern:

When ending a session, the AI provides a continuation prompt for the next session:

## Continuation Prompt
[Copy this to start a new session with full context]

See .agent/workflows/session-manager.md for the complete guide.

Cross-Session Memory System

"Compound, then clear" - Sessions should build on each other. The memory system stores knowledge, patterns, and learnings for future sessions using SQLite FTS5 for fast full-text search.

Slash commands:

Memory types:

CLI usage:

# Store a memory
~/.aidevops/agents/scripts/memory-helper.sh store "WORKING_SOLUTION" "Fixed CORS with nginx headers" "cors,nginx"

# Recall memories
~/.aidevops/agents/scripts/memory-helper.sh recall "cors"

# View statistics
~/.aidevops/agents/scripts/memory-helper.sh stats

# Maintenance
~/.aidevops/agents/scripts/memory-helper.sh validate   # Check for stale entries
~/.aidevops/agents/scripts/memory-helper.sh prune      # Remove stale memories

Storage: ~/.aidevops/.agent-workspace/memory/memory.db

See .agent/memory/README.md for complete documentation.

Installation

Slash commands are automatically installed by setup.sh:

# Commands are deployed to:
~/.config/opencode/commands/

# Regenerate commands manually:
.agent/scripts/generate-opencode-commands.sh

Usage

In OpenCode, type the command at the prompt:

/preflight
/release minor
/feature add-user-authentication

Commands invoke the corresponding workflow subagent with appropriate context.

Creating Custom Agents

Create a markdown file in ~/.config/opencode/agent/ (OpenCode) or reference in your AI's system prompt:

---
description: Short description of what this agent does
mode: subagent
temperature: 0.2
tools:
  bash: true
  specific-mcp_*: true
---

# Agent Name

Detailed instructions for the agent...

See .agent/opencode-integration.md for complete documentation.

Usage Examples

Server Management

# List all servers across providers
./.agent/scripts/servers-helper.sh list

# Connect to specific servers
./.agent/scripts/hostinger-helper.sh connect example.com
./.agent/scripts/hetzner-helper.sh connect main web-server

# Execute commands remotely
./.agent/scripts/hostinger-helper.sh exec example.com "uptime"

Monitoring & Uptime (Updown.io)

# List all monitors
./.agent/scripts/updown-helper.sh list

# Add a new website check
./.agent/scripts/updown-helper.sh add https://example.com "My Website"

Domain & DNS Management

# Purchase and configure domain
./.agent/scripts/spaceship-helper.sh purchase example.com
./.agent/scripts/dns-helper.sh cloudflare add-record example.com A 192.168.1.1

# Check domain availability
./.agent/scripts/101domains-helper.sh check-availability example.com

Strategic Keyword Research

# Basic keyword research with volume, CPC, difficulty
./.agent/scripts/keyword-research-helper.sh research "seo tools" --limit 20

# Google autocomplete long-tail discovery
./.agent/scripts/keyword-research-helper.sh autocomplete "how to" --provider both

# Extended research with SERP weakness detection
./.agent/scripts/keyword-research-helper.sh extended "keywords" --quick

# Competitor keyword research
./.agent/scripts/keyword-research-helper.sh extended --competitor ahrefs.com --limit 50

# Keyword gap analysis (find keywords competitor ranks for but you don't)
./.agent/scripts/keyword-research-helper.sh extended --gap semrush.com,ahrefs.com

# Domain research (all keywords a domain ranks for)
./.agent/scripts/keyword-research-helper.sh extended --domain example.com --limit 100

Features:

• 6 Research Modes: Keyword expansion, autocomplete, domain research, competitor research, keyword gap, extended SERP analysis
• 17 SERP Weaknesses: Low domain score, no backlinks, thin content, UGC-heavy, non-HTTPS, and more
• KeywordScore Algorithm: 0-100 score based on weakness count, volume, and difficulty
• Multi-Provider: DataForSEO (primary), Serper (autocomplete), Ahrefs (domain ratings)
• Locale Support: US/UK/CA/AU/DE/FR/ES with saved preferences
• Output Formats: Markdown tables (TUI) and CSV export to ~/Downloads

Quality Control & Performance

# Run quality analysis with auto-fixes
bash .agent/scripts/qlty-cli.sh check 10
bash .agent/scripts/qlty-cli.sh fix

# Run chunked Codacy analysis for large repositories
bash .agent/scripts/codacy-cli-chunked.sh quick    # Fast analysis
bash .agent/scripts/codacy-cli-chunked.sh chunked # Full analysis

# AI coding assistance
bash .agent/scripts/ampcode-cli.sh scan ./src
bash .agent/scripts/continue-cli.sh review

# Audit website performance
./.agent/scripts/pagespeed-helper.sh wordpress https://example.com

Documentation & Resources

Wiki Guides:

• Getting Started - Installation and setup
• CLI Reference - aidevops command documentation
• MCP Integrations - MCP servers setup
• Providers - Service provider configurations
• Workflows Guide - Development workflows
• The Agent Directory - Agent file structure
• Understanding AGENTS.md - How agents work

Agent Guides (in .agent/):

• API Integrations - Service APIs
• Browser Automation - Web scraping and automation
• PageSpeed - Performance auditing
• Pandoc - Document format conversion
• Security - Enterprise security standards

Provider-Specific Guides: Hostinger, Hetzner, Cloudflare, WordPress, Git platforms, Vercel CLI, Coolify CLI, and more in .agent/

Architecture

aidevops/
├── setup.sh                       # Main setup script
├── AGENTS.md                      # AI agent guidance (dev)
├── .agent/                        # Agents and documentation
│   ├── AGENTS.md                  # User guide (deployed to ~/.aidevops/agents/)
│   ├── *.md                       # ~15 main agents
│   ├── scripts/                   # 100+ helper scripts
│   ├── tools/                     # Cross-domain utilities
│   ├── services/                  # External service integrations
│   └── workflows/                 # Development process guides
├── configs/                       # Configuration templates
├── ssh/                           # SSH key management
└── templates/                     # Reusable templates

Configuration & Setup

# 1. Copy and customize configuration templates
cp configs/hostinger-config.json.txt configs/hostinger-config.json
cp configs/hetzner-config.json.txt configs/hetzner-config.json
# Edit with your actual credentials

# 2. Test connections
./.agent/scripts/servers-helper.sh list

# 3. Install MCP integrations (optional)
bash .agent/scripts/setup-mcp-integrations.sh all

Security & Best Practices

Credential Management:

• Store API tokens in separate config files (never hardcode)
• Use Ed25519 SSH keys (modern, secure, fast)
• Set proper file permissions (600 for configs)
• Regular key rotation and access audits

Quality Assurance:

• Multi-platform analysis (SonarCloud, CodeFactor, Codacy, CodeRabbit, Qlty, Snyk, Gemini Code Assist)
• Automated security monitoring and vulnerability detection

Contributing & License

Contributing:

1. Fork the repository
2. Create feature branch
3. Add provider support or improvements
4. Test with your infrastructure
5. Submit pull request

License: MIT License - see LICENSE file for details Created by Marcus Quinn - Copyright © 2025

What This Framework Achieves

For You:

• Unified infrastructure management across all services
• AI-powered automation with standardized commands
• Enterprise-grade security and quality assurance
• Time savings through consistent interfaces

For Your AI Assistant:

• Structured access to entire DevOps ecosystem
• Real-time documentation via Context7 MCP
• Quality control with automated fixes
• Performance monitoring with and continual improvement of agents' token efficiency, tool use, and file location consistency

Get Started:

# npm (recommended)
npm install -g aidevops && aidevops update

# Bun (fast alternative)
bun install -g aidevops && aidevops update

# Homebrew
brew install marcusquinn/tap/aidevops && aidevops update

# Direct from source
bash <(curl -fsSL https://aidevops.sh/install)

Transform your AI assistant into a powerful infrastructure management tool with seamless access to all your servers and services.