@renatocostaguedesdemorais/devs-loop-mcp 0.1.0

package/lib/api.cjs

@@ -0,0 +1,87 @@
+// ============================================================
+// DEVS-LOOP — ClickUp API Client
+// Zero dependências externas — usa apenas Node.js nativo
+// ============================================================
+
+const https = require("https");
+const path = require("path");
+const fs = require("fs");
+const { getHomeConfigDir, getPackageRoot, getProjectConfigDir } = require("./paths.cjs");
+
+// Carregar .env manualmente (sem dotenv)
+function loadEnv() {
+  const locations = [
+    path.join(getProjectConfigDir(), ".env"),
+    path.join(getHomeConfigDir(), ".env"),
+    path.join(process.cwd(), ".env"),
+    path.join(getPackageRoot(), ".env"),
+  ];
+
+  for (const loc of locations) {
+    if (fs.existsSync(loc)) {
+      const content = fs.readFileSync(loc, "utf8");
+      for (const line of content.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#")) continue;
+        const eqIndex = trimmed.indexOf("=");
+        if (eqIndex === -1) continue;
+        const key = trimmed.slice(0, eqIndex).trim();
+        const val = trimmed.slice(eqIndex + 1).trim();
+        if (!process.env[key]) process.env[key] = val;
+      }
+      break;
+    }
+  }
+}
+
+loadEnv();
+
+const API_TOKEN = process.env.CLICKUP_API_TOKEN;
+
+if (!API_TOKEN) {
+  console.error("❌ CLICKUP_API_TOKEN não definido.");
+  console.error("   Crie .devs-loop/.env com: CLICKUP_API_TOKEN=pk_...");
+  process.exit(1);
+}
+
+// Request genérico para a API do ClickUp
+function request(method, endpoint, body = null) {
+  return new Promise((resolve, reject) => {
+    const options = {
+      hostname: "api.clickup.com",
+      path: `/api/v2${endpoint}`,
+      method,
+      headers: {
+        Authorization: API_TOKEN,
+        "Content-Type": "application/json",
+      },
+    };
+
+    const req = https.request(options, (res) => {
+      let data = "";
+      res.on("data", (chunk) => (data += chunk));
+      res.on("end", () => {
+        try {
+          resolve({ status: res.statusCode, data: JSON.parse(data) });
+        } catch {
+          resolve({ status: res.statusCode, data: data });
+        }
+      });
+    });
+
+    req.on("error", reject);
+
+    if (body) req.write(JSON.stringify(body));
+    req.end();
+  });
+}
+
+// Helpers
+const api = {
+  get: (endpoint) => request("GET", endpoint),
+  post: (endpoint, body) => request("POST", endpoint, body),
+  put: (endpoint, body) => request("PUT", endpoint, body),
+  delete: (endpoint) => request("DELETE", endpoint),
+};
+
+module.exports = { api, loadEnv };

package/lib/coach.cjs

@@ -0,0 +1,222 @@
+// ============================================================
+// DEVS-LOOP — Coach (Guia Proativo)
+// Observa, questiona e guia o dev — mas NUNCA bloqueia
+// A palavra final é SEMPRE do dev
+// ============================================================
+
+const session = require("./session.cjs");
+const learnings = require("./learnings.cjs");
+
+// ─── Analisar e gerar nudges/alertas ───
+function analyze(context = {}) {
+  const nudges = [];
+  const s = session.loadSession();
+  const l = learnings.load();
+
+  if (!s) return nudges;
+
+  // ─── 1. ESCOPO ───
+  if (context.currentFile && s.initiative) {
+    nudges.push(...checkScope(context, s));
+  }
+
+  // ─── 2. TEMPO ───
+  nudges.push(...checkTime(s, l));
+
+  // ─── 3. PADRÕES ───
+  nudges.push(...checkPatterns(context, s, l));
+
+  // ─── 4. QUALIDADE ───
+  nudges.push(...checkQuality(context, s));
+
+  // ─── 5. REGRAS CUSTOMIZADAS ───
+  nudges.push(...checkCustomRules(context, l));
+
+  return nudges;
+}
+
+// ─── Verificar escopo ───
+function checkScope(context, s) {
+  const nudges = [];
+  const { currentFile, currentAction, filesChanged = [] } = context;
+
+  // Se está mexendo em muitos arquivos fora do padrão da iniciativa
+  if (filesChanged.length > 10) {
+    nudges.push({
+      type: "scope",
+      severity: "warning",
+      message: `⚠️ Você já mexeu em ${filesChanged.length} arquivos nesta sessão. A iniciativa era "${s.initiative}". Está tudo dentro do escopo ou surgiu algo novo?`,
+      suggestion: "Se surgiu algo fora do escopo, considere criar uma task separada para não misturar.",
+    });
+  }
+
+  return nudges;
+}
+
+// ─── Verificar tempo ───
+function checkTime(s, l) {
+  const nudges = [];
+  const timer = session.timerStatus();
+
+  if (timer) {
+    // Verificar se está demorando mais que a média para o tipo
+    const avgTime = l.avgTimeByType;
+    const activeTask = s.taskIds?.find((t) => t.id === timer.taskId);
+
+    if (activeTask?.type && avgTime[activeTask.type]) {
+      const avg = avgTime[activeTask.type].avg;
+      if (timer.minutes > avg * 2 && timer.minutes > 30) {
+        nudges.push({
+          type: "time",
+          severity: "info",
+          message: `⏱️ Você está há ${timer.minutes}min nesta task. A média para ${activeTask.type} é ${avg}min. Está travado em algo?`,
+          suggestion: "Se estiver travado, considere: (1) criar um Spike separado, (2) pedir ajuda, ou (3) simplificar o escopo.",
+        });
+      }
+    }
+
+    // Alerta genérico se >60min sem concluir
+    if (timer.minutes > 60) {
+      nudges.push({
+        type: "time",
+        severity: "warning",
+        message: `⏱️ Já são ${timer.minutes}min na task atual. Talvez seja hora de quebrar em subtarefas menores?`,
+        suggestion: "Tasks grandes tendem a ser mal estimadas. Considere concluir o que já funciona e criar uma nova task para o restante.",
+      });
+    }
+  }
+
+  // Sessão muito longa sem pausa
+  if (s.startTimestamp) {
+    const sessionMinutes = Math.floor((Date.now() - s.startTimestamp) / 60000);
+    if (sessionMinutes > 180) {
+      nudges.push({
+        type: "wellbeing",
+        severity: "info",
+        message: `☕ Sessão ativa há ${Math.floor(sessionMinutes / 60)}h${sessionMinutes % 60}min. Já fez uma pausa?`,
+        suggestion: "Pausas regulares melhoram a qualidade do código. Considere um break de 10min.",
+      });
+    }
+  }
+
+  return nudges;
+}
+
+// ─── Verificar padrões ───
+function checkPatterns(context, s, l) {
+  const nudges = [];
+
+  // Se o dev está criando muitas tasks Bug, algo pode estar errado
+  const currentBugs = (s.taskIds || []).filter((t) => t.type === "Bug").length;
+  if (currentBugs >= 3) {
+    nudges.push({
+      type: "pattern",
+      severity: "info",
+      message: `🐛 Já são ${currentBugs} bugs nesta sessão. Pode ser um sinal de que algo estrutural precisa de atenção.`,
+      suggestion: "Considere criar uma task de Refactor para resolver a causa raiz ao invés de corrigir sintomas.",
+    });
+  }
+
+  // Se o dev está investigando muito sem implementar
+  const spikes = (s.taskIds || []).filter((t) => t.type === "Spike").length;
+  const features = (s.taskIds || []).filter((t) => t.type === "Feature").length;
+  if (spikes >= 3 && features === 0) {
+    nudges.push({
+      type: "pattern",
+      severity: "info",
+      message: `🔍 Já foram ${spikes} investigações sem nenhuma Feature implementada. Já tem informação suficiente para começar?`,
+      suggestion: "Às vezes é melhor começar com um MVP simples do que investigar todas as possibilidades.",
+    });
+  }
+
+  // Se tem tasks criadas mas nenhuma concluída
+  if (s.tasksCreated >= 5 && s.tasksCompleted === 0) {
+    nudges.push({
+      type: "pattern",
+      severity: "warning",
+      message: `📋 ${s.tasksCreated} tasks criadas, nenhuma concluída. Está pulando entre tarefas?`,
+      suggestion: "Foco em concluir uma task antes de começar outra. Context switching reduz produtividade.",
+    });
+  }
+
+  return nudges;
+}
+
+// ─── Verificar qualidade ───
+function checkQuality(context, s) {
+  const nudges = [];
+
+  // Se está criando Feature sem testes
+  if (context.hasNewFeature && !context.hasTests) {
+    nudges.push({
+      type: "quality",
+      severity: "suggestion",
+      message: "🧪 Feature nova sem testes detectados. Quer que eu crie uma task de QA para validação?",
+      suggestion: "Cada Feature deveria ter pelo menos uma task de QA correspondente.",
+    });
+  }
+
+  // Se não tem Spike mas é algo novo
+  if (context.isNewDomain && !context.hasSpikeInSession) {
+    nudges.push({
+      type: "quality",
+      severity: "suggestion",
+      message: "🔍 Parece que é a primeira vez trabalhando com isso. Faz sentido criar um Spike primeiro para investigar?",
+      suggestion: "Um Spike de 20-30min pode evitar horas de retrabalho.",
+    });
+  }
+
+  return nudges;
+}
+
+// ─── Verificar regras customizadas ───
+function checkCustomRules(context, l) {
+  const nudges = [];
+  const activeRules = l.customRules?.filter((r) => r.active) || [];
+
+  for (const rule of activeRules) {
+    nudges.push({
+      type: "custom_rule",
+      severity: "reminder",
+      message: `📌 Lembrete: ${rule.rule}`,
+    });
+  }
+
+  return nudges;
+}
+
+// ─── Formatar nudges para exibição ───
+function formatNudges(nudges) {
+  if (nudges.length === 0) return "";
+
+  const lines = ["\n┌─ 🧭 DEVS-LOOP Coach ─────────────────────"];
+
+  for (const n of nudges) {
+    lines.push(`│ ${n.message}`);
+    if (n.suggestion) {
+      lines.push(`│   💡 ${n.suggestion}`);
+    }
+    lines.push("│");
+  }
+
+  lines.push("│ → Essas são sugestões. A decisão é sua.");
+  lines.push("└───────────────────────────────────────────\n");
+
+  return lines.join("\n");
+}
+
+// ─── Mensagem proativa baseada em contexto ───
+function getProactiveMessage(context = {}) {
+  const nudges = analyze(context);
+  return nudges.length > 0 ? formatNudges(nudges) : "";
+}
+
+module.exports = {
+  analyze,
+  formatNudges,
+  getProactiveMessage,
+  checkScope,
+  checkTime,
+  checkPatterns,
+  checkQuality,
+};

package/lib/config.cjs

@@ -0,0 +1,104 @@
+// ============================================================
+// DEVS-LOOP — Config Loader
+// Carrega config.json e resolve IDs por nome
+// ============================================================
+
+const fs = require("fs");
+const path = require("path");
+const { getHomeConfigDir, getPackageRoot, getProjectConfigDir } = require("./paths.cjs");
+
+const CONFIG_PATHS = [
+  path.join(getProjectConfigDir(), "config.json"),
+  path.join(getHomeConfigDir(), "config.json"),
+  path.join(getPackageRoot(), "config.json"),
+];
+
+let _config = null;
+
+function load() {
+  if (_config) return _config;
+
+  for (const p of CONFIG_PATHS) {
+    if (fs.existsSync(p)) {
+      _config = JSON.parse(fs.readFileSync(p, "utf8"));
+      return _config;
+    }
+  }
+
+  console.error("❌ config.json não encontrado");
+  process.exit(1);
+}
+
+function get(key) {
+  const cfg = load();
+  return key.split(".").reduce((obj, k) => obj?.[k], cfg);
+}
+
+// Resolvedores de ID por nome legível
+function resolveProject(name) {
+  const cfg = load();
+  const upper = name.toUpperCase();
+
+  // Busca exata
+  if (cfg.projetos[name]) return cfg.projetos[name];
+
+  // Busca case-insensitive
+  for (const [key, val] of Object.entries(cfg.projetos)) {
+    if (key.toUpperCase() === upper) return val;
+  }
+
+  return null;
+}
+
+function resolveProjectList(name) {
+  const cfg = load();
+  const mapping = cfg.project_lists || {};
+  const upper = name.toUpperCase();
+
+  if (mapping[name]) {
+    return typeof mapping[name] === "string" ? mapping[name] : mapping[name]?.id || null;
+  }
+
+  for (const [key, val] of Object.entries(mapping)) {
+    if (key.toUpperCase() === upper) {
+      return typeof val === "string" ? val : val?.id || null;
+    }
+  }
+
+  return null;
+}
+
+function resolveSize(size) {
+  const cfg = load();
+  return cfg.labels?.tamanho?.[size] || null;
+}
+
+function resolveTypeLabel(taskType) {
+  const cfg = load();
+  const mapping = cfg.task_type_mapping?.[taskType];
+  if (!mapping) return null;
+  return cfg.labels?.tipos_tarefas?.[mapping.label] || null;
+}
+
+function resolveStructure(taskType) {
+  const cfg = load();
+  const mapping = cfg.task_type_mapping?.[taskType];
+  if (!mapping?.estrutura) return null;
+  return cfg.labels?.estrutura?.[mapping.estrutura] || null;
+}
+
+function listProjects() {
+  const cfg = load();
+  return Object.keys(cfg.projetos).sort();
+}
+
+module.exports = {
+  load,
+  get,
+  resolveProject,
+  resolveProjectList,
+  resolveSize,
+  resolveTypeLabel,
+  resolveStructure,
+  listProjects,
+};

package/lib/learnings.cjs

@@ -0,0 +1,215 @@
+// ============================================================
+// DEVS-LOOP — Learnings (Auto-aprendizado)
+// Acumula conhecimento a cada sessão e se atualiza sozinho
+// ============================================================
+
+const fs = require("fs");
+const path = require("path");
+const { ensureDir, getHomeConfigDir, getPackageRoot } = require("./paths.cjs");
+
+const LEARNINGS_FILE = path.join(getHomeConfigDir(), "learnings.json");
+const CONFIG_FILE = path.join(getHomeConfigDir(), "config.json");
+const DEFAULT_CONFIG_FILE = path.join(getPackageRoot(), "config.json");
+
+function ensureConfigSeeded() {
+  ensureDir(getHomeConfigDir());
+
+  if (!fs.existsSync(CONFIG_FILE) && fs.existsSync(DEFAULT_CONFIG_FILE)) {
+    fs.copyFileSync(DEFAULT_CONFIG_FILE, CONFIG_FILE);
+  }
+}
+
+function load() {
+  ensureDir(getHomeConfigDir());
+  if (fs.existsSync(LEARNINGS_FILE)) {
+    return JSON.parse(fs.readFileSync(LEARNINGS_FILE, "utf8"));
+  }
+  return {
+    version: 1,
+    lastUpdated: null,
+    sessions: { total: 0, history: [] },
+    patterns: {},
+    projectStats: {},
+    taskTypeStats: {},
+    avgTimeByType: {},
+    customRules: [],
+    knownIssues: [],
+    devPreferences: {},
+  };
+}
+
+function save(data) {
+  ensureDir(getHomeConfigDir());
+  data.lastUpdated = new Date().toISOString();
+  fs.writeFileSync(LEARNINGS_FILE, JSON.stringify(data, null, 2), "utf8");
+}
+
+// ─── Registrar fim de sessão ───
+function recordSession(sessionData) {
+  const l = load();
+
+  l.sessions.total++;
+  l.sessions.history.push({
+    date: new Date().toISOString(),
+    project: sessionData.project,
+    initiative: sessionData.initiative,
+    tasksCreated: sessionData.tasksCreated,
+    tasksCompleted: sessionData.tasksCompleted,
+    totalMinutes: sessionData.totalMinutes || 0,
+    tasks: (sessionData.tasks || []).map((t) => ({
+      name: t.name,
+      type: t.type,
+      size: t.size,
+      completed: t.completed,
+    })),
+  });
+
+  // Manter apenas últimas 50 sessões
+  if (l.sessions.history.length > 50) {
+    l.sessions.history = l.sessions.history.slice(-50);
+  }
+
+  // Stats por projeto
+  const proj = sessionData.project;
+  if (!l.projectStats[proj]) {
+    l.projectStats[proj] = { sessions: 0, tasks: 0, totalMinutes: 0 };
+  }
+  l.projectStats[proj].sessions++;
+  l.projectStats[proj].tasks += sessionData.tasksCreated;
+  l.projectStats[proj].totalMinutes += sessionData.totalMinutes || 0;
+
+  save(l);
+}
+
+// ─── Registrar padrão observado ───
+function recordPattern(patternKey, data) {
+  const l = load();
+
+  if (!l.patterns[patternKey]) {
+    l.patterns[patternKey] = { count: 0, firstSeen: new Date().toISOString(), data: [] };
+  }
+
+  l.patterns[patternKey].count++;
+  l.patterns[patternKey].lastSeen = new Date().toISOString();
+  l.patterns[patternKey].data.push(data);
+
+  // Manter últimos 20 por padrão
+  if (l.patterns[patternKey].data.length > 20) {
+    l.patterns[patternKey].data = l.patterns[patternKey].data.slice(-20);
+  }
+
+  save(l);
+}
+
+// ─── Registrar tempo médio por tipo de task ───
+function recordTaskTime(taskType, minutes) {
+  const l = load();
+
+  if (!l.avgTimeByType[taskType]) {
+    l.avgTimeByType[taskType] = { total: 0, count: 0, avg: 0 };
+  }
+
+  l.avgTimeByType[taskType].total += minutes;
+  l.avgTimeByType[taskType].count++;
+  l.avgTimeByType[taskType].avg = Math.round(
+    l.avgTimeByType[taskType].total / l.avgTimeByType[taskType].count
+  );
+
+  save(l);
+}
+
+// ─── Auto-detectar novo projeto ───
+function detectNewProject(projectName) {
+  ensureConfigSeeded();
+  const config = JSON.parse(fs.readFileSync(CONFIG_FILE, "utf8"));
+
+  // Verificar se já existe (case-insensitive)
+  const upper = projectName.toUpperCase();
+  for (const key of Object.keys(config.projetos)) {
+    if (key.toUpperCase() === upper) return false;
+  }
+
+  return true; // É novo
+}
+
+// ─── Adicionar projeto ao config ───
+function addProject(projectName, projectId) {
+  ensureConfigSeeded();
+  const config = JSON.parse(fs.readFileSync(CONFIG_FILE, "utf8"));
+  config.projetos[projectName] = projectId;
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), "utf8");
+
+  recordPattern("new_project_added", { name: projectName, id: projectId });
+  console.log(`📦 Projeto '${projectName}' adicionado ao config.json`);
+}
+
+// ─── Registrar preferência do dev ───
+function setPreference(key, value) {
+  const l = load();
+  l.devPreferences[key] = { value, updatedAt: new Date().toISOString() };
+  save(l);
+}
+
+function getPreference(key) {
+  const l = load();
+  return l.devPreferences[key]?.value || null;
+}
+
+// ─── Registrar regra customizada ───
+function addCustomRule(rule) {
+  const l = load();
+  l.customRules.push({
+    rule,
+    addedAt: new Date().toISOString(),
+    active: true,
+  });
+  save(l);
+  console.log(`📝 Regra adicionada: "${rule}"`);
+}
+
+// ─── Registrar issue conhecida ───
+function addKnownIssue(issue, resolution) {
+  const l = load();
+  l.knownIssues.push({
+    issue,
+    resolution,
+    addedAt: new Date().toISOString(),
+  });
+  save(l);
+}
+
+// ─── Gerar contexto para o agente ───
+function getContextForAgent(project) {
+  const l = load();
+  const context = {
+    totalSessions: l.sessions.total,
+    avgTimeByType: l.avgTimeByType,
+    customRules: l.customRules.filter((r) => r.active).map((r) => r.rule),
+    devPreferences: l.devPreferences,
+    knownIssues: l.knownIssues.slice(-10),
+  };
+
+  if (project && l.projectStats[project]) {
+    context.projectHistory = l.projectStats[project];
+  }
+
+  // Últimas 5 sessões
+  context.recentSessions = l.sessions.history.slice(-5);
+
+  return context;
+}
+
+module.exports = {
+  load,
+  save,
+  recordSession,
+  recordPattern,
+  recordTaskTime,
+  detectNewProject,
+  addProject,
+  setPreference,
+  getPreference,
+  addCustomRule,
+  addKnownIssue,
+  getContextForAgent,
+};