home / skills / zpankz / mcp-skillset / commands-router

commands-router skill

safe

This skill routes tasks to appropriate reasoning frameworks and command patterns for structured development workflows and brainstorming.

npx playbooks add skill zpankz/mcp-skillset --skill commands-router

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

3.7 KB

---
name: commands-router
description: Routes tasks to reasoning frameworks and command patterns in commands-db. Triggers on structured development workflows, skill commands (sc:*), brainstorming, architecture, or any task matching command framework patterns. Uses reasoning-index for semantic routing.
---

# Commands Router

Routes tasks to appropriate reasoning frameworks and command patterns.

## Trigger Conditions

Activate when task involves:
- Structured development workflow (implement, build, test)
- Skill command invocation (sc:*)
- Brainstorming or ideation
- Architecture or design decisions
- Workflow templates
- Schema-based operations

## Command Categories

### SC Commands (Skill Commands)
Primary action verbs for development tasks.

| Command | Trigger Keywords | Purpose |
|:--------|:-----------------|:--------|
| `sc:analyze` | analyze, evaluate, assess, audit | Deep analysis |
| `sc:build` | build, compile, package | Build operations |
| `sc:cleanup` | clean, organize, declutter | Code cleanup |
| `sc:design` | design, architect, plan | Architecture |
| `sc:document` | document, readme, guide | Documentation |
| `sc:estimate` | estimate, cost, time | Estimation |
| `sc:explain` | explain, clarify, describe | Explanations |
| `sc:git` | commit, push, merge | Git operations |
| `sc:implement` | implement, code, feature | Implementation |
| `sc:improve` | improve, enhance, optimize | Improvement |
| `sc:load` | load, context, import | Context loading |
| `sc:spawn` | spawn, delegate, parallel | Delegation |
| `sc:task` | task, complex, persistent | Complex tasks |
| `sc:test` | test, verify, validate | Testing |
| `sc:troubleshoot` | debug, fix, diagnose | Debugging |
| `sc:workflow` | workflow, prd, process | Workflows |

### BMAD Framework
| Module | Purpose |
|:-------|:--------|
| `bmad:brainstorm` | Structured brainstorming |
| `bmad:party-mode` | Multi-agent ideation |
| `bmad:prd` | Product requirements |
| `bmad:architecture` | System architecture |

## Routing Logic

```bash
# Use reasoning-index for semantic routing
reasoning-index search "{user_intent}"
reasoning-index suggest "{task_description}"

# Example output:
# {
#   "commands": ["sc:implement", "sc:design"],
#   "skills": ["test-driven-development"],
#   "reasoning_chain": ["sc:design", "sc:implement", "sc:test"]
# }
```

## Decision Tree

```
Command Task Detected
    │
    ├── Implementation?
    │   ├── New feature? → sc:implement
    │   ├── Build? → sc:build
    │   └── Improvement? → sc:improve
    │
    ├── Analysis?
    │   ├── Code review? → sc:analyze
    │   ├── Debugging? → sc:troubleshoot
    │   └── Testing? → sc:test
    │
    ├── Design?
    │   ├── Architecture? → sc:design
    │   ├── Brainstorm? → bmad:brainstorm
    │   └── PRD? → bmad:prd
    │
    ├── Documentation?
    │   ├── README? → sc:document
    │   ├── Explain? → sc:explain
    │   └── Guide? → sc:document
    │
    └── Operations?
        ├── Git? → sc:git
        ├── Cleanup? → sc:cleanup
        └── Complex? → sc:task
```

## Usage

```bash
# Search commands
reasoning-index search "debug authentication"

# Get reasoning chain suggestion
reasoning-index suggest "implement user login"

# List all SC commands
reasoning-index list sc

# Build knowledge graph
reasoning-index graph "optimize performance" --depth 2
```

## Integration

- **reasoning-index**: Primary routing CLI
- **commands-db**: Command framework database
- **skill-db**: Skill integration
- **meta-router**: Parent router

## Command Chaining

```
Design → Implement → Test → Document

sc:design → sc:implement → sc:test → sc:document
```

Overview

This skill routes development and ideation tasks to the most suitable reasoning frameworks and command patterns in the commands database. It detects structured workflows, skill-style commands, brainstorming and architecture requests, then returns recommended command chains and target skills for execution.

How this skill works

The router inspects task text for trigger keywords and schema patterns, then uses a reasoning-index semantic search to match intent to command categories (sc:* and bmad:*). It returns suggested command lists, reasoning chains, and relevant skills or frameworks to drive the next steps. Simple decision logic maps implementation, analysis, design, documentation, and operations intents to concrete commands.

When to use it

When you need to map a natural-language task to development or workflow commands
During planning: architecture decisions, PRDs, or structured brainstorming
When invoking skill commands (sc:*) or asking for command chains
To generate testable workflows: design → implement → test → document
When building automation that requires semantic routing to tooling

Best practices

Provide a concise task description including verbs and desired outcome
Include context like ‘new feature’, ‘bug’, or ‘performance’ to improve routing
Use the reasoning-index suggest/search endpoints to preview chains before execution
Chain commands explicitly for multi-step processes (design → implement → test)
Map each step to a concrete skill in skill-db when automating execution

Example use cases

User asks: “Implement user login” → suggest sc:design, sc:implement, sc:test
A debugging request: “Troubleshoot authentication failures” → route to sc:troubleshoot and sc:analyze
Team brainstorming session: “Generate product ideas for file sharing” → route to bmad:brainstorm and bmad:prd
CI action: “Build and package release” → map to sc:build then sc:git for deployment
Cleanup sprint: “Refactor and tidy up utilities” → route to sc:cleanup and sc:improve

FAQ

What inputs produce the best routing suggestions?

Short, action-oriented task descriptions with keywords like implement, test, design, debug, or document yield accurate command mappings.

Can the router create multi-step workflows?

Yes. It returns recommended reasoning chains (e.g., sc:design → sc:implement → sc:test → sc:document) that you can execute or adapt.