code-assistant-manager

Code Assistant Manager (CAM)

[![License](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT) [![Code Quality](https://img.shields.io/badge/code%20quality-A+-brightgreen.svg)](https://github.com/Chat2AnyLLM/code-assistant-manager/actions) **One CLI to Rule Them All.**
Tired of juggling multiple AI coding assistants? **CAM** is a unified Python CLI to manage configurations, prompts, skills, and plugins for **17 AI assistants** including Claude, Codex, Gemini, Qwen, Copilot, Blackbox, Goose, Continue, and more from a single, polished terminal interface.

Installation

Quick Install (Recommended)

Since CAM is not yet published to PyPI, install it locally:

# Clone the repository
git clone https://github.com/Chat2AnyLLM/code-assistant-manager.git
cd code-assistant-manager

# Run the install script
./install.sh

Or use pipx (Works on MacOS)

  # Install pipx if not present                                                                                                                                          
  brew install pipx                                               
                                                                                                                                                                         
  # Clone the repository                                          
  git clone https://github.com/Chat2AnyLLM/code-assistant-manager.git
  cd code-assistant-manager                                          
                                                                                                                                                                         
  # Install using pipx
  pipx install . 

Alternative Methods

# Install using the install script directly
./install.sh

# Or install from the web
curl -fsSL https://raw.githubusercontent.com/Chat2AnyLLM/code-assistant-manager/main/install.sh | bash

# Install from source directly
git clone https://github.com/Chat2AnyLLM/code-assistant-manager.git
cd code-assistant-manager
pip install -e ".[dev]"

Quick Start

Create your base config files:

mkdir -p ~/.config/code-assistant-manager
cp code_assistant_manager/providers.json ~/.config/code-assistant-manager/providers.json
touch ~/.env
chmod 600 ~/.env

Set up your API keys in .env:

export ANTHROPIC_API_KEY="your-anthropic-key"
export GITHUB_TOKEN="your-github-token"
export GEMINI_API_KEY="your-gemini-key"

Source the environment file and verify setup:
```
source ~/.env
cam doctor
```
Launch the interactive menu:
```
cam launch
```
Select your assistant and start coding!

Configuration files

CAM uses these main configuration files:

~/.config/code-assistant-manager/providers.json: endpoint/provider settings used by cam.
~/.env: API keys and sensitive environment variables.
~/.config/code-assistant-manager/config.yaml: repository-source config for skills, agents, and plugins.

How `config.yaml` is used for skill/agent/plugin repos

CAM loads ~/.config/code-assistant-manager/config.yaml first; if missing, it falls back to bundled code_assistant_manager/config.yaml.
The file defines source lists for skills, agents, and plugins.
Local JSON sources (skill_repos.json, agent_repos.json, plugin_repos.json) are loaded first.
Remote sources are merged after local sources and do not override existing local keys.
Remote responses are cached in ~/.cache/code-assistant-manager/repos (TTL controlled by config.yaml).

Why CAM?

In the era of AI-driven development, developers often use multiple powerful assistants like Claude, GitHub Copilot, and Gemini. However, this leads to a fragmented and inefficient workflow:

Scattered Configurations: Each tool has its own setup, API keys, and configuration files.
Inconsistent Behavior: System prompts and custom instructions diverge, leading to different AI behaviors across projects.
Wasted Time: Constantly switching between different CLIs and UIs is a drain on productivity.

CAM solves this by providing a single, consistent interface to manage everything, turning a chaotic toolkit into a cohesive and powerful development partner.

Key Features

Core Capabilities

Unified Management: One tool (cam) to install, configure, and run all your AI assistants
Centralized Configuration: Manage all API keys and endpoint settings from a single providers.json file with environment variables in .env
Interactive TUI: A polished, interactive menu (cam launch) for easy navigation and operation with arrow-key navigation
MCP Registry: Built-in registry with 381 pre-configured MCP servers ready to install across all supported tools
Extensible Framework: Standardized architecture for managing agents, prompts, skills, and plugins

Supported AI Assistants

CAM supports 17 AI coding assistants:

Assistant	Command	Install Method
Claude	`claude`	Shell script
Codex	`codex`	npm
Gemini	`gemini`	npm
Qwen	`qwen`	npm
Copilot	`copilot`	npm
CodeBuddy	`codebuddy`	npm
Droid	`droid`	Shell script
iFlow	`iflow`	npm
Crush	`crush`	npm
Cursor	`cursor-agent`	Shell script
Blackbox	`blackbox`	Shell script
Neovate	`neovate`	npm
Qoder	`qodercli`	npm
Zed	`zed`	Shell script
Goose	`goose`	Shell script
Continue	`continue`	npm
OpenCode	`opencode`	npm

Agents, Prompts & Skills

Agents

Manage standalone assistant configurations with markdown-based definitions and YAML front matter.

Prompts

Reusable system prompts with fancy name generation synced across assistants at user or project scope.

Skills

Custom tools and functionalities for your agents (directory-based with SKILL.md).

Plugins

Marketplace extensions for supported assistants (GitHub repos or local paths).

Command Reference

Command	Alias	Description
`cam launch [TOOL]`	`l`	Launch interactive TUI or a specific assistant
`cam doctor`	`d`	Run diagnostic checks on environment and API keys
`cam agent`	`ag`	Manage agent configurations (list, install, fetch from repos)
`cam prompt`	`p`	Manage and sync system prompts across assistants
`cam skill`	`s`	Install and manage skill collections
`cam plugin`	`pl`	Manage marketplace extensions (plugins)
`cam mcp`	`m`	Manage MCP servers (add, remove, list, install)
`cam upgrade [TARGET]`	`u`	Upgrade tools (default: all) with parallel execution
`cam install [TARGET]`	`i`	Alias for upgrade
`cam uninstall [TARGET]`	`un`	Uninstall tools and backup configurations
`cam config`	`cf`	Manage CAM’s internal configuration files
`cam version`	`v`	Display current version

Note: non-boolean CLI options are long-form only. For example, use --config and --scope (not -c or -s).

Governance & Quality

CAM is governed by a speckit-driven development framework ensuring consistent, high-quality evolution with:

Constitutional Principles: Unified interface, security-first design, TDD practices, extensible architecture, quality assurance
Enterprise Security: Config-first approach eliminates shell injection vulnerabilities
Comprehensive Testing: Enterprise-grade test suite with 1,423+ tests
Automated Quality Assurance: Built-in complexity monitoring, file size limits, and CI/CD quality gates

Community & Support

Discord: Join our community for discussions and support
GitHub Issues: Report bugs and request features
Contributing: See our Contributing Guidelines

License

This project is licensed under the MIT License.