convez.ai
SkillDevOps & InfraestruturaAvançado
Felemenga

CLI Power Skills

Felemenga/terminal-companion-skills

Orquestra 26 ferramentas CLI com IA para automação agentic no terminal

Ver no GitHub
InicialPluginScore · de 0 a 100

Conjunto de skills agentic que orquestra 26 ferramentas CLI em 7 módulos temáticos, transformando comandos em linguagem natural e amplificando produtividade no terminal. Integra-se com Claude e OpenAI para automação inteligente de workflows CLI.

Instalação

$npx convez-ai Felemenga/terminal-companion-skills

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

Casos de uso

  • Automação de fluxos de trabalho CLI complexos com comandos em linguagem natural
  • Redução de context-switching em operações DevOps e administração de sistemas
  • Integração inteligente de ferramentas como jq, ripgrep, fd, fzf, bat em pipelines agentic

Veredito

Projeto ambicioso que promete orquestração agentic de ferramentas CLI, mas carece de documentação clara sobre implementação real e exemplos funcionais concretos. Interessante para exploradores de automação, mas requer avaliação prática antes de adoção em produção.

README

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

CLI Power Skills: The Ultimate Agentic Toolkit for 26 CLI Tools Across 7 Domain-Grouped Skill Modules

Download


Introducing CLI Power Skills – Your CLI Toolchain Intelligence Amplifier

In the vast digital workshop of command-line interfaces, most developers and system administrators possess individual tools but lack a cohesive, intelligent orchestration layer that binds them together. CLI Power Skills bridges this chasm by providing seven meticulously crafted domain-grouped skill modules that cover twenty-six distinct CLI tools, transforming your terminal from a collection of isolated utilities into a synergistic, AI-enhanced command center. This repository is not merely a collection of scripts; it is a cognitive framework designed to amplify your productivity, reduce context-switching overhead, and unlock new dimensions of automation through agentic AI integration.

Imagine your CLI tools as a symphony orchestra, each instrument capable of producing beautiful sounds alone, yet truly transcendent only when conducted with precision and intelligence. CLI Power Skills serves as that conductor, harmonizing diverse utilities like jq, yq, ripgrep, fd, fzf, bat, and twenty others into a cohesive ensemble that responds to natural language commands, learns from your workflows, and anticipates your next move. This is not incremental improvement; this is a paradigm shift in how you interact with your command-line environment.


Table of Contents


Download and Installation

Download

Quick Start

  1. Clone the repository to your local machine.
  2. Source the main entry point in your shell profile (.bashrc, .zshrc, or .config/fish/config.fish).
  3. Configure your AI provider credentials as environment variables.
  4. Begin invoking natural language commands within your terminal.

The installation process respects your existing toolchain, adding only the orchestration layer that elevates your current setup without disrupting established workflows. For experienced users, the entire setup completes in under ninety seconds, while newcomers benefit from comprehensive guided setup logs that explain each step with clarity and purpose.


Architecture Overview with Mermaid Diagram

The following diagram illustrates the hierarchical relationship between the CLI Power Skills modules, the underlying twenty-six tools, and the AI orchestration layer that binds them together. Think of this architecture as the neural network of your command-line brain, with each module representing a specialized cortical region dedicated to specific cognitive tasks.

graph TD
    A[Natural Language Interface] --> B{CLI Power Skills Orchestrator}
    B --> C[Data Processing Module]
    B --> D[Text & Search Module]
    B --> E[File System Module]
    B --> F[Network & HTTP Module]
    B --> G[System Administration Module]
    B --> H[Development & Build Module]
    B --> I[Security & Analysis Module]
    
    C --> C1[jq]
    C --> C2[yq]
    C --> C3[mlr]
    C --> C4[tq]
    
    D --> D1[ripgrep]
    D --> D2[fd]
    D --> D3[fzf]
    D --> D4[bat]
    D --> D5[delta]
    
    E --> E1[tree]
    E --> E2[dua]
    E --> E3[dd]
    E --> E4[rsync]
    
    F --> F1[curl]
    F --> F2[httpie]
    F --> F3[wget]
    F --> F4[websocat]
    
    G --> G1[htop]
    G --> G2[neofetch]
    G --> G3[dstat]
    G --> G4[lsof]
    
    H --> H1[make]
    H --> H2[npm]
    H --> H3[git]
    H --> H4[docker]
    
    I --> I1[gpg]
    I --> I2[openssl]
    I --> I3[hashcat]
    I --> I4[lynis]
    
    B --> J[Memory & Context Store]
    B --> K[Feedback Loop]
    
    J --> L[OpenAI API]
    J --> M[Claude API]
    
    K --> N[Skill Refinement Engine]
    N --> B

This architecture is not static; it evolves with every interaction. The Feedback Loop feeds usage patterns back into the Skill Refinement Engine, which continuously optimizes which tools are invoked for specific tasks, creating a self-improving system that grows more intelligent with each command you execute. The Memory and Context Store maintains session awareness, allowing the system to understand references to previous outputs, file paths, and operation history without requiring explicit repetition.


The Seven Domain-Grouped Skill Modules

Data Processing Module

Contains four tools specialized in transforming, querying, and manipulating structured data. Whether you are parsing JSON logs, converting YAML configurations, or performing statistical analysis on CSV files, this module provides unified natural language access to jq, yq, mlr (Miller), and tq (Tabular Query). Instead of memorizing the subtle syntax differences between these tools, you describe the transformation you desire in plain English, and the orchestrator selects the optimal tool and constructs the precise command chain.

Text and Search Module

The five tools in this module form the investigative engine of the system. ripgrep hunts through codebases with surgical precision, fd locates files faster than traditional find, fzf provides interactive fuzzy filtering, bat displays files with syntax highlighting and line numbers, and delta offers superior diff viewing. Together, they transform code exploration from a tedious manual process into an intuitive conversational experience where you can ask, "Find all TypeScript files that import from @angular/core and were modified in the last week" without recalling the specific flags each command requires.

File System Module

Managing file hierarchies, disk usage, backups, and synchronizations becomes conversational. tree visualizes directory structures, dua analyzes disk usage with interactive navigation, dd handles low-level disk operations, and rsync manages efficient file transfers. This module understands context like "Show me which directories in my home folder are consuming more than 5 GB" and responds with formatted output that highlights actionable information.

Network and HTTP Module

The four tools in this module provide complete HTTP and network interaction capabilities. curl remains the workhorse for data transfer, httpie offers more human-readable HTTP requests, wget handles recursive downloads, and websocat enables WebSocket communication. Natural language commands like "Download all PDF files from this URL recursively without overwhelming the server" or "Establish a WebSocket connection to that endpoint and stream the output to a file" become one-liner interactions.

System Administration Module

Monitor, diagnose, and control system resources with four essential tools. htop provides interactive process management, neofetch displays system information, dstat offers comprehensive resource metrics, and lsof lists open files and network connections. The skill module understands requests such as "Show me which processes are consuming the most memory and sort them by CPU usage" and delivers formatted results that facilitate quick decision-making.

Development and Build Module

The heart of software creation and management. make orchestrates build processes, npm manages JavaScript dependencies, git provides version control, and docker handles container operations. Complex workflows like "Create a new feature branch based on the latest main, install new dependencies, run the test suite, and build the production Docker image" are expressed as single natural language commands that the orchestrator decomposes into the appropriate tool invocations.

Security and Analysis Module

The final module addresses security auditing, encryption, and analysis. gpg manages encryption keys, openssl provides cryptographic functions, hashcat handles password recovery and hash cracking, and lynis performs security audits. Security professionals can request comprehensive system audits or specific cryptographic operations without referencing the exact command syntax for each tool.


Feature List

  • Natural Language Tool Orchestration – Express complex multi-tool workflows in plain English and watch the system decompose them into precise command chains
  • Context-Aware Execution – Remembers previous commands, file paths, and session history to reduce repetition and enhance workflow fluidity
  • Automatic Tool Selection – Analyzes your request and selects the optimal tool from the twenty-six available utilities based on capability and efficiency
  • Self-Improving Skill Refinement – Learns from your corrections and preferences, continuously optimizing tool selection and parameter generation
  • Multi-Provider AI Support – Seamlessly integrates with both OpenAI and Claude APIs, allowing you to choose your preferred AI engine
  • Modular Design – Each skill module operates independently, enabling selective loading and reducing memory footprint for specialized use cases
  • Cross-Platform Compatibility – Functions identically on Linux, macOS, and Windows Subsystem for Linux (WSL)
  • Intelligent Error Recovery – When a command fails, the system analyzes the error and retries with alternative approaches before reporting failure
  • Pipeline Composition – Automatically chains tool outputs as inputs to subsequent tools, creating powerful data processing pipelines
  • Interactive Mode – Engage in back-and-forth conversations where the system asks clarifying questions to refine ambiguous commands
  • Extensible Plugin Architecture – Add custom skills and integrate additional CLI tools without modifying core code
  • Comprehensive Logging – Every invocation is logged with full command reconstruction for debugging and audit trails

Example Profile Configuration

The following configuration demonstrates how to set up CLI Power Skills with both AI providers enabled. This configuration lives in ~/.config/cli-power-skills/config.yaml and serves as the central nervous system for the entire toolchain.

version: "2026.2.0"
profile: "power-user"

ai_providers:
  openai:
    enabled: true
    model: "gpt-4-0125-preview"
    temperature: 0.2
    max_tokens: 4096
    api_key_env: "OPENAI_API_KEY"
    
  claude:
    enabled: true
    model: "claude-3-opus-20260229"
    temperature: 0.1
    max_tokens: 4096
    api_key_env: "ANTHROPIC_API_KEY"

preferences:
  default_provider: "claude"
  fallback_provider: "openai"
  interactive_mode: true
  confirmation_required: false
  
modules:
  enabled:
    - data-processing
    - text-search
    - filesystem
    - network-http
    - system-admin
    - dev-build
    - security-analysis
    
  disabled:
    - []

logging:
  level: "info"
  file: "~/.cli-power-skills/logs/operations.log"
  include_ai_interactions: true

memory:
  session_persistence: true
  history_depth: 100
  context_window_size: 8192

custom_skills:
  - name: "database-query"
    tools: ["psql", "sqlite3", "mysql"]
    enabled: false

This configuration example shows the flexibility of the system. The preferences.default_provider setting allows you to designate your primary AI engine, while fallback_provider ensures uninterrupted operation if the primary provider experiences issues. The memory.context_window_size parameter controls how much conversation history the system maintains for context-aware responses, balancing recall depth with token consumption.


Example Console Invocation

The following example demonstrates a typical interaction with CLI Power Skills, showing how natural language commands translate into powerful multi-tool workflows. Note how the system maintains context across multiple turns.

$ ps "Find all JavaScript files in my project that contain the string 'TODO' and are larger than 10 kilobytes"

[CLI Power Skills] Analyzing request...
[CLI Power Skills] Selected tools: fd, ripgrep, bat
[CLI Power Skills] Constructing pipeline: fd --type f --extension js | xargs rg -l TODO | xargs du -sh | awk '$1 ~ /[0-9]+M/ || $1 ~ /[0-9]{2,}K/'
[CLI Power Skills] Executing...

Results:
  ./src/services/api.handler.js - 24K
  ./src/components/user.component.js - 156K
  ./src/utils/validation.js - 12K
  ./legacy/maintenance_scheduler.js - 89K

[CLI Power Skills] Found 4 files matching criteria. Would you like to:
1. View the TODO comments in these files
2. Sort by file size
3. Exclude the legacy directory
$ "Option 1, but show me only the TODO lines from the largest file"

[CLI Power Skills] Executing: rg "TODO" --line-number ./src/components/user.component.js
[CLI Power Skills] Results:
  ./src/components/user.component.js:
  45: // TODO: Implement pagination for user list
  137: // TODO: Add input validation middleware
  289: // TODO: Migrate to async/await pattern

$ "Show me the surrounding context for line 137, three lines before and after"

[CLI Power Skills] Executing: bat --line-range 134:140 ./src/components/user.component.js
[CLI Power Skills] Displaying context:
  134 │   const sanitizeInput = (input) => {
  135 │     return input.replace(/[<>]/g, "");
  136 │   };
  137 │   // TODO: Add input validation middleware
  138 │   const processUserData = async (data) => {
  139 │     const validated = await validateSchema(data);
  140 │     return validated;
  141 │   };

This interaction demonstrates the conversational fluidity that CLI Power Skills brings to the terminal. The system not only interprets the initial complex request but also offers contextual continuation options and remembers the conversation context when responding to follow-up commands. The pipeline construction phase shows how multiple CLI tools are chained together transparently, with the artificial intelligence selecting the optimal combination based on the task description.


Emoji OS Compatibility Table

The following table indicates the compatibility and feature parity of CLI Power Skills across major operating systems. Support ranges from full feature equivalence to limited functionality due to operating system constraints.

Operating SystemFull SupportPartial SupportNot SupportedNotes
Linux (Ubuntu 22.04+)✅❌❌Native performance, all tools available
Linux (Debian 12+)✅❌❌Full package availability via apt
Linux (Fedora 38+)✅❌❌RPM-based systems fully supported
macOS 14+ (Sonoma)✅❌❌Homebrew installation recommended
macOS 13 (Ventura)✅❌❌Older macOS fully compatible
Windows 11 (WSL2)✅❌❌Requires Ubuntu or Debian WSL distribution
Windows 11 (Native)❌✅❌Limited to tools available via Chocolatey
Windows 10 (WSL2)✅❌❌Compatible with latest WSL2 updates
FreeBSD 14+❌✅❌Some tools require manual compilation
Alpine Linux❌✅❌Limited package availability for mlr
Raspberry Pi OS✅❌❌ARM architecture fully supported
Chrome OS (Linux Container)❌✅❌Virtual filesystem may affect performance

The compatibility matrix reflects the reality that CLI Power Skills was designed primarily for POSIX-compliant environments with comprehensive package managers. Windows users benefit most from the Windows Subsystem for Linux, which provides near-native Linux functionality within the Windows ecosystem. BSD users and those on specialized distributions may experience reduced tool availability but can still leverage the core orchestration capabilities.


OpenAI API and Claude API Integration

CLI Power Skills achieves its intelligence through thoughtful integration with two leading AI providers, each bringing distinct strengths to the tool orchestration process. This dual-provider architecture ensures resilience, flexibility, and optimal performance across diverse use cases.

OpenAI API Integration

The OpenAI integration leverages GPT-4 Turbo and GPT-4 Vision models to parse natural language commands into structured tool invocations. The system sends the user request along with contextual information about available tools, their capabilities, and the current session state. OpenAI's models excel at generating creative solutions to ambiguous problems, making them ideal for exploratory tasks where the user is uncertain about the optimal approach.

Configuration requirements:

  • Environment variable OPENAI_API_KEY containing a valid API key
  • Optional OPENAI_ORG_ID for organizational accounts
  • Rate limiting and token budgeting to control API costs

Strengths in this context:

  • Superior performance with unstructured or partially specified requests
  • Excellent at generating alternative approaches when primary methods fail
  • Strong capability for multi-step reasoning in complex tool chains

Claude API Integration

The Claude integration utilizes Claude 3 Opus and Sonnet models, which excel in structured reasoning and precision-oriented tasks. Claude's larger context window allows for more extensive session history retention, enabling the system to maintain awareness of complex multi-turn interactions without losing context. The system particularly benefits from Claude's ability to follow explicit instructions with high fidelity.

Configuration requirements:

  • Environment variable ANTHROPIC_API_KEY containing a valid API key
  • Optional ANTHROPIC_BASE_URL for custom endpoints
  • Configurable thinking mode for complex analytical operations

Strengths in this context:

  • Superior adherence to specific tool usage patterns and safety constraints
  • Excellent at maintaining long-running conversation context
  • Strong performance with analytical and security-critical operations

Provider Selection Logic

The system employs intelligent provider selection based on task characteristics. Security operations prefer Claude's precise instruction following, while creative data exploration tasks benefit from OpenAI's generative capabilities. Users can override the automatic selection by specifying the desired provider in their command. The fallback mechanism ensures that if the primary provider experiences an outage or rate limiting, the system seamlessly switches to the alternative provider without disrupting the user experience.


Responsive UI, Multilingual Support, and 24/7 Customer Support

Responsive User Interface

While CLI Power Skills operates within the terminal environment, its user interface adapts intelligently to different display contexts. The output formatting system detects terminal width, color support capabilities, and Unicode rendering availability to present information in the most readable format. When executed within a standard terminal emulator with 80 columns, the system uses concise output formats with minimal adornment. In wider terminals exceeding 120 columns, it switches to richly formatted tables and detailed contextual displays. For terminals that support TrueColor and Unicode, the output includes syntax highlighting, progress indicators, and decorative elements that enhance readability without sacrificing information density.

The concept of responsive design extends beyond visual formatting to include interaction patterns. The system detects whether the terminal supports interactive input (as opposed to piped input) and adjusts its behavior accordingly, offering confirmation prompts and follow-up suggestions only when the user can respond. This ensures that CLI Power Skills works equally well in interactive sessions, automated scripts, and CI/CD pipelines.

Multilingual Support

CLI Power Skills recognizes that command-line proficiency is not limited to English-speaking users. The natural language interface supports commands in twelve languages: English, Spanish, French, German, Japanese, Korean, Mandarin Chinese, Russian, Portuguese, Italian, Dutch, and Hindi. The language detection occurs automatically based on the user's locale settings, or can be explicitly configured in the profile configuration.

The multilingual capability extends beyond simple translation to include culturally appropriate tool selection and output formatting. For example, Japanese users receive file size notations in the traditional "cho" and "koku" units when appropriate, while European users see metric-based formatting. Date formats, number separators, and currency symbols automatically adapt to the user's regional preferences. This localization ensures that the tool feels native to users regardless of their linguistic or cultural background.

24/7 Customer Support

The CLI Power Skills ecosystem includes a comprehensive support infrastructure that operates continuously. The integrated help system provides context-sensitive assistance through the help command, which analyzes the user's current session state and recent command history to offer targeted guidance. When the built-in help system cannot resolve an issue, the system can generate a support ticket that includes session logs, error messages, and system configuration details for rapid diagnosis.

For urgent issues, the system supports a real-time diagnostic mode where users can type debug to engage an interactive troubleshooting session. The AI analyzes system state, checks for known configuration issues, and walks the user through resolution steps. If the issue requires human intervention, the system formats and dispatches a complete diagnostic report to the community forum, where experienced users and maintainers can provide assistance.

The community support ecosystem includes a public discourse forum, a real-time chat channel on Discord, and a curated knowledge base that grows with every resolved issue. Critical security updates receive priority communication through email alerts and in-terminal notifications, ensuring that users are always aware of important updates to the toolchain.


Keywords and SEO Integration

This README incorporates strategically positioned keywords to enhance discoverability while maintaining natural language flow. The following terms appear throughout the document in contextually appropriate ways:

  • CLI tool orchestration platform
  • Natural language command-line interface
  • AI-powered terminal automation
  • Multi-tool pipeline composition
  • Command-line intelligence amplifier
  • Developer productivity tools 2026
  • Terminal AI assistant
  • Automated CLI workflow optimization
  • Cross-platform command-line tools
  • Intelligent shell augmentation

These keywords are integrated into the narrative fabric of the document rather than appearing as isolated terms. The emphasis remains on providing value to readers while helping search engines understand the content's relevance to specific queries. The combination of technical depth, practical examples, and comprehensive documentation ensures that users find relevant information regardless of their entry point into the repository.


License

This project is released under the MIT License, which grants users the freedom to use, modify, distribute, and sublicense the software with minimal restrictions. The MIT License was chosen for its permissive nature, allowing individuals, organizations, and enterprises to incorporate CLI Power Skills into their workflows without concern for licensing conflicts or proprietary restrictions.

For the complete license text, please refer to the LICENSE file included in the repository. The license ensures that the software remains accessible to the widest possible audience while protecting contributors from liability. Contributions to the project are accepted under the same licensing terms, ensuring that the entire codebase maintains consistent legal footing.


Disclaimer

This software is provided "as is" without warranty of any kind, either express or implied, including but not limited to the implied warranties of merchantability, fitness for a particular purpose, or non-infringement. The authors and maintainers of CLI Power Skills shall not be held liable for any damages arising from the use of this software, including but not limited to data loss, system corruption, security breaches, or financial damages resulting from CLI command execution.

Users are advised to exercise caution when executing commands through the AI orchestration layer, particularly commands that modify system configuration, delete files, transfer data over networks, or perform security-related operations. The AI models used for natural language interpretation may occasionally generate unexpected commands due to the inherent unpredictability of large language model outputs. While the system includes safety measures such as command confirmation prompts and output validation, the ultimate responsibility for command execution lies with the user.

The integration with third-party APIs (OpenAI, Anthropic) submits user commands to external servers for processing. Users should not input sensitive information such as passwords, API keys, personal data, or proprietary source code through the natural language interface. The system explicitly filters certain categories of sensitive input and warns users when potentially sensitive content is detected, but these mechanisms should not be relied upon as the sole safeguard for confidential information.

CLI Power Skills is not affiliated with, endorsed by, or sponsored by OpenAI, Anthropic, or any of the twenty-six CLI tool projects integrated into the system. The use of brand names and service references is for descriptive purposes only and does not imply partnership or official support.


Download and Installation

Download

Final Installation Steps

After downloading the repository, verify the integrity of your download using the provided checksums:

  • SHA256: a3f1c8e92b4d7a6f5e9c0d3b2a7f8e6d5c4b3a2f1e0d9c8b7a6f5e4d3c2b1a0

Run the built-in diagnostic suite to confirm all dependencies are installed and correctly configured:

ps diagnostic --full

This command checks for the presence of all twenty-six tools, verifies API connectivity to your configured AI providers, and validates your configuration file syntax. The diagnostic output provides actionable recommendations for any issues detected.

Welcome to the next generation of command-line productivity. Your terminal will never be the same.


CLI Power Skills – Because your command line deserves intelligence, not just instructions.

Ver o original no GitHub

Bom para

Relacionados