Divide and Conquer

Divide tarefas complexas em partes gerenciáveis e as armazena em JSON estruturado.

Documentação

Divide and Conquer MCP Server

Um servidor Model Context Protocol (MCP) que permite que agentes de IA dividam tarefas complexas em partes gerenciáveis usando um formato JSON estruturado.

Sumário

Propósito
Principais Recursos
Início Rápido
Instalação
Ferramentas
Exemplos de Uso
Casos de Uso
Armazenamento de Configuração
Contribuição
Licença

Propósito

O Divide and Conquer MCP Server é uma evolução do Temp Notes MCP Server, projetado especificamente para tarefas complexas que precisam ser divididas em partes gerenciáveis. Em vez de usar um arquivo de texto simples, este servidor usa um formato JSON estruturado para armazenar informações de tarefas, listas de verificação e contexto, facilitando o acompanhamento do progresso e a manutenção do contexto em várias conversas.

Principais Recursos

Formato JSON Estruturado: Em vez de texto simples, usa uma estrutura JSON para armazenar informações de tarefas
Rastreamento de Tarefas: Inclui funcionalidade de lista de verificação com rastreamento de status de conclusão
Preservação de Contexto: Campos dedicados para contexto de tarefa e descrições detalhadas
Monitoramento de Progresso: Visualização fácil de tarefas concluídas vs. restantes
Ordenação de Tarefas: Mantém a ordem das tarefas para execução sequencial
Inserção de Tarefas: Capacidade de inserir novas tarefas em posições específicas na lista de verificação
Metadados: Rastreia informações adicionais como tags, prioridade e tempo estimado de conclusão
Notas e Recursos: Armazena notas e recursos adicionais relacionados à tarefa

Início Rápido

Adicione o servidor à sua configuração MCP:

{
  "mcpServers": {
    "divide-and-conquer": {
      "command": "npx",
      "args": ["-y", "@landicefu/divide-and-conquer-mcp-server"],
      "disabled": false
    }
  }
}

Comece a usá-lo em suas conversas:

// Initialize a new task
await use_mcp_tool({
  server_name: "divide-and-conquer",
  tool_name: "initialize_task",
  arguments: {
    task_description: "Refactor the authentication system",
    context_for_all_tasks: "The current system uses session-based authentication."
  }
});

// Add checklist items
await use_mcp_tool({
  server_name: "divide-and-conquer",
  tool_name: "add_checklist_item",
  arguments: {
    task: "Analyze current authentication flow",
    detailed_description: "Review the existing authentication code.",
    context_and_plan: "Look at src/auth/* files. The current implementation uses express-session with MongoDB store."
  }
});

Instalação

Instalando via Smithery

Para instalar o Divide and Conquer Server para Claude Desktop automaticamente via Smithery:

npx -y @smithery/cli install @landicefu/divide-and-conquer-mcp-server --client claude

Opção 1: Usando npx (Recomendado)

Adicione o servidor à sua configuração MCP:

{
  "mcpServers": {
    "divide-and-conquer": {
      "command": "npx",
      "args": ["-y", "@landicefu/divide-and-conquer-mcp-server"],
      "disabled": false
    }
  }
}

Opção 2: Instalar a partir do código-fonte

Clone o repositório:

git clone https://github.com/landicefu/divide-and-conquer-mcp-server.git
cd divide-and-conquer-mcp-server

Instale as dependências:
```
npm install
```
Compile o servidor:
```
npm run build
```

Adicione o servidor à sua configuração MCP:

{
  "mcpServers": {
    "divide-and-conquer": {
      "command": "node",
      "args": ["/path/to/divide-and-conquer-mcp-server/build/index.js"],
      "disabled": false
    }
  }
}

Ferramentas

O Divide and Conquer MCP Server fornece as seguintes ferramentas:

`initialize_task`

Cria uma nova tarefa com a descrição especificada e itens de lista de verificação iniciais opcionais.

`update_task_description`

Atualiza a descrição principal da tarefa.

`update_context`

Atualiza as informações de contexto para todas as tarefas.

`add_checklist_item`

Adiciona um novo item à lista de verificação.

`update_checklist_item`

Atualiza um item existente da lista de verificação.

`mark_task_done`

Marca um item da lista de verificação como concluído.

`mark_task_undone`

Marca um item da lista de verificação como não concluído.

`remove_checklist_item`

Remove um item da lista de verificação.

`reorder_checklist_item`

Move um item da lista de verificação para uma nova posição.

`add_note`

Adiciona uma nota à tarefa.

`add_resource`

Adiciona um recurso à tarefa.

`update_metadata`

Atualiza os metadados da tarefa.

`clear_task`

Limpa os dados atuais da tarefa.

`get_checklist_summary`

Retorna um resumo da lista de verificação com o status de conclusão. As informações de contexto são intencionalmente excluídas do resumo para economizar espaço na janela de contexto.

`get_current_task_details`

Recupera os detalhes da tarefa atual (primeira tarefa não concluída) com contexto completo, juntamente com todas as outras tarefas com campos limitados. Para a tarefa atual, todos os campos, incluindo context_and_plan, são incluídos. Para outras tarefas, apenas task, detailed_description e status done são incluídos (context_and_plan é excluído). Esta é a ferramenta recomendada para usar ao trabalhar com tarefas.

Exemplos de Uso

Inicializando uma Tarefa Complexa

await use_mcp_tool({
  server_name: "divide-and-conquer",
  tool_name: "initialize_task",
  arguments: {
    task_description: "Refactor the authentication system to use JWT tokens and improve security",
    context_for_all_tasks: "The current system uses session-based authentication with cookies. We need to migrate to JWT for better scalability and security.",
    initial_checklist: [
      {
        task: "Analyze current authentication flow",
        detailed_description: "Review the existing authentication code to understand the current flow.",
        context_and_plan: "Look at src/auth/* files. The current implementation uses express-session with MongoDB store. Pay special attention to session expiration handling."
      },
      {
        task: "Design JWT implementation",
        detailed_description: "Create a design document outlining how JWT will be implemented.",
        context_and_plan: "Consider token structure, storage, and refresh mechanisms. Research best practices for JWT implementation in Node.js applications. Reference the security requirements document in docs/security.md."
      }
    ],
    metadata: {
      tags: ["security", "refactoring", "authentication"],
      priority: "high",
      estimated_completion_time: "2 weeks"
    }
  }
});

Obtendo um Resumo da Lista de Verificação

const summary = await use_mcp_tool({
  server_name: "divide-and-conquer",
  tool_name: "get_checklist_summary",
  arguments: {
    include_descriptions: true
  }
});

// Result contains a formatted summary of the checklist with completion status (context is excluded to save space)

Obtendo Detalhes da Tarefa Atual

const taskDetails = await use_mcp_tool({
  server_name: "divide-and-conquer",
  tool_name: "get_current_task_details",
  arguments: {}
});

// Result contains:
// - ultimate_goal: The final goal of the entire task (task_description)
// - tasks: Array of all tasks, where the current task (first uncompleted) has all fields including context_and_plan,
//   while other tasks have limited fields (task, detailed_description, done) without context_and_plan
// - current_task_index: Index of the current task (first uncompleted)
// - Additional task metadata, notes, resources, etc.

Casos de Uso

1. Tarefas Complexas de Desenvolvimento de Software

Ao trabalhar em tarefas complexas de desenvolvimento de software, os agentes de IA frequentemente enfrentam limitações de janela de contexto que dificultam a conclusão de todas as etapas em uma única conversa. O Divide and Conquer MCP Server permite que os agentes:

Dividam tarefas grandes em partes menores e gerenciáveis
Acompanhem o progresso em várias conversas
Mantenham contexto importante que de outra forma seria perdido
Organizem tarefas em uma sequência lógica
Documentem decisões e recursos

2. Planejamento e Gerenciamento de Projetos

Para tarefas de planejamento e gerenciamento de projetos, o servidor permite:

Criar planos de projeto estruturados com tarefas e subtarefas
Acompanhar o progresso e o status de conclusão
Manter contexto e requisitos
Documentar decisões e recursos
Colaborar em várias conversas

3. Pesquisa e Análise

Ao conduzir pesquisa e análise, os agentes podem:

Dividir perguntas de pesquisa em áreas específicas para investigar
Acompanhar o progresso e as descobertas
Manter contexto e informações de fundo
Documentar fontes e recursos
Organizar descobertas de forma estruturada

Estrutura JSON

O servidor usa a seguinte estrutura JSON para armazenar informações de tarefas:

{
  "task_description": "A medium-level detailed description about the whole task. The final goal we want to achieve.",
  
  "checklist": [
    {
      "done": false,
      "task": "A short yet comprehensive name for the task",
      "detailed_description": "A longer description about what we want to achieve with this task",
      "context_and_plan": "Related information, files the agent should read, and more details from other tasks, as well as a detailed plan for this task. This is typically the longest string."
    }
  ],
  
  "context_for_all_tasks": "Information that all tasks in the checklist should include.",
  
  "metadata": {
    "created_at": "ISO timestamp",
    "updated_at": "ISO timestamp",
    "progress": {
      "completed": 0,
      "total": 1,
      "percentage": 0
    },
    "tags": ["tag1", "tag2"],
    "priority": "high|medium|low",
    "estimated_completion_time": "ISO timestamp or duration"
  },
  
  "notes": [
    {
      "timestamp": "ISO timestamp",
      "content": "Additional notes or observations about the overall task"
    }
  ],
  
  "resources": [
    {
      "name": "Resource name",
      "url": "URL or file path",
      "description": "Description of the resource"
    }
  ]
}

Armazenamento de Configuração

Por padrão, o Divide and Conquer MCP Server armazena dados de tarefas no seguinte local:

No macOS/Linux: ~/.mcp_config/divide_and_conquer.json (que expande para /Users/username/.mcp_config/divide_and_conquer.json)
No Windows: C:\Users\username\.mcp_config\divide_and_conquer.json

Este arquivo é criado automaticamente quando você inicializa uma tarefa pela primeira vez. Se o arquivo não existir quando você tentar ler os dados da tarefa, o servidor retornará uma estrutura de tarefa vazia e criará o arquivo na próxima vez que você gravar.

O servidor lida com os seguintes cenários:

Se o arquivo não existir ao ler: Retorna uma estrutura de tarefa vazia
Se o diretório não existir: Cria a estrutura de diretórios automaticamente ao gravar
Se o arquivo estiver corrompido ou inacessível: Retorna mensagens de erro apropriadas

Contribuição

Contribuições são bem-vindas! Sinta-se à vontade para enviar um Pull Request.

Licença

Este projeto é licenciado sob a Licença MIT - consulte o arquivo LICENSE para obter detalhes.