minerva-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,2097 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import chalk5 from "chalk";
+
+// src/program.ts
+import { Command as Command20 } from "commander";
+
+// src/config/constants.ts
+var APP_NAME = "minerva";
+var APP_DESCRIPTION = "Organiza\xE7\xE3o acad\xEAmica para estudantes de ADS da FATEC \u{1F989}";
+var APP_VERSION = "0.1.0";
+var DEFAULT_VAULT_DIRNAME = "fatec-ads";
+var MATRIZ_URL = "https://fatectq.cps.sp.gov.br/matriz-curricular-ads/";
+
+// src/commands/cheatsheet.ts
+import path5 from "path";
+import { Command } from "commander";
+
+// src/services/config.ts
+import path2 from "path";
+import fs2 from "fs-extra";
+
+// src/types/index.ts
+import { z } from "zod";
+var disciplinaSchema = z.object({
+  nome: z.string().min(1),
+  /** Carga horária em aulas, conforme a matriz oficial. */
+  aulas: z.number().int().positive()
+});
+var semestreSchema = z.object({
+  numero: z.number().int().min(1).max(6),
+  disciplinas: z.array(disciplinaSchema).min(1)
+});
+var matrizSchema = z.object({
+  curso: z.string(),
+  instituicao: z.string(),
+  fonte: z.string().url(),
+  atualizadaEm: z.string(),
+  semestres: z.array(semestreSchema).length(6)
+});
+var minervaConfigSchema = z.object({
+  versao: z.string(),
+  aluno: z.string(),
+  semestreAtual: z.number().int().min(1).max(6),
+  criadoEm: z.string(),
+  horasEstudadas: z.number().nonnegative().default(0)
+});
+
+// src/utils/paths.ts
+import path from "path";
+import { fileURLToPath } from "url";
+import fs from "fs-extra";
+var CONFIG_FILE = "minerva.json";
+var VAULT_FOLDERS = [
+  "dashboard",
+  "roadmap",
+  "curriculo",
+  "portfolio",
+  "entrevistas",
+  "estagio",
+  "certificados",
+  "artigos",
+  "livros",
+  "snippets",
+  "flashcards",
+  "cheatsheets",
+  "laboratorio",
+  "desafios",
+  "templates",
+  "projetos-pessoais"
+];
+var DISCIPLINA_FOLDERS = [
+  "Aulas",
+  "Projetos",
+  "Trabalhos",
+  "Exercicios",
+  "Resumos",
+  "Flashcards",
+  "Provas",
+  "Laboratorio",
+  "Referencias"
+];
+function semestreDir(root, numero) {
+  return path.join(root, `${numero}-semestre`);
+}
+function builtinTemplatesDir() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    path.resolve(here, "../templates"),
+    path.resolve(here, "../../templates"),
+    path.resolve(here, "../../src/templates")
+  ];
+  for (const candidate of candidates) {
+    if (fs.existsSync(path.join(candidate, "aula.hbs"))) return candidate;
+  }
+  throw new Error(
+    "Templates embutidos n\xE3o encontrados. Reinstale a minerva-cli."
+  );
+}
+async function findVaultRoot(cwd) {
+  let dir = path.resolve(cwd);
+  for (; ; ) {
+    if (await fs.pathExists(path.join(dir, CONFIG_FILE))) return dir;
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+// src/services/config.ts
+async function loadConfig(root) {
+  const raw = await fs2.readJson(path2.join(root, CONFIG_FILE));
+  return minervaConfigSchema.parse(raw);
+}
+async function saveConfig(root, config) {
+  await fs2.writeJson(path2.join(root, CONFIG_FILE), config, { spaces: 4 });
+}
+async function requireVault(cwd = process.cwd()) {
+  const root = await findVaultRoot(cwd);
+  if (!root) {
+    throw new Error(
+      'Nenhum vault Minerva encontrado. Rode "minerva init" primeiro (ou entre na pasta do seu vault).'
+    );
+  }
+  return { root, config: await loadConfig(root) };
+}
+
+// src/services/template.ts
+import path3 from "path";
+import fs3 from "fs-extra";
+import Handlebars from "handlebars";
+
+// src/utils/slug.ts
+function slugify(text) {
+  return text.normalize("NFD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function safeFolderName(text) {
+  return text.replace(/[\\/:*?"<>|]/g, " ").replace(/\s+/g, " ").trim();
+}
+function todayISO(date = /* @__PURE__ */ new Date()) {
+  return date.toISOString().slice(0, 10);
+}
+
+// src/services/template.ts
+var handlebars = Handlebars.create();
+handlebars.registerHelper("hoje", () => todayISO());
+async function resolveTemplate(name, vaultRoot) {
+  const filename = `${name}.hbs`;
+  if (vaultRoot) {
+    const custom = path3.join(vaultRoot, "templates", filename);
+    if (await fs3.pathExists(custom)) return fs3.readFile(custom, "utf8");
+  }
+  return fs3.readFile(path3.join(builtinTemplatesDir(), filename), "utf8");
+}
+async function renderTemplate(name, data, vaultRoot) {
+  const source = await resolveTemplate(name, vaultRoot);
+  return handlebars.compile(source)(data);
+}
+async function renderToFile(name, data, destination, vaultRoot) {
+  if (await fs3.pathExists(destination)) {
+    throw new Error(`Arquivo j\xE1 existe: ${destination}`);
+  }
+  const content = await renderTemplate(name, data, vaultRoot);
+  await fs3.outputFile(destination, content, "utf8");
+}
+
+// src/utils/logger.ts
+import chalk from "chalk";
+import ora from "ora";
+var logger = {
+  info(message) {
+    console.log(`${chalk.blue("\u2139")} ${message}`);
+  },
+  success(message) {
+    console.log(`${chalk.green("\u2714")} ${message}`);
+  },
+  warn(message) {
+    console.warn(`${chalk.yellow("\u26A0")} ${message}`);
+  },
+  error(message) {
+    console.error(`${chalk.red("\u2716")} ${chalk.red(message)}`);
+  },
+  title(message) {
+    console.log(`
+${chalk.bold.magenta("\u{1F989} " + message)}
+`);
+  },
+  item(message) {
+    console.log(`  ${chalk.dim("\u2022")} ${message}`);
+  },
+  blank() {
+    console.log();
+  }
+};
+function spinner(text) {
+  return ora({ text, color: "magenta" });
+}
+function progressBar(current, total, width = 20) {
+  const ratio = total === 0 ? 0 : Math.min(Math.max(current / total, 0), 1);
+  const filled = Math.round(ratio * width);
+  const bar = "\u2588".repeat(filled) + "\u2591".repeat(width - filled);
+  return `[${bar}] ${Math.round(ratio * 100)}%`;
+}
+
+// src/utils/prompts.ts
+import { input, number, select } from "@inquirer/prompts";
+
+// src/services/matriz.ts
+import path4 from "path";
+import fs4 from "fs-extra";
+
+// src/data/matriz.ts
+var matrizOficial = {
+  curso: "An\xE1lise e Desenvolvimento de Sistemas",
+  instituicao: "FATEC Taquaritinga",
+  fonte: "https://fatectq.cps.sp.gov.br/matriz-curricular-ads/",
+  atualizadaEm: "2026-07-13",
+  semestres: [
+    {
+      numero: 1,
+      disciplinas: [
+        { nome: "Programa\xE7\xE3o em Microinform\xE1tica", aulas: 80 },
+        { nome: "Sistemas de Informa\xE7\xE3o", aulas: 80 },
+        { nome: "Algoritmos e L\xF3gica de Programa\xE7\xE3o", aulas: 80 },
+        {
+          nome: "Arquitetura e Organiza\xE7\xE3o de Computadores",
+          aulas: 80
+        },
+        { nome: "Administra\xE7\xE3o Geral", aulas: 80 },
+        { nome: "Matem\xE1tica Discreta", aulas: 80 },
+        { nome: "Comunica\xE7\xE3o e Express\xE3o", aulas: 80 },
+        { nome: "Ingl\xEAs I", aulas: 40 }
+      ]
+    },
+    {
+      numero: 2,
+      disciplinas: [
+        { nome: "Engenharia de Software I", aulas: 80 },
+        { nome: "Linguagem de Programa\xE7\xE3o", aulas: 80 },
+        { nome: "Programa\xE7\xE3o de Scripts", aulas: 80 },
+        { nome: "Sistemas Operacionais I", aulas: 80 },
+        { nome: "Laborat\xF3rio de Hardware", aulas: 40 },
+        { nome: "Contabilidade", aulas: 40 },
+        { nome: "Estat\xEDstica Aplicada", aulas: 80 },
+        { nome: "C\xE1lculo", aulas: 80 },
+        { nome: "Ingl\xEAs II", aulas: 40 }
+      ]
+    },
+    {
+      numero: 3,
+      disciplinas: [
+        { nome: "Engenharia de Software II", aulas: 80 },
+        { nome: "Intera\xE7\xE3o Humano Computador", aulas: 40 },
+        { nome: "Programa\xE7\xE3o Web", aulas: 80 },
+        { nome: "Sistemas Operacionais II", aulas: 80 },
+        { nome: "Estruturas de Dados", aulas: 80 },
+        { nome: "Banco de Dados", aulas: 80 },
+        { nome: "Economia e Finan\xE7as", aulas: 40 },
+        { nome: "Programa\xE7\xE3o Linear e Aplica\xE7\xF5es", aulas: 80 },
+        { nome: "Ingl\xEAs III", aulas: 40 }
+      ]
+    },
+    {
+      numero: 4,
+      disciplinas: [
+        { nome: "Engenharia de Software III", aulas: 80 },
+        { nome: "Programa\xE7\xE3o Orientada a Objetos", aulas: 80 },
+        { nome: "Redes de Computadores", aulas: 80 },
+        { nome: "Seguran\xE7a da Informa\xE7\xE3o", aulas: 40 },
+        { nome: "Programa\xE7\xE3o para Banco de Dados", aulas: 80 },
+        { nome: "Laborat\xF3rio de Banco de Dados", aulas: 80 },
+        { nome: "Gest\xE3o de Projetos", aulas: 80 },
+        { nome: "Sociedade e Tecnologia", aulas: 40 },
+        { nome: "Ingl\xEAs IV", aulas: 40 }
+      ]
+    },
+    {
+      numero: 5,
+      disciplinas: [
+        { nome: "Laborat\xF3rio de Engenharia de Software", aulas: 80 },
+        { nome: "Gest\xE3o de Equipes", aulas: 40 },
+        { nome: "T\xF3picos Especiais em Inform\xE1tica", aulas: 80 },
+        { nome: "Empreendedorismo", aulas: 40 },
+        {
+          nome: "Metodologia da Pesquisa Cient\xEDfico-Tecnol\xF3gica",
+          aulas: 40
+        },
+        { nome: "Ingl\xEAs V", aulas: 40 },
+        { nome: "Trabalho de Gradua\xE7\xE3o I", aulas: 80 }
+      ]
+    },
+    {
+      numero: 6,
+      disciplinas: [
+        { nome: "\xC9tica e Responsabilidade Profissional", aulas: 40 },
+        { nome: "Auditoria de Sistemas", aulas: 80 },
+        {
+          nome: "Gest\xE3o e Governan\xE7a de Tecnologia da Informa\xE7\xE3o",
+          aulas: 80
+        },
+        { nome: "Ingl\xEAs VI", aulas: 40 },
+        { nome: "Trabalho de Gradua\xE7\xE3o II", aulas: 80 },
+        { nome: "Est\xE1gio Supervisionado", aulas: 240 }
+      ]
+    }
+  ]
+};
+
+// src/services/matriz.ts
+var MATRIZ_FILE = path4.join("curriculo", "matriz.json");
+async function loadMatriz(vaultRoot) {
+  if (vaultRoot) {
+    const file = path4.join(vaultRoot, MATRIZ_FILE);
+    if (await fs4.pathExists(file)) {
+      const raw = await fs4.readJson(file);
+      return matrizSchema.parse(raw);
+    }
+  }
+  return matrizOficial;
+}
+async function saveMatriz(vaultRoot, matriz) {
+  await fs4.outputJson(path4.join(vaultRoot, MATRIZ_FILE), matriz, {
+    spaces: 4
+  });
+}
+function getSemestre(matriz, numero) {
+  const semestre = matriz.semestres.find((s) => s.numero === numero);
+  if (!semestre) {
+    throw new Error(`Semestre inv\xE1lido: ${numero}. Use um valor de 1 a 6.`);
+  }
+  return semestre;
+}
+function parseMatrizHtml(html, fonte) {
+  const text = html.replace(/<script[\s\S]*?<\/script>/gi, " ").replace(/<style[\s\S]*?<\/style>/gi, " ").replace(/<[^>]+>/g, "\n").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&#8211;|&ndash;/g, "\u2013");
+  const lines = text.split("\n").map((line) => line.trim()).filter(Boolean);
+  const semestres = [];
+  let atual = null;
+  for (const line of lines) {
+    const header = /^(\d)\s*[ºo°]?\s*semestre/i.exec(line);
+    if (header) {
+      const numero = Number(header[1]);
+      if (numero >= 1 && numero <= 6) {
+        atual = { numero, disciplinas: [] };
+        semestres.push(atual);
+      }
+      continue;
+    }
+    const item = /^(.+?)\s*[–—-]\s*(\d+)\s*aulas?/i.exec(line);
+    if (item && atual) {
+      atual.disciplinas.push({
+        nome: item[1].trim(),
+        aulas: Number(item[2])
+      });
+    }
+  }
+  return matrizSchema.parse({
+    curso: matrizOficial.curso,
+    instituicao: matrizOficial.instituicao,
+    fonte,
+    atualizadaEm: todayISO(),
+    semestres
+  });
+}
+async function fetchMatriz(url = matrizOficial.fonte) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Falha ao baixar a matriz (HTTP ${response.status}).`);
+  }
+  try {
+    return parseMatrizHtml(await response.text(), url);
+  } catch (cause) {
+    throw new Error(
+      "N\xE3o consegui interpretar a p\xE1gina da FATEC (o layout pode ter mudado). A matriz embutida na CLI continua v\xE1lida.",
+      { cause }
+    );
+  }
+}
+
+// src/utils/prompts.ts
+async function pickDisciplina(matriz, semestre, preset) {
+  const disciplinas = getSemestre(matriz, semestre).disciplinas;
+  if (preset) {
+    const found = disciplinas.find(
+      (d) => d.nome.toLowerCase() === preset.toLowerCase()
+    );
+    if (found) return found.nome;
+  }
+  return select({
+    message: `Disciplina (${semestre}\xBA semestre):`,
+    choices: disciplinas.map((d) => ({ value: d.nome }))
+  });
+}
+async function pickSemestre(defaultValue) {
+  const value = await number({
+    message: "Semestre (1-6):",
+    default: defaultValue,
+    min: 1,
+    max: 6
+  });
+  return value ?? defaultValue;
+}
+async function askTitulo(message) {
+  return input({
+    message,
+    validate: (value) => value.trim().length > 0 || "O t\xEDtulo n\xE3o pode ficar vazio."
+  });
+}
+
+// src/commands/cheatsheet.ts
+function cheatsheetCommand() {
+  return new Command("cheatsheet").description("Cria uma cheatsheet avulsa (ex.: Git, SQL, Linux)").argument("[titulo]", "assunto da cheatsheet").action(async (titulo) => {
+    const vault = await requireVault();
+    const tituloFinal = titulo ?? await askTitulo("Assunto da cheatsheet:");
+    const destination = path5.join(
+      vault.root,
+      "cheatsheets",
+      `${slugify(tituloFinal)}.md`
+    );
+    const spin = spinner("Criando cheatsheet...").start();
+    try {
+      await renderToFile(
+        "cheatsheet",
+        { titulo: tituloFinal, disciplina: "" },
+        destination,
+        vault.root
+      );
+      spin.succeed("Cheatsheet criada!");
+      logger.item(path5.relative(vault.root, destination));
+    } catch (error) {
+      spin.fail("N\xE3o consegui criar a cheatsheet.");
+      throw error;
+    }
+  });
+}
+
+// src/commands/commit.ts
+import { Command as Command2 } from "commander";
+
+// src/services/git.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var exec = promisify(execFile);
+async function isGitRepo(cwd) {
+  try {
+    await exec("git", ["rev-parse", "--git-dir"], { cwd });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function commitVault(root, message) {
+  if (!await isGitRepo(root)) {
+    throw new Error(
+      'O vault n\xE3o \xE9 um reposit\xF3rio Git. Rode "git init" dentro dele.'
+    );
+  }
+  await exec("git", ["add", "-A"], { cwd: root });
+  try {
+    await exec("git", ["commit", "-m", message], { cwd: root });
+    return true;
+  } catch (error) {
+    const stdout = error instanceof Error && "stdout" in error ? String(error.stdout) : "";
+    if (stdout.includes("nothing to commit")) return false;
+    throw error;
+  }
+}
+
+// src/commands/commit.ts
+function commitCommand() {
+  return new Command2("commit").description("Faz git add + commit de todas as mudan\xE7as do vault").argument("[mensagem]", "mensagem do commit").action(async (mensagem) => {
+    const vault = await requireVault();
+    const spin = spinner("Commitando o vault...").start();
+    try {
+      const committed = await commitVault(
+        vault.root,
+        mensagem ?? `minerva: estudos de ${todayISO()}`
+      );
+      if (committed) spin.succeed("Commit criado!");
+      else spin.info("Nada novo para commitar.");
+    } catch (error) {
+      spin.fail("Falha ao commitar.");
+      throw error;
+    }
+  });
+}
+
+// src/commands/completion.ts
+import { Command as Command3 } from "commander";
+function buildScript(shell, commands) {
+  const list = commands.join(" ");
+  if (shell === "bash") {
+    return `# minerva \u2014 bash completion (adicione ao ~/.bashrc)
+_minerva_completions() {
+    if [ "\${COMP_CWORD}" -eq 1 ]; then
+        COMPREPLY=($(compgen -W "${list}" -- "\${COMP_WORDS[1]}"))
+    fi
+}
+complete -F _minerva_completions minerva
+`;
+  }
+  return `# minerva \u2014 zsh completion (adicione ao ~/.zshrc)
+_minerva() {
+    if (( CURRENT == 2 )); then
+        compadd ${list}
+    fi
+}
+compdef _minerva minerva
+`;
+}
+function completionCommand() {
+  return new Command3("completion").description("Gera script de autocomplete para bash ou zsh").argument("<shell>", "bash ou zsh").action(function(shell) {
+    if (shell !== "bash" && shell !== "zsh") {
+      throw new Error('Shell n\xE3o suportado. Use "bash" ou "zsh".');
+    }
+    const commands = (this.parent?.commands ?? []).map((c) => c.name()).filter((name) => name !== "completion");
+    console.log(buildScript(shell, commands));
+  });
+}
+
+// src/commands/config.ts
+import { Command as Command4 } from "commander";
+var EDITABLE_KEYS = ["aluno", "semestreAtual", "horasEstudadas"];
+function configCommand() {
+  const command = new Command4("config").description(
+    "Mostra ou edita a configura\xE7\xE3o do vault (minerva.json)"
+  );
+  command.command("show", { isDefault: true }).description("Mostra a configura\xE7\xE3o atual").option("--json", "sa\xEDda em JSON").action(async (options) => {
+    const vault = await requireVault();
+    if (options.json) {
+      console.log(JSON.stringify(vault.config, null, 2));
+      return;
+    }
+    logger.title("Configura\xE7\xE3o do vault");
+    for (const [key, value] of Object.entries(vault.config)) {
+      logger.item(`${key}: ${String(value)}`);
+    }
+  });
+  command.command("set").description(`Edita uma chave (${EDITABLE_KEYS.join(", ")})`).argument("<chave>").argument("<valor>").action(async (chave, valor) => {
+    const vault = await requireVault();
+    if (!EDITABLE_KEYS.includes(chave)) {
+      throw new Error(
+        `Chave inv\xE1lida: "${chave}". Chaves edit\xE1veis: ${EDITABLE_KEYS.join(", ")}.`
+      );
+    }
+    const parsed = chave === "aluno" ? valor : Number(valor.replace(",", "."));
+    const config = minervaConfigSchema.parse({
+      ...vault.config,
+      [chave]: parsed
+    });
+    await saveConfig(vault.root, config);
+    logger.success(`${chave} = ${String(parsed)}`);
+  });
+  return command;
+}
+
+// src/commands/dashboard.ts
+import path8 from "path";
+import { Command as Command5 } from "commander";
+
+// src/services/dashboard.ts
+import path7 from "path";
+import fs6 from "fs-extra";
+
+// src/services/scaffold.ts
+import path6 from "path";
+import fs5 from "fs-extra";
+function disciplinaDir(root, semestre, disciplina) {
+  return path6.join(semestreDir(root, semestre), safeFolderName(disciplina));
+}
+async function scaffoldDisciplina(root, semestre, disciplina) {
+  const dir = disciplinaDir(root, semestre, disciplina.nome);
+  await Promise.all(
+    DISCIPLINA_FOLDERS.map((folder) => fs5.ensureDir(path6.join(dir, folder)))
+  );
+  const files = [
+    [
+      "README.md",
+      () => renderTemplate(
+        "disciplina",
+        { disciplina: disciplina.nome, semestre, aulas: disciplina.aulas },
+        root
+      )
+    ],
+    [
+      "Cheatsheet.md",
+      () => renderTemplate(
+        "cheatsheet",
+        { titulo: disciplina.nome, disciplina: disciplina.nome },
+        root
+      )
+    ],
+    [
+      "Resumo-Final.md",
+      () => renderTemplate(
+        "resumo-final",
+        { disciplina: disciplina.nome, semestre },
+        root
+      )
+    ]
+  ];
+  for (const [filename, render] of files) {
+    const destination = path6.join(dir, filename);
+    if (!await fs5.pathExists(destination)) {
+      await fs5.outputFile(destination, await render(), "utf8");
+    }
+  }
+  return dir;
+}
+async function scaffoldVaultFolders(root) {
+  await Promise.all(
+    VAULT_FOLDERS.map((folder) => fs5.ensureDir(path6.join(root, folder)))
+  );
+}
+async function scaffoldTemplates(root) {
+  await fs5.copy(builtinTemplatesDir(), path6.join(root, "templates"), {
+    overwrite: false
+  });
+}
+async function scaffoldSemestres(root, matriz) {
+  let total = 0;
+  for (const semestre of matriz.semestres) {
+    for (const disciplina of semestre.disciplinas) {
+      await scaffoldDisciplina(root, semestre.numero, disciplina);
+      total += 1;
+    }
+  }
+  return total;
+}
+async function scaffoldObsidian(root) {
+  const obsidianDirs = [
+    "obsidian/daily-notes",
+    "obsidian/canvas",
+    "obsidian/attachments",
+    "obsidian/excalidraw"
+  ];
+  await Promise.all(
+    obsidianDirs.map((dir) => fs5.ensureDir(path6.join(root, dir)))
+  );
+  const settings = path6.join(root, ".obsidian");
+  await fs5.ensureDir(settings);
+  await fs5.writeJson(
+    path6.join(settings, "app.json"),
+    { attachmentFolderPath: "obsidian/attachments" },
+    { spaces: 4 }
+  );
+  await fs5.writeJson(
+    path6.join(settings, "daily-notes.json"),
+    { folder: "obsidian/daily-notes", format: "YYYY-MM-DD" },
+    { spaces: 4 }
+  );
+  await fs5.writeJson(
+    path6.join(settings, "templates.json"),
+    { folder: "templates" },
+    { spaces: 4 }
+  );
+  await fs5.writeJson(
+    path6.join(settings, "types.json"),
+    {
+      types: {
+        disciplina: "text",
+        semestre: "number",
+        tipo: "text",
+        status: "text",
+        data: "date"
+      }
+    },
+    { spaces: 4 }
+  );
+}
+
+// src/services/dashboard.ts
+async function listMarkdown(dir) {
+  if (!await fs6.pathExists(dir)) return [];
+  const entries = await fs6.readdir(dir);
+  return entries.filter((entry) => entry.endsWith(".md"));
+}
+async function countPendencias(dir) {
+  if (!await fs6.pathExists(dir)) return 0;
+  let count = 0;
+  const stack = [dir];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    for (const entry of await fs6.readdir(current, {
+      withFileTypes: true
+    })) {
+      const full = path7.join(current, entry.name);
+      if (entry.isDirectory()) stack.push(full);
+      else if (entry.name.endsWith(".md")) {
+        const content = await fs6.readFile(full, "utf8");
+        count += (content.match(/^\s*[-*] \[ \]/gm) ?? []).length;
+      }
+    }
+  }
+  return count;
+}
+function extractProvaDate(content) {
+  const match = /^data-prova:\s*(\d{4}-\d{2}-\d{2})/m.exec(content);
+  return match ? match[1] : null;
+}
+async function collectDashboardData(vault, matriz) {
+  const semestre = getSemestre(matriz, vault.config.semestreAtual);
+  const disciplinas = [];
+  const proximasProvas = [];
+  const hoje = todayISO();
+  for (const disciplina of semestre.disciplinas) {
+    const dir = disciplinaDir(vault.root, semestre.numero, disciplina.nome);
+    const [aulas, resumos, provas, trabalhos, projetos, pendencias] = await Promise.all([
+      listMarkdown(path7.join(dir, "Aulas")),
+      listMarkdown(path7.join(dir, "Resumos")),
+      listMarkdown(path7.join(dir, "Provas")),
+      listMarkdown(path7.join(dir, "Trabalhos")),
+      listMarkdown(path7.join(dir, "Projetos")),
+      countPendencias(dir)
+    ]);
+    for (const arquivo of provas) {
+      const content = await fs6.readFile(
+        path7.join(dir, "Provas", arquivo),
+        "utf8"
+      );
+      const data = extractProvaDate(content);
+      if (data && data >= hoje) {
+        proximasProvas.push({
+          disciplina: disciplina.nome,
+          arquivo,
+          data
+        });
+      }
+    }
+    disciplinas.push({
+      nome: disciplina.nome,
+      aulas: aulas.length,
+      resumos: resumos.length,
+      provas: provas.length,
+      trabalhos: trabalhos.length,
+      projetos: projetos.length,
+      pendencias
+    });
+  }
+  proximasProvas.sort((a, b) => a.data.localeCompare(b.data));
+  return {
+    geradoEm: hoje,
+    semestreAtual: semestre.numero,
+    horasEstudadas: vault.config.horasEstudadas,
+    progressoCurso: progressBar(semestre.numero - 1, 6),
+    disciplinas,
+    proximasProvas,
+    totalPendencias: disciplinas.reduce((sum, d) => sum + d.pendencias, 0)
+  };
+}
+async function generateDashboard(vault, matriz) {
+  const data = await collectDashboardData(vault, matriz);
+  const content = await renderTemplate(
+    "dashboard",
+    data,
+    vault.root
+  );
+  const destination = path7.join(vault.root, "dashboard", "Dashboard.md");
+  await fs6.outputFile(destination, content, "utf8");
+  return destination;
+}
+
+// src/commands/dashboard.ts
+function dashboardCommand() {
+  return new Command5("dashboard").description("Gera/atualiza o dashboard de estudos").action(async () => {
+    const vault = await requireVault();
+    const matriz = await loadMatriz(vault.root);
+    const spin = spinner("Analisando seu vault...").start();
+    try {
+      const file = await generateDashboard(vault, matriz);
+      spin.succeed("Dashboard atualizado!");
+      logger.item(path8.relative(vault.root, file));
+    } catch (error) {
+      spin.fail("Falha ao gerar o dashboard.");
+      throw error;
+    }
+  });
+}
+
+// src/commands/disciplina.ts
+import path9 from "path";
+import { Command as Command6 } from "commander";
+function disciplinaCommand() {
+  const command = new Command6("disciplina").description(
+    "Lista disciplinas ou adiciona uma disciplina extra"
+  );
+  command.command("list", { isDefault: true }).description("Lista as disciplinas de todos os semestres").action(async () => {
+    const vault = await requireVault();
+    const matriz = await loadMatriz(vault.root);
+    logger.title(matriz.curso);
+    for (const semestre of matriz.semestres) {
+      const marker = semestre.numero === vault.config.semestreAtual ? " \u{1F448} atual" : "";
+      logger.info(`${semestre.numero}\xBA semestre${marker}`);
+      for (const d of semestre.disciplinas) {
+        logger.item(`${d.nome} (${d.aulas} aulas)`);
+      }
+      logger.blank();
+    }
+  });
+  command.command("add").description("Cria a estrutura de uma disciplina extra").argument("[nome]", "nome da disciplina").option("-s, --semestre <n>", "semestre onde criar").option("-a, --aulas <n>", "carga hor\xE1ria em aulas", "80").action(
+    async (nome, options) => {
+      const vault = await requireVault();
+      const nomeFinal = nome ?? await askTitulo("Nome da disciplina:");
+      const semestre = options.semestre ? Number(options.semestre) : await pickSemestre(vault.config.semestreAtual);
+      const spin = spinner("Criando disciplina...").start();
+      try {
+        const dir = await scaffoldDisciplina(vault.root, semestre, {
+          nome: nomeFinal,
+          aulas: Number(options.aulas)
+        });
+        spin.succeed(`Disciplina "${nomeFinal}" criada!`);
+        logger.item(path9.relative(vault.root, dir));
+      } catch (error) {
+        spin.fail("N\xE3o consegui criar a disciplina.");
+        throw error;
+      }
+    }
+  );
+  return command;
+}
+
+// src/commands/doctor.ts
+import path10 from "path";
+import { Command as Command7 } from "commander";
+import fs7 from "fs-extra";
+function doctorCommand() {
+  return new Command7("doctor").description("Verifica a sa\xFAde do ambiente e do vault").action(async () => {
+    logger.title("Minerva Doctor");
+    const root = await findVaultRoot(process.cwd());
+    const checks = [
+      {
+        label: "Node.js",
+        run: () => {
+          const major = Number(process.versions.node.split(".")[0]);
+          if (major < 20) {
+            throw new Error(
+              `v${process.versions.node} \u2014 atualize para a LTS (>= 20)`
+            );
+          }
+          return Promise.resolve(`v${process.versions.node}`);
+        }
+      },
+      {
+        label: "Templates embutidos",
+        run: () => Promise.resolve(builtinTemplatesDir())
+      },
+      {
+        label: "Vault Minerva",
+        run: () => {
+          if (!root) {
+            throw new Error('n\xE3o encontrado \u2014 rode "minerva init"');
+          }
+          return Promise.resolve(root);
+        }
+      }
+    ];
+    if (root) {
+      checks.push(
+        {
+          label: "Configura\xE7\xE3o (minerva.json)",
+          run: async () => {
+            const config = await loadConfig(root);
+            return `aluno: ${config.aluno}, ${config.semestreAtual}\xBA semestre`;
+          }
+        },
+        {
+          label: "Matriz curricular",
+          run: async () => {
+            const matriz = await loadMatriz(root);
+            const total = matriz.semestres.reduce(
+              (sum, s) => sum + s.disciplinas.length,
+              0
+            );
+            return `${total} disciplinas (atualizada em ${matriz.atualizadaEm})`;
+          }
+        },
+        {
+          label: "Reposit\xF3rio Git",
+          run: async () => {
+            if (!await fs7.pathExists(path10.join(root, ".git"))) {
+              throw new Error('ausente \u2014 rode "git init" no vault');
+            }
+            return "ok";
+          }
+        },
+        {
+          label: "Vault do Obsidian",
+          run: async () => {
+            if (!await fs7.pathExists(path10.join(root, ".obsidian"))) {
+              throw new Error(
+                'pasta .obsidian ausente \u2014 rode "minerva init" novamente'
+              );
+            }
+            return "ok";
+          }
+        }
+      );
+    }
+    let failures = 0;
+    for (const check of checks) {
+      try {
+        logger.success(`${check.label}: ${await check.run()}`);
+      } catch (error) {
+        failures += 1;
+        logger.error(
+          `${check.label}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    logger.blank();
+    if (failures === 0) {
+      logger.success("Tudo certo! Bons estudos. \u{1F989}");
+    } else {
+      logger.warn(`${failures} problema(s) encontrado(s).`);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/estudo.ts
+import { Command as Command8 } from "commander";
+
+// src/services/estudo.ts
+import path11 from "path";
+import fs8 from "fs-extra";
+import { z as z2 } from "zod";
+var ESTUDO_LOG_FILE = path11.join("dashboard", "estudo.json");
+var sessaoSchema = z2.object({
+  data: z2.string(),
+  horas: z2.number().positive(),
+  disciplina: z2.string().optional()
+});
+var logSchema = z2.array(sessaoSchema);
+async function loadEstudoLog(root) {
+  const file = path11.join(root, ESTUDO_LOG_FILE);
+  if (!await fs8.pathExists(file)) return [];
+  const raw = await fs8.readJson(file);
+  return logSchema.parse(raw);
+}
+async function registrarEstudo(vault, horas, disciplina) {
+  if (!Number.isFinite(horas) || horas <= 0) {
+    throw new Error("Informe um n\xFAmero de horas maior que zero (ex.: 1.5).");
+  }
+  const sessao = {
+    data: todayISO(),
+    horas,
+    ...disciplina ? { disciplina } : {}
+  };
+  const log = await loadEstudoLog(vault.root);
+  log.push(sessao);
+  await fs8.outputJson(path11.join(vault.root, ESTUDO_LOG_FILE), log, {
+    spaces: 4
+  });
+  vault.config.horasEstudadas = Math.round((vault.config.horasEstudadas + horas) * 100) / 100;
+  await saveConfig(vault.root, vault.config);
+  return sessao;
+}
+function horasPorDisciplina(log) {
+  const totals = /* @__PURE__ */ new Map();
+  for (const sessao of log) {
+    const key = sessao.disciplina ?? "(geral)";
+    totals.set(key, (totals.get(key) ?? 0) + sessao.horas);
+  }
+  return totals;
+}
+
+// src/commands/estudo.ts
+function estudoCommand() {
+  return new Command8("estudo").description("Registra horas de estudo (alimenta o dashboard)").argument("[horas]", "horas estudadas (ex.: 1.5)").option("-d, --disciplina <nome>", "disciplina estudada").option("--json", "sa\xEDda em JSON").action(
+    async (horas, options) => {
+      const vault = await requireVault();
+      if (horas === void 0) {
+        const log = await loadEstudoLog(vault.root);
+        const totals = horasPorDisciplina(log);
+        if (options.json) {
+          console.log(
+            JSON.stringify(
+              {
+                total: vault.config.horasEstudadas,
+                porDisciplina: Object.fromEntries(totals)
+              },
+              null,
+              2
+            )
+          );
+          return;
+        }
+        logger.title(`${vault.config.horasEstudadas}h estudadas no total`);
+        for (const [disciplina2, total] of totals) {
+          logger.item(`${disciplina2}: ${total}h`);
+        }
+        if (totals.size === 0) {
+          logger.info("Registre sua primeira sess\xE3o: minerva estudo 1.5");
+        }
+        return;
+      }
+      const valor = Number(horas.replace(",", "."));
+      const matriz = await loadMatriz(vault.root);
+      const disciplina = options.disciplina ? await pickDisciplina(
+        matriz,
+        vault.config.semestreAtual,
+        options.disciplina
+      ) : void 0;
+      const sessao = await registrarEstudo(vault, valor, disciplina);
+      await generateDashboard(vault, matriz);
+      logger.success(
+        `+${sessao.horas}h registradas${disciplina ? ` em ${disciplina}` : ""}. Total: ${vault.config.horasEstudadas}h. Dashboard atualizado!`
+      );
+    }
+  );
+}
+
+// src/commands/flashcards.ts
+import path15 from "path";
+import { Command as Command10 } from "commander";
+
+// src/services/anki.ts
+import path12 from "path";
+import fs9 from "fs-extra";
+function parseFlashcards(content, deck) {
+  const cards = [];
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("#") || trimmed.startsWith(">")) continue;
+    const match = /^(.+?)\s*::\s*(.+)$/.exec(trimmed);
+    if (match) {
+      cards.push({
+        pergunta: match[1].trim(),
+        resposta: match[2].trim(),
+        deck
+      });
+    }
+  }
+  return cards;
+}
+async function collectMarkdownFiles(dir) {
+  if (!await fs9.pathExists(dir)) return [];
+  const files = [];
+  const stack = [dir];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    for (const entry of await fs9.readdir(current, { withFileTypes: true })) {
+      const full = path12.join(current, entry.name);
+      if (entry.isDirectory()) stack.push(full);
+      else if (entry.name.endsWith(".md")) files.push(full);
+    }
+  }
+  return files;
+}
+async function collectAllFlashcards(vault) {
+  const cards = [];
+  const stack = [vault.root];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    for (const entry of await fs9.readdir(current, { withFileTypes: true })) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+      const full = path12.join(current, entry.name);
+      if (!entry.isDirectory()) continue;
+      if (entry.name.toLowerCase() === "flashcards") {
+        const deck = path12.basename(path12.dirname(full));
+        for (const file of await collectMarkdownFiles(full)) {
+          cards.push(...parseFlashcards(await fs9.readFile(file, "utf8"), deck));
+        }
+      } else {
+        stack.push(full);
+      }
+    }
+  }
+  return cards;
+}
+async function exportAnki(vault) {
+  const cards = await collectAllFlashcards(vault);
+  const lines = [
+    "#separator:tab",
+    "#html:false",
+    "#deck column:3",
+    ...cards.map(
+      (card) => `${card.pergunta.replace(/\t/g, " ")}	${card.resposta.replace(/\t/g, " ")}	FATEC::${card.deck.replace(/\t/g, " ")}`
+    )
+  ];
+  const file = path12.join(
+    vault.root,
+    "flashcards",
+    `anki-export-${todayISO()}.txt`
+  );
+  await fs9.outputFile(file, lines.join("\n"), "utf8");
+  return { file, total: cards.length };
+}
+
+// src/commands/note-factory.ts
+import path14 from "path";
+import { Command as Command9 } from "commander";
+import fs11 from "fs-extra";
+import { input as input2 } from "@inquirer/prompts";
+
+// src/services/notes.ts
+import path13 from "path";
+import fs10 from "fs-extra";
+var NOTE_SPECS = {
+  aula: { template: "aula", folder: "Aulas", prefix: "aula" },
+  resumo: { template: "resumo", folder: "Resumos", prefix: "resumo" },
+  prova: { template: "prova", folder: "Provas", prefix: "prova" },
+  trabalho: { template: "trabalho", folder: "Trabalhos", prefix: "trabalho" },
+  projeto: { template: "projeto", folder: "Projetos", prefix: "projeto" },
+  flashcard: {
+    template: "flashcard",
+    folder: "Flashcards",
+    prefix: "flashcards"
+  }
+};
+async function createNote(vault, input5) {
+  const spec = NOTE_SPECS[input5.kind];
+  const dir = path13.join(
+    disciplinaDir(vault.root, input5.semestre, input5.disciplina),
+    spec.folder
+  );
+  await fs10.ensureDir(dir);
+  const filename = `${todayISO()}-${spec.prefix}-${slugify(input5.titulo)}.md`;
+  const destination = path13.join(dir, filename);
+  await renderToFile(
+    spec.template,
+    {
+      titulo: input5.titulo,
+      disciplina: input5.disciplina,
+      semestre: input5.semestre,
+      data: todayISO(),
+      ...input5.extra
+    },
+    destination,
+    vault.root
+  );
+  return destination;
+}
+
+// src/services/ai.ts
+import Anthropic from "@anthropic-ai/sdk";
+var AI_MODEL = "claude-opus-4-8";
+function anthropicProvider() {
+  if (!process.env["ANTHROPIC_API_KEY"]) {
+    throw new Error(
+      'Defina a vari\xE1vel de ambiente ANTHROPIC_API_KEY para usar os recursos de IA.\n  Ex.: export ANTHROPIC_API_KEY="sk-ant-..."'
+    );
+  }
+  const client = new Anthropic();
+  return {
+    async generate(prompt, material) {
+      try {
+        const stream = client.messages.stream({
+          model: AI_MODEL,
+          max_tokens: 64e3,
+          thinking: { type: "adaptive" },
+          system: "Voc\xEA \xE9 um monitor de estudos da FATEC (curso de An\xE1lise e Desenvolvimento de Sistemas). Responda sempre em portugu\xEAs do Brasil, em Markdown puro, sem pre\xE2mbulos.",
+          messages: [
+            {
+              role: "user",
+              content: `${prompt}
+
+<material>
+${material}
+</material>`
+            }
+          ]
+        });
+        const message = await stream.finalMessage();
+        return message.content.filter((block) => block.type === "text").map((block) => block.text).join("\n");
+      } catch (error) {
+        if (error instanceof Anthropic.AuthenticationError) {
+          throw new Error("ANTHROPIC_API_KEY inv\xE1lida. Verifique a chave.");
+        }
+        if (error instanceof Anthropic.RateLimitError) {
+          throw new Error(
+            "Limite de requisi\xE7\xF5es da API atingido. Tente novamente em instantes."
+          );
+        }
+        if (error instanceof Anthropic.APIConnectionError) {
+          throw new Error(
+            "Sem conex\xE3o com a API da Anthropic. Verifique sua internet."
+          );
+        }
+        throw error;
+      }
+    }
+  };
+}
+function resumoPrompt(disciplina, tema) {
+  return `Gere um resumo de estudo sobre "${tema}" para a disciplina "${disciplina}", baseado nas anota\xE7\xF5es de aula fornecidas no material. Estruture com: vis\xE3o geral, pontos principais numerados, explica\xE7\xE3o com palavras simples e uma se\xE7\xE3o "Poss\xEDveis quest\xF5es de prova" com checkboxes (- [ ]). Se o material for insuficiente, complemente com seu conhecimento e sinalize o que n\xE3o veio das anota\xE7\xF5es.`;
+}
+function flashcardsPrompt(disciplina, tema) {
+  return `Gere de 10 a 20 flashcards sobre "${tema}" para a disciplina "${disciplina}", baseados no material fornecido. Formato obrigat\xF3rio: uma linha por card, "pergunta :: resposta" (compat\xEDvel com o plugin Spaced Repetition do Obsidian). Perguntas objetivas, respostas curtas. N\xE3o use cabe\xE7alhos nem numera\xE7\xE3o \u2014 apenas as linhas de cards.`;
+}
+
+// src/utils/dates.ts
+function isValidISODate(value) {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(value)) return false;
+  const date = /* @__PURE__ */ new Date(`${value}T00:00:00Z`);
+  return !Number.isNaN(date.getTime()) && date.toISOString().slice(0, 10) === value;
+}
+function addDaysISO(iso, days) {
+  const date = /* @__PURE__ */ new Date(`${iso}T00:00:00Z`);
+  date.setUTCDate(date.getUTCDate() + days);
+  return date.toISOString().slice(0, 10);
+}
+var DATE_HINT = "Use uma data v\xE1lida no formato YYYY-MM-DD.";
+
+// src/commands/note-factory.ts
+async function readMaterial(dir) {
+  if (!await fs11.pathExists(dir)) return "";
+  const parts = [];
+  for (const file of (await fs11.readdir(dir)).filter((f) => f.endsWith(".md"))) {
+    parts.push(await fs11.readFile(path14.join(dir, file), "utf8"));
+  }
+  return parts.join("\n\n---\n\n");
+}
+function noteCommand(spec) {
+  const command = new Command9(spec.name).description(spec.description).argument("[titulo]", "t\xEDtulo da nota").option("-d, --disciplina <nome>", "disciplina (evita o prompt)").option("-s, --semestre <n>", "semestre (padr\xE3o: semestre atual)").option("-c, --commit", "faz git commit no vault ap\xF3s criar");
+  if (spec.extraField) {
+    command.option(
+      `--${spec.extraField.flag} <valor>`,
+      spec.extraField.flagDescription
+    );
+  }
+  if (spec.ai) {
+    command.option(
+      "--ai",
+      `gera o conte\xFAdo com IA a partir de ${spec.ai.sourceFolder}/ (requer ANTHROPIC_API_KEY)`
+    );
+  }
+  command.action(
+    async (titulo, options) => {
+      const vault = await requireVault();
+      const matriz = await loadMatriz(vault.root);
+      const semestre = options["semestre"] ? Number(options["semestre"]) : await pickSemestre(vault.config.semestreAtual);
+      const disciplina = await pickDisciplina(
+        matriz,
+        semestre,
+        options["disciplina"]
+      );
+      const tituloFinal = titulo ?? await askTitulo(spec.tituloPrompt);
+      const extra = {};
+      if (spec.extraField) {
+        const field = spec.extraField;
+        const camel = field.flag.replace(
+          /-(\w)/g,
+          (_, c) => c.toUpperCase()
+        );
+        let value = options[camel];
+        if (value !== void 0 && field.isDate && !isValidISODate(value)) {
+          throw new Error(`Data inv\xE1lida: "${value}". ${DATE_HINT}`);
+        }
+        value ??= await input2({
+          message: field.prompt,
+          default: todayISO(),
+          validate: (v) => !field.isDate || isValidISODate(v) || DATE_HINT
+        });
+        extra[field.key] = value;
+      }
+      let conteudoIA;
+      if (spec.ai && options["ai"]) {
+        const provider = anthropicProvider();
+        const sourceDir = path14.join(
+          disciplinaDir(vault.root, semestre, disciplina),
+          spec.ai.sourceFolder
+        );
+        const spinAi = spinner(
+          `Gerando conte\xFAdo com IA (${spec.ai.sourceFolder}/)...`
+        ).start();
+        try {
+          const material = await readMaterial(sourceDir);
+          conteudoIA = await provider.generate(
+            spec.ai.buildPrompt(disciplina, tituloFinal),
+            material || "(sem anota\xE7\xF5es \u2014 use seu conhecimento)"
+          );
+          spinAi.succeed("Conte\xFAdo gerado pela IA!");
+        } catch (error) {
+          spinAi.fail("Falha na gera\xE7\xE3o com IA.");
+          throw error;
+        }
+      }
+      const spin = spinner("Criando nota...").start();
+      try {
+        const file = await createNote(vault, {
+          kind: spec.kind,
+          semestre,
+          disciplina,
+          titulo: tituloFinal,
+          extra
+        });
+        if (conteudoIA) {
+          await fs11.appendFile(file, `
+## Gerado por IA
+
+${conteudoIA}
+`);
+        }
+        spin.succeed(`Pronto! Nota criada em:`);
+        logger.item(path14.relative(vault.root, file));
+        if (options["commit"]) {
+          const committed = await commitVault(
+            vault.root,
+            `minerva: ${spec.name} "${tituloFinal}" (${disciplina})`
+          );
+          if (committed) logger.success("Commit criado no vault.");
+          else logger.info("Nada novo para commitar.");
+        }
+      } catch (error) {
+        spin.fail("N\xE3o consegui criar a nota.");
+        throw error;
+      }
+    }
+  );
+  return command;
+}
+
+// src/commands/notes.ts
+function aulaCommand() {
+  return noteCommand({
+    kind: "aula",
+    name: "aula",
+    description: "Cria a anota\xE7\xE3o de uma aula",
+    tituloPrompt: "T\xEDtulo da aula:"
+  });
+}
+function resumoCommand() {
+  return noteCommand({
+    kind: "resumo",
+    name: "resumo",
+    description: "Cria um resumo de estudo",
+    tituloPrompt: "Tema do resumo:",
+    ai: { sourceFolder: "Aulas", buildPrompt: resumoPrompt }
+  });
+}
+function provaCommand() {
+  return noteCommand({
+    kind: "prova",
+    name: "prova",
+    description: "Agenda e planeja uma prova",
+    tituloPrompt: "Nome da prova (ex.: P1):",
+    extraField: {
+      key: "dataProva",
+      prompt: "Data da prova (YYYY-MM-DD):",
+      flag: "data",
+      flagDescription: "data da prova (YYYY-MM-DD)",
+      isDate: true
+    }
+  });
+}
+function trabalhoCommand() {
+  return noteCommand({
+    kind: "trabalho",
+    name: "trabalho",
+    description: "Cria um trabalho acad\xEAmico",
+    tituloPrompt: "T\xEDtulo do trabalho:",
+    extraField: {
+      key: "entrega",
+      prompt: "Data de entrega (YYYY-MM-DD):",
+      flag: "entrega",
+      flagDescription: "data de entrega (YYYY-MM-DD)",
+      isDate: true
+    }
+  });
+}
+function projetoCommand() {
+  return noteCommand({
+    kind: "projeto",
+    name: "projeto",
+    description: "Cria um projeto",
+    tituloPrompt: "Nome do projeto:"
+  });
+}
+function flashcardsNewCommand() {
+  return noteCommand({
+    kind: "flashcard",
+    name: "new",
+    description: "Cria um deck de flashcards",
+    tituloPrompt: "Tema dos flashcards:",
+    ai: { sourceFolder: "Resumos", buildPrompt: flashcardsPrompt }
+  });
+}
+
+// src/commands/flashcards.ts
+function flashcardsCommand() {
+  const command = new Command10("flashcards").description(
+    "Cria decks de flashcards ou exporta para o Anki"
+  );
+  const create = flashcardsNewCommand();
+  command.addCommand(create, { isDefault: true });
+  command.command("export").description("Exporta todos os flashcards para um TSV import\xE1vel no Anki").action(async () => {
+    const vault = await requireVault();
+    const spin = spinner("Coletando flashcards do vault...").start();
+    try {
+      const { file, total } = await exportAnki(vault);
+      spin.succeed(`${total} flashcard(s) exportado(s)!`);
+      logger.item(path15.relative(vault.root, file));
+      logger.info("No Anki: Arquivo \u2192 Importar e selecione esse arquivo.");
+    } catch (error) {
+      spin.fail("Falha na exporta\xE7\xE3o.");
+      throw error;
+    }
+  });
+  return command;
+}
+
+// src/commands/init.ts
+import path16 from "path";
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+import { Command as Command11 } from "commander";
+import fs12 from "fs-extra";
+import { input as input3, number as number2 } from "@inquirer/prompts";
+var exec2 = promisify2(execFile2);
+var GITIGNORE = `.obsidian/workspace*
+.obsidian/cache
+.trash/
+.DS_Store
+`;
+var ROADMAP = `# \u{1F5FA}\uFE0F Roadmap da Gradua\xE7\xE3o
+
+- [ ] 1\xBA semestre conclu\xEDdo
+- [ ] 2\xBA semestre conclu\xEDdo
+- [ ] 3\xBA semestre conclu\xEDdo
+- [ ] Est\xE1gio conquistado
+- [ ] 4\xBA semestre conclu\xEDdo
+- [ ] 5\xBA semestre conclu\xEDdo
+- [ ] Trabalho de Gradua\xE7\xE3o entregue
+- [ ] 6\xBA semestre conclu\xEDdo
+- [ ] \u{1F393} Formado!
+`;
+async function initGit(root) {
+  try {
+    await exec2("git", ["init"], { cwd: root });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function writeIfMissing(file, content) {
+  if (!await fs12.pathExists(file)) {
+    await fs12.outputFile(file, content, "utf8");
+  }
+}
+function initCommand() {
+  return new Command11("init").description("Cria a estrutura completa do curso (vault de estudos)").argument("[pasta]", "pasta de destino", DEFAULT_VAULT_DIRNAME).option("-s, --semestre <n>", "semestre atual (1-6)").option("-a, --aluno <nome>", "seu nome").action(
+    async (pasta, options) => {
+      logger.title("Minerva CLI \u2014 vamos montar sua gradua\xE7\xE3o!");
+      const aluno = options.aluno ?? await input3({ message: "Seu nome:", default: "Estudante" });
+      const semestreAtual = options.semestre !== void 0 ? Number(options.semestre) : await number2({
+        message: "Em qual semestre voc\xEA est\xE1? (1-6)",
+        default: 1,
+        min: 1,
+        max: 6
+      }) ?? 1;
+      const root = path16.resolve(pasta);
+      const config = {
+        versao: APP_VERSION,
+        aluno,
+        semestreAtual,
+        criadoEm: todayISO(),
+        horasEstudadas: 0
+      };
+      const spin = spinner("Criando estrutura de pastas...").start();
+      try {
+        await fs12.ensureDir(root);
+        await scaffoldVaultFolders(root);
+        await saveConfig(root, config);
+        spin.text = "Salvando matriz curricular...";
+        await saveMatriz(root, matrizOficial);
+        spin.text = "Copiando templates...";
+        await scaffoldTemplates(root);
+        spin.text = "Criando semestres e disciplinas...";
+        const totalDisciplinas = await scaffoldSemestres(root, matrizOficial);
+        spin.text = "Preparando vault do Obsidian...";
+        await scaffoldObsidian(root);
+        spin.text = "Gerando README e dashboard...";
+        await writeIfMissing(
+          path16.join(root, "README.md"),
+          await renderTemplate("readme", {
+            ...config,
+            curso: matrizOficial.curso,
+            instituicao: matrizOficial.instituicao,
+            semestres: matrizOficial.semestres
+          })
+        );
+        await writeIfMissing(path16.join(root, ".gitignore"), GITIGNORE);
+        await writeIfMissing(
+          path16.join(root, "roadmap", "Roadmap.md"),
+          ROADMAP
+        );
+        await generateDashboard({ root, config }, matrizOficial);
+        spin.text = "Inicializando Git...";
+        const gitOk = await initGit(root);
+        spin.succeed("Vault criado com sucesso!");
+        logger.blank();
+        logger.success(`\u{1F4C1} ${root}`);
+        logger.item(`${totalDisciplinas} disciplinas em 6 semestres`);
+        logger.item("Dashboard em dashboard/Dashboard.md");
+        logger.item("Abra a pasta como vault no Obsidian \u{1F7E3}");
+        if (!gitOk) {
+          logger.warn("Git n\xE3o encontrado \u2014 reposit\xF3rio n\xE3o inicializado.");
+        }
+        logger.blank();
+        logger.info(`Pr\xF3ximo passo: cd ${pasta} && minerva dashboard`);
+      } catch (error) {
+        spin.fail("Falha ao criar o vault.");
+        throw error;
+      }
+    }
+  );
+}
+
+// src/commands/nota.ts
+import chalk2 from "chalk";
+import { Command as Command12 } from "commander";
+import { input as input4 } from "@inquirer/prompts";
+
+// src/services/notas.ts
+import path17 from "path";
+import fs13 from "fs-extra";
+import { z as z3 } from "zod";
+var NOTAS_FILE = path17.join("curriculo", "notas.json");
+var MEDIA_APROVACAO = 6;
+var notaSchema = z3.object({
+  disciplina: z3.string(),
+  avaliacao: z3.string(),
+  valor: z3.number().min(0).max(10),
+  peso: z3.number().positive().default(1)
+});
+var notasSchema = z3.array(notaSchema);
+async function loadNotas(root) {
+  const file = path17.join(root, NOTAS_FILE);
+  if (!await fs13.pathExists(file)) return [];
+  const raw = await fs13.readJson(file);
+  return notasSchema.parse(raw);
+}
+async function registrarNota(root, nota) {
+  const notas = await loadNotas(root);
+  const existing = notas.findIndex(
+    (n) => n.disciplina === nota.disciplina && n.avaliacao.toLowerCase() === nota.avaliacao.toLowerCase()
+  );
+  if (existing >= 0) notas[existing] = nota;
+  else notas.push(nota);
+  await fs13.outputJson(path17.join(root, NOTAS_FILE), notas, { spaces: 4 });
+}
+function media(notas) {
+  const pesoTotal = notas.reduce((sum, n) => sum + n.peso, 0);
+  if (pesoTotal === 0) return 0;
+  const soma = notas.reduce((sum, n) => sum + n.valor * n.peso, 0);
+  return Math.round(soma / pesoTotal * 100) / 100;
+}
+function boletim(notas) {
+  const porDisciplina = /* @__PURE__ */ new Map();
+  for (const nota of notas) {
+    const list = porDisciplina.get(nota.disciplina) ?? [];
+    list.push(nota);
+    porDisciplina.set(nota.disciplina, list);
+  }
+  return [...porDisciplina.entries()].map(([disciplina, list]) => {
+    const m = media(list);
+    return {
+      disciplina,
+      notas: list,
+      media: m,
+      situacao: m >= MEDIA_APROVACAO ? "aprovado" : m >= MEDIA_APROVACAO - 2 ? "em risco" : "reprovado"
+    };
+  });
+}
+
+// src/commands/nota.ts
+var SITUACAO_COLOR = {
+  aprovado: chalk2.green,
+  "em risco": chalk2.yellow,
+  reprovado: chalk2.red
+};
+function notaCommand() {
+  const command = new Command12("nota").description(
+    "Registra notas e mostra o boletim com m\xE9dias"
+  );
+  command.command("boletim", { isDefault: true }).description("Mostra m\xE9dias e situa\xE7\xE3o por disciplina").option("--json", "sa\xEDda em JSON").action(async (options) => {
+    const vault = await requireVault();
+    const notas = await loadNotas(vault.root);
+    const linhas = boletim(notas);
+    if (options.json) {
+      console.log(JSON.stringify(linhas, null, 2));
+      return;
+    }
+    if (linhas.length === 0) {
+      logger.info("Nenhuma nota registrada. Use: minerva nota add");
+      return;
+    }
+    logger.title(`Boletim (m\xE9dia m\xEDnima: ${MEDIA_APROVACAO})`);
+    for (const linha of linhas) {
+      const color = SITUACAO_COLOR[linha.situacao];
+      logger.info(
+        `${linha.disciplina}: m\xE9dia ${chalk2.bold(linha.media)} \u2014 ${color(linha.situacao)}`
+      );
+      for (const nota of linha.notas) {
+        logger.item(`${nota.avaliacao}: ${nota.valor} (peso ${nota.peso})`);
+      }
+    }
+  });
+  command.command("add").description("Registra a nota de uma avalia\xE7\xE3o").argument("[valor]", "nota de 0 a 10").option("-d, --disciplina <nome>", "disciplina").option("-a, --avaliacao <nome>", "nome da avalia\xE7\xE3o (ex.: P1)").option("-p, --peso <n>", "peso da avalia\xE7\xE3o", "1").option("-s, --semestre <n>", "semestre da disciplina").action(
+    async (valor, options) => {
+      const vault = await requireVault();
+      const matriz = await loadMatriz(vault.root);
+      const semestre = options.semestre ? Number(options.semestre) : vault.config.semestreAtual;
+      const disciplina = await pickDisciplina(
+        matriz,
+        semestre,
+        options.disciplina
+      );
+      const avaliacao = options.avaliacao ?? await input4({
+        message: "Avalia\xE7\xE3o (ex.: P1, Trabalho 1):",
+        validate: (v) => v.trim().length > 0 || "Informe um nome."
+      });
+      const valorFinal = Number(
+        (valor ?? await input4({
+          message: "Nota (0-10):",
+          validate: (v) => {
+            const n = Number(v.replace(",", "."));
+            return Number.isFinite(n) && n >= 0 && n <= 10 || "Informe uma nota entre 0 e 10.";
+          }
+        })).replace(",", ".")
+      );
+      await registrarNota(vault.root, {
+        disciplina,
+        avaliacao,
+        valor: valorFinal,
+        peso: Number(options.peso)
+      });
+      const notas = await loadNotas(vault.root);
+      const linha = boletim(notas).find((b) => b.disciplina === disciplina);
+      logger.success(
+        `${avaliacao} = ${valorFinal} registrada em ${disciplina}.`
+      );
+      logger.info(
+        `M\xE9dia atual: ${linha.media} (${SITUACAO_COLOR[linha.situacao](linha.situacao)})`
+      );
+    }
+  );
+  return command;
+}
+
+// src/commands/open.ts
+import path18 from "path";
+import { execFile as execFile3 } from "child_process";
+import { promisify as promisify3 } from "util";
+import { Command as Command13 } from "commander";
+var exec3 = promisify3(execFile3);
+async function openUrl(url) {
+  const opener = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  await exec3(opener, [url], { shell: process.platform === "win32" });
+}
+function openCommand() {
+  return new Command13("open").description("Abre o dashboard (ou um arquivo) no Obsidian").argument("[arquivo]", "caminho relativo dentro do vault").action(async (arquivo) => {
+    const vault = await requireVault();
+    const target = path18.join(
+      vault.root,
+      arquivo ?? path18.join("dashboard", "Dashboard.md")
+    );
+    const url = `obsidian://open?path=${encodeURIComponent(target)}`;
+    try {
+      await openUrl(url);
+      logger.success("Abrindo no Obsidian...");
+    } catch {
+      logger.error(
+        "N\xE3o consegui abrir o Obsidian. Ele est\xE1 instalado? O vault j\xE1 foi aberto nele ao menos uma vez?"
+      );
+      logger.info(`Arquivo: ${target}`);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/pendencias.ts
+import chalk3 from "chalk";
+import { Command as Command14 } from "commander";
+
+// src/services/pendencias.ts
+import path19 from "path";
+import fs14 from "fs-extra";
+async function scanFile(file, root, disciplina) {
+  const content = await fs14.readFile(file, "utf8");
+  const items = [];
+  content.split("\n").forEach((line, index) => {
+    const match = /^\s*[-*] \[ \]\s*(.*)$/.exec(line);
+    if (match) {
+      items.push({
+        disciplina,
+        arquivo: path19.relative(root, file),
+        linha: index + 1,
+        texto: match[1]?.trim() ?? ""
+      });
+    }
+  });
+  return items;
+}
+async function listPendencias(vault, matriz) {
+  const semestre = getSemestre(matriz, vault.config.semestreAtual);
+  const pendencias = [];
+  for (const disciplina of semestre.disciplinas) {
+    const dir = disciplinaDir(vault.root, semestre.numero, disciplina.nome);
+    if (!await fs14.pathExists(dir)) continue;
+    const stack = [dir];
+    while (stack.length > 0) {
+      const current = stack.pop();
+      for (const entry of await fs14.readdir(current, { withFileTypes: true })) {
+        const full = path19.join(current, entry.name);
+        if (entry.isDirectory()) stack.push(full);
+        else if (entry.name.endsWith(".md")) {
+          pendencias.push(
+            ...await scanFile(full, vault.root, disciplina.nome)
+          );
+        }
+      }
+    }
+  }
+  return pendencias;
+}
+
+// src/commands/pendencias.ts
+function pendenciasCommand() {
+  return new Command14("pendencias").description("Lista as tarefas pendentes (- [ ]) do semestre atual").option("--json", "sa\xEDda em JSON").action(async (options) => {
+    const vault = await requireVault();
+    const matriz = await loadMatriz(vault.root);
+    const pendencias = await listPendencias(vault, matriz);
+    if (options.json) {
+      console.log(JSON.stringify(pendencias, null, 2));
+      return;
+    }
+    if (pendencias.length === 0) {
+      logger.success("Nenhuma pend\xEAncia aberta. \u{1F389}");
+      return;
+    }
+    logger.title(`${pendencias.length} pend\xEAncia(s) aberta(s)`);
+    let atual = "";
+    for (const p of pendencias) {
+      if (p.disciplina !== atual) {
+        atual = p.disciplina;
+        logger.info(chalk3.bold(atual));
+      }
+      logger.item(
+        `${p.texto || "(sem descri\xE7\xE3o)"} ${chalk3.dim(`\u2014 ${p.arquivo}:${p.linha}`)}`
+      );
+    }
+  });
+}
+
+// src/commands/portfolio.ts
+import path20 from "path";
+import { Command as Command15 } from "commander";
+import fs15 from "fs-extra";
+async function collectProjects(root) {
+  const items = [];
+  const pessoais = path20.join(root, "projetos-pessoais");
+  if (await fs15.pathExists(pessoais)) {
+    for (const entry of await fs15.readdir(pessoais, {
+      withFileTypes: true
+    })) {
+      if (entry.isDirectory() || entry.name.endsWith(".md")) {
+        items.push({
+          titulo: entry.name.replace(/\.md$/, ""),
+          origem: "Projeto pessoal",
+          caminho: path20.join("projetos-pessoais", entry.name)
+        });
+      }
+    }
+  }
+  const matriz = await loadMatriz(root);
+  for (const semestre of matriz.semestres) {
+    for (const disciplina of semestre.disciplinas) {
+      const dir = path20.join(
+        disciplinaDir(root, semestre.numero, disciplina.nome),
+        "Projetos"
+      );
+      if (!await fs15.pathExists(dir)) continue;
+      for (const file of await fs15.readdir(dir)) {
+        if (!file.endsWith(".md")) continue;
+        items.push({
+          titulo: file.replace(/\.md$/, ""),
+          origem: `${disciplina.nome} (${semestre.numero}\xBA sem.)`,
+          caminho: path20.relative(root, path20.join(dir, file))
+        });
+      }
+    }
+  }
+  return items;
+}
+function portfolioCommand() {
+  return new Command15("portfolio").description("Gera o \xEDndice do portf\xF3lio com todos os seus projetos").action(async () => {
+    const vault = await requireVault();
+    const spin = spinner("Reunindo seus projetos...").start();
+    try {
+      const items = await collectProjects(vault.root);
+      const lines = [
+        "# \u{1F4BC} Portf\xF3lio",
+        "",
+        `> Gerado por \`minerva portfolio\` em ${todayISO()}.`,
+        "",
+        "| Projeto | Origem | Nota |",
+        "| ------- | ------ | ---- |",
+        ...items.map(
+          (item) => `| ${item.titulo} | ${item.origem} | [abrir](../${item.caminho.split(path20.sep).join("/")}) |`
+        ),
+        ""
+      ];
+      const destination = path20.join(vault.root, "portfolio", "Portfolio.md");
+      await fs15.outputFile(destination, lines.join("\n"), "utf8");
+      spin.succeed(`Portf\xF3lio atualizado com ${items.length} projeto(s)!`);
+      logger.item(path20.relative(vault.root, destination));
+    } catch (error) {
+      spin.fail("Falha ao gerar o portf\xF3lio.");
+      throw error;
+    }
+  });
+}
+
+// src/commands/semana.ts
+import { Command as Command16 } from "commander";
+
+// src/services/agenda.ts
+import path21 from "path";
+import fs16 from "fs-extra";
+var FRONTMATTER_DATES = [
+  { folder: "Provas", field: "data-prova", tipo: "prova" },
+  { folder: "Trabalhos", field: "entrega", tipo: "entrega" }
+];
+function extractDate(content, field) {
+  const match = new RegExp(`^${field}:\\s*(\\d{4}-\\d{2}-\\d{2})`, "m").exec(
+    content
+  );
+  return match ? match[1] : null;
+}
+function extractTitle(content, fallback) {
+  const match = /^# .*?[—-]\s*(.+)$/m.exec(content);
+  return match ? match[1].trim() : fallback;
+}
+async function proximosCompromissos(vault, matriz, dias = 7) {
+  const semestre = getSemestre(matriz, vault.config.semestreAtual);
+  const inicio = todayISO();
+  const fim = addDaysISO(inicio, dias);
+  const compromissos = [];
+  for (const disciplina of semestre.disciplinas) {
+    for (const spec of FRONTMATTER_DATES) {
+      const dir = path21.join(
+        disciplinaDir(vault.root, semestre.numero, disciplina.nome),
+        spec.folder
+      );
+      if (!await fs16.pathExists(dir)) continue;
+      for (const file of await fs16.readdir(dir)) {
+        if (!file.endsWith(".md")) continue;
+        const full = path21.join(dir, file);
+        const content = await fs16.readFile(full, "utf8");
+        const data = extractDate(content, spec.field);
+        if (data && data >= inicio && data <= fim) {
+          compromissos.push({
+            tipo: spec.tipo,
+            disciplina: disciplina.nome,
+            titulo: extractTitle(content, file.replace(/\.md$/, "")),
+            data,
+            arquivo: path21.relative(vault.root, full)
+          });
+        }
+      }
+    }
+  }
+  return compromissos.sort((a, b) => a.data.localeCompare(b.data));
+}
+
+// src/commands/semana.ts
+function semanaCommand() {
+  return new Command16("semana").description("Mostra provas, entregas e pend\xEAncias dos pr\xF3ximos dias").option("--dias <n>", "janela em dias", "7").option("--json", "sa\xEDda em JSON").action(async (options) => {
+    const vault = await requireVault();
+    const matriz = await loadMatriz(vault.root);
+    const dias = Number(options.dias);
+    const [compromissos, pendencias] = await Promise.all([
+      proximosCompromissos(vault, matriz, dias),
+      listPendencias(vault, matriz)
+    ]);
+    if (options.json) {
+      console.log(
+        JSON.stringify(
+          { compromissos, totalPendencias: pendencias.length },
+          null,
+          2
+        )
+      );
+      return;
+    }
+    logger.title(`Sua semana (pr\xF3ximos ${dias} dias)`);
+    if (compromissos.length === 0) {
+      logger.success("Nenhuma prova ou entrega no per\xEDodo. \u{1F389}");
+    }
+    for (const c of compromissos) {
+      const icon = c.tipo === "prova" ? "\u{1F3AF}" : "\u{1F4E6}";
+      logger.item(`${c.data} ${icon} ${c.disciplina} \u2014 ${c.titulo}`);
+    }
+    logger.blank();
+    if (pendencias.length > 0) {
+      logger.warn(
+        `${pendencias.length} pend\xEAncia(s) aberta(s) \u2014 veja "minerva pendencias".`
+      );
+    }
+  });
+}
+
+// src/commands/semestre.ts
+import { Command as Command17 } from "commander";
+function semestreCommand() {
+  return new Command17("semestre").description("Mostra ou define o semestre atual").argument("[numero]", "novo semestre (1-6)").action(async (numero) => {
+    const vault = await requireVault();
+    const matriz = await loadMatriz(vault.root);
+    if (numero === void 0) {
+      const atual = getSemestre(matriz, vault.config.semestreAtual);
+      logger.title(`${atual.numero}\xBA semestre`);
+      logger.info(`Progresso do curso: ${progressBar(atual.numero - 1, 6)}`);
+      for (const d of atual.disciplinas) {
+        logger.item(`${d.nome} (${d.aulas} aulas)`);
+      }
+      return;
+    }
+    const novo = getSemestre(matriz, Number(numero));
+    vault.config.semestreAtual = novo.numero;
+    await saveConfig(vault.root, vault.config);
+    await generateDashboard(vault, matriz);
+    logger.success(
+      `Semestre atual definido para ${novo.numero}\xBA. Dashboard atualizado!`
+    );
+  });
+}
+
+// src/commands/stats.ts
+import chalk4 from "chalk";
+import { Command as Command18 } from "commander";
+
+// src/services/stats.ts
+import path22 from "path";
+import fs17 from "fs-extra";
+var NOTE_FILENAME = /^(\d{4}-\d{2}-\d{2})-(aula|resumo|prova|trabalho|projeto|flashcards)-/;
+async function collectDates(root) {
+  const dates = [];
+  const stack = [root];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    for (const entry of await fs17.readdir(current, { withFileTypes: true })) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+      const full = path22.join(current, entry.name);
+      if (entry.isDirectory()) stack.push(full);
+      else {
+        const match = NOTE_FILENAME.exec(entry.name);
+        if (match) dates.push([match[1], match[2]]);
+      }
+    }
+  }
+  return dates;
+}
+async function collectStats(vault, dias = 30) {
+  const entries = await collectDates(vault.root);
+  const estudoLog = await loadEstudoLog(vault.root);
+  const hoje = todayISO();
+  const inicio = addDaysISO(hoje, -dias);
+  const notasPorDia = {};
+  const notasPorTipo = {};
+  const diasAtivos = new Set(estudoLog.map((s) => s.data));
+  for (const [data, tipo] of entries) {
+    notasPorTipo[tipo] = (notasPorTipo[tipo] ?? 0) + 1;
+    diasAtivos.add(data);
+    if (data >= inicio && data <= hoje) {
+      notasPorDia[data] = (notasPorDia[data] ?? 0) + 1;
+    }
+  }
+  let streak = 0;
+  for (let dia = hoje; diasAtivos.has(dia); dia = addDaysISO(dia, -1)) {
+    streak += 1;
+  }
+  return {
+    notasPorDia,
+    notasPorTipo,
+    streak,
+    horasEstudadas: vault.config.horasEstudadas,
+    totalNotas: entries.length
+  };
+}
+
+// src/commands/stats.ts
+function cell(count) {
+  if (count === 0) return chalk4.dim("\xB7");
+  if (count === 1) return chalk4.green("\u25AA");
+  if (count <= 3) return chalk4.green("\u25AE");
+  return chalk4.bold.green("\u2588");
+}
+function statsCommand() {
+  return new Command18("stats").description("Mostra estat\xEDsticas de const\xE2ncia (notas, streak, horas)").option("--dias <n>", "janela do gr\xE1fico em dias", "30").option("--json", "sa\xEDda em JSON").action(async (options) => {
+    const vault = await requireVault();
+    const dias = Number(options.dias);
+    const stats = await collectStats(vault, dias);
+    if (options.json) {
+      console.log(JSON.stringify(stats, null, 2));
+      return;
+    }
+    logger.title("Suas estat\xEDsticas de estudo");
+    logger.info(`\u{1F525} Streak: ${chalk4.bold(stats.streak)} dia(s) seguidos`);
+    logger.info(`\u23F1\uFE0F  Horas estudadas: ${stats.horasEstudadas}h`);
+    logger.info(`\u{1F4DD} Notas criadas: ${stats.totalNotas}`);
+    logger.blank();
+    const hoje = todayISO();
+    let graph = "";
+    for (let i = dias - 1; i >= 0; i -= 1) {
+      graph += cell(stats.notasPorDia[addDaysISO(hoje, -i)] ?? 0);
+    }
+    logger.info(`\xDAltimos ${dias} dias: ${graph}`);
+    logger.blank();
+    for (const [tipo, total] of Object.entries(stats.notasPorTipo).sort(
+      (a, b) => b[1] - a[1]
+    )) {
+      logger.item(`${tipo}: ${total}`);
+    }
+  });
+}
+
+// src/commands/update-matriz.ts
+import { Command as Command19 } from "commander";
+function updateMatrizCommand() {
+  return new Command19("update-matriz").description("Atualiza a matriz curricular a partir do site da FATEC").option("--url <url>", "URL alternativa da matriz", MATRIZ_URL).action(async (options) => {
+    const vault = await requireVault();
+    const spin = spinner("Baixando matriz curricular...").start();
+    try {
+      const matriz = await fetchMatriz(options.url);
+      await saveMatriz(vault.root, matriz);
+      spin.succeed("Matriz curricular atualizada!");
+      const total = matriz.semestres.reduce(
+        (sum, s) => sum + s.disciplinas.length,
+        0
+      );
+      logger.item(`${total} disciplinas em 6 semestres`);
+      logger.item(`Fonte: ${matriz.fonte}`);
+    } catch (error) {
+      spin.fail("N\xE3o foi poss\xEDvel atualizar a matriz.");
+      logger.warn(
+        "A matriz embutida na CLI continua funcionando normalmente."
+      );
+      throw error;
+    }
+  });
+}
+
+// src/program.ts
+function buildProgram() {
+  const program = new Command20(APP_NAME).description(APP_DESCRIPTION).version(APP_VERSION, "-v, --version", "mostra a vers\xE3o").helpCommand("help [comando]", "mostra ajuda de um comando").showSuggestionAfterError();
+  program.addCommand(initCommand());
+  program.addCommand(dashboardCommand());
+  program.addCommand(aulaCommand());
+  program.addCommand(resumoCommand());
+  program.addCommand(provaCommand());
+  program.addCommand(trabalhoCommand());
+  program.addCommand(projetoCommand());
+  program.addCommand(portfolioCommand());
+  program.addCommand(cheatsheetCommand());
+  program.addCommand(flashcardsCommand());
+  program.addCommand(semestreCommand());
+  program.addCommand(disciplinaCommand());
+  program.addCommand(estudoCommand());
+  program.addCommand(pendenciasCommand());
+  program.addCommand(semanaCommand());
+  program.addCommand(notaCommand());
+  program.addCommand(statsCommand());
+  program.addCommand(openCommand());
+  program.addCommand(commitCommand());
+  program.addCommand(configCommand());
+  program.addCommand(completionCommand());
+  program.addCommand(updateMatrizCommand());
+  program.addCommand(doctorCommand());
+  program.command("version").description("mostra a vers\xE3o da Minerva CLI").action(() => {
+    console.log(APP_VERSION);
+  });
+  return program;
+}
+
+// src/index.ts
+async function main() {
+  try {
+    await buildProgram().parseAsync(process.argv);
+  } catch (error) {
+    if (error instanceof Error && error.name === "ExitPromptError") {
+      logger.info("At\xE9 a pr\xF3xima! \u{1F44B}");
+      return;
+    }
+    logger.error(error instanceof Error ? error.message : String(error));
+    if (process.env["DEBUG"] && error instanceof Error) {
+      console.error(chalk5.dim(error.stack ?? ""));
+    }
+    process.exitCode = 1;
+  }
+}
+void main();
+export {
+  buildProgram
+};
+//# sourceMappingURL=index.js.map