convez.ai
MCP Server
nukhbaposai-lang

cc-commander-arsenal

nukhbaposai-lang/cc-commander-arsenal

Ver no GitHub
InicialPluginScore · de 0 a 100

CC Commander Pro 2026: Master Claude Code with 60+ Plugins, 22 Agents & 9 Lifecycle Hooks

Instalação

$npx convez-ai nukhbaposai-lang/cc-commander-arsenal

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
0
Forks
0
Acompanhando
0
Saúde
28%
Último commit
há 6 meses
Versão
—
Issues abertas
0
Contribuidores
1

README

A tradução para o português deste README ainda está na fila.

Agentic CLI Orchestrator – The Command Center for AI-Native Development

Download

Live Demo • Documentation • Community • Changelog

The Agentic CLI Orchestrator transforms your terminal into a self-organizing swarm of specialized AI agents. Inspired by the architecture of CC Commander, this framework elevates the concept from plugin-based tools to a fully autonomous development orchestration layer. Instead of merely running commands, you delegate entire workflows to agentic squads that communicate, negotiate, and execute without manual intervention.

Download


🧠 What Makes This Different

Traditional CLI orchestrators treat AI as a single assistant. This repository reimagines the terminal as a digital atelier — a workshop where multiple AI craftspeople collaborate simultaneously on different facets of your project. Each agent possesses a unique cognitive specialization, from architectural planning to pixel-perfect UI implementation.

The system is built on three revolutionary principles:

  • Decentralized Intelligence – No single point of failure. If one agent stalls, its peers redistribute the workload.
  • Contextual Autonomy – Agents remember past interactions and adapt their behavior based on project maturity.
  • Lifecycle Awareness – The orchestrator understands development phases (prototyping, testing, deployment) and adjusts agent deployment accordingly.

📐 Architecture Overview (Mermaid Diagram)

graph TD
    A[User Terminal Command] --> B{Agentic Orchestrator Core}
    B --> C[Workflow Parser]
    B --> D[Agent Registry]
    B --> E[Memory Cache]
    
    C --> F[Task Decomposition Engine]
    D --> G[Specialist Agent Pool]
    E --> H[Contextual Recall]
    
    G --> G1[Architecture Agent]
    G --> G2[Code Synthesis Agent]
    G --> G3[Testing Harness Agent]
    G --> G4[Documentation Agent]
    G --> G5[UI Component Agent]
    
    F --> I[Lifecycle Hook Manager]
    I --> J[Pre-Execution Hooks]
    I --> K[Post-Execution Hooks]
    I --> L[Error Recovery Hooks]
    
    J --> M[Environment Validation]
    K --> N[Artifact Generation]
    L --> O[Fallback Strategies]
    
    H --> G
    M --> G1
    N --> G5
    O --> G3

The diagram above illustrates how a single terminal invocation triggers a cascade of specialized agents, each operating within a defined lifecycle stage.


🚀 Quick Start

Prerequisites

  • Node.js 18+ or Python 3.10+
  • OpenAI API key (for GPT-4o/4.5 agents)
  • Claude API key (for Anthropic-powered specialists)
  • Git 2.30+

Installation

macOS / Linux

curl -fsSL https://agentic-cli.io/install.sh | bash

Windows (PowerShell)

iwr -useb https://agentic-cli.io/install.ps1 | iex

Or download the binary directly:

Download


🎛️ Example Profile Configuration

Profiles are the personality layer of the orchestrator. Each profile defines which agents are active, their communication protocols, and how they handle failures.

# ~/.agentic-cli/profiles/fullstack-dev.yaml
profile:
  name: "Full-Stack Accelerator"
  language: "TypeScript"
  framework: "Next.js 15"
  
  agents:
    architecture:
      model: "claude-3-opus"
      temperature: 0.2
      memory: "project-global"
    
    code-synthesis:
      model: "gpt-4o"
      temperature: 0.4
      plugins: ["eslint", "prettier", "type-check"]
    
    ui-component:
      model: "claude-3-sonnet"
      temperature: 0.7
      library: "shadcn/ui"
    
    documentation:
      model: "gpt-4o-mini"
      temperature: 0.3
      output: "README.md"
  
  hooks:
    on-init:
      - validate-node-version
      - install-dependencies
      - initialize-git
    
    on-error:
      - rollback-changes
      - notify-user
      - suggest-alternative
    
    on-complete:
      - run-tests
      - generate-docs
      - optimize-bundle

This configuration activates a squad of four agents with distinct model backends, each tuned for a specific cognitive task.


🖥️ Example Console Invocation

agentic-cli --profile fullstack-dev --prompt "Build a responsive dashboard with real-time data visualization, dark mode toggle, and export to CSV functionality"

What happens under the hood:

  1. The orchestrator parses the natural language prompt
  2. The Architecture Agent decomposes the request into 12 discrete tasks
  3. The Code Synthesis Agent generates the component tree
  4. The UI Component Agent creates pixel-perfect, responsive layouts
  5. The Testing Harness Agent writes unit and integration tests concurrently
  6. The Documentation Agent produces inline comments and a README
[16:32:01] Orchestrator initialized
[16:32:03] Architecture Agent: Analyzing scope... identified 12 tasks
[16:32:08] Code Synthesis Agent: Generating component tree
[16:32:15] UI Component Agent: Applying responsive breakpoints
[16:32:22] Testing Harness Agent: Writing test suite
[16:32:30] Documentation Agent: Generating README
[16:32:35] Hooks: Running post-complete validation
[16:32:40] ✅ Project generated in ./dashboard-output/

💻 OS Compatibility

Operating SystemVersionSupport StatusNative Install
macOS14.x (Sonoma)✅ FullHomebrew
macOS13.x (Ventura)✅ FullHomebrew
Ubuntu22.04 LTS✅ FullAPT
Ubuntu20.04 LTS✅ FullAPT
Debian12✅ FullAPT
Fedora39✅ FullDNF
Windows11✅ FullWinget/Chocolatey
Windows10⚠️ LimitedManual
Alpine3.19✅ FullAPK
Arch LinuxRolling✅ FullAUR

✨ Feature Matrix

Core Capabilities

FeatureDescriptionStatus
Multi-Agent OrchestrationDeploy up to 22 specialist agents simultaneously✅
Plugin ArchitectureExtend with 60+ community plugins✅
Lifecycle Hooks9 lifecycle stages with 25 handler slots✅
Context MemoryPersistent project-wide memory with semantic recall✅
Hybrid API SupportOpenAI GPT-4o/4.5 + Claude Opus/Sonnet integration✅
Responsive UI GenerationAutomatic breakpoint adaptation for all screen sizes✅
Multilingual OutputGenerate code and documentation in 15+ languages✅
24/7 Autonomous ModeHeadless operation with cron-based scheduling✅

Integration Features

  • OpenAI API: Direct integration with GPT-4o, GPT-4 Turbo, and o1 models
  • Claude API: Seamless connection to Claude 3 Opus, Sonnet, and Haiku
  • Local LLM Support: Fallback to Ollama, LM Studio, or llama.cpp
  • VSCode Extension: In-editor agentic assistance
  • GitHub Actions: CI/CD pipeline integration
  • Slack & Discord: Notification channels for async workflows

🌐 API Integration Example

OpenAI Configuration

export OPENAI_API_KEY="sk-your-key-here"
export AGENTIC_CLI_DEFAULT_MODEL="gpt-4o"

Claude Configuration

export ANTHROPIC_API_KEY="sk-ant-your-key-here"
export AGENTIC_CLI_CLAUDE_MODEL="claude-3-opus-20240229"

Hybrid Mode

The orchestrator intelligently routes tasks to the optimal model:

  • Architecture & Planning: Claude 3 Opus (superior reasoning)
  • Code Generation: GPT-4o (broader training data)
  • UI Components: Claude 3 Sonnet (better visual understanding)
  • Testing & Validation: GPT-4o-mini (cost efficiency)

⚠️ Disclaimer

Important Notice (2026)

The Agentic CLI Orchestrator is provided as-is under the MIT License. While the system incorporates multiple safety layers and fallback mechanisms, users are responsible for:

  1. Code Review: All generated code should be reviewed before deployment to production environments
  2. API Costs: Usage of OpenAI and Anthropic APIs incurs charges based on token consumption
  3. Security Compliance: The orchestrator does not automatically enforce organizational security policies
  4. Data Privacy: Sensitive information should not be shared with cloud-based AI models
  5. Intellectual Property: Generated code may contain code patterns similar to existing copyrighted works

The developers assume no liability for damages arising from the use of this software. By downloading and using this tool, you acknowledge these terms and agree to use the system responsibly.


📜 License

This project is licensed under the MIT License – see the LICENSE file for details.

The MIT License permits:

  • ✅ Commercial use
  • ✅ Modification
  • ✅ Distribution
  • ✅ Private use
  • ✅ Sublicensing

The only requirement is that the original copyright notice and permission notice shall be included in all copies or substantial portions of the Software.


🔗 Download & Installation

Download

Quick Install (All Platforms)

curl -fsSL https://agentic-cli.io/install.sh | bash

Verify Installation

agentic-cli --version
# Output: Agentic CLI Orchestrator v2.4.1 (2026)

🤝 Contributing

We welcome contributions from the community. The plugin architecture is designed to be extensible, and new agent specializations can be added with minimal friction.

Plugin Development

// Example plugin: security-audit-agent
module.exports = {
  name: "security-audit-agent",
  version: "1.0.0",
  hooks: {
    "pre-commit": async (context) => {
      // Scan for secrets
      // Check dependency vulnerabilities
      // Audit permissions
      return context;
    },
  },
};

🌟 Community & Support

The orchestrator is completely free to use in 2026. Enterprise licensing with dedicated agent pools and on-premise deployment options will be available in Q3 2026.


🏆 Acknowledgments

This project builds upon the foundational concepts of agentic orchestration popularized by the CC Commander ecosystem. The architecture has been reimagined and extended to support fully autonomous, multi-model, multi-agent workflows suitable for production-grade software development.


Download

Ready to transform your terminal into a digital atelier? Download now and experience the future of AI-native development.

Ver o original no GitHub

Bom para

Relacionados