@soltaoverbo/cli 0.2.0

package/.turbo/turbo-build.log

@@ -0,0 +1,13 @@
+
+> @soltaoverbo/cli@0.2.0 build C:\Users\aresn\OneDrive\Documentos\GitHub\verbo\packages\cli
+> tsup
+
+CLI Building entry: src/bin.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.5.1
+CLI Using tsup config: C:\Users\aresn\OneDrive\Documentos\GitHub\verbo\packages\cli\tsup.config.ts
+CLI Target: node20
+CLI Cleaning output folder
+ESM Build start
+ESM dist\bin.js 11.08 KB
+ESM ⚡️ Build success in 26ms

package/dist/bin.js

@@ -0,0 +1,345 @@
+#!/usr/bin/env node
+
+// src/bin.ts
+import { execSync } from "child_process";
+
+// src/commands/install.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { buildTermIndex, loadTerms, SpacedRepetition } from "@soltaoverbo/core";
+
+// src/ui.ts
+var R = "\x1B[0m";
+var bold = (s) => `\x1B[1m${s}${R}`;
+var dim = (s) => `\x1B[2m${s}${R}`;
+var green = (s) => `\x1B[32m${s}${R}`;
+var yellow = (s) => `\x1B[33m${s}${R}`;
+var cyan = (s) => `\x1B[36m${s}${R}`;
+function progressBar(pct, width) {
+  const filled = Math.round(pct / 100 * width);
+  const empty = width - filled;
+  return `\x1B[32m${"\u2588".repeat(filled)}\x1B[2m${"\u2591".repeat(empty)}${R}`;
+}
+
+// src/commands/install.ts
+var CLAUDE_SETTINGS = join(homedir(), ".claude", "settings.json");
+var VERBO_PREFIX = "verbo \xB7 ";
+function runInstall() {
+  if (!existsSync(CLAUDE_SETTINGS)) {
+    console.error(`Claude Code n\xE3o encontrado em ${CLAUDE_SETTINGS}`);
+    process.exit(1);
+  }
+  const settings = JSON.parse(readFileSync(CLAUDE_SETTINGS, "utf-8"));
+  const sr = new SpacedRepetition();
+  const allTerms = buildTermIndex(loadTerms());
+  const absorbed = sr.absorbedIds();
+  const inProgress = sr.inProgressIds();
+  const inProgressTerms = allTerms.filter((t) => inProgress.has(t.id));
+  const newTerms = allTerms.filter((t) => !absorbed.has(t.id) && !inProgress.has(t.id));
+  const candidates = [...inProgressTerms, ...newTerms].slice(0, 10);
+  const verbSpinners = candidates.map((t) => `${VERBO_PREFIX}${t.term} \u2192 ${t.translation}`);
+  const existing = (settings.spinnerVerbs?.verbs ?? []).filter(
+    (v) => !v.startsWith(VERBO_PREFIX)
+  );
+  settings.spinnerVerbs = {
+    mode: settings.spinnerVerbs?.mode ?? "replace",
+    verbs: [...existing, ...verbSpinners]
+  };
+  writeFileSync(CLAUDE_SETTINGS, JSON.stringify(settings, null, 2), "utf-8");
+  console.log();
+  console.log(bold("  verbo instalado no Claude Code!"));
+  console.log(dim("  " + "\u2500".repeat(42)));
+  for (const v of verbSpinners) {
+    console.log(`  ${green("\u2713")} ${v}`);
+  }
+  console.log();
+  console.log(dim("  Esses termos aparecem enquanto o Claude pensa."));
+  console.log(dim("  Rode 'verbo install' novamente para atualizar."));
+  console.log();
+}
+
+// src/commands/list.ts
+import { loadTerms as loadTerms2, SpacedRepetition as SpacedRepetition2 } from "@soltaoverbo/core";
+var CATEGORIES = ["general", "backend", "frontend", "devops", "data", "ai"];
+function runList(args) {
+  const catIdx = args.indexOf("--category");
+  const catFilter = catIdx !== -1 ? args[catIdx + 1]?.toLowerCase() : void 0;
+  const showAbsorbed = args.includes("--absorbed");
+  if (catFilter && !CATEGORIES.includes(catFilter)) {
+    console.error(`Categoria inv\xE1lida: "${catFilter}". V\xE1lidas: ${CATEGORIES.join(", ")}`);
+    process.exit(1);
+  }
+  const sr = new SpacedRepetition2();
+  const absorbed = sr.absorbedIds();
+  let terms = loadTerms2();
+  if (catFilter) terms = terms.filter((t) => t.category === catFilter);
+  if (!showAbsorbed) terms = terms.filter((t) => !absorbed.has(t.id));
+  if (terms.length === 0) {
+    const hint = showAbsorbed ? "" : ` ${dim("(use --absorbed para ver absorvidos)")}`;
+    console.log(dim(`
+  Nenhum termo encontrado.${hint}
+`));
+    return;
+  }
+  const grouped = terms.reduce((acc, t) => {
+    ;
+    (acc[t.category] ??= []).push(t);
+    return acc;
+  }, {});
+  console.log();
+  for (const cat of CATEGORIES) {
+    const group = grouped[cat];
+    if (!group) continue;
+    console.log(bold(`  ${cat.toUpperCase()} (${group.length})`));
+    console.log(dim("  " + "\u2500".repeat(44)));
+    for (const term of group) {
+      const tag = absorbed.has(term.id) ? yellow(" \u2713") : "";
+      console.log(
+        `  ${cyan(term.term.padEnd(22))}${tag} ${green(term.translation)}`
+      );
+      if (term.explanation) {
+        const short = term.explanation.length > 60 ? term.explanation.slice(0, 57) + "..." : term.explanation;
+        console.log(`  ${"".padEnd(22)}   ${dim(short)}`);
+      }
+    }
+    console.log();
+  }
+  console.log(dim(`  Total: ${terms.length} termos
+`));
+}
+
+// src/commands/reset.ts
+import { createInterface } from "readline";
+import { SpacedRepetition as SpacedRepetition3 } from "@soltaoverbo/core";
+async function runReset() {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  await new Promise((resolve) => {
+    rl.question(
+      `${yellow("\u26A0")}  Isso apagar\xE1 todo o hist\xF3rico de aprendizado. Confirmar? ${dim("[s/N]")} `,
+      (answer) => {
+        rl.close();
+        if (answer.trim().toLowerCase() === "s") {
+          new SpacedRepetition3().reset();
+          console.log(bold("\u2713 Hist\xF3rico resetado."));
+        } else {
+          console.log(dim("Cancelado."));
+        }
+        resolve();
+      }
+    );
+  });
+}
+
+// src/commands/start.ts
+import { createInterface as createInterface2 } from "readline";
+import { readFileSync as readFileSync2 } from "fs";
+import { extname } from "path";
+import {
+  buildTermIndex as buildTermIndex2,
+  injectComments,
+  loadTerms as loadTerms3,
+  SpacedRepetition as SpacedRepetition4
+} from "@soltaoverbo/core";
+var CODE_EXTS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".py",
+  ".go",
+  ".rs",
+  ".java",
+  ".kt",
+  ".rb",
+  ".php",
+  ".cs",
+  ".swift",
+  ".dart",
+  ".scala",
+  ".ex",
+  ".exs",
+  ".sh",
+  ".bash",
+  ".zsh",
+  ".fish",
+  ".sql",
+  ".lua",
+  ".c",
+  ".cpp",
+  ".h",
+  ".hpp"
+]);
+async function runStart(args) {
+  const watchIdx = args.indexOf("--watch");
+  const watchDir = watchIdx !== -1 ? args[watchIdx + 1] ?? "." : void 0;
+  const extIdx = args.indexOf("--ext");
+  const extArg = extIdx !== -1 ? args[extIdx + 1] : void 0;
+  const extensions = extArg ? new Set(extArg.split(",").map((e) => e.startsWith(".") ? e : `.${e}`)) : CODE_EXTS;
+  const sr = new SpacedRepetition4();
+  const terms = buildTermIndex2(loadTerms3());
+  if (watchDir) {
+    await watchMode(watchDir, extensions, sr, terms);
+  } else {
+    await pipeMode(sr, terms);
+  }
+}
+async function pipeMode(sr, terms) {
+  const rl = createInterface2({ input: process.stdin, terminal: false });
+  const lines = [];
+  for await (const line of rl) lines.push(line);
+  const seenTerms = sr.absorbedIds();
+  const { code, injected } = injectComments(lines.join("\n"), seenTerms, terms);
+  process.stdout.write(code + "\n");
+  for (const match of injected) sr.markSeen(match.id);
+  if (injected.length > 0) {
+    process.stderr.write(dim(`
+[verbo] ${injected.length} termo(s) anotado(s)
+`));
+  }
+}
+async function watchMode(dir, extensions, sr, terms) {
+  const { default: chokidar } = await import("chokidar");
+  console.error(bold(`[verbo] Observando ${dir}`) + dim(" \u2014 Ctrl+C para parar"));
+  process.stderr.write(renderStatusLine(dir, sr));
+  const watcher = chokidar.watch(dir, {
+    ignoreInitial: true,
+    ignored: /([\\/])(\.git|node_modules|dist|\.turbo)([\\/])/,
+    persistent: true,
+    awaitWriteFinish: { stabilityThreshold: 150, pollInterval: 50 }
+  });
+  const handle = (filePath) => {
+    if (!extensions.has(extname(filePath))) return;
+    let source;
+    try {
+      source = readFileSync2(filePath, "utf-8");
+    } catch {
+      return;
+    }
+    const seenTerms = sr.absorbedIds();
+    const { injected } = injectComments(source, seenTerms, terms);
+    if (injected.length > 0) {
+      process.stderr.write("\r\x1B[2K");
+      for (const match of injected) {
+        sr.markSeen(match.id);
+        logTerm(filePath, match);
+      }
+    }
+    process.stderr.write(renderStatusLine(dir, sr));
+  };
+  watcher.on("add", handle).on("change", handle);
+  await new Promise((resolve) => {
+    process.on("SIGINT", () => {
+      process.stderr.write(dim("\n[verbo] Encerrando...\n"));
+      void watcher.close().then(resolve);
+    });
+  });
+}
+function renderStatusLine(dir, sr) {
+  const s = sr.stats();
+  return `\r\x1B[2K ${bold("verbo")}  ${dim(dir)}  ${dim("\xB7")}  ${cyan(String(s.newToday))} hoje  ${dim("\xB7")}  ${s.total} vistos  ${dim("\xB7")}  ${green(String(s.absorbed))} absorvidos`;
+}
+function logTerm(filePath, match) {
+  const short = filePath.replace(/\\/g, "/").split("/").slice(-2).join("/");
+  process.stderr.write(
+    `${dim(short)}  ${cyan(match.term)} ${dim("\u2192")} ${green(match.translation)}
+${"".padEnd(short.length + 2)}  ${dim(match.explanation)}
+`
+  );
+}
+
+// src/commands/stats.ts
+import { SpacedRepetition as SpacedRepetition5 } from "@soltaoverbo/core";
+function runStats(args = []) {
+  const sr = new SpacedRepetition5();
+  const s = sr.stats();
+  if (args.includes("--short")) {
+    process.stdout.write(`verbo \xB7 ${s.newToday} hoje \xB7 ${s.total} vistos \xB7 ${s.absorbed} abs
+`);
+    return;
+  }
+  console.log();
+  console.log(bold("  verbo \u2014 progresso de aprendizado"));
+  console.log(dim("  " + "\u2500".repeat(38)));
+  console.log(`  ${cyan("Total visto")}:       ${bold(String(s.total))}`);
+  console.log(`  ${green("Absorvidos")}:        ${bold(String(s.absorbed))}`);
+  console.log(`  ${yellow("Em progresso")}:      ${bold(String(s.inProgress))}`);
+  console.log(`  ${cyan("Novos hoje")}:        ${bold(String(s.newToday))}`);
+  if (s.total > 0) {
+    const pct = Math.round(s.absorbed / s.total * 100);
+    console.log();
+    console.log(`  ${progressBar(pct, 32)} ${pct}% absorvido`);
+  }
+  console.log();
+}
+
+// src/bin.ts
+if (process.platform === "win32") {
+  try {
+    execSync("chcp 65001", { stdio: "ignore" });
+  } catch {
+  }
+}
+var VERSION = "0.1.0";
+var [, , sub, ...rest] = process.argv;
+function help() {
+  console.log(`
+  ${bold("verbo")} v${VERSION} \u2014 aprenda ingl\xEAs t\xE9cnico passivamente
+
+  ${bold("USO")}
+    verbo <comando> [op\xE7\xF5es]
+
+  ${bold("COMANDOS")}
+    ${bold("start")}                  Modo pipe: l\xEA stdin e injeta coment\xE1rios em pt-BR
+    ${bold("start --watch")} ${dim("<dir>")}   Observa diret\xF3rio e loga termos novos no terminal
+    ${bold("stats")}                  Mostra seu progresso de aprendizado
+    ${bold("stats --short")}          Sa\xEDda compacta para status bars
+    ${bold("install")}                Injeta termos no Claude Code (barra de pensamento)
+    ${bold("reset")}                  Limpa todo o hist\xF3rico
+    ${bold("list")}                   Lista todos os termos dispon\xEDveis
+    ${bold("list --category")} ${dim("<cat>")}  Filtra por: general, backend, frontend, devops, data
+    ${bold("list --absorbed")}        Inclui termos j\xE1 absorvidos
+
+  ${bold("EXEMPLOS")}
+    cat handler.ts | verbo start
+    verbo start --watch ./src
+    verbo stats
+    verbo install
+    verbo list --category backend
+
+  ${bold("OP\xC7\xD5ES GLOBAIS")}
+    ${bold("--version")}, ${bold("-v")}         Vers\xE3o atual
+    ${bold("--help")}, ${bold("-h")}             Esta ajuda
+`);
+}
+switch (sub) {
+  case "start":
+    await runStart(rest);
+    break;
+  case "stats":
+    runStats(rest);
+    break;
+  case "install":
+    runInstall();
+    break;
+  case "reset":
+    await runReset();
+    break;
+  case "list":
+    runList(rest);
+    break;
+  case "--version":
+  case "-v":
+    console.log(VERSION);
+    break;
+  case "--help":
+  case "-h":
+  case void 0:
+    help();
+    break;
+  default:
+    console.error(`Comando desconhecido: "${sub}". Use "verbo --help" para ver os comandos.`);
+    process.exit(1);
+}

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@soltaoverbo/cli",
+  "version": "0.2.0",
+  "description": "CLI para verbo.dev — aprenda inglês técnico passivamente",
+  "bin": {
+    "verbo": "./dist/bin.js"
+  },
+  "type": "module",
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "lint": "eslint src"
+  },
+  "dependencies": {
+    "@soltaoverbo/core": "workspace:*",
+    "chokidar": "^3.6.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.3.5",
+    "@types/node": "^22.10.1"
+  }
+}

package/src/bin.ts

@@ -0,0 +1,75 @@
+import { execSync } from "node:child_process"
+import { runInstall } from "./commands/install.ts"
+import { runList } from "./commands/list.ts"
+import { runReset } from "./commands/reset.ts"
+import { runStart } from "./commands/start.ts"
+import { runStats } from "./commands/stats.ts"
+import { bold, dim } from "./ui.ts"
+
+if (process.platform === "win32") {
+  try { execSync("chcp 65001", { stdio: "ignore" }) } catch {}
+}
+
+const VERSION = "0.1.0"
+const [, , sub, ...rest] = process.argv
+
+function help(): void {
+  console.log(`
+  ${bold("verbo")} v${VERSION} — aprenda inglês técnico passivamente
+
+  ${bold("USO")}
+    verbo <comando> [opções]
+
+  ${bold("COMANDOS")}
+    ${bold("start")}                  Modo pipe: lê stdin e injeta comentários em pt-BR
+    ${bold("start --watch")} ${dim("<dir>")}   Observa diretório e loga termos novos no terminal
+    ${bold("stats")}                  Mostra seu progresso de aprendizado
+    ${bold("stats --short")}          Saída compacta para status bars
+    ${bold("install")}                Injeta termos no Claude Code (barra de pensamento)
+    ${bold("reset")}                  Limpa todo o histórico
+    ${bold("list")}                   Lista todos os termos disponíveis
+    ${bold("list --category")} ${dim("<cat>")}  Filtra por: general, backend, frontend, devops, data
+    ${bold("list --absorbed")}        Inclui termos já absorvidos
+
+  ${bold("EXEMPLOS")}
+    cat handler.ts | verbo start
+    verbo start --watch ./src
+    verbo stats
+    verbo install
+    verbo list --category backend
+
+  ${bold("OPÇÕES GLOBAIS")}
+    ${bold("--version")}, ${bold("-v")}         Versão atual
+    ${bold("--help")}, ${bold("-h")}             Esta ajuda
+`)
+}
+
+switch (sub) {
+  case "start":
+    await runStart(rest)
+    break
+  case "stats":
+    runStats(rest)
+    break
+  case "install":
+    runInstall()
+    break
+  case "reset":
+    await runReset()
+    break
+  case "list":
+    runList(rest)
+    break
+  case "--version":
+  case "-v":
+    console.log(VERSION)
+    break
+  case "--help":
+  case "-h":
+  case undefined:
+    help()
+    break
+  default:
+    console.error(`Comando desconhecido: "${sub}". Use "verbo --help" para ver os comandos.`)
+    process.exit(1)
+}

package/src/commands/install.ts

@@ -0,0 +1,51 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs"
+import { homedir } from "node:os"
+import { join } from "node:path"
+import { buildTermIndex, loadTerms, SpacedRepetition } from "@soltaoverbo/core"
+import { bold, dim, green } from "../ui.ts"
+
+const CLAUDE_SETTINGS = join(homedir(), ".claude", "settings.json")
+const VERBO_PREFIX = "verbo · "
+
+export function runInstall(): void {
+  if (!existsSync(CLAUDE_SETTINGS)) {
+    console.error(`Claude Code não encontrado em ${CLAUDE_SETTINGS}`)
+    process.exit(1)
+  }
+
+  const settings = JSON.parse(readFileSync(CLAUDE_SETTINGS, "utf-8"))
+
+  const sr = new SpacedRepetition()
+  const allTerms = buildTermIndex(loadTerms())
+  const absorbed = sr.absorbedIds()
+  const inProgress = sr.inProgressIds()
+
+  // Prefer terms already in progress (reforço), complete com novos se precisar
+  const inProgressTerms = allTerms.filter((t) => inProgress.has(t.id))
+  const newTerms = allTerms.filter((t) => !absorbed.has(t.id) && !inProgress.has(t.id))
+  const candidates = [...inProgressTerms, ...newTerms].slice(0, 10)
+
+  const verbSpinners = candidates.map((t) => `${VERBO_PREFIX}${t.term} → ${t.translation}`)
+
+  const existing: string[] = (settings.spinnerVerbs?.verbs ?? []).filter(
+    (v: string) => !v.startsWith(VERBO_PREFIX),
+  )
+
+  settings.spinnerVerbs = {
+    mode: settings.spinnerVerbs?.mode ?? "replace",
+    verbs: [...existing, ...verbSpinners],
+  }
+
+  writeFileSync(CLAUDE_SETTINGS, JSON.stringify(settings, null, 2), "utf-8")
+
+  console.log()
+  console.log(bold("  verbo instalado no Claude Code!"))
+  console.log(dim("  " + "─".repeat(42)))
+  for (const v of verbSpinners) {
+    console.log(`  ${green("✓")} ${v}`)
+  }
+  console.log()
+  console.log(dim("  Esses termos aparecem enquanto o Claude pensa."))
+  console.log(dim("  Rode 'verbo install' novamente para atualizar."))
+  console.log()
+}

package/src/commands/list.ts

@@ -0,0 +1,59 @@
+import { loadTerms, SpacedRepetition } from "@soltaoverbo/core"
+import { bold, cyan, dim, green, yellow } from "../ui.ts"
+
+const CATEGORIES = ["general", "backend", "frontend", "devops", "data", "ai"]
+
+export function runList(args: string[]): void {
+  const catIdx = args.indexOf("--category")
+  const catFilter = catIdx !== -1 ? args[catIdx + 1]?.toLowerCase() : undefined
+  const showAbsorbed = args.includes("--absorbed")
+
+  if (catFilter && !CATEGORIES.includes(catFilter)) {
+    console.error(`Categoria inválida: "${catFilter}". Válidas: ${CATEGORIES.join(", ")}`)
+    process.exit(1)
+  }
+
+  const sr = new SpacedRepetition()
+  const absorbed = sr.absorbedIds()
+
+  let terms = loadTerms()
+  if (catFilter) terms = terms.filter((t) => t.category === catFilter)
+  if (!showAbsorbed) terms = terms.filter((t) => !absorbed.has(t.id))
+
+  if (terms.length === 0) {
+    const hint = showAbsorbed ? "" : ` ${dim("(use --absorbed para ver absorvidos)")}`
+    console.log(dim(`\n  Nenhum termo encontrado.${hint}\n`))
+    return
+  }
+
+  // group by category (Node 20 compat — no Map.groupBy)
+  const grouped = terms.reduce<Record<string, typeof terms>>((acc, t) => {
+    ;(acc[t.category] ??= []).push(t)
+    return acc
+  }, {})
+
+  console.log()
+  for (const cat of CATEGORIES) {
+    const group = grouped[cat]
+    if (!group) continue
+
+    console.log(bold(`  ${cat.toUpperCase()} (${group.length})`))
+    console.log(dim("  " + "─".repeat(44)))
+
+    for (const term of group) {
+      const tag = absorbed.has(term.id) ? yellow(" ✓") : ""
+      console.log(
+        `  ${cyan(term.term.padEnd(22))}${tag} ${green(term.translation)}`,
+      )
+      if (term.explanation) {
+        const short = term.explanation.length > 60
+          ? term.explanation.slice(0, 57) + "..."
+          : term.explanation
+        console.log(`  ${"".padEnd(22)}   ${dim(short)}`)
+      }
+    }
+    console.log()
+  }
+
+  console.log(dim(`  Total: ${terms.length} termos\n`))
+}

package/src/commands/reset.ts

@@ -0,0 +1,23 @@
+import { createInterface } from "node:readline"
+import { SpacedRepetition } from "@soltaoverbo/core"
+import { bold, dim, yellow } from "../ui.ts"
+
+export async function runReset(): Promise<void> {
+  const rl = createInterface({ input: process.stdin, output: process.stdout })
+
+  await new Promise<void>((resolve) => {
+    rl.question(
+      `${yellow("⚠")}  Isso apagará todo o histórico de aprendizado. Confirmar? ${dim("[s/N]")} `,
+      (answer) => {
+        rl.close()
+        if (answer.trim().toLowerCase() === "s") {
+          new SpacedRepetition().reset()
+          console.log(bold("✓ Histórico resetado."))
+        } else {
+          console.log(dim("Cancelado."))
+        }
+        resolve()
+      },
+    )
+  })
+}

package/src/commands/start.ts

@@ -0,0 +1,133 @@
+import { createInterface } from "node:readline"
+import { readFileSync } from "node:fs"
+import { extname } from "node:path"
+import {
+  buildTermIndex,
+  injectComments,
+  loadTerms,
+  SpacedRepetition,
+  type TermMatch,
+} from "@soltaoverbo/core"
+import { bold, cyan, dim, green } from "../ui.ts"
+
+const CODE_EXTS = new Set([
+  ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs",
+  ".py", ".go", ".rs", ".java", ".kt", ".rb", ".php", ".cs",
+  ".swift", ".dart", ".scala", ".ex", ".exs",
+  ".sh", ".bash", ".zsh", ".fish",
+  ".sql", ".lua", ".c", ".cpp", ".h", ".hpp",
+])
+
+export async function runStart(args: string[]): Promise<void> {
+  const watchIdx = args.indexOf("--watch")
+  const watchDir = watchIdx !== -1 ? (args[watchIdx + 1] ?? ".") : undefined
+  const extIdx = args.indexOf("--ext")
+  const extArg = extIdx !== -1 ? args[extIdx + 1] : undefined
+  const extensions = extArg
+    ? new Set(extArg.split(",").map((e) => (e.startsWith(".") ? e : `.${e}`)))
+    : CODE_EXTS
+
+  const sr = new SpacedRepetition()
+  const terms = buildTermIndex(loadTerms())
+
+  if (watchDir) {
+    await watchMode(watchDir, extensions, sr, terms)
+  } else {
+    await pipeMode(sr, terms)
+  }
+}
+
+// ─── Pipe mode ──────────────────────────────────────────────────────────────
+// Usage: cat file.ts | verbo start
+// Reads stdin, injects pt-BR comments, writes to stdout.
+
+async function pipeMode(
+  sr: SpacedRepetition,
+  terms: ReturnType<typeof buildTermIndex>,
+): Promise<void> {
+  const rl = createInterface({ input: process.stdin, terminal: false })
+  const lines: string[] = []
+  for await (const line of rl) lines.push(line)
+
+  const seenTerms = sr.absorbedIds()
+  const { code, injected } = injectComments(lines.join("\n"), seenTerms, terms)
+
+  process.stdout.write(code + "\n")
+
+  for (const match of injected) sr.markSeen(match.id)
+
+  if (injected.length > 0) {
+    process.stderr.write(dim(`\n[verbo] ${injected.length} termo(s) anotado(s)\n`))
+  }
+}
+
+// ─── Watch mode ──────────────────────────────────────────────────────────────
+// Usage: verbo start --watch ./src
+// Watches a directory; logs newly detected terms to stderr without touching files.
+
+async function watchMode(
+  dir: string,
+  extensions: Set<string>,
+  sr: SpacedRepetition,
+  terms: ReturnType<typeof buildTermIndex>,
+): Promise<void> {
+  const { default: chokidar } = await import("chokidar")
+
+  console.error(bold(`[verbo] Observando ${dir}`) + dim(" — Ctrl+C para parar"))
+  process.stderr.write(renderStatusLine(dir, sr))
+
+  const watcher = chokidar.watch(dir, {
+    ignoreInitial: true,
+    ignored: /([\\/])(\.git|node_modules|dist|\.turbo)([\\/])/,
+    persistent: true,
+    awaitWriteFinish: { stabilityThreshold: 150, pollInterval: 50 },
+  })
+
+  const handle = (filePath: string) => {
+    if (!extensions.has(extname(filePath))) return
+    let source: string
+    try { source = readFileSync(filePath, "utf-8") } catch { return }
+
+    const seenTerms = sr.absorbedIds()
+    const { injected } = injectComments(source, seenTerms, terms)
+
+    if (injected.length > 0) {
+      process.stderr.write("\r\x1b[2K")
+      for (const match of injected) {
+        sr.markSeen(match.id)
+        logTerm(filePath, match)
+      }
+    }
+
+    process.stderr.write(renderStatusLine(dir, sr))
+  }
+
+  watcher.on("add", handle).on("change", handle)
+
+  await new Promise<void>((resolve) => {
+    process.on("SIGINT", () => {
+      process.stderr.write(dim("\n[verbo] Encerrando...\n"))
+      void watcher.close().then(resolve)
+    })
+  })
+}
+
+function renderStatusLine(dir: string, sr: SpacedRepetition): string {
+  const s = sr.stats()
+  return (
+    `\r\x1b[2K` +
+    ` ${bold("verbo")}  ${dim(dir)}  ${dim("·")}` +
+    `  ${cyan(String(s.newToday))} hoje` +
+    `  ${dim("·")}  ${s.total} vistos` +
+    `  ${dim("·")}  ${green(String(s.absorbed))} absorvidos`
+  )
+}
+
+function logTerm(filePath: string, match: TermMatch): void {
+  // Show only last 2 path segments to keep lines short
+  const short = filePath.replace(/\\/g, "/").split("/").slice(-2).join("/")
+  process.stderr.write(
+    `${dim(short)}  ${cyan(match.term)} ${dim("→")} ${green(match.translation)}\n` +
+    `${"".padEnd(short.length + 2)}  ${dim(match.explanation)}\n`,
+  )
+}

package/src/commands/stats.ts

@@ -0,0 +1,28 @@
+import { SpacedRepetition } from "@soltaoverbo/core"
+import { bold, cyan, dim, green, progressBar, yellow } from "../ui.ts"
+
+export function runStats(args: string[] = []): void {
+  const sr = new SpacedRepetition()
+  const s = sr.stats()
+
+  if (args.includes("--short")) {
+    process.stdout.write(`verbo · ${s.newToday} hoje · ${s.total} vistos · ${s.absorbed} abs\n`)
+    return
+  }
+
+  console.log()
+  console.log(bold("  verbo — progresso de aprendizado"))
+  console.log(dim("  " + "─".repeat(38)))
+  console.log(`  ${cyan("Total visto")}:       ${bold(String(s.total))}`)
+  console.log(`  ${green("Absorvidos")}:        ${bold(String(s.absorbed))}`)
+  console.log(`  ${yellow("Em progresso")}:      ${bold(String(s.inProgress))}`)
+  console.log(`  ${cyan("Novos hoje")}:        ${bold(String(s.newToday))}`)
+
+  if (s.total > 0) {
+    const pct = Math.round((s.absorbed / s.total) * 100)
+    console.log()
+    console.log(`  ${progressBar(pct, 32)} ${pct}% absorvido`)
+  }
+
+  console.log()
+}

package/src/ui.ts

@@ -0,0 +1,14 @@
+// ANSI helpers — thin wrappers so we never need chalk
+const R = "\x1b[0m"
+
+export const bold  = (s: string) => `\x1b[1m${s}${R}`
+export const dim   = (s: string) => `\x1b[2m${s}${R}`
+export const green = (s: string) => `\x1b[32m${s}${R}`
+export const yellow = (s: string) => `\x1b[33m${s}${R}`
+export const cyan  = (s: string) => `\x1b[36m${s}${R}`
+
+export function progressBar(pct: number, width: number): string {
+  const filled = Math.round((pct / 100) * width)
+  const empty = width - filled
+  return `\x1b[32m${"█".repeat(filled)}\x1b[2m${"░".repeat(empty)}${R}`
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src"]
+}

package/tsup.config.ts

@@ -0,0 +1,13 @@
+import { defineConfig } from "tsup"
+
+export default defineConfig({
+  entry: ["src/bin.ts"],
+  format: ["esm"],
+  target: "node20",
+  outDir: "dist",
+  clean: true,
+  dts: false,
+  // shebang injected by tsup banner so chmod +x works after install
+  banner: { js: "#!/usr/bin/env node" },
+  external: ["chokidar", "@soltaoverbo/core"],
+})