feat: add multi-tool integration scripts and converted agent files

Adds support for installing The Agency agents across 7 agentic coding
tools via two scripts:

scripts/convert.sh
  - Reads all 61 agents and converts them into tool-specific formats
  - Supports: Antigravity, Gemini CLI, OpenCode, Cursor, Aider, Windsurf
  - Shellcheck-clean, pure bash, no external deps
  - Run: ./scripts/convert.sh [--tool <name>]

scripts/install.sh
  - Interactive terminal UI with auto-detection of installed tools
  - Pre-selects detected tools, toggle by number or bulk commands
  - Falls back gracefully in CI / non-interactive mode
  - Cross-platform: Linux, macOS (bash 3.2+), Windows Git Bash / WSL
  - Run: ./scripts/install.sh [--tool <name>] [--no-interactive]

integrations/ (generated, committed for reference)
  - antigravity/   SKILL.md per agent (61 files)
  - gemini-cli/    SKILL.md per agent + gemini-extension.json
  - opencode/      .md agent files for .opencode/agent/
  - cursor/        .mdc rule files for .cursor/rules/
  - aider/         single CONVENTIONS.md (all agents combined)
  - windsurf/      single .windsurfrules (all agents combined)
  - claude-code/   README only (agents copied directly from repo root)
  - README.md      full usage + tool-specific instructions

README.md
  - Added Multi-Tool Integrations section with supported tools table,
    quick-start guide, per-tool expandable instructions, and updated
    roadmap marking integrations as complete
This commit is contained in:
4shil
2026-03-08 20:30:01 +05:30
parent 5e32f1d1ac
commit 4f68131a01
258 changed files with 88856 additions and 1 deletions

208
README.md
View File

@@ -315,14 +315,220 @@ Each agent is designed with:
---
---
## 🔌 Multi-Tool Integrations
The Agency works natively with Claude Code, and ships conversion + install scripts so you can use the same agents across every major agentic coding tool.
### Supported Tools
| Tool | Format | Install Target |
|------|--------|----------------|
| [Claude Code](https://claude.ai/code) | `.md` with YAML frontmatter | `~/.claude/agents/` |
| [Antigravity](https://github.com/google-gemini/antigravity) | `SKILL.md` per skill dir | `~/.gemini/antigravity/skills/` |
| [Gemini CLI](https://github.com/google-gemini/gemini-cli) | Extension + `SKILL.md` | `~/.gemini/extensions/agency-agents/` |
| [OpenCode](https://opencode.ai) | `.md` with YAML frontmatter | `.opencode/agent/` (project-scoped) |
| [Cursor](https://cursor.sh) | `.mdc` rule files | `.cursor/rules/` (project-scoped) |
| [Aider](https://aider.chat) | Single `CONVENTIONS.md` | `./CONVENTIONS.md` (project-scoped) |
| [Windsurf](https://codeium.com/windsurf) | Single `.windsurfrules` | `./.windsurfrules` (project-scoped) |
---
### ⚡ Quick Install
**Step 1 — Generate integration files:**
```bash
./scripts/convert.sh
```
**Step 2 — Install (interactive, auto-detects your tools):**
```bash
./scripts/install.sh
```
The installer scans your system for installed tools, shows a checkbox UI, and lets you pick exactly what to install:
```
╔══════════════════════════════════════════════════╗
║ 🎭 The Agency — Tool Installer ║
╚══════════════════════════════════════════════════╝
System scan complete. ● = detected on your system
[✓] 1) ● Claude Code (claude.ai/code)
[✓] 2) ● Antigravity (~/.gemini/antigravity)
[ ] 3) ○ Gemini CLI (gemini extension)
[ ] 4) ○ OpenCode (opencode.ai)
[✓] 5) ● Cursor (.cursor/rules)
[ ] 6) ○ Aider (CONVENTIONS.md)
[ ] 7) ○ Windsurf (.windsurfrules)
[1-7] toggle [a] select all [n] select none
[d] detected only [Enter] install [q] quit
```
**Or install a specific tool directly:**
```bash
./scripts/install.sh --tool cursor
./scripts/install.sh --tool opencode
./scripts/install.sh --tool antigravity
```
**Non-interactive (CI/scripts):**
```bash
./scripts/install.sh --no-interactive --tool all
```
---
### Tool-Specific Instructions
<details>
<summary><strong>Claude Code</strong></summary>
Agents are copied directly from the repo into `~/.claude/agents/` — no conversion needed.
```bash
./scripts/install.sh --tool claude-code
```
Then activate in Claude Code:
```
Use the Frontend Developer agent to review this component.
```
See [integrations/claude-code/README.md](integrations/claude-code/README.md) for details.
</details>
<details>
<summary><strong>Antigravity (Gemini)</strong></summary>
Each agent becomes a skill in `~/.gemini/antigravity/skills/agency-<slug>/`.
```bash
./scripts/install.sh --tool antigravity
```
Activate in Gemini with Antigravity:
```
@agency-frontend-developer review this React component
```
See [integrations/antigravity/README.md](integrations/antigravity/README.md) for details.
</details>
<details>
<summary><strong>Gemini CLI</strong></summary>
Installs as a Gemini CLI extension with 61 skills + a manifest.
```bash
./scripts/install.sh --tool gemini-cli
```
See [integrations/gemini-cli/README.md](integrations/gemini-cli/README.md) for details.
</details>
<details>
<summary><strong>OpenCode</strong></summary>
Agents are placed in `.opencode/agent/` in your project root (project-scoped).
```bash
cd /your/project
/path/to/agency-agents/scripts/install.sh --tool opencode
```
Or install globally:
```bash
mkdir -p ~/.config/opencode/agent
cp integrations/opencode/agent/*.md ~/.config/opencode/agent/
```
Activate in OpenCode:
```
Use the Backend Architect agent to design this API.
```
See [integrations/opencode/README.md](integrations/opencode/README.md) for details.
</details>
<details>
<summary><strong>Cursor</strong></summary>
Each agent becomes a `.mdc` rule file in `.cursor/rules/` of your project.
```bash
cd /your/project
/path/to/agency-agents/scripts/install.sh --tool cursor
```
Rules are auto-applied when Cursor detects them in the project. Reference them explicitly:
```
Use the @security-engineer rules to review this code.
```
See [integrations/cursor/README.md](integrations/cursor/README.md) for details.
</details>
<details>
<summary><strong>Aider</strong></summary>
All agents are compiled into a single `CONVENTIONS.md` file that Aider reads automatically.
```bash
cd /your/project
/path/to/agency-agents/scripts/install.sh --tool aider
```
Then reference agents in your Aider session:
```
Use the Frontend Developer agent to refactor this component.
```
See [integrations/aider/README.md](integrations/aider/README.md) for details.
</details>
<details>
<summary><strong>Windsurf</strong></summary>
All agents are compiled into `.windsurfrules` in your project root.
```bash
cd /your/project
/path/to/agency-agents/scripts/install.sh --tool windsurf
```
Reference agents in Windsurf's Cascade:
```
Use the Reality Checker agent to verify this is production ready.
```
See [integrations/windsurf/README.md](integrations/windsurf/README.md) for details.
</details>
---
### Regenerating After Changes
When you add new agents or edit existing ones, regenerate all integration files:
```bash
./scripts/convert.sh # regenerate all
./scripts/convert.sh --tool cursor # regenerate just one tool
```
---
## 🗺️ Roadmap
- [ ] Interactive agent selector web tool
- [x] Multi-agent workflow examples — see [examples/](examples/)
- [x] Multi-tool integration scripts (Claude Code, Antigravity, Gemini CLI, OpenCode, Cursor, Aider, Windsurf)
- [ ] Video tutorials on agent design
- [ ] Community agent marketplace
- [ ] Agent "personality quiz" for project matching
- [ ] Integration examples with popular tools
- [ ] "Agent of the Week" showcase series
---