@onion-ai/cli 1.0.0-beta.1

package/framework/utils/task-manager/interface.md

@@ -0,0 +1,248 @@
+# 📐 Interface ITaskManager
+
+## 🎯 Propósito
+
+Define o contrato que todos os adapters de gerenciadores de tarefas devem implementar, garantindo consistência e permitindo troca transparente de provedores.
+
+---
+
+## 📋 Interface Completa
+
+```typescript
+/**
+ * Interface abstrata para gerenciadores de tarefas.
+ * Todos os adapters (ClickUp, Asana, Linear) devem implementar esta interface.
+ */
+interface ITaskManager {
+  // ═══════════════════════════════════════════════════════════════════════════
+  // IDENTIFICAÇÃO
+  // ═══════════════════════════════════════════════════════════════════════════
+  
+  /**
+   * Nome do provedor: 'clickup' | 'asana' | 'linear' | 'none'
+   */
+  readonly provider: TaskManagerProvider;
+  
+  /**
+   * Indica se o provedor está configurado corretamente
+   */
+  readonly isConfigured: boolean;
+  
+  // ═══════════════════════════════════════════════════════════════════════════
+  // CRUD DE TASKS
+  // ═══════════════════════════════════════════════════════════════════════════
+  
+  /**
+   * Cria uma nova task no gerenciador.
+   * @param input - Dados da task a criar
+   * @returns Task criada com ID e URL
+   */
+  createTask(input: CreateTaskInput): Promise<TaskOutput>;
+  
+  /**
+   * Obtém detalhes de uma task existente.
+   * @param taskId - ID da task no provedor
+   * @returns Task completa com todos os detalhes
+   */
+  getTask(taskId: string): Promise<TaskOutput>;
+  
+  /**
+   * Atualiza uma task existente.
+   * @param taskId - ID da task
+   * @param updates - Campos a atualizar (parcial)
+   * @returns Task atualizada
+   */
+  updateTask(taskId: string, updates: UpdateTaskInput): Promise<TaskOutput>;
+  
+  /**
+   * Remove uma task.
+   * @param taskId - ID da task
+   * @returns true se removida com sucesso
+   */
+  deleteTask(taskId: string): Promise<boolean>;
+  
+  // ═══════════════════════════════════════════════════════════════════════════
+  // SUBTASKS
+  // ═══════════════════════════════════════════════════════════════════════════
+  
+  /**
+   * Cria uma subtask vinculada a uma task pai.
+   * @param parentId - ID da task pai
+   * @param input - Dados da subtask
+   * @returns Subtask criada
+   */
+  createSubtask(parentId: string, input: CreateTaskInput): Promise<TaskOutput>;
+  
+  /**
+   * Lista todas as subtasks de uma task.
+   * @param parentId - ID da task pai
+   * @returns Array de subtasks
+   */
+  getSubtasks(parentId: string): Promise<TaskOutput[]>;
+  
+  // ═══════════════════════════════════════════════════════════════════════════
+  // COMENTÁRIOS
+  // ═══════════════════════════════════════════════════════════════════════════
+  
+  /**
+   * Adiciona um comentário a uma task.
+   * @param taskId - ID da task
+   * @param comment - Texto do comentário
+   * @returns Comentário criado
+   */
+  addComment(taskId: string, comment: string): Promise<CommentOutput>;
+  
+  /**
+   * Lista comentários de uma task.
+   * @param taskId - ID da task
+   * @returns Array de comentários
+   */
+  getComments(taskId: string): Promise<CommentOutput[]>;
+  
+  // ═══════════════════════════════════════════════════════════════════════════
+  // STATUS
+  // ═══════════════════════════════════════════════════════════════════════════
+  
+  /**
+   * Atualiza o status de uma task.
+   * @param taskId - ID da task
+   * @param status - Novo status (mapeado internamente pelo adapter)
+   * @returns Task atualizada
+   */
+  updateStatus(taskId: string, status: TaskStatus): Promise<TaskOutput>;
+  
+  // ═══════════════════════════════════════════════════════════════════════════
+  // BUSCA
+  // ═══════════════════════════════════════════════════════════════════════════
+  
+  /**
+   * Busca tasks com filtros.
+   * @param query - Critérios de busca
+   * @returns Array de tasks que correspondem aos critérios
+   */
+  searchTasks(query: SearchQuery): Promise<TaskOutput[]>;
+  
+  // ═══════════════════════════════════════════════════════════════════════════
+  // PROJETOS/LISTAS
+  // ═══════════════════════════════════════════════════════════════════════════
+  
+  /**
+   * Lista projetos/listas disponíveis.
+   * @returns Array de projetos
+   */
+  getProjectList(): Promise<ProjectOutput[]>;
+  
+  /**
+   * Obtém detalhes de um projeto.
+   * @param projectId - ID do projeto
+   * @returns Projeto com detalhes
+   */
+  getProject(projectId: string): Promise<ProjectOutput>;
+  
+  // ═══════════════════════════════════════════════════════════════════════════
+  // VALIDAÇÃO
+  // ═══════════════════════════════════════════════════════════════════════════
+  
+  /**
+   * Valida se um ID de task é válido para este provedor.
+   * @param taskId - ID a validar
+   * @returns true se o formato é válido
+   */
+  validateTaskId(taskId: string): boolean;
+  
+  /**
+   * Detecta o provedor de origem de um ID de task.
+   * @param taskId - ID da task
+   * @returns Nome do provedor ou null se desconhecido
+   */
+  getProviderFromTaskId(taskId: string): TaskManagerProvider | null;
+}
+```
+
+---
+
+## 📊 Métodos por Categoria
+
+| Categoria | Métodos | Descrição |
+|-----------|---------|-----------|
+| **Identificação** | `provider`, `isConfigured` | Informações do adapter |
+| **CRUD Tasks** | `createTask`, `getTask`, `updateTask`, `deleteTask` | Operações básicas |
+| **Subtasks** | `createSubtask`, `getSubtasks` | Hierarquia de tasks |
+| **Comentários** | `addComment`, `getComments` | Documentação e discussão |
+| **Status** | `updateStatus` | Workflow |
+| **Busca** | `searchTasks` | Localização de tasks |
+| **Projetos** | `getProjectList`, `getProject` | Navegação |
+| **Validação** | `validateTaskId`, `getProviderFromTaskId` | Compatibilidade |
+
+---
+
+## 🔄 Mapeamento por Provedor
+
+### Status
+
+| Interface | ClickUp | Asana | Linear |
+|-----------|---------|-------|--------|
+| `backlog` | "backlog" | - | "backlog" |
+| `todo` | "to do" | - | "todo" |
+| `in_progress` | "in progress" | - | "in_progress" |
+| `done` | "done" | completed: true | "done" |
+| `closed` | "closed" | completed: true | "canceled" |
+
+### Prioridade
+
+| Interface | ClickUp | Asana | Linear |
+|-----------|---------|-------|--------|
+| `urgent` | 1 | - | 1 |
+| `high` | 2 | - | 2 |
+| `normal` | 3 | - | 3 |
+| `low` | 4 | - | 4 |
+
+---
+
+## 🧪 Exemplo de Uso
+
+```typescript
+// Obter adapter
+const taskManager = getTaskManager();
+
+// Verificar configuração
+if (!taskManager.isConfigured) {
+  console.warn('⚠️ Provedor não configurado. Execute /meta/setup-integration');
+  return;
+}
+
+// Criar task
+const task = await taskManager.createTask({
+  name: 'Implementar feature X',
+  description: 'Descrição detalhada...',
+  priority: 'high',
+  tags: ['feature', 'v2']
+});
+
+console.log(`✅ Task criada: ${task.url}`);
+
+// Criar subtask
+const subtask = await taskManager.createSubtask(task.id, {
+  name: 'Fase 1: Setup'
+});
+
+// Adicionar comentário
+await taskManager.addComment(task.id, '🚀 Desenvolvimento iniciado!');
+
+// Atualizar status
+await taskManager.updateStatus(subtask.id, 'in_progress');
+```
+
+---
+
+## 📚 Referências
+
+- [Tipos Compartilhados](./types.md)
+- [Factory](./factory.md)
+- [Adapters](./adapters/)
+
+---
+
+**Versão**: 1.0.0
+**Criado em**: 2025-11-24
+

package/framework/utils/task-manager/types.md

@@ -0,0 +1,409 @@
+# 📦 Tipos Compartilhados - Task Manager
+
+## 🎯 Propósito
+
+Define os tipos TypeScript compartilhados entre todos os adapters, garantindo consistência nas operações de entrada e saída.
+
+---
+
+## 🔧 Enums e Constantes
+
+```typescript
+/**
+ * Provedores de gerenciamento de tarefas suportados.
+ */
+type TaskManagerProvider = 'clickup' | 'asana' | 'linear' | 'none';
+
+/**
+ * Status genéricos (mapeados internamente por cada adapter).
+ */
+type TaskStatus = 
+  | 'backlog'
+  | 'todo'
+  | 'in_progress'
+  | 'review'
+  | 'done'
+  | 'closed'
+  | 'canceled';
+
+/**
+ * Níveis de prioridade.
+ */
+type TaskPriority = 'urgent' | 'high' | 'normal' | 'low';
+```
+
+---
+
+## 📥 Tipos de Entrada (Input)
+
+### CreateTaskInput
+
+```typescript
+/**
+ * Dados para criação de uma nova task.
+ */
+interface CreateTaskInput {
+  /** Nome/título da task (obrigatório) */
+  name: string;
+  
+  /** Descrição em texto plano */
+  description?: string;
+  
+  /** Descrição em Markdown */
+  markdownDescription?: string;
+  
+  /** ID do projeto/lista onde criar */
+  projectId?: string;
+  
+  /** Prioridade da task */
+  priority?: TaskPriority;
+  
+  /** Data de vencimento (ISO 8601: YYYY-MM-DD) */
+  dueDate?: string;
+  
+  /** Data de início (ISO 8601: YYYY-MM-DD) */
+  startDate?: string;
+  
+  /** IDs de usuários assignees */
+  assignees?: string[];
+  
+  /** Tags/labels */
+  tags?: string[];
+  
+  /** Estimativa de tempo (minutos) */
+  timeEstimate?: number;
+}
+```
+
+### UpdateTaskInput
+
+```typescript
+/**
+ * Dados para atualização de task (todos opcionais).
+ */
+interface UpdateTaskInput {
+  /** Novo nome */
+  name?: string;
+  
+  /** Nova descrição */
+  description?: string;
+  
+  /** Nova descrição markdown */
+  markdownDescription?: string;
+  
+  /** Novo status */
+  status?: TaskStatus;
+  
+  /** Nova prioridade */
+  priority?: TaskPriority;
+  
+  /** Nova data de vencimento */
+  dueDate?: string | null;
+  
+  /** Nova data de início */
+  startDate?: string | null;
+  
+  /** Novos assignees (substitui existentes) */
+  assignees?: string[];
+  
+  /** Novas tags (substitui existentes) */
+  tags?: string[];
+  
+  /** Nova estimativa */
+  timeEstimate?: number;
+}
+```
+
+### SearchQuery
+
+```typescript
+/**
+ * Critérios de busca de tasks.
+ */
+interface SearchQuery {
+  /** Texto para buscar no nome/descrição */
+  text?: string;
+  
+  /** Filtrar por projeto */
+  projectId?: string;
+  
+  /** Filtrar por status (múltiplos) */
+  status?: TaskStatus[];
+  
+  /** Filtrar por assignee */
+  assignee?: string;
+  
+  /** Filtrar por tags */
+  tags?: string[];
+  
+  /** Filtrar por prioridade */
+  priority?: TaskPriority[];
+  
+  /** Limite de resultados */
+  limit?: number;
+  
+  /** Offset para paginação */
+  offset?: number;
+  
+  /** Ordenação */
+  orderBy?: 'created' | 'updated' | 'due_date' | 'priority';
+  
+  /** Direção da ordenação */
+  orderDirection?: 'asc' | 'desc';
+}
+```
+
+---
+
+## 📤 Tipos de Saída (Output)
+
+### TaskOutput
+
+```typescript
+/**
+ * Task retornada pelo adapter (normalizada).
+ */
+interface TaskOutput {
+  /** ID único no provedor */
+  id: string;
+  
+  /** Provedor de origem */
+  provider: TaskManagerProvider;
+  
+  /** Nome/título */
+  name: string;
+  
+  /** Descrição (texto plano) */
+  description: string;
+  
+  /** Status normalizado */
+  status: TaskStatus;
+  
+  /** Status original do provedor */
+  statusRaw?: string;
+  
+  /** Cor do status (hex) */
+  statusColor?: string;
+  
+  /** Prioridade */
+  priority?: TaskPriority;
+  
+  /** URL para abrir no provedor */
+  url: string;
+  
+  /** Data de criação (ISO 8601) */
+  createdAt: string;
+  
+  /** Data de última atualização (ISO 8601) */
+  updatedAt: string;
+  
+  /** Data de vencimento (ISO 8601) */
+  dueDate?: string;
+  
+  /** Data de início (ISO 8601) */
+  startDate?: string;
+  
+  /** Usuários assignees */
+  assignees: UserOutput[];
+  
+  /** Tags/labels */
+  tags: string[];
+  
+  /** Subtasks (se solicitadas) */
+  subtasks?: TaskOutput[];
+  
+  /** ID da task pai (se for subtask) */
+  parent?: string;
+  
+  /** ID do projeto/lista */
+  projectId?: string;
+  
+  /** Nome do projeto/lista */
+  projectName?: string;
+  
+  /** Tempo estimado (minutos) */
+  timeEstimate?: number;
+  
+  /** Tempo gasto (minutos) */
+  timeSpent?: number;
+}
+```
+
+### CommentOutput
+
+```typescript
+/**
+ * Comentário retornado pelo adapter.
+ */
+interface CommentOutput {
+  /** ID único do comentário */
+  id: string;
+  
+  /** Texto do comentário */
+  text: string;
+  
+  /** Autor do comentário */
+  author: UserOutput;
+  
+  /** Data de criação (ISO 8601) */
+  createdAt: string;
+  
+  /** Se foi resolvido (threads) */
+  resolved?: boolean;
+}
+```
+
+### UserOutput
+
+```typescript
+/**
+ * Usuário normalizado.
+ */
+interface UserOutput {
+  /** ID único no provedor */
+  id: string;
+  
+  /** Nome de exibição */
+  name: string;
+  
+  /** Email (se disponível) */
+  email?: string;
+  
+  /** URL do avatar */
+  avatarUrl?: string;
+}
+```
+
+### ProjectOutput
+
+```typescript
+/**
+ * Projeto/Lista normalizado.
+ */
+interface ProjectOutput {
+  /** ID único */
+  id: string;
+  
+  /** Nome do projeto */
+  name: string;
+  
+  /** URL no provedor */
+  url?: string;
+  
+  /** Descrição */
+  description?: string;
+  
+  /** Se está arquivado */
+  archived?: boolean;
+  
+  /** ID do workspace/space pai */
+  workspaceId?: string;
+}
+```
+
+---
+
+## ⚙️ Tipos de Configuração
+
+### ProviderConfig
+
+```typescript
+/**
+ * Configuração de um provedor.
+ */
+interface ProviderConfig {
+  /** Nome do provedor */
+  provider: TaskManagerProvider;
+  
+  /** Se está configurado corretamente */
+  isConfigured: boolean;
+  
+  /** Variáveis de ambiente obrigatórias */
+  requiredEnvVars: string[];
+  
+  /** Variáveis de ambiente opcionais */
+  optionalEnvVars: string[];
+  
+  /** Mensagem de erro se não configurado */
+  errorMessage?: string;
+}
+```
+
+### ValidationResult
+
+```typescript
+/**
+ * Resultado de validação de ID.
+ */
+interface ValidationResult {
+  /** Se o ID é válido */
+  valid: boolean;
+  
+  /** Mensagem de aviso (se houver) */
+  warning?: string;
+  
+  /** Provedor detectado */
+  detectedProvider?: TaskManagerProvider;
+}
+```
+
+---
+
+## 🔄 Mapeamento de Status por Provedor
+
+```typescript
+/**
+ * Mapeamento de status normalizado → provedor.
+ */
+const STATUS_MAPPING: Record<TaskManagerProvider, Record<TaskStatus, string>> = {
+  clickup: {
+    backlog: 'backlog',
+    todo: 'to do',
+    in_progress: 'in progress',
+    review: 'review',
+    done: 'done',
+    closed: 'closed',
+    canceled: 'closed'
+  },
+  asana: {
+    backlog: 'To Do',        // Mapeado para seção
+    todo: 'To Do',
+    in_progress: 'In Progress',
+    review: 'Review',
+    done: 'Done',            // completed: true
+    closed: 'Done',
+    canceled: 'Done'
+  },
+  linear: {
+    backlog: 'Backlog',
+    todo: 'Todo',
+    in_progress: 'In Progress',
+    review: 'In Review',
+    done: 'Done',
+    closed: 'Canceled',
+    canceled: 'Canceled'
+  },
+  none: {
+    backlog: 'backlog',
+    todo: 'todo',
+    in_progress: 'in_progress',
+    review: 'review',
+    done: 'done',
+    closed: 'closed',
+    canceled: 'canceled'
+  }
+};
+```
+
+---
+
+## 📚 Referências
+
+- [Interface ITaskManager](./interface.md)
+- [Detector de Provedor](./detector.md)
+
+---
+
+**Versão**: 1.0.0
+**Criado em**: 2025-11-24
+

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@onion-ai/cli",
+  "version": "1.0.0-beta.1",
+  "description": "The Onion Framework - AI-powered development workflow system for Claude Code",
+  "type": "module",
+  "bin": {
+    "onion": "./bin/onion.js"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "framework/",
+    "LICENSE",
+    "README.md"
+  ],
+  "scripts": {
+    "sync": "node scripts/sync-framework.js",
+    "prepublishOnly": "npm run sync"
+  },
+  "keywords": [
+    "claude-code",
+    "ai-framework",
+    "development-workflow",
+    "onion-framework",
+    "agents",
+    "commands",
+    "skills"
+  ],
+  "author": "David <david@onion.ai>",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "commander": "^12.1.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/onion-ai/cli.git"
+  }
+}