@tostudy-ai/cli 0.1.0

package/dist/cli.js

@@ -0,0 +1,1786 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/picocolors/picocolors.js
+var require_picocolors = __commonJS({
+  "../../node_modules/picocolors/picocolors.js"(exports, module) {
+    var p = process || {};
+    var argv = p.argv || [];
+    var env = p.env || {};
+    var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+    var formatter = (open, close, replace = open) => (input) => {
+      let string = "" + input, index = string.indexOf(close, open.length);
+      return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+    };
+    var replaceClose = (string, close, replace, index) => {
+      let result = "", cursor = 0;
+      do {
+        result += string.substring(cursor, index) + replace;
+        cursor = index + close.length;
+        index = string.indexOf(close, cursor);
+      } while (~index);
+      return result + string.substring(cursor);
+    };
+    var createColors = (enabled = isColorSupported) => {
+      let f = enabled ? formatter : () => String;
+      return {
+        isColorSupported: enabled,
+        reset: f("\x1B[0m", "\x1B[0m"),
+        bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+        dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+        italic: f("\x1B[3m", "\x1B[23m"),
+        underline: f("\x1B[4m", "\x1B[24m"),
+        inverse: f("\x1B[7m", "\x1B[27m"),
+        hidden: f("\x1B[8m", "\x1B[28m"),
+        strikethrough: f("\x1B[9m", "\x1B[29m"),
+        black: f("\x1B[30m", "\x1B[39m"),
+        red: f("\x1B[31m", "\x1B[39m"),
+        green: f("\x1B[32m", "\x1B[39m"),
+        yellow: f("\x1B[33m", "\x1B[39m"),
+        blue: f("\x1B[34m", "\x1B[39m"),
+        magenta: f("\x1B[35m", "\x1B[39m"),
+        cyan: f("\x1B[36m", "\x1B[39m"),
+        white: f("\x1B[37m", "\x1B[39m"),
+        gray: f("\x1B[90m", "\x1B[39m"),
+        bgBlack: f("\x1B[40m", "\x1B[49m"),
+        bgRed: f("\x1B[41m", "\x1B[49m"),
+        bgGreen: f("\x1B[42m", "\x1B[49m"),
+        bgYellow: f("\x1B[43m", "\x1B[49m"),
+        bgBlue: f("\x1B[44m", "\x1B[49m"),
+        bgMagenta: f("\x1B[45m", "\x1B[49m"),
+        bgCyan: f("\x1B[46m", "\x1B[49m"),
+        bgWhite: f("\x1B[47m", "\x1B[49m"),
+        blackBright: f("\x1B[90m", "\x1B[39m"),
+        redBright: f("\x1B[91m", "\x1B[39m"),
+        greenBright: f("\x1B[92m", "\x1B[39m"),
+        yellowBright: f("\x1B[93m", "\x1B[39m"),
+        blueBright: f("\x1B[94m", "\x1B[39m"),
+        magentaBright: f("\x1B[95m", "\x1B[39m"),
+        cyanBright: f("\x1B[96m", "\x1B[39m"),
+        whiteBright: f("\x1B[97m", "\x1B[39m"),
+        bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+        bgRedBright: f("\x1B[101m", "\x1B[49m"),
+        bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+        bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+        bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+        bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+        bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+        bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+      };
+    };
+    module.exports = createColors();
+    module.exports.createColors = createColors;
+  }
+});
+
+// src/cli.ts
+import { Command as Command15 } from "commander";
+
+// src/commands/login.ts
+import { Command } from "commander";
+import { execFile } from "node:child_process";
+
+// src/auth/oauth-server.ts
+import http from "node:http";
+function startCallbackServer(port) {
+  return new Promise((resolve, reject) => {
+    const server = http.createServer((req, res) => {
+      const url = new URL(req.url, `http://localhost:${port}`);
+      if (url.pathname === "/callback") {
+        const code = url.searchParams.get("code");
+        if (code) {
+          res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+          res.end("<html><body><h1>Autenticado!</h1><p>Pode fechar esta aba.</p></body></html>");
+          server.close();
+          resolve({ code });
+        } else {
+          res.writeHead(400);
+          res.end("Missing code");
+        }
+      } else {
+        res.writeHead(404);
+        res.end("Not found");
+      }
+    });
+    server.listen(port, () => {
+    });
+    server.on("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        reject(new Error(`Port ${port} est\xE1 em uso. Tente novamente.`));
+      } else {
+        reject(err);
+      }
+    });
+    setTimeout(() => {
+      server.close();
+      reject(new Error("Login timeout \u2014 nenhuma resposta em 2 minutos"));
+    }, 12e4);
+  });
+}
+
+// src/auth/session.ts
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+function getConfigDir(override) {
+  if (override) return override;
+  if (process.platform === "linux" && process.env["XDG_CONFIG_HOME"]) {
+    return path.join(process.env["XDG_CONFIG_HOME"], "tostudy");
+  }
+  return path.join(os.homedir(), ".tostudy");
+}
+async function saveSession(session, configDir) {
+  const dir = getConfigDir(configDir);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, "config.json"), JSON.stringify(session, null, 2), {
+    mode: 384
+  });
+}
+async function getSession(configDir) {
+  const dir = getConfigDir(configDir);
+  const p = path.join(dir, "config.json");
+  if (!fs.existsSync(p)) return null;
+  return JSON.parse(fs.readFileSync(p, "utf-8"));
+}
+async function clearSession(configDir) {
+  const dir = getConfigDir(configDir);
+  const p = path.join(dir, "config.json");
+  if (fs.existsSync(p)) fs.unlinkSync(p);
+  const ap = path.join(dir, "active-course.json");
+  if (fs.existsSync(ap)) fs.unlinkSync(ap);
+}
+async function getActiveCourse(configDir) {
+  const dir = getConfigDir(configDir);
+  const p = path.join(dir, "active-course.json");
+  if (!fs.existsSync(p)) return null;
+  return JSON.parse(fs.readFileSync(p, "utf-8"));
+}
+async function setActiveCourse(course, configDir) {
+  const dir = getConfigDir(configDir);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, "active-course.json"), JSON.stringify(course, null, 2), {
+    mode: 384
+  });
+}
+async function requireSession(configDir) {
+  const session = await getSession(configDir);
+  if (!session) {
+    process.stderr.write("Erro: N\xE3o autenticado. Rode: tostudy login\n");
+    process.exit(2);
+  }
+  const expiresAt = new Date(session.expiresAt);
+  if (expiresAt < /* @__PURE__ */ new Date()) {
+    process.stderr.write("Erro: Sess\xE3o expirada. Rode: tostudy login\n");
+    process.exit(2);
+  }
+  return session;
+}
+async function requireActiveCourse(configDir) {
+  const course = await getActiveCourse(configDir);
+  if (!course) {
+    process.stderr.write("Erro: Nenhum curso ativo. Rode: tostudy select <curso>\n");
+    process.exit(3);
+  }
+  return course;
+}
+
+// src/output/formatter.ts
+function output(data, opts) {
+  if (opts.json) {
+    process.stdout.write(JSON.stringify(data, null, 2) + "\n");
+  } else if (typeof data === "string") {
+    process.stdout.write(data + "\n");
+  } else {
+    process.stdout.write(JSON.stringify(data, null, 2) + "\n");
+  }
+}
+function error(msg, code = 1) {
+  process.stderr.write(`Erro: ${msg}
+`);
+  process.exit(code);
+}
+function progressBar(percent, width = 20) {
+  const clamped = Math.max(0, Math.min(100, percent));
+  const filled = Math.round(clamped / 100 * width);
+  const empty = width - filled;
+  return "\u2588".repeat(filled) + "\u2591".repeat(empty) + ` ${clamped}%`;
+}
+function formatCourseList(courses) {
+  if (courses.length === 0) {
+    return [
+      "Nenhum curso encontrado.",
+      "",
+      "\u2192 tostudy enroll <curso>  para se matricular em um curso"
+    ].join("\n");
+  }
+  const lines = ["Seus cursos:", ""];
+  courses.forEach((course, idx) => {
+    const bar = progressBar(course.progress);
+    lines.push(`  ${idx + 1}. ${course.title}`);
+    lines.push(`     ${bar}`);
+    lines.push(`     Professor: ${course.creatorName}`);
+    lines.push("");
+  });
+  lines.push("\u2192 tostudy select <n\xFAmero>  para ativar um curso");
+  lines.push("\u2192 tostudy progress         para ver seu progresso");
+  return lines.join("\n");
+}
+function formatProgress(data) {
+  const { currentModule, currentLesson } = data;
+  const courseBar = progressBar(data.coursePercent);
+  const moduleBar = progressBar(data.modulePercent);
+  const lines = [
+    "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
+    `M\xF3dulo ${currentModule.order} de ${currentModule.totalModules}: ${currentModule.title}`,
+    `  Curso:   ${courseBar}`,
+    `  M\xF3dulo:  ${moduleBar}`,
+    "",
+    `Li\xE7\xE3o atual (${currentLesson.order}/${currentLesson.totalLessons}): ${currentLesson.title}`,
+    `Li\xE7\xF5es conclu\xEDdas: ${data.completedLessons}`,
+    `Tempo restante estimado: ~${data.estimatedMinutesRemaining} min`,
+    "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
+    "",
+    "\u2192 tostudy next    para avan\xE7ar para a pr\xF3xima li\xE7\xE3o",
+    "\u2192 tostudy lesson  para ver o conte\xFAdo da li\xE7\xE3o atual"
+  ];
+  return lines.join("\n");
+}
+function formatLesson(data) {
+  const { lesson, wayfinding, progress } = data;
+  const courseBar = progressBar(progress.coursePercent);
+  const moduleBar = progressBar(progress.modulePercent);
+  const lines = [
+    `\u2501\u2501\u2501 M\xF3dulo ${wayfinding.moduleOrder}/${wayfinding.totalModules} \xB7 Li\xE7\xE3o ${wayfinding.lessonOrder}/${wayfinding.totalLessons} \u2501\u2501\u2501`,
+    "",
+    `\u{1F4D6} ${lesson.title}`,
+    `   M\xF3dulo: ${lesson.moduleTitle}  |  Tipo: ${lesson.type}`,
+    "",
+    lesson.content,
+    "",
+    `  Curso:   ${courseBar}`,
+    `  M\xF3dulo:  ${moduleBar}`
+  ];
+  if (lesson.acceptanceCriteria) {
+    lines.push("", "Crit\xE9rios de aceita\xE7\xE3o:", lesson.acceptanceCriteria);
+  }
+  if (lesson.exerciseContent) {
+    lines.push("", "\u2500\u2500\u2500 Exerc\xEDcio \u2500\u2500\u2500", lesson.exerciseContent);
+  }
+  lines.push(
+    "",
+    "\u2192 tostudy validate <resposta>  para validar sua solu\xE7\xE3o",
+    "\u2192 tostudy hint                 para obter uma dica",
+    "\u2192 tostudy next                 para avan\xE7ar (ap\xF3s completar)"
+  );
+  return lines.join("\n");
+}
+function formatValidation(data) {
+  const statusIcon = data.passed ? "\u2713" : "\u2717";
+  const statusLabel = data.passed ? "APROVADO" : "REPROVADO";
+  const scoreStr = data.score !== null ? ` \xB7 Pontua\xE7\xE3o: ${data.score}/100` : "";
+  const lines = [`${statusIcon} Valida\xE7\xE3o: ${statusLabel}${scoreStr}`, "", "Crit\xE9rios:"];
+  data.criteria.forEach((c) => {
+    const icon = c.met ? "  \u2713" : "  \u2717";
+    lines.push(`${icon} ${c.criteria}`);
+    if (c.comment) {
+      lines.push(`      ${c.comment}`);
+    }
+  });
+  lines.push("", `Feedback: ${data.feedback}`, "");
+  if (data.passed) {
+    lines.push("\u2192 tostudy next  para avan\xE7ar para a pr\xF3xima li\xE7\xE3o");
+  } else {
+    lines.push(
+      "\u2192 tostudy hint      para obter uma dica",
+      "\u2192 tostudy validate  para tentar novamente"
+    );
+  }
+  return lines.join("\n");
+}
+function formatHint(data) {
+  const levelLabel = data.levelLabel ?? `N\xEDvel ${data.level}`;
+  const lines = [
+    `\u{1F4A1} Dica (${levelLabel} \xB7 ${data.level}/${data.maxLevel}):`,
+    "",
+    data.hint,
+    ""
+  ];
+  if (data.level < data.maxLevel) {
+    lines.push(`\u2192 tostudy hint  para uma dica mais detalhada (n\xEDvel ${data.level + 1})`);
+  } else {
+    lines.push("\u2192 tostudy validate  para tentar sua solu\xE7\xE3o");
+  }
+  return lines.join("\n");
+}
+function formatModuleStart(data) {
+  const { module: mod, firstLesson, wayfinding } = data;
+  const lines = [
+    `\u2501\u2501\u2501 M\xF3dulo ${wayfinding.moduleOrder}/${wayfinding.totalModules} \u2501\u2501\u2501`,
+    "",
+    `\u{1F5C2}  ${mod.title}`
+  ];
+  if (mod.description) {
+    lines.push("", mod.description);
+  }
+  if (mod.objectives && mod.objectives.length > 0) {
+    lines.push("", "Objetivos:");
+    mod.objectives.forEach((obj) => lines.push(`  \u2022 ${obj}`));
+  }
+  lines.push("", "\u2500\u2500\u2500 Primeira Li\xE7\xE3o \u2500\u2500\u2500", "", `\u{1F4D6} ${firstLesson.title}`, "", firstLesson.content);
+  if (firstLesson.lessonIntroContent) {
+    lines.push("", firstLesson.lessonIntroContent);
+  }
+  if (firstLesson.exerciseContent) {
+    lines.push("", "\u2500\u2500\u2500 Exerc\xEDcio \u2500\u2500\u2500", firstLesson.exerciseContent);
+  }
+  if (firstLesson.acceptanceCriteria) {
+    lines.push("", "Crit\xE9rios de aceita\xE7\xE3o:", firstLesson.acceptanceCriteria);
+  }
+  lines.push(
+    "",
+    "\u2192 tostudy validate <resposta>  para validar sua solu\xE7\xE3o",
+    "\u2192 tostudy hint                 para obter uma dica"
+  );
+  return lines.join("\n");
+}
+
+// src/commands/login.ts
+var DEFAULT_API_URL = "https://tostudy.ai";
+var PORT = 9876;
+var loginCommand = new Command("login").description("Autentica no ToStudy via browser").option("--manual", "Login manual (sem browser)").option("--api-url <url>", "API URL override", DEFAULT_API_URL).action(async (opts) => {
+  const apiUrl = opts.apiUrl;
+  if (opts.manual) {
+    console.log(`
+  Acesse este endere\xE7o no seu browser:`);
+    console.log(`  ${apiUrl}/api/cli/auth/authorize?port=${PORT}
+`);
+    console.log("  Ap\xF3s autorizar, o browser ser\xE1 redirecionado e o login ser\xE1 conclu\xEDdo.");
+    console.log("  Certifique-se de rodar este comando sem --manual para o fluxo autom\xE1tico.\n");
+    return;
+  }
+  console.log("\n  Abrindo browser para autentica\xE7\xE3o...\n");
+  const serverPromise = startCallbackServer(PORT);
+  const authUrl = `${apiUrl}/api/cli/auth/authorize?port=${PORT}`;
+  const openCmd = process.platform === "darwin" ? "open" : "xdg-open";
+  execFile(openCmd, [authUrl], (err) => {
+    if (err) {
+      console.log(`  N\xE3o foi poss\xEDvel abrir o browser automaticamente.`);
+      console.log(`  Abra manualmente: ${authUrl}
+`);
+    }
+  });
+  try {
+    const { code } = await serverPromise;
+    const res = await fetch(`${apiUrl}/api/cli/auth/exchange`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ code })
+    });
+    if (!res.ok) {
+      const body = await res.json();
+      error(body.error ?? "Falha na autentica\xE7\xE3o");
+    }
+    const { token: token2, userId, userName, expiresAt } = await res.json();
+    await saveSession({ token: token2, userId, userName, expiresAt, apiUrl });
+    console.log(`
+  Logado como ${userName}
+`);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "Login falhou";
+    error(msg);
+  }
+});
+
+// src/commands/logout.ts
+import { Command as Command2 } from "commander";
+var logoutCommand = new Command2("logout").description("Remove token local").action(async () => {
+  await clearSession();
+  console.log("\n  Deslogado com sucesso.\n");
+});
+
+// src/commands/setup.ts
+import { Command as Command3 } from "commander";
+
+// src/installer/node-detector.ts
+import { execFileSync } from "node:child_process";
+function detectNode() {
+  try {
+    const version = execFileSync("node", ["--version"], {
+      encoding: "utf-8"
+    }).trim();
+    let nodePath = null;
+    try {
+      const whichCmd = process.platform === "win32" ? "where" : "which";
+      nodePath = execFileSync(whichCmd, ["node"], { encoding: "utf-8" }).trim();
+    } catch {
+    }
+    const major = parseInt(version.replace("v", ""), 10);
+    return { installed: true, version, meetsMinimum: major >= 18, path: nodePath };
+  } catch {
+    return { installed: false, version: null, meetsMinimum: false, path: null };
+  }
+}
+
+// src/installer/ide-detector.ts
+import { execFileSync as execFileSync2 } from "node:child_process";
+import fs2 from "node:fs";
+import path2 from "node:path";
+import os2 from "node:os";
+function checkExists(p) {
+  return fs2.existsSync(p);
+}
+function detectIDEs() {
+  const home = os2.homedir();
+  const ides = [
+    // Claude Code: detected by presence of 'claude' binary
+    {
+      name: "Claude Code",
+      id: "claude-code",
+      detected: false,
+      configPath: path2.join(home, ".mcp.json")
+    },
+    // Cursor: ~/.cursor directory
+    {
+      name: "Cursor",
+      id: "cursor",
+      detected: checkExists(path2.join(home, ".cursor")),
+      configPath: path2.join(home, ".cursor", "mcp.json")
+    },
+    // VS Code: ~/.vscode directory
+    {
+      name: "VS Code",
+      id: "vscode",
+      detected: checkExists(path2.join(home, ".vscode")),
+      configPath: ".vscode/mcp.json"
+    },
+    // Claude Desktop: platform-specific config dir
+    {
+      name: "Claude Desktop",
+      id: "desktop",
+      detected: checkExists(
+        process.platform === "darwin" ? path2.join(home, "Library", "Application Support", "Claude") : process.platform === "win32" ? path2.join(process.env["APPDATA"] ?? home, "Claude") : path2.join(home, ".config", "claude")
+      ),
+      configPath: process.platform === "darwin" ? path2.join(
+        home,
+        "Library",
+        "Application Support",
+        "Claude",
+        "claude_desktop_config.json"
+      ) : process.platform === "win32" ? path2.join(process.env["APPDATA"] ?? home, "Claude", "claude_desktop_config.json") : path2.join(home, ".config", "claude", "claude_desktop_config.json")
+    },
+    // Windsurf: ~/.codeium/windsurf
+    {
+      name: "Windsurf",
+      id: "windsurf",
+      detected: checkExists(path2.join(home, ".codeium", "windsurf")),
+      configPath: path2.join(home, ".codeium", "windsurf", "mcp_config.json")
+    },
+    // OpenCode: ~/.opencode
+    {
+      name: "OpenCode",
+      id: "opencode",
+      detected: checkExists(path2.join(home, ".opencode")),
+      configPath: path2.join(home, ".opencode", "opencode.json")
+    },
+    // Manual (always available as fallback)
+    {
+      name: "Manual",
+      id: "manual",
+      detected: false,
+      configPath: "mcp.json"
+    }
+  ];
+  const claudeIde = ides.find((ide) => ide.id === "claude-code");
+  if (claudeIde) {
+    try {
+      execFileSync2("which", ["claude"], { encoding: "utf-8" });
+      claudeIde.detected = true;
+    } catch {
+    }
+  }
+  return ides;
+}
+
+// src/commands/setup.ts
+var setupCommand = new Command3("setup").description("Configura ambiente para estudar").option("--quick", "Setup r\xE1pido (sem wizard)").option("--ide <ide>", "Configura IDE espec\xEDfica").action(async (_opts) => {
+  console.log("\n  ToStudy Setup\n  \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n");
+  console.log("  1. Verificando Node.js...");
+  const node = detectNode();
+  if (!node.installed) {
+    console.log("  \u2717 Node.js n\xE3o encontrado");
+    console.log("  \u2192 Instale via: https://nodejs.org/ ou `nvm install --lts`\n");
+    process.exit(1);
+  }
+  if (!node.meetsMinimum) {
+    console.log(`  \u2717 Node.js ${node.version} \xE9 muito antigo (m\xEDnimo: v18)`);
+    console.log("  \u2192 Atualize via: `nvm install --lts`\n");
+    process.exit(1);
+  }
+  console.log(`  \u2713 Node.js ${node.version}
+`);
+  console.log("  2. Verificando autentica\xE7\xE3o...");
+  let session = null;
+  try {
+    session = await getSession();
+  } catch {
+  }
+  if (!session) {
+    console.log("  \u2717 N\xE3o autenticado");
+    console.log("  \u2192 Rode: tostudy login\n");
+    process.exit(1);
+  }
+  console.log(`  \u2713 Logado como ${session.userName}
+`);
+  console.log("  3. Detectando IDEs...");
+  let ides = [];
+  try {
+    ides = detectIDEs();
+  } catch {
+  }
+  const detected = ides.filter((ide) => ide.detected);
+  if (detected.length === 0) {
+    console.log("  \u25CB Nenhum IDE detectado");
+    console.log("  \u2192 Use tostudy diretamente no terminal\n");
+  } else {
+    for (const ide of detected) {
+      console.log(`  \u2713 ${ide.name} detectado`);
+    }
+    console.log("");
+  }
+  console.log("  Setup completo!");
+  console.log("  \u2192 tostudy courses  (ver cursos matriculados)");
+  console.log("  \u2192 tostudy doctor   (diagn\xF3stico completo)\n");
+});
+
+// src/commands/doctor.ts
+import { Command as Command4 } from "commander";
+var doctorCommand = new Command4("doctor").description("Diagn\xF3stico do ambiente").option("--json", "Output JSON").option("--fix", "Auto-corrigir problemas (reservado para vers\xF5es futuras)").action(async (opts) => {
+  const checks = {};
+  const node = detectNode();
+  const envChecks = {
+    os: { platform: process.platform, arch: process.arch },
+    node: { ...node },
+    pnpm: null,
+    git: null
+  };
+  try {
+    const { execFileSync: execFileSync3 } = await import("node:child_process");
+    envChecks["pnpm"] = execFileSync3("pnpm", ["--version"], { encoding: "utf-8" }).trim();
+  } catch {
+    envChecks["pnpm"] = null;
+  }
+  try {
+    const { execFileSync: execFileSync3 } = await import("node:child_process");
+    envChecks["git"] = execFileSync3("git", ["--version"], { encoding: "utf-8" }).trim().replace("git version ", "");
+  } catch {
+    envChecks["git"] = null;
+  }
+  checks["environment"] = envChecks;
+  let session = null;
+  try {
+    session = await getSession();
+  } catch {
+  }
+  checks["auth"] = {
+    loggedIn: !!session,
+    userName: session?.userName ?? null,
+    expiresAt: session?.expiresAt ?? null
+  };
+  try {
+    const apiUrl = session?.apiUrl ?? "https://tostudy.ai";
+    const start = Date.now();
+    const res = await fetch(`${apiUrl}/api/mcp/heartbeat`, {
+      method: "POST",
+      headers: session ? { Authorization: `Bearer ${session.token}` } : {},
+      signal: AbortSignal.timeout(5e3)
+    });
+    checks["connectivity"] = { ok: res.ok, latencyMs: Date.now() - start };
+  } catch {
+    checks["connectivity"] = { ok: false, latencyMs: null };
+  }
+  let ides = [];
+  try {
+    ides = detectIDEs();
+  } catch {
+  }
+  checks["ides"] = ides.filter((ide) => ide.detected);
+  if (opts.json) {
+    output(checks, { json: true });
+    return;
+  }
+  const pnpmVersion = envChecks["pnpm"];
+  const gitVersion = envChecks["git"];
+  const connectivity = checks["connectivity"];
+  console.log("\n  Ambiente");
+  console.log(
+    `  ${node.installed ? "\u2713" : "\u2717"} Node          ${node.version ?? "n\xE3o encontrado"}`
+  );
+  console.log(
+    `  ${node.meetsMinimum ? "\u2713" : "\u2717"} Vers\xE3o        ${node.meetsMinimum ? "OK (>= 18)" : "Desatualizado"}`
+  );
+  console.log(`  \u2713 OS            ${process.platform} (${process.arch})`);
+  console.log(`  ${pnpmVersion ? "\u2713" : "\u25CB"} pnpm          ${pnpmVersion ?? "n\xE3o encontrado"}`);
+  console.log(`  ${gitVersion ? "\u2713" : "\u25CB"} git           ${gitVersion ?? "n\xE3o encontrado"}`);
+  console.log("\n  Autentica\xE7\xE3o");
+  console.log(`  ${session ? "\u2713" : "\u2717"} Token         ${session ? "v\xE1lido" : "n\xE3o logado"}`);
+  if (session) {
+    console.log(`  \u2713 Usu\xE1rio       ${session.userName}`);
+  }
+  console.log("\n  Conectividade");
+  console.log(
+    `  ${connectivity.ok ? "\u2713" : "\u2717"} API           ${connectivity.ok ? `OK (${connectivity.latencyMs}ms)` : "indispon\xEDvel"}`
+  );
+  console.log("\n  LLM Clients");
+  for (const ide of ides) {
+    console.log(
+      `  ${ide.detected ? "\u2713" : "\u25CB"} ${ide.name.padEnd(14)} ${ide.detected ? "detectado" : "n\xE3o detectado"}`
+    );
+  }
+  console.log("");
+});
+
+// src/commands/courses.ts
+import { Command as Command5 } from "commander";
+
+// ../../packages/logger/src/types.ts
+var LOG_LEVELS = {
+  trace: 0,
+  debug: 1,
+  info: 2,
+  warn: 3,
+  error: 4,
+  fatal: 5
+};
+
+// ../../packages/logger/src/context/async-context.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+var asyncLocalStorage = new AsyncLocalStorage();
+function getLogContext() {
+  return asyncLocalStorage.getStore();
+}
+
+// ../../packages/logger/src/formatters/json.ts
+function formatJson(entry) {
+  const { timestamp, level, message, service, environment, context, data, error: error2 } = entry;
+  const output2 = {
+    timestamp,
+    level,
+    message,
+    service,
+    environment,
+    ...context,
+    ...data
+  };
+  if (error2) {
+    output2.error = error2;
+  }
+  return JSON.stringify(output2);
+}
+
+// ../../packages/logger/src/formatters/pretty.ts
+var import_picocolors = __toESM(require_picocolors(), 1);
+var LEVEL_COLORS = {
+  trace: import_picocolors.default.gray,
+  debug: import_picocolors.default.cyan,
+  info: import_picocolors.default.green,
+  warn: import_picocolors.default.yellow,
+  error: import_picocolors.default.red,
+  fatal: (s) => import_picocolors.default.bgRed(import_picocolors.default.white(s))
+};
+var LEVEL_WIDTH = 5;
+function formatTime(timestamp) {
+  const date = new Date(timestamp);
+  const hours = String(date.getUTCHours()).padStart(2, "0");
+  const minutes = String(date.getUTCMinutes()).padStart(2, "0");
+  const seconds = String(date.getUTCSeconds()).padStart(2, "0");
+  return `${hours}:${minutes}:${seconds}`;
+}
+function formatLevel(level) {
+  const colorFn = LEVEL_COLORS[level];
+  return colorFn(level.toUpperCase().padEnd(LEVEL_WIDTH));
+}
+function formatData(data) {
+  const entries = Object.entries(data);
+  if (entries.length === 0) return "";
+  const lines = entries.map(([key, value]) => {
+    const formatted = typeof value === "object" ? JSON.stringify(value) : String(value);
+    return `               ${import_picocolors.default.dim(key + ":")} ${formatted}`;
+  });
+  return "\n" + lines.join("\n");
+}
+function formatPretty(entry) {
+  const { timestamp, level, message, service, context, data, error: error2 } = entry;
+  const time = formatTime(timestamp);
+  const lvl = formatLevel(level);
+  const mod = context.module ? import_picocolors.default.dim(`[${context.module}]`) + " " : "";
+  const svc = import_picocolors.default.dim(`[${service}]`) + " ";
+  let output2 = `${import_picocolors.default.dim(time)} ${lvl} ${svc}${mod}${message}`;
+  const traceInfo = {};
+  if (context.traceId) traceInfo.traceId = context.traceId;
+  if (context.requestId && context.requestId !== context.traceId) {
+    traceInfo.requestId = context.requestId;
+  }
+  if (context.caller) traceInfo.caller = context.caller;
+  if (context.duration !== void 0) traceInfo.duration = `${context.duration}ms`;
+  const allData = { ...traceInfo, ...data };
+  if (Object.keys(allData).length > 0) {
+    output2 += formatData(allData);
+  }
+  if (error2) {
+    output2 += "\n" + import_picocolors.default.red(`               ${error2.name}: ${error2.message}`);
+    if (error2.code) {
+      output2 += import_picocolors.default.dim(` (${error2.code})`);
+    }
+    if (error2.stack) {
+      const stackLines = error2.stack.split("\n").slice(1, 4);
+      output2 += "\n" + stackLines.map((l) => import_picocolors.default.dim(`               ${l.trim()}`)).join("\n");
+    }
+    if (error2.cause) {
+      output2 += "\n" + import_picocolors.default.dim(`               Caused by: ${error2.cause.name}: ${error2.cause.message}`);
+    }
+  }
+  return output2;
+}
+
+// ../../packages/logger/src/sanitize.ts
+var SENSITIVE_FIELDS = [
+  // Authentication
+  "password",
+  "senha",
+  "pwd",
+  "pass",
+  "token",
+  "accessToken",
+  "access_token",
+  "refreshToken",
+  "refresh_token",
+  "apiKey",
+  "api_key",
+  "apikey",
+  "secret",
+  "secretKey",
+  "secret_key",
+  "authorization",
+  "auth",
+  "bearer",
+  // Payment
+  "creditCard",
+  "credit_card",
+  "cardNumber",
+  "card_number",
+  "cvv",
+  "cvc",
+  "securityCode",
+  "security_code",
+  "accountNumber",
+  "account_number",
+  // Personal identification
+  "cpf",
+  "rg",
+  "ssn",
+  "cnh",
+  "passport",
+  "email",
+  "phone",
+  // Crypto
+  "privateKey",
+  "private_key",
+  "privatekey",
+  "mnemonic",
+  "seed",
+  "seedPhrase",
+  "seed_phrase"
+];
+function email(value) {
+  if (!value || typeof value !== "string") return "[INVALID_EMAIL]";
+  const atIndex = value.indexOf("@");
+  if (atIndex === -1) return "[INVALID_EMAIL]";
+  const [user, domain] = [value.slice(0, atIndex), value.slice(atIndex + 1)];
+  if (!user || !domain) return "[INVALID_EMAIL]";
+  const maskedUser = user.length <= 1 ? "*" : user[0] + "*".repeat(Math.min(user.length - 1, 5));
+  return `${maskedUser}@${domain}`;
+}
+function phone(value) {
+  if (!value || typeof value !== "string") return "[INVALID_PHONE]";
+  const digits = value.replace(/\D/g, "");
+  if (digits.length < 4) return "[INVALID_PHONE]";
+  return "*".repeat(digits.length - 4) + digits.slice(-4);
+}
+function cpf(value) {
+  if (!value || typeof value !== "string") return "[INVALID_CPF]";
+  const digits = value.replace(/\D/g, "");
+  if (digits.length !== 11) return "[INVALID_CPF]";
+  return `***.***${digits.slice(6, 9)}-**`;
+}
+function creditCard(value) {
+  if (!value || typeof value !== "string") return "[INVALID_CARD]";
+  const digits = value.replace(/\D/g, "");
+  if (digits.length < 4) return "[INVALID_CARD]";
+  return "*".repeat(digits.length - 4) + digits.slice(-4);
+}
+function ip(value) {
+  if (!value || typeof value !== "string") return "[INVALID_IP]";
+  if (value.includes(":")) {
+    const lastColon = value.lastIndexOf(":");
+    return value.slice(0, lastColon + 1) + "xxxx";
+  }
+  const lastDot = value.lastIndexOf(".");
+  if (lastDot === -1) return "[INVALID_IP]";
+  return value.slice(0, lastDot + 1) + "xxx";
+}
+function token(value) {
+  if (!value || typeof value !== "string") return "[REDACTED]";
+  if (value.length <= 8) return "[REDACTED]";
+  return `${value.slice(0, 4)}...[REDACTED]...${value.slice(-4)}`;
+}
+function isSensitiveKey(key) {
+  const lowerKey = key.toLowerCase();
+  return SENSITIVE_FIELDS.some((field) => {
+    const lowerField = field.toLowerCase();
+    if (lowerKey === lowerField) return true;
+    if (lowerKey.endsWith(lowerField)) return true;
+    const fieldIdx = key.toLowerCase().indexOf(lowerField);
+    if (fieldIdx === 0) {
+      const afterIdx = lowerField.length;
+      if (afterIdx >= key.length) return true;
+      const nextChar = key[afterIdx];
+      if (nextChar && (nextChar === nextChar.toUpperCase() || !/[a-zA-Z]/.test(nextChar))) {
+        return true;
+      }
+    }
+    const patterns = [
+      `_${lowerField}`,
+      `${lowerField}_`,
+      `-${lowerField}`,
+      `${lowerField}-`,
+      `_${lowerField}_`,
+      `-${lowerField}-`
+    ];
+    return patterns.some((p) => lowerKey.includes(p));
+  });
+}
+function object(obj, additionalSensitiveKeys) {
+  if (!obj || typeof obj !== "object") return obj;
+  const sanitized = { ...obj };
+  for (const [key, value] of Object.entries(sanitized)) {
+    const isAdditionalKey = additionalSensitiveKeys?.some(
+      (k) => key.toLowerCase() === k.toLowerCase()
+    );
+    if (isSensitiveKey(key) || isAdditionalKey) {
+      sanitized[key] = "[REDACTED]";
+      continue;
+    }
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      sanitized[key] = object(
+        value,
+        additionalSensitiveKeys
+      );
+      continue;
+    }
+    if (Array.isArray(value)) {
+      sanitized[key] = value.map((item) => {
+        if (item && typeof item === "object" && !Array.isArray(item)) {
+          return object(item, additionalSensitiveKeys);
+        }
+        return item;
+      });
+    }
+  }
+  return sanitized;
+}
+function headers(hdrs) {
+  const sensitiveHeaders = [
+    "authorization",
+    "x-api-key",
+    "x-auth-token",
+    "cookie",
+    "set-cookie"
+  ];
+  const sanitized = { ...hdrs };
+  for (const key of Object.keys(sanitized)) {
+    if (sensitiveHeaders.some((h) => key.toLowerCase() === h)) {
+      sanitized[key] = "[REDACTED]";
+    }
+  }
+  return sanitized;
+}
+var sanitize = {
+  email,
+  phone,
+  cpf,
+  creditCard,
+  ip,
+  token,
+  object,
+  headers,
+  isSensitiveKey
+};
+
+// ../../packages/logger/src/logger.base.ts
+function extractErrorInfo(error2, includeStack) {
+  const info = {
+    name: error2.name,
+    message: error2.message
+  };
+  if (includeStack && error2.stack) {
+    info.stack = error2.stack;
+  }
+  if ("code" in error2 && typeof error2.code === "string") {
+    info.code = error2.code;
+  }
+  if (error2.cause instanceof Error) {
+    info.cause = extractErrorInfo(error2.cause, includeStack);
+  }
+  return info;
+}
+var BaseLogger = class {
+  level;
+  format;
+  module;
+  service;
+  environment;
+  additionalContext;
+  transports;
+  shouldSanitize;
+  sensitiveFields;
+  includeCaller;
+  constructor(options, defaults) {
+    this.level = options.level ?? defaults.level;
+    this.format = options.format ?? defaults.format;
+    this.module = options.module;
+    this.service = options.service ?? defaults.service;
+    this.environment = options.environment ?? defaults.env;
+    this.additionalContext = {};
+    this.transports = [];
+    this.shouldSanitize = options.sanitize ?? true;
+    this.sensitiveFields = options.sensitiveFields;
+    this.includeCaller = options.includeCaller ?? "errors";
+  }
+  /**
+   * Get caller information for error logging (Node.js only).
+   */
+  getCaller() {
+    return void 0;
+  }
+  /**
+   * Flush any buffered logs (e.g., file transport).
+   */
+  flush() {
+  }
+  shouldLog(level) {
+    return LOG_LEVELS[level] >= LOG_LEVELS[this.level];
+  }
+  buildEntry(level, message, data, error2) {
+    const asyncContext = this.getLogContext() ?? {};
+    const context = {
+      ...asyncContext,
+      ...this.additionalContext
+    };
+    if (this.module) {
+      context.module = this.module;
+    }
+    const shouldIncludeCaller = this.includeCaller === true || this.includeCaller === "errors" && (level === "error" || level === "fatal");
+    if (shouldIncludeCaller) {
+      const caller = this.getCaller();
+      if (caller) context.caller = caller;
+    }
+    return {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      message,
+      service: this.service,
+      environment: this.environment,
+      context,
+      data,
+      error: error2
+    };
+  }
+  /**
+   * Normalizes any data type to Record<string, unknown> for structured logging.
+   */
+  normalizeData(data) {
+    if (data === null || data === void 0) {
+      return void 0;
+    }
+    if (data instanceof Error) {
+      return {
+        error: data.message,
+        errorName: data.name,
+        stack: data.stack
+      };
+    }
+    if (typeof data === "string" || typeof data === "number" || typeof data === "boolean") {
+      return { value: data };
+    }
+    if (Array.isArray(data)) {
+      return { items: data };
+    }
+    if (typeof data === "object") {
+      const obj = data;
+      return this.shouldSanitize ? sanitize.object(obj, this.sensitiveFields) : obj;
+    }
+    return { value: String(data) };
+  }
+  log(level, message, data, errorObj) {
+    if (!this.shouldLog(level)) return;
+    const normalizedData = this.normalizeData(data);
+    const errorInfo = errorObj ? extractErrorInfo(errorObj, !this.isProd()) : void 0;
+    const entry = this.buildEntry(level, message, normalizedData, errorInfo);
+    const formatted = this.format === "json" ? formatJson(entry) : formatPretty(entry);
+    for (const transport of this.transports) {
+      transport.log(entry, formatted);
+    }
+    this.flush();
+  }
+  trace(message, ...args) {
+    this.log("trace", message, args.length === 1 ? args[0] : args.length > 1 ? args : void 0);
+  }
+  debug(message, ...args) {
+    this.log("debug", message, args.length === 1 ? args[0] : args.length > 1 ? args : void 0);
+  }
+  info(message, ...args) {
+    this.log("info", message, args.length === 1 ? args[0] : args.length > 1 ? args : void 0);
+  }
+  warn(message, ...args) {
+    this.log("warn", message, args.length === 1 ? args[0] : args.length > 1 ? args : void 0);
+  }
+  error(message, errorOrData, data) {
+    if (errorOrData instanceof Error) {
+      this.log("error", message, data, errorOrData);
+    } else {
+      this.log("error", message, errorOrData);
+    }
+  }
+  /**
+   * Log a fatal error (system-critical).
+   */
+  fatal(message, errorOrData, data) {
+    if (errorOrData instanceof Error) {
+      this.log("fatal", message, data, errorOrData);
+    } else {
+      this.log("fatal", message, errorOrData);
+    }
+  }
+  /**
+   * Get the current trace ID from context.
+   */
+  getTraceId() {
+    const ctx = this.getLogContext();
+    return ctx?.traceId ?? this.additionalContext.traceId;
+  }
+  /**
+   * Get the current span ID from context.
+   */
+  getSpanId() {
+    const ctx = this.getLogContext();
+    return ctx?.spanId ?? this.additionalContext.spanId;
+  }
+  /**
+   * Time an async operation and log its duration.
+   */
+  async time(operation, fn, data) {
+    const start = Date.now();
+    try {
+      const result = await fn();
+      const duration = Date.now() - start;
+      this.info(`${operation} completed`, { ...data, duration, operation });
+      return result;
+    } catch (error2) {
+      const duration = Date.now() - start;
+      this.error(`${operation} failed`, error2, { ...data, duration, operation });
+      throw error2;
+    }
+  }
+  /**
+   * Time a sync operation and log its duration.
+   */
+  timeSync(operation, fn, data) {
+    const start = Date.now();
+    try {
+      const result = fn();
+      const duration = Date.now() - start;
+      this.info(`${operation} completed`, { ...data, duration, operation });
+      return result;
+    } catch (error2) {
+      const duration = Date.now() - start;
+      this.error(`${operation} failed`, error2, { ...data, duration, operation });
+      throw error2;
+    }
+  }
+};
+
+// ../../packages/logger/src/transports/console.ts
+var ConsoleTransport = class {
+  log(entry, formatted) {
+    if (entry.level === "error" || entry.level === "fatal") {
+      process.stderr.write(formatted + "\n");
+    } else {
+      process.stdout.write(formatted + "\n");
+    }
+  }
+};
+
+// ../../packages/logger/src/transports/file.ts
+import { appendFileSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+var FileTransport = class {
+  dir;
+  initialized = false;
+  buffer = [];
+  constructor(options) {
+    this.dir = options.dir;
+  }
+  init() {
+    if (this.initialized) return;
+    if (!existsSync(this.dir)) {
+      mkdirSync(this.dir, { recursive: true });
+    }
+    const gitignore = join(this.dir, ".gitignore");
+    if (!existsSync(gitignore)) {
+      writeFileSync(gitignore, "*.log\n");
+    }
+    this.initialized = true;
+  }
+  log(entry, formatted) {
+    this.init();
+    const line = formatted + "\n";
+    this.buffer.push({ file: "combined.log", content: line });
+    if (entry.level === "error") {
+      this.buffer.push({ file: "error.log", content: line });
+    }
+  }
+  flush() {
+    for (const { file, content } of this.buffer) {
+      const filepath = join(this.dir, file);
+      appendFileSync(filepath, content);
+    }
+    this.buffer = [];
+  }
+};
+
+// ../../packages/logger/src/logger.ts
+function detectEnvironment() {
+  const isProd = process.env.NODE_ENV === "production" || !!process.env.VERCEL || !!process.env.RAILWAY_ENVIRONMENT;
+  let env = process.env.NODE_ENV || "development";
+  if (process.env.VERCEL) env = process.env.VERCEL_ENV || "production";
+  if (process.env.RAILWAY_ENVIRONMENT) env = process.env.RAILWAY_ENVIRONMENT;
+  return { isProd, env };
+}
+function getDefaultFormat() {
+  const override = process.env.LOG_FORMAT;
+  if (override === "json" || override === "pretty") return override;
+  const { isProd } = detectEnvironment();
+  return isProd ? "json" : "pretty";
+}
+function getDefaultLevel() {
+  const override = process.env.LOG_LEVEL;
+  if (override && override in LOG_LEVELS) return override;
+  const { isProd } = detectEnvironment();
+  return isProd ? "info" : "debug";
+}
+function getDefaultService() {
+  return process.env.SERVICE_NAME || process.env.VERCEL_GIT_REPO_SLUG || process.env.RAILWAY_SERVICE_NAME || "unknown-service";
+}
+function getCaller() {
+  const err = new Error();
+  const stack = err.stack?.split("\n");
+  if (!stack) return void 0;
+  for (let i = 3; i < stack.length; i++) {
+    const line = stack[i];
+    if (!line) continue;
+    if (line.includes("/logger/src/")) continue;
+    if (line.includes("@repo/logger")) continue;
+    const match = line.match(/at (?:(.+?) )?\(?(.+?):(\d+):(\d+)\)?/);
+    if (match) {
+      const [, fnName, file, lineNum] = match;
+      const fileName = file?.split("/").pop() || file;
+      return fnName ? `${fileName}:${lineNum}:${fnName}` : `${fileName}:${lineNum}`;
+    }
+  }
+  return void 0;
+}
+var Logger = class _Logger extends BaseLogger {
+  fileTransport;
+  _isProd;
+  constructor(options = {}) {
+    const { isProd, env } = detectEnvironment();
+    super(options, {
+      level: getDefaultLevel(),
+      format: getDefaultFormat(),
+      service: getDefaultService(),
+      env
+    });
+    this._isProd = isProd;
+    this.transports = [new ConsoleTransport()];
+    if (!isProd && !process.env.VERCEL && !process.env.RAILWAY_ENVIRONMENT) {
+      this.fileTransport = new FileTransport({ dir: "logs" });
+      this.transports.push(this.fileTransport);
+    }
+  }
+  getLogContext() {
+    return getLogContext();
+  }
+  isProd() {
+    return this._isProd;
+  }
+  getCaller() {
+    return getCaller();
+  }
+  flush() {
+    this.fileTransport?.flush();
+  }
+  /**
+   * Create a child logger with additional context.
+   * Child shares transports with parent.
+   */
+  child(context) {
+    const child = new _Logger({
+      level: this.level,
+      format: this.format,
+      module: this.module,
+      service: this.service,
+      environment: this.environment,
+      sanitize: this.shouldSanitize,
+      sensitiveFields: this.sensitiveFields,
+      includeCaller: this.includeCaller
+    });
+    child.additionalContext = { ...this.additionalContext, ...context };
+    child.transports = this.transports;
+    child.fileTransport = this.fileTransport;
+    return child;
+  }
+};
+
+// ../../packages/logger/src/index.ts
+var logger = new Logger();
+function createLogger(module, options) {
+  return new Logger({ ...options, module });
+}
+
+// ../../packages/tostudy-core/src/courses/list-courses.ts
+async function listCourses(input, deps) {
+  deps.logger.info("tostudy-core: listCourses", { userId: input.userId });
+  return deps.data.courses.list(input.userId);
+}
+
+// ../../packages/tostudy-core/src/courses/select-course.ts
+async function selectCourse(input, deps) {
+  deps.logger.info("tostudy-core: selectCourse", input);
+  return deps.data.courses.select(input.userId, input.courseId);
+}
+
+// ../../packages/tostudy-core/src/courses/get-progress.ts
+async function getProgress(input, deps) {
+  deps.logger.info("tostudy-core: getProgress", input);
+  return deps.data.courses.getProgress(input.enrollmentId);
+}
+
+// ../../packages/tostudy-core/src/adapters/http.ts
+var CliApiError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = "CliApiError";
+  }
+};
+async function apiFetch(url, token2, init) {
+  const response = await fetch(url, {
+    ...init,
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token2}`,
+      ...init?.headers
+    }
+  });
+  const body = await response.json();
+  if (!response.ok) {
+    throw new CliApiError(body.error ?? `API error ${response.status}`, response.status);
+  }
+  return body;
+}
+function createHttpProvider(apiUrl, token2) {
+  const base = `${apiUrl}/api/cli`;
+  return {
+    courses: {
+      list: async (_userId) => {
+        const res = await apiFetch(`${base}/courses`, token2);
+        return res.courses;
+      },
+      select: async (_userId, courseId) => {
+        const res = await apiFetch(`${base}/courses/select`, token2, {
+          method: "POST",
+          body: JSON.stringify({ courseId })
+        });
+        return res.course;
+      },
+      getProgress: async (enrollmentId) => {
+        return apiFetch(`${base}/progress?enrollmentId=${encodeURIComponent(enrollmentId)}`, token2);
+      }
+    },
+    lessons: {
+      next: async (enrollmentId, userConfirmation) => {
+        return apiFetch(`${base}/lessons/next`, token2, {
+          method: "POST",
+          body: JSON.stringify({ enrollmentId, userConfirmation })
+        });
+      },
+      getContent: async (lessonId, enrollmentId) => {
+        const params = new URLSearchParams({ lessonId });
+        if (enrollmentId) params.set("enrollmentId", enrollmentId);
+        return apiFetch(`${base}/lessons/content?${params.toString()}`, token2);
+      },
+      getHint: async (_userId, enrollmentId) => {
+        return apiFetch(`${base}/lessons/hint`, token2, {
+          method: "POST",
+          body: JSON.stringify({ enrollmentId })
+        });
+      },
+      startModule: async (enrollmentId) => {
+        return apiFetch(`${base}/modules/start`, token2, {
+          method: "POST",
+          body: JSON.stringify({ enrollmentId })
+        });
+      },
+      startNextModule: async (enrollmentId) => {
+        return apiFetch(`${base}/modules/start-next`, token2, {
+          method: "POST",
+          body: JSON.stringify({ enrollmentId })
+        });
+      }
+    },
+    exercises: {
+      validate: async (lessonId, solution, _userId, enrollmentId) => {
+        return apiFetch(`${base}/exercises/validate`, token2, {
+          method: "POST",
+          body: JSON.stringify({ lessonId, solution, enrollmentId })
+        });
+      }
+    }
+  };
+}
+
+// src/commands/courses.ts
+var logger2 = createLogger("cli:courses");
+var coursesCommand = new Command5("courses").description("List your enrolled courses with progress").option("--json", "Output structured JSON").action(async (opts) => {
+  try {
+    const session = await requireSession();
+    const data = createHttpProvider(session.apiUrl, session.token);
+    const deps = { data, logger: logger2 };
+    const courses = await listCourses({ userId: session.userId }, deps);
+    if (opts.json) {
+      output(courses, { json: true });
+    } else {
+      output(formatCourseList(courses), { json: false });
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    error(msg);
+  }
+});
+
+// src/commands/select.ts
+import { Command as Command6 } from "commander";
+var logger3 = createLogger("cli:select");
+var selectCommand = new Command6("select").description("Activate a course by ID or list index number").argument("<course>", "Course ID (UUID) or index number from `tostudy courses`").option("--json", "Output structured JSON").action(async (course, opts) => {
+  try {
+    const session = await requireSession();
+    const data = createHttpProvider(session.apiUrl, session.token);
+    const deps = { data, logger: logger3 };
+    const courses = await listCourses({ userId: session.userId }, deps);
+    let courseId = course;
+    let enrollmentId = "";
+    if (/^\d+$/.test(course)) {
+      const idx = parseInt(course, 10) - 1;
+      if (idx < 0 || idx >= courses.length) {
+        error(`\xCDndice ${course} inv\xE1lido. Voc\xEA tem ${courses.length} curso(s).`);
+      }
+      const found = courses[idx];
+      courseId = found.courseId;
+      enrollmentId = found.enrollmentId;
+    } else {
+      const found = courses.find((c) => c.courseId === course);
+      if (found) {
+        enrollmentId = found.enrollmentId;
+      }
+    }
+    const detail = await selectCourse({ userId: session.userId, courseId }, deps);
+    await setActiveCourse({
+      courseId: detail.courseId,
+      courseTitle: detail.courseTitle,
+      enrollmentId
+    });
+    if (opts.json) {
+      output({ ...detail, enrollmentId }, { json: true });
+    } else {
+      output(
+        [
+          `\u2713 Curso ativado: ${detail.courseTitle}`,
+          `  Progresso: ${detail.progress}%  |  ${detail.moduleCount} m\xF3dulos  |  ${detail.lessonCount} li\xE7\xF5es`,
+          "",
+          "\u2192 tostudy progress  para ver seu progresso detalhado",
+          "\u2192 tostudy start     para come\xE7ar o m\xF3dulo atual",
+          "\u2192 tostudy next      para avan\xE7ar para a pr\xF3xima li\xE7\xE3o"
+        ].join("\n"),
+        { json: false }
+      );
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    error(msg);
+  }
+});
+
+// src/commands/progress.ts
+import { Command as Command7 } from "commander";
+var logger4 = createLogger("cli:progress");
+var progressCommand = new Command7("progress").description("Show your progress in the active course").option("--json", "Output structured JSON").action(async (opts) => {
+  try {
+    const session = await requireSession();
+    const activeCourse = await requireActiveCourse();
+    const data = createHttpProvider(session.apiUrl, session.token);
+    const deps = { data, logger: logger4 };
+    const progress = await getProgress({ enrollmentId: activeCourse.enrollmentId }, deps);
+    if (opts.json) {
+      output(progress, { json: true });
+    } else {
+      output(formatProgress(progress), { json: false });
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    error(msg);
+  }
+});
+
+// src/commands/start.ts
+import { Command as Command8 } from "commander";
+
+// ../../packages/tostudy-core/src/lessons/next-lesson.ts
+async function nextLesson(input, deps) {
+  deps.logger.info("tostudy-core: nextLesson", { enrollmentId: input.enrollmentId });
+  return deps.data.lessons.next(input.enrollmentId, input.userConfirmation);
+}
+
+// ../../packages/tostudy-core/src/lessons/get-content.ts
+async function getContent(input, deps) {
+  deps.logger.info("tostudy-core: getContent", { lessonId: input.lessonId });
+  return deps.data.lessons.getContent(input.lessonId, input.enrollmentId);
+}
+
+// ../../packages/tostudy-core/src/lessons/get-hint.ts
+async function getHint(input, deps) {
+  deps.logger.info("tostudy-core: getHint", { userId: input.userId });
+  return deps.data.lessons.getHint(input.userId, input.enrollmentId);
+}
+
+// ../../packages/tostudy-core/src/lessons/start-module.ts
+async function startModule(input, deps) {
+  deps.logger.info("tostudy-core: startModule", { enrollmentId: input.enrollmentId });
+  return deps.data.lessons.startModule(input.enrollmentId);
+}
+
+// ../../packages/tostudy-core/src/lessons/start-next-module.ts
+async function startNextModule(input, deps) {
+  deps.logger.info("tostudy-core: startNextModule", { enrollmentId: input.enrollmentId });
+  return deps.data.lessons.startNextModule(input.enrollmentId);
+}
+
+// src/commands/start.ts
+var logger5 = createLogger("cli:start");
+var startCommand = new Command8("start").description("Start (or resume) the current module of the active course").option("--json", "Output structured JSON").action(async (opts) => {
+  try {
+    const session = await requireSession();
+    const activeCourse = await requireActiveCourse();
+    const data = createHttpProvider(session.apiUrl, session.token);
+    const deps = { data, logger: logger5 };
+    const moduleData = await startModule({ enrollmentId: activeCourse.enrollmentId }, deps);
+    if (opts.json) {
+      output(moduleData, { json: true });
+    } else {
+      output(formatModuleStart(moduleData), { json: false });
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    error(msg);
+  }
+});
+
+// src/commands/start-next.ts
+import { Command as Command9 } from "commander";
+var logger6 = createLogger("cli:start-next");
+var startNextCommand = new Command9("start-next").description("Transition to the next module after completing the current one").option("--json", "Output structured JSON").action(async (opts) => {
+  try {
+    const session = await requireSession();
+    const activeCourse = await requireActiveCourse();
+    const data = createHttpProvider(session.apiUrl, session.token);
+    const deps = { data, logger: logger6 };
+    const moduleData = await startNextModule({ enrollmentId: activeCourse.enrollmentId }, deps);
+    if (opts.json) {
+      output(moduleData, { json: true });
+    } else {
+      output(formatModuleStart(moduleData), { json: false });
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    error(msg);
+  }
+});
+
+// src/commands/next.ts
+import { Command as Command10 } from "commander";
+var logger7 = createLogger("cli:next");
+var nextCommand = new Command10("next").description("Advance to the next lesson in the active course").option("--json", "Output structured JSON").action(async (opts) => {
+  try {
+    const session = await requireSession();
+    const activeCourse = await requireActiveCourse();
+    const data = createHttpProvider(session.apiUrl, session.token);
+    const deps = { data, logger: logger7 };
+    const lessonData = await nextLesson(
+      { enrollmentId: activeCourse.enrollmentId, userConfirmation: "cli-next" },
+      deps
+    );
+    if (opts.json) {
+      output(lessonData, { json: true });
+    } else {
+      output(formatLesson(lessonData), { json: false });
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    error(msg);
+  }
+});
+
+// src/commands/lesson.ts
+import { Command as Command11 } from "commander";
+var logger8 = createLogger("cli:lesson");
+function formatLessonContent(data) {
+  const lines = [
+    `\u2501\u2501\u2501 Li\xE7\xE3o: ${data.title} \u2501\u2501\u2501`,
+    "",
+    `Tipo: ${data.type}  |  Dura\xE7\xE3o estimada: ~${data.estimatedTimeMinutes} min`,
+    "",
+    data.content
+  ];
+  if (data.acceptanceCriteria) {
+    lines.push("", "Crit\xE9rios de aceita\xE7\xE3o:", data.acceptanceCriteria);
+  }
+  if (data.hints && data.hints.length > 0) {
+    lines.push("", `Dicas dispon\xEDveis: ${data.hints.length}`);
+  }
+  lines.push(
+    "",
+    "\u2192 tostudy validate <arquivo>  para validar sua solu\xE7\xE3o",
+    "\u2192 tostudy hint                para obter uma dica",
+    "\u2192 tostudy next                para avan\xE7ar para a pr\xF3xima li\xE7\xE3o"
+  );
+  return lines.join("\n");
+}
+var lessonCommand = new Command11("lesson").description("Show the content of the current lesson").option("--json", "Output structured JSON").action(async (opts) => {
+  try {
+    const session = await requireSession();
+    const activeCourse = await requireActiveCourse();
+    const data = createHttpProvider(session.apiUrl, session.token);
+    const deps = { data, logger: logger8 };
+    const lessonId = activeCourse.currentLessonId;
+    if (!lessonId) {
+      error("Nenhuma li\xE7\xE3o ativa encontrada. Rode: tostudy start  ou  tostudy next");
+    }
+    const content = await getContent({ lessonId, enrollmentId: activeCourse.enrollmentId }, deps);
+    if (opts.json) {
+      output(content, { json: true });
+    } else {
+      output(formatLessonContent(content), { json: false });
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    error(msg);
+  }
+});
+
+// src/commands/hint.ts
+import { Command as Command12 } from "commander";
+var logger9 = createLogger("cli:hint");
+var hintCommand = new Command12("hint").description("Get a progressive hint for the current exercise").option("--json", "Output structured JSON").action(async (opts) => {
+  try {
+    const session = await requireSession();
+    const activeCourse = await requireActiveCourse();
+    const data = createHttpProvider(session.apiUrl, session.token);
+    const deps = { data, logger: logger9 };
+    const hint = await getHint(
+      { userId: session.userId, enrollmentId: activeCourse.enrollmentId },
+      deps
+    );
+    if (opts.json) {
+      output(hint, { json: true });
+    } else {
+      output(formatHint(hint), { json: false });
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    error(msg);
+  }
+});
+
+// src/commands/validate.ts
+import fs3 from "node:fs";
+import { Command as Command13 } from "commander";
+
+// ../../packages/tostudy-core/src/exercises/validate-solution.ts
+async function validateSolution(input, deps) {
+  deps.logger.info("tostudy-core: validateSolution", { lessonId: input.lessonId });
+  return deps.data.exercises.validate(
+    input.lessonId,
+    input.solution,
+    input.userId,
+    input.enrollmentId
+  );
+}
+
+// src/commands/validate.ts
+var logger10 = createLogger("cli:validate");
+var validateCommand = new Command13("validate").description("Validate your solution for the current exercise").argument("[file]", "Path to the solution file to read").option("--stdin", "Read solution from stdin instead of a file").option("--json", "Output structured JSON").action(async (file, opts) => {
+  try {
+    const session = await requireSession();
+    const activeCourse = await requireActiveCourse();
+    const lessonId = activeCourse.currentLessonId;
+    if (!lessonId) {
+      error("Nenhuma li\xE7\xE3o ativa encontrada. Rode: tostudy start  ou  tostudy next");
+    }
+    let solution;
+    if (opts.stdin) {
+      solution = fs3.readFileSync("/dev/stdin", "utf-8");
+    } else if (file) {
+      if (!fs3.existsSync(file)) {
+        error(`Arquivo n\xE3o encontrado: ${file}`);
+      }
+      solution = fs3.readFileSync(file, "utf-8");
+    } else {
+      error("Forne\xE7a um arquivo ou use --stdin.\n\nExemplo: tostudy validate resposta.md");
+    }
+    const data = createHttpProvider(session.apiUrl, session.token);
+    const deps = { data, logger: logger10 };
+    const result = await validateSolution(
+      {
+        lessonId,
+        solution,
+        userId: session.userId,
+        enrollmentId: activeCourse.enrollmentId
+      },
+      deps
+    );
+    if (opts.json) {
+      output(result, { json: true });
+    } else {
+      output(formatValidation(result), { json: false });
+    }
+    process.exit(result.passed ? 0 : 1);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    error(msg);
+  }
+});
+
+// src/commands/menu.ts
+import { Command as Command14 } from "commander";
+var menuCommand = new Command14("menu").description("Show available commands and current study context").action(async () => {
+  const session = await getSession();
+  const activeCourse = session ? await getActiveCourse() : null;
+  const lines = [
+    "\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510",
+    "\u2502             ToStudy CLI \u2014 Menu              \u2502",
+    "\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518",
+    ""
+  ];
+  if (!session) {
+    lines.push(
+      "  Status: N\xE3o autenticado",
+      "",
+      "  Para come\xE7ar:",
+      "    tostudy login          Autenticar com sua conta ToStudy",
+      ""
+    );
+  } else {
+    lines.push(`  Usu\xE1rio: ${session.userName}`);
+    if (activeCourse) {
+      lines.push(`  Curso ativo: ${activeCourse.courseTitle}`, "");
+    } else {
+      lines.push(
+        "  Curso ativo: (nenhum)",
+        "  \u2192 tostudy courses   para ver seus cursos",
+        "  \u2192 tostudy select <n\xFAmero>  para ativar um curso",
+        ""
+      );
+    }
+    lines.push(
+      "  \u2500\u2500\u2500 Navega\xE7\xE3o \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
+      "    tostudy courses        Listar seus cursos",
+      "    tostudy select <id>    Ativar um curso",
+      "    tostudy progress       Ver progresso do curso ativo",
+      "",
+      "  \u2500\u2500\u2500 Estudo \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
+      "    tostudy start          Iniciar/retomar o m\xF3dulo atual",
+      "    tostudy start-next     Avan\xE7ar para o pr\xF3ximo m\xF3dulo",
+      "    tostudy next           Avan\xE7ar para a pr\xF3xima li\xE7\xE3o",
+      "    tostudy lesson         Ver conte\xFAdo da li\xE7\xE3o atual",
+      "",
+      "  \u2500\u2500\u2500 Exerc\xEDcios \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
+      "    tostudy validate <arquivo>  Validar sua solu\xE7\xE3o",
+      "    tostudy hint                Obter uma dica progressiva",
+      "",
+      "  \u2500\u2500\u2500 Dicas r\xE1pidas \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
+      "    Adicione --json a qualquer comando para sa\xEDda em JSON",
+      "    Adicione --help a qualquer comando para ver op\xE7\xF5es",
+      ""
+    );
+  }
+  output(lines.join("\n"), { json: false });
+});
+
+// src/cli.ts
+function createProgram() {
+  const program2 = new Command15();
+  program2.name("tostudy").description("ToStudy CLI \u2014 study courses from the terminal").version("0.1.0").option("--json", "Output structured JSON (for LLM agents)").option("--verbose", "Enable debug output").option("--course <id>", "Override active course ID");
+  program2.addCommand(setupCommand);
+  program2.addCommand(doctorCommand);
+  program2.addCommand(loginCommand);
+  program2.addCommand(logoutCommand);
+  program2.addCommand(coursesCommand);
+  program2.addCommand(selectCommand);
+  program2.addCommand(progressCommand);
+  program2.addCommand(startCommand);
+  program2.addCommand(startNextCommand);
+  program2.addCommand(nextCommand);
+  program2.addCommand(lessonCommand);
+  program2.addCommand(hintCommand);
+  program2.addCommand(validateCommand);
+  program2.addCommand(menuCommand);
+  return program2;
+}
+
+// src/cli-entry.ts
+var program = createProgram();
+program.parse();
+//# sourceMappingURL=cli.js.map