Complex plan

Servidor MCP Complex Plans

Um servidor Model Context Protocol (MCP) projetado para aprimorar fluxos de trabalho de IA com recursos avançados de planejamento e pensamento sequencial. Este servidor permite que agentes de IA criem planos estruturados, gerenciem tarefas com eficiência e se integrem perfeitamente a ambientes de desenvolvimento.

Nota

Esta ferramenta foi desenvolvida principalmente para funcionar com o Mistral Vibe CLI, mas deve funcionar com qualquer modelo compatível com MCP. Embora não tenha sido extensivamente testada com outros modelos, contribuições e testes são bem-vindos!

Dica

Escolha modelos europeus quando puder, a Europa é simplesmente melhor! 🇪🇺

Recursos

• Criação e Gerenciamento de Planos: Crie, atualize, liste e exclua planos estruturados para tarefas complexas
• Pensamento Sequencial: Ferramenta integrada para resolução dinâmica de problemas e análise
• Configuração: Comportamento personalizável por meio de arquivos de configuração, argumentos de CLI e variáveis de ambiente
• Integração com Git: Gerenciamento automático do .gitignore
• Integração com Editor: Abra arquivos no seu editor preferido para revisão

Todas as ferramentas operam com segurança dentro do diretório de planos configurado (padrão .complex_plans) e podem ser usadas nos modos chat e plan.

Instalação

Configuração do Mistral Vibe CLI

Para usar este servidor com o Mistral Vibe CLI, adicione a seguinte configuração ao seu ~/.vibe/config.toml:

Importante

Remova a linha mcp_servers = [] da parte superior do arquivo para que isso funcione!

[[mcp_servers]]
name = "complex_plans"
transport = "stdio"
command = "npx"
args = ["-y", "@tuchsoft/mcp-complex-plans"]

[tools.complex_plans_createPlan]
permission = "always"
[tools.complex_plans_updatePlan]
permission = "always"
[tools.complex_plans_openInEditor]
permission = "always"
[tools.complex_plans_sequentialThinking]
permission = "always"
[tools.complex_plans_listPlans]
permission = "always"
[tools.complex_plans_readPlan]
permission = "always"
[tools.complex_plans_deletePlan]
permission = "ask"

Uso no modo plano/chat

Para usar as ferramentas no modo plano/chat, crie ou edite o arquivo de configuração ~/.vibe/agents/plan.toml (e/ou chat.toml):

enabled_tools = [
    "complex_plans_createPlan",
    "complex_plans_updatePlan",
    "complex_plans_openInEditor",
    "complex_plans_sequentialThinking",
    "complex_plans_readPlan",
    "complex_plans_listPlans"
]

Trecho recomendado de System Prompt

Para melhores resultados, edite seu system prompt para incluir um trecho como o seguinte, a fim de instruir o modelo sobre quando usar esta ferramenta:

**FOR COMPLEX, MULTI-FILE EDITS, ALWAYS GENERATE A MARKDOWN PLAN FIRST:** if the user request a complex task that require editing multiple files, traverse the project or make a lot of changes, **YOU MUST** create a markdown plan and ask the user to confirm it before proceeding, use the `complex_plans_createPlan` tool (and consequitive `complex_plans_readPlan`, `complex_plans_updatePlan`, `complex_plans_listPlans`, `complex_plans_openInEditor`, (optional) `complex_plans_deletePlan` tools).
**ALWAYS** ask the user to review and accept the plan after calling `complex_plans_openInEditor` and **BEFORE** doing anything else, do not proceed with the implementation until the user has accepted the plan.
Follow the instrucion provided by the tool itself.
Also if the user request a plan creation **ALWAYS** use the `complex_plans_createPlan` tool.

Opcionalmente, adicione também este outro bloco para garantir que a cadeia de pensamento seja usada sempre que possível:

**ALWAYS USE AN INTERNAL CHAIN OF THOUGHT**: Before answering to the user, writing code, editing a file, or performing whatever action, **always** use an internal chain of thought to verify your findings trough the use of the `complex_plans_sequentialThinking` tool.
Use as many tokens as you believe are necessary for your internal reasoning.
Output limit and verbosity constraints do not apply to your internal reasoning.
Always use the `complex_plans_sequentialThinking` tool for any task that is not a direct question-answer, as a rule of thumb if you are reading a file, you must also use the `complex_plans_sequentialThinking` tool.

Configuração do Claude Code

Para usar este servidor com o Claude Code, adicione o seguinte ao seu ~/.claude/claude.json (global) ou .claude/settings.json (nível de projeto):

Configuração global (~/.claude/claude.json):

{
  "mcpServers": {
    "complex_plans": {
      "command": "npx",
      "args": ["-y", "@tuchsoft/mcp-complex-plans", "--disabled-tools=sequentialThinking"]
    }
  }
}

Ou via CLI do Claude Code:

claude mcp add complex_plans npx -- -y @tuchsoft/mcp-complex-plans --disabled-tools=sequentialThinking

Nota sobre sequentialThinking: O Claude possui raciocínio estendido nativo integrado. É fortemente recomendado desabilitar a ferramenta sequentialThinking (como mostrado acima) para evitar redundância e conflitos com o próprio raciocínio do Claude. Quando desabilitada, a ferramenta é completamente removida do contexto do Claude — nenhuma instrução sobre ela permanece visível.

Trecho recomendado de CLAUDE.md

Adicione isto ao CLAUDE.md do seu projeto para instruir o Claude sobre quando usar as ferramentas de planejamento:

## Complex Plans

**FOR COMPLEX, MULTI-FILE EDITS, ALWAYS GENERATE A MARKDOWN PLAN FIRST:** If the user requests a complex task that requires editing multiple files, traversing the project, or making many changes, **YOU MUST** create a markdown plan and ask the user to confirm it before proceeding. Use the `complex_plans_createPlan` tool (and subsequent `complex_plans_readPlan`, `complex_plans_updatePlan`, `complex_plans_listPlans`, `complex_plans_openInEditor`, and optionally `complex_plans_deletePlan` tools).

**ALWAYS** ask the user to review and accept the plan after calling `complex_plans_openInEditor` and **BEFORE** doing anything else. Do not proceed with the implementation until the user has accepted the plan.

Follow the instructions provided by each tool. When asked to create a plan, always use `complex_plans_createPlan`.

**IMPORTANT**: Ignore the built-in `EnterPlanMode` and `ExitPlanMode` tools — use `complex_plans_createPlan` instead for all planning workflows.

Nota sobre instruções injetadas: O servidor envia automaticamente um conjunto de instruções ao modelo na inicialização (por exemplo, para usar o conjunto de ferramentas complex_plans e, quando auto_delete_plans estiver desabilitado, tratar planos existentes como dados históricos). Os trechos acima ainda são úteis como fallback ou para ênfase adicional.

Uso

1. O modelo deve decidir por conta própria quando usar a ferramenta quando a tarefa for complexa, longa ou exigir a edição de muitos arquivos.
2. Para forçar o modelo a criar um plano, basta incluir algo como Create a plan before implementing
3. Para editar um plano:
   • Você pode fazer isso manualmente editando o arquivo do plano. A seção Additional user provided details é onde você pode fornecer informações adicionais que o modelo não considerou. Lembre-se de remover da seção Risks/Doubts qualquer item para o qual você forneça uma resposta clara.
   • Você pode pedir ao modelo para fazer isso usando o prompt Edit the plan to... (ou Edit my XYZ plan to... se não estiver na mesma conversa)

Configuração

O servidor suporta múltiplos métodos de configuração com a seguinte ordem de prioridade (da maior para a menor):

1. Arquivo de configuração no nível do projeto ([your_project]/<plans_dir>/config.json) - Prioridade mais alta
2. Argumentos de CLI - Substituem variáveis de ambiente
3. Variáveis de ambiente - Substituem valores padrão
4. Valores padrão - Prioridade mais baixa

Opções de Configuração

Opção	Tipo	Padrão	Argumento CLI	Variável de Ambiente	Descrição
default_editor	string	"zed"	--default-editor=	MCP_COMPLEX_PLANS_DEFAULT_EDITOR	Editor padrão para abrir arquivos
auto_delete_plans	boolean	false	--auto-delete-plans=	MCP_COMPLEX_PLANS_AUTO_DELETE_PLANS	Excluir planos automaticamente após a implementação
add_to_gitignore	boolean	true	--add-to-gitignore=	MCP_COMPLEX_PLANS_ADD_TO_GITIGNORE	Adicionar automaticamente o diretório de planos ao .gitignore
plans_dir	string	".complex_plans"	--plans-dir=	MCP_COMPLEX_PLANS_PLANS_DIR	Nome do diretório usado para armazenar arquivos de plano
disabled_tools	string[]	[]	--disabled-tools=	MCP_COMPLEX_PLANS_DISABLED_TOOLS	Lista de ferramentas para desabilitar (separadas por vírgula)

Exemplos de Configuração

Arquivo de configuração (.complex_plans/config.json):

{
  "default_editor": "vscode",
  "auto_delete_plans": false,
  "add_to_gitignore": true,
  "plans_dir": ".complex_plans",
  "disabled_tools": ["listPlans"]
}

Argumentos de CLI:

node dist/index.js --default-editor=vscode --auto-delete-plans=false --plans-dir=.complex_plans --disabled-tools=listPlans,deletePlan

Variáveis de ambiente:

export MCP_COMPLEX_PLANS_DEFAULT_EDITOR="vscode"
export MCP_COMPLEX_PLANS_AUTO_DELETE_PLANS="false"
export MCP_COMPLEX_PLANS_PLANS_DIR=".complex_plans"
export MCP_COMPLEX_PLANS_DISABLED_TOOLS="listPlans,deletePlan"

Ferramentas

Ferramentas Disponíveis

• createPlan: Crie planos estruturados para tarefas complexas
• updatePlan: Modifique planos existentes usando blocos SEARCH/REPLACE
• deletePlan: Remova planos concluídos ou obsoletos
• listPlans: Liste todos os planos disponíveis no projeto atual
• openInEditor: Abra arquivos no seu editor configurado para revisão
• sequentialThinking: Ferramenta dinâmica de resolução de problemas e análise

Pensamento sequencial

A implementação do pensamento sequencial é baseada em sequentialthinking; para documentação detalhada da ferramenta e padrões de uso, consulte esse repositório.

Desenvolvimento

npm install
npm run build
npm link #To then test using npx as normal

Licença

MIT