@tostudy-ai/cli 0.16.9 → 0.16.11

package/dist/cli.js

@@ -2829,18 +2829,6 @@ var init_errors_en_us = __esm({
 });
 
 // src/errors/index.ts
-import fs6 from "node:fs";
-import path7 from "node:path";
-function readStoredLocale() {
-  try {
-    const p = path7.join(getConfigDir(), "config.json");
-    if (!fs6.existsSync(p)) return null;
-    const { locale } = JSON.parse(fs6.readFileSync(p, "utf-8"));
-    return locale === "pt-BR" || locale === "en-US" ? locale : null;
-  } catch {
-    return null;
-  }
-}
 function resolveLocale() {
   if (_cachedLocale !== null) return _cachedLocale;
   const argv = process.argv;
@@ -2852,8 +2840,8 @@ function resolveLocale() {
       return val;
     }
   }
-  const stored = readStoredLocale();
-  if (stored) {
+  const stored = process.env["TOSTUDY_LOCALE"];
+  if (stored === "pt-BR" || stored === "en-US") {
     _cachedLocale = stored;
     return stored;
   }
@@ -2888,7 +2876,6 @@ var BUNDLES, _cachedLocale;
 var init_errors = __esm({
   "src/errors/index.ts"() {
     "use strict";
-    init_config_dir();
     init_errors_pt_br();
     init_errors_en_us();
     BUNDLES = {
@@ -2902,12 +2889,12 @@ var init_errors = __esm({
 // src/workspace/workspace-marker.ts
 import { existsSync as existsSync3, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3, readFileSync as readFileSync2 } from "node:fs";
 import os4 from "node:os";
-import path8 from "node:path";
+import path7 from "node:path";
 function resolveMarkerPath(workspacePath) {
-  if (path8.basename(workspacePath) === ".tostudy") {
-    return path8.join(workspacePath, "workspace.json");
+  if (path7.basename(workspacePath) === ".tostudy") {
+    return path7.join(workspacePath, "workspace.json");
   }
-  return path8.join(workspacePath, ".tostudy", "workspace.json");
+  return path7.join(workspacePath, ".tostudy", "workspace.json");
 }
 async function readWorkspaceMarker(workspacePath) {
   const filePath = resolveMarkerPath(workspacePath);
@@ -2925,13 +2912,13 @@ async function readWorkspaceMarker(workspacePath) {
   }
 }
 async function writeWorkspaceMarker(workspacePath, input2, options = {}) {
-  const homeDir = path8.resolve(options.homeDir ?? os4.homedir());
-  const resolvedWorkspace = path8.resolve(workspacePath);
-  if (resolvedWorkspace === homeDir || homeDir.startsWith(resolvedWorkspace + path8.sep)) {
+  const homeDir = path7.resolve(options.homeDir ?? os4.homedir());
+  const resolvedWorkspace = path7.resolve(workspacePath);
+  if (resolvedWorkspace === homeDir || homeDir.startsWith(resolvedWorkspace + path7.sep)) {
     throw new Error(getErrors().workspaceRefusedAtHome);
   }
   const filePath = resolveMarkerPath(workspacePath);
-  const dir = path8.dirname(filePath);
+  const dir = path7.dirname(filePath);
   if (!existsSync3(dir)) {
     mkdirSync3(dir, { recursive: true });
   }
@@ -2968,7 +2955,7 @@ __export(workspace_state_exports, {
 });
 import { readFileSync as readFileSync3, writeFileSync as writeFileSync4 } from "node:fs";
 import os5 from "node:os";
-import path9 from "node:path";
+import path8 from "node:path";
 async function readWorkspaceState(workspacePath) {
   const marker = await readWorkspaceMarker(workspacePath);
   if (!marker) return null;
@@ -2997,13 +2984,13 @@ async function readWorkspaceState(workspacePath) {
   }
 }
 async function findWorkspaceState(startCwd = process.cwd(), homeDir = os5.homedir()) {
-  const home = path9.resolve(homeDir);
-  let current = path9.resolve(startCwd);
+  const home = path8.resolve(homeDir);
+  let current = path8.resolve(startCwd);
   while (true) {
     if (current === home) return null;
     const state = await readWorkspaceState(current);
     if (state) return { state, workspacePath: current };
-    const parent = path9.dirname(current);
+    const parent = path8.dirname(current);
     if (parent === current) return null;
     current = parent;
   }
@@ -3072,7 +3059,7 @@ __export(course_state_exports, {
   setCourseWorkspacePath: () => setCourseWorkspacePath,
   setLastInitCourseId: () => setLastInitCourseId
 });
-import fs7 from "node:fs";
+import fs6 from "node:fs";
 async function getCourseOnboardingState(courseId, configDir) {
   const state = readCourseOnboardingState(configDir);
   return state[courseId] ?? null;
@@ -3094,7 +3081,7 @@ async function saveCourseLearnerProfile(course, learnerProfile, artifacts, confi
 }
 async function clearAllCourseOnboarding(configDir) {
   const onboardingPath = getCourseOnboardingPath(configDir);
-  if (fs7.existsSync(onboardingPath)) fs7.unlinkSync(onboardingPath);
+  if (fs6.existsSync(onboardingPath)) fs6.unlinkSync(onboardingPath);
 }
 var init_course_state = __esm({
   "src/onboarding/course-state.ts"() {
@@ -3137,14 +3124,14 @@ __export(resolve_exports, {
   resolveVaultPath: () => resolveVaultPath,
   resolveWorkspace: () => resolveWorkspace
 });
-import fs8 from "node:fs/promises";
-import path10 from "node:path";
+import fs7 from "node:fs/promises";
+import path9 from "node:path";
 import os6 from "node:os";
 async function resolveWorkspace(courseTitle, basePath = DEFAULT_BASE) {
   const slug = courseSlug(courseTitle);
-  const candidate = path10.join(basePath, slug);
+  const candidate = path9.join(basePath, slug);
   try {
-    await fs8.access(path10.join(candidate, ".ana-config.json"));
+    await fs7.access(path9.join(candidate, ".ana-config.json"));
     return { found: true, workspacePath: candidate, source: "default" };
   } catch {
     return { found: false, workspacePath: null };
@@ -3154,49 +3141,49 @@ async function isCwdWorkspace(cwd = process.cwd()) {
   return await resolveCwdWorkspacePath(cwd) !== null;
 }
 async function resolveCwdWorkspacePath(cwd = process.cwd()) {
-  const tostudyDir = path10.join(cwd, ".tostudy");
+  const tostudyDir = path9.join(cwd, ".tostudy");
   try {
-    const stat = await fs8.stat(tostudyDir);
+    const stat = await fs7.stat(tostudyDir);
     if (stat.isDirectory()) return tostudyDir;
   } catch {
   }
   try {
-    await fs8.access(path10.join(cwd, ".ana-config.json"));
+    await fs7.access(path9.join(cwd, ".ana-config.json"));
     return cwd;
   } catch {
     return null;
   }
 }
 async function findCwdWorkspaceUpwards(startCwd = process.cwd(), homeDir = os6.homedir()) {
-  const home = path10.resolve(homeDir);
-  let current = path10.resolve(startCwd);
+  const home = path9.resolve(homeDir);
+  let current = path9.resolve(startCwd);
   while (true) {
     if (current === home) return null;
     const direct = await resolveCwdWorkspacePath(current);
     if (direct) return direct;
-    const parent = path10.dirname(current);
+    const parent = path9.dirname(current);
     if (parent === current) return null;
     current = parent;
   }
 }
 function resolveVaultPath(workspacePath, slug) {
-  const base = path10.basename(workspacePath) === ".tostudy" ? path10.dirname(workspacePath) : workspacePath;
-  return path10.join(base, `vault-${slug}`);
+  const base = path9.basename(workspacePath) === ".tostudy" ? path9.dirname(workspacePath) : workspacePath;
+  return path9.join(base, `vault-${slug}`);
 }
 function cliWorkspacePaths(workspacePath, courseTitle) {
-  const base = path10.basename(workspacePath) === ".tostudy" ? path10.dirname(workspacePath) : workspacePath;
+  const base = path9.basename(workspacePath) === ".tostudy" ? path9.dirname(workspacePath) : workspacePath;
   return { workspace: base, vault: resolveVaultPath(workspacePath, courseSlug(courseTitle)) };
 }
 async function findExistingVault(workspacePath, slug) {
   const slugged = resolveVaultPath(workspacePath, slug);
   try {
-    await fs8.access(path10.join(slugged, ".ana-vault.json"));
+    await fs7.access(path9.join(slugged, ".ana-vault.json"));
     return slugged;
   } catch {
   }
-  const legacy = path10.join(workspacePath, "vault");
+  const legacy = path9.join(workspacePath, "vault");
   try {
-    await fs8.access(path10.join(legacy, ".ana-vault.json"));
+    await fs7.access(path9.join(legacy, ".ana-vault.json"));
     return legacy;
   } catch {
     return null;
@@ -3209,7 +3196,7 @@ async function resolveEffectiveWorkspace(courseTitle, storedPath, cwd = process.
   }
   if (storedPath) {
     try {
-      await fs8.access(path10.join(storedPath, ".ana-config.json"));
+      await fs7.access(path9.join(storedPath, ".ana-config.json"));
       return { found: true, workspacePath: storedPath, source: "stored" };
     } catch {
     }
@@ -3230,7 +3217,7 @@ var init_resolve = __esm({
   "src/workspace/resolve.ts"() {
     "use strict";
     init_slug();
-    DEFAULT_BASE = path10.join(os6.homedir(), "study");
+    DEFAULT_BASE = path9.join(os6.homedir(), "study");
     courseSlug = slugify;
     resolveActiveCourseWithOverride = resolveActiveCourseFromWorkspace;
   }
@@ -3426,7 +3413,7 @@ var CLI_VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    CLI_VERSION = true ? "0.16.9" : "0.7.1";
+    CLI_VERSION = true ? "0.16.11" : "0.7.1";
   }
 });
 
@@ -3440,13 +3427,13 @@ __export(update_checker_exports, {
   readCache: () => readCache,
   writeCache: () => writeCache
 });
-import fs9 from "node:fs";
-import path11 from "node:path";
+import fs8 from "node:fs";
+import path10 from "node:path";
 function readCache(configDir) {
   try {
-    const p = path11.join(configDir ?? getConfigDir(), CACHE_FILE);
-    if (!fs9.existsSync(p)) return null;
-    return JSON.parse(fs9.readFileSync(p, "utf-8"));
+    const p = path10.join(configDir ?? getConfigDir(), CACHE_FILE);
+    if (!fs8.existsSync(p)) return null;
+    return JSON.parse(fs8.readFileSync(p, "utf-8"));
   } catch {
     return null;
   }
@@ -3454,8 +3441,8 @@ function readCache(configDir) {
 function writeCache(cache, configDir) {
   try {
     const dir = configDir ?? getConfigDir();
-    fs9.mkdirSync(dir, { recursive: true });
-    fs9.writeFileSync(path11.join(dir, CACHE_FILE), JSON.stringify(cache));
+    fs8.mkdirSync(dir, { recursive: true });
+    fs8.writeFileSync(path10.join(dir, CACHE_FILE), JSON.stringify(cache));
   } catch {
   }
 }
@@ -3525,17 +3512,17 @@ var init_update_checker = __esm({
 });
 
 // src/learner-brief/cache.ts
-import fs10 from "node:fs";
-import path12 from "node:path";
+import fs9 from "node:fs";
+import path11 from "node:path";
 function resolveCachePath(configDir) {
-  return path12.join(configDir, "student-brief.json");
+  return path11.join(configDir, "student-brief.json");
 }
 async function readBriefCache(configDir) {
   const dir = configDir ?? getConfigDir();
   const p = resolveCachePath(dir);
-  if (!fs10.existsSync(p)) return null;
+  if (!fs9.existsSync(p)) return null;
   try {
-    const raw = fs10.readFileSync(p, "utf-8");
+    const raw = fs9.readFileSync(p, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -3543,8 +3530,8 @@ async function readBriefCache(configDir) {
 }
 async function writeBriefCache(configDir, cache) {
   const dir = configDir ?? getConfigDir();
-  fs10.mkdirSync(dir, { recursive: true });
-  fs10.writeFileSync(resolveCachePath(dir), JSON.stringify(cache, null, 2), { mode: 384 });
+  fs9.mkdirSync(dir, { recursive: true });
+  fs9.writeFileSync(resolveCachePath(dir), JSON.stringify(cache, null, 2), { mode: 384 });
 }
 var init_cache = __esm({
   "src/learner-brief/cache.ts"() {
@@ -3554,23 +3541,23 @@ var init_cache = __esm({
 });
 
 // src/tutor-persona/cache.ts
-import fs11 from "node:fs";
-import path13 from "node:path";
+import fs10 from "node:fs";
+import path12 from "node:path";
 function resolveCachePath2(configDir) {
-  return path13.join(configDir, "tutor-personalities.json");
+  return path12.join(configDir, "tutor-personalities.json");
 }
 function readAll(configDir) {
   const p = resolveCachePath2(configDir);
-  if (!fs11.existsSync(p)) return {};
+  if (!fs10.existsSync(p)) return {};
   try {
-    return JSON.parse(fs11.readFileSync(p, "utf-8"));
+    return JSON.parse(fs10.readFileSync(p, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeAll(configDir, cache) {
-  fs11.mkdirSync(configDir, { recursive: true });
-  fs11.writeFileSync(resolveCachePath2(configDir), JSON.stringify(cache, null, 2), { mode: 384 });
+  fs10.mkdirSync(configDir, { recursive: true });
+  fs10.writeFileSync(resolveCachePath2(configDir), JSON.stringify(cache, null, 2), { mode: 384 });
 }
 async function readPersonaCacheForCourse(configDir, courseId) {
   const dir = configDir ?? getConfigDir();
@@ -4813,7 +4800,7 @@ var init_next = __esm({
 
 // src/commands/lesson.ts
 import { Command as Command11 } from "commander";
-import path14 from "node:path";
+import path13 from "node:path";
 function adjustTimeEstimate(type, baseMinutes) {
   if (type === "exercise") return Math.max(baseMinutes, 30);
   return baseMinutes;
@@ -4826,7 +4813,7 @@ function formatLessonContent(data, workspacePath, courseTitle) {
   const isPractical = data.type === "exercise" || isCheckpoint(data.title);
   const lines = [`\u2501\u2501\u2501 Li\xE7\xE3o: ${data.title} \u2501\u2501\u2501`];
   if (isPractical && workspacePath) {
-    const base = path14.basename(workspacePath) === ".tostudy" ? path14.dirname(workspacePath) : workspacePath;
+    const base = path13.basename(workspacePath) === ".tostudy" ? path13.dirname(workspacePath) : workspacePath;
     const slug = courseSlug(courseTitle);
     const vaultPath = resolveVaultPath(workspacePath, slug);
     lines.push(
@@ -5370,10 +5357,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path25) {
-  if (!path25)
+function getElementAtPath(obj, path24) {
+  if (!path24)
     return obj;
-  return path25.reduce((acc, key) => acc?.[key], obj);
+  return path24.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -5685,11 +5672,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path25, issues) {
+function prefixIssues(path24, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path25);
+    iss.path.unshift(path24);
     return iss;
   });
 }
@@ -5931,7 +5918,7 @@ function formatError(error49, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error49, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error50, path25 = []) => {
+  const processError = (error50, path24 = []) => {
     var _a2, _b;
     for (const issue2 of error50.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -5941,7 +5928,7 @@ function treeifyError(error49, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path25, ...issue2.path];
+        const fullpath = [...path24, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -5973,8 +5960,8 @@ function treeifyError(error49, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path25 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path25) {
+  const path24 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path24) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -18668,13 +18655,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path25 = ref.slice(1).split("/").filter(Boolean);
-  if (path25.length === 0) {
+  const path24 = ref.slice(1).split("/").filter(Boolean);
+  if (path24.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path25[0] === defsKey) {
-    const key = path25[1];
+  if (path24[0] === defsKey) {
+    const key = path24[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -20006,8 +19993,8 @@ var init_init_template = __esm({
 });
 
 // src/commands/validate.ts
-import fs12 from "node:fs";
-import path15 from "node:path";
+import fs11 from "node:fs";
+import path14 from "node:path";
 import { Command as Command14 } from "commander";
 var logger16, validateCommand;
 var init_validate = __esm({
@@ -20051,21 +20038,21 @@ var init_validate = __esm({
         }
         let solution;
         if (opts.stdin) {
-          solution = fs12.readFileSync("/dev/stdin", "utf-8");
+          solution = fs11.readFileSync("/dev/stdin", "utf-8");
         } else if (file2) {
-          if (!fs12.existsSync(file2)) {
+          if (!fs11.existsSync(file2)) {
             if (opts.json)
               jsonError("file_not_found", { message: `Arquivo n\xE3o encontrado: ${file2}` });
             error(`Arquivo n\xE3o encontrado: ${file2}`);
           }
-          solution = fs12.readFileSync(file2, "utf-8");
+          solution = fs11.readFileSync(file2, "utf-8");
         } else {
           if (opts.json)
             jsonError("no_solution_provided", { message: "Forne\xE7a um arquivo ou use --stdin" });
           error("Forne\xE7a um arquivo ou use --stdin.\n\nExemplo: tostudy validate resposta.md");
         }
         if (file2 && activeCourse.courseTags?.length) {
-          const ext = path15.extname(file2).toLowerCase();
+          const ext = path14.extname(file2).toLowerCase();
           const LANG_EXTENSIONS = {
             ".html": ["html", "html5"],
             ".css": ["css"],
@@ -20533,14 +20520,14 @@ var init_init = __esm({
 });
 
 // ../../packages/tostudy-core/src/workspace/setup-workspace.ts
-import fs13 from "node:fs/promises";
-import path16 from "node:path";
+import fs12 from "node:fs/promises";
+import path15 from "node:path";
 async function setupWorkspace(input2) {
-  const workspacePath = path16.join(input2.basePath, input2.courseSlug);
+  const workspacePath = path15.join(input2.basePath, input2.courseSlug);
   for (const dir of WORKSPACE_DIRS) {
-    await fs13.mkdir(path16.join(workspacePath, dir), { recursive: true });
+    await fs12.mkdir(path15.join(workspacePath, dir), { recursive: true });
   }
-  const configPath = path16.join(workspacePath, ".ana-config.json");
+  const configPath = path15.join(workspacePath, ".ana-config.json");
   const config2 = {
     courseId: input2.courseId,
     courseSlug: input2.courseSlug,
@@ -20550,7 +20537,7 @@ async function setupWorkspace(input2) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     lastAccessedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  await fs13.writeFile(configPath, JSON.stringify(config2, null, 2), "utf-8");
+  await fs12.writeFile(configPath, JSON.stringify(config2, null, 2), "utf-8");
   const readme = [
     `# ${input2.courseName}`,
     "",
@@ -20575,7 +20562,7 @@ async function setupWorkspace(input2) {
     "tostudy vault sync      # Sincronizar progresso",
     "```"
   ].join("\n");
-  await fs13.writeFile(path16.join(workspacePath, "README.md"), readme, "utf-8");
+  await fs12.writeFile(path15.join(workspacePath, "README.md"), readme, "utf-8");
   return { workspacePath, directories: WORKSPACE_DIRS, configPath };
 }
 var WORKSPACE_DIRS;
@@ -20676,8 +20663,8 @@ var init_templates = __esm({
 });
 
 // ../../packages/tostudy-core/src/workspace/extract-exercise.ts
-import fs14 from "node:fs/promises";
-import path17 from "node:path";
+import fs13 from "node:fs/promises";
+import path16 from "node:path";
 function padOrder(n) {
   return String(n).padStart(2, "0");
 }
@@ -20703,16 +20690,16 @@ async function extractExercise(input2) {
   const lessonData = resolveWorkspaceTokens(input2.lessonData, paths);
   const moduleDir = `${padOrder(lessonData.moduleOrder)}-${lessonData.moduleSlug}`;
   const lessonDir = `${padOrder(lessonData.lessonOrder)}-${lessonData.lessonSlug}`;
-  const exercisePath = path17.join(workspacePath, "exercises", moduleDir, lessonDir);
-  await fs14.mkdir(exercisePath, { recursive: true });
+  const exercisePath = path16.join(workspacePath, "exercises", moduleDir, lessonDir);
+  await fs13.mkdir(exercisePath, { recursive: true });
   const extractedFiles = [];
   let hasStarterCode = false;
   if (lessonData.sandpackConfig?.files) {
     for (const [filePath, fileData] of Object.entries(lessonData.sandpackConfig.files)) {
       const cleanPath = filePath.startsWith("/") ? filePath.slice(1) : filePath;
-      const fullPath = path17.join(exercisePath, cleanPath);
-      await fs14.mkdir(path17.dirname(fullPath), { recursive: true });
-      await fs14.writeFile(fullPath, fileData.code, "utf-8");
+      const fullPath = path16.join(exercisePath, cleanPath);
+      await fs13.mkdir(path16.dirname(fullPath), { recursive: true });
+      await fs13.writeFile(fullPath, fileData.code, "utf-8");
       extractedFiles.push(cleanPath);
       hasStarterCode = true;
     }
@@ -20720,13 +20707,13 @@ async function extractExercise(input2) {
     const tierData = getTierData(lessonData.structuredData, exerciseTier);
     const tierCode = tierData?.code;
     if (tierCode) {
-      await fs14.writeFile(path17.join(exercisePath, "exercise.js"), tierCode, "utf-8");
+      await fs13.writeFile(path16.join(exercisePath, "exercise.js"), tierCode, "utf-8");
       extractedFiles.push("exercise.js");
       hasStarterCode = true;
     } else {
       const starter = getStarterCode(lessonData.structuredData);
       if (starter) {
-        await fs14.writeFile(path17.join(exercisePath, "exercise.js"), starter, "utf-8");
+        await fs13.writeFile(path16.join(exercisePath, "exercise.js"), starter, "utf-8");
         extractedFiles.push("exercise.js");
         hasStarterCode = true;
       }
@@ -20744,8 +20731,8 @@ async function extractExercise(input2) {
           ...exerciseDeps
         }
       };
-      await fs14.writeFile(
-        path17.join(exercisePath, "package.json"),
+      await fs13.writeFile(
+        path16.join(exercisePath, "package.json"),
         JSON.stringify(pkgJson, null, 2),
         "utf-8"
       );
@@ -20757,20 +20744,20 @@ async function extractExercise(input2) {
       );
       for (const [configFile, configContent] of Object.entries(scaffold.configs)) {
         if (!sandpackFileNames.has(configFile)) {
-          await fs14.writeFile(path17.join(exercisePath, configFile), configContent, "utf-8");
+          await fs13.writeFile(path16.join(exercisePath, configFile), configContent, "utf-8");
           extractedFiles.push(configFile);
         }
       }
       const setupSh = `#!/bin/sh
 ${scaffold.setupScript}
 `;
-      await fs14.writeFile(path17.join(exercisePath, "setup.sh"), setupSh, "utf-8");
+      await fs13.writeFile(path16.join(exercisePath, "setup.sh"), setupSh, "utf-8");
       extractedFiles.push("setup.sh");
     }
   }
   const readme = generateReadme(lessonData, exerciseTier);
-  const readmePath = path17.join(exercisePath, "README.md");
-  await fs14.writeFile(readmePath, readme, "utf-8");
+  const readmePath = path16.join(exercisePath, "README.md");
+  await fs13.writeFile(readmePath, readme, "utf-8");
   extractedFiles.push("README.md");
   return {
     exercisePath,
@@ -20852,9 +20839,9 @@ var init_workspace = __esm({
 
 // src/commands/workspace.ts
 import { Command as Command17 } from "commander";
-import path18 from "node:path";
+import path17 from "node:path";
 import os8 from "node:os";
-import fs15 from "node:fs/promises";
+import fs14 from "node:fs/promises";
 var logger18, workspaceCommand;
 var init_workspace2 = __esm({
   "src/commands/workspace.ts"() {
@@ -20878,14 +20865,14 @@ var init_workspace2 = __esm({
         let directories;
         if (!opts.path && cwdIsWorkspace) {
           const resolvedCwd = await resolveCwdWorkspacePath(process.cwd());
-          workspacePath = resolvedCwd ?? path18.join(process.cwd(), ".tostudy");
-          await fs15.mkdir(workspacePath, { recursive: true });
+          workspacePath = resolvedCwd ?? path17.join(process.cwd(), ".tostudy");
+          await fs14.mkdir(workspacePath, { recursive: true });
           directories = ["exercises", "generated", "notes", "diagrams"];
           for (const dir of directories) {
-            await fs15.mkdir(path18.join(workspacePath, dir), { recursive: true });
+            await fs14.mkdir(path17.join(workspacePath, dir), { recursive: true });
           }
-          const configPath = path18.join(workspacePath, ".ana-config.json");
-          await fs15.writeFile(
+          const configPath = path17.join(workspacePath, ".ana-config.json");
+          await fs14.writeFile(
             configPath,
             JSON.stringify(
               {
@@ -20903,7 +20890,7 @@ var init_workspace2 = __esm({
             "utf-8"
           );
         } else {
-          const basePath = opts.path ?? path18.join(os8.homedir(), "study");
+          const basePath = opts.path ?? path17.join(os8.homedir(), "study");
           const result2 = await setupWorkspace({
             courseId: activeCourse.courseId,
             courseSlug: courseSlug(activeCourse.courseTitle),
@@ -20937,7 +20924,7 @@ Pr\xF3ximo passo: tostudy export
         process.exit(1);
       }
     });
-    workspaceCommand.command("status").description("Mostrar status do workspace do curso ativo").option("--path <dir>", "Diret\xF3rio base do workspace", path18.join(os8.homedir(), "study")).option("--json", "Output structured JSON").action(async (opts) => {
+    workspaceCommand.command("status").description("Mostrar status do workspace do curso ativo").option("--path <dir>", "Diret\xF3rio base do workspace", path17.join(os8.homedir(), "study")).option("--json", "Output structured JSON").action(async (opts) => {
       try {
         const activeCourse = await requireActiveCourse();
         const onboardingState = await getCourseOnboardingState(activeCourse.courseId);
@@ -20954,40 +20941,40 @@ Pr\xF3ximo passo: tostudy export
         const workspacePath = ws.workspacePath;
         let configData = null;
         try {
-          const raw = await fs15.readFile(path18.join(workspacePath, ".ana-config.json"), "utf-8");
+          const raw = await fs14.readFile(path17.join(workspacePath, ".ana-config.json"), "utf-8");
           configData = JSON.parse(raw);
         } catch {
           configData = null;
         }
-        const exercisesDir = path18.join(workspacePath, "exercises");
+        const exercisesDir = path17.join(workspacePath, "exercises");
         let exerciseCount = 0;
         try {
-          const moduleDirs = await fs15.readdir(exercisesDir);
+          const moduleDirs = await fs14.readdir(exercisesDir);
           for (const modDir of moduleDirs) {
-            const modPath = path18.join(exercisesDir, modDir);
-            const stat = await fs15.stat(modPath);
+            const modPath = path17.join(exercisesDir, modDir);
+            const stat = await fs14.stat(modPath);
             if (stat.isDirectory()) {
-              const lessonDirs = await fs15.readdir(modPath);
+              const lessonDirs = await fs14.readdir(modPath);
               for (const lessonDir of lessonDirs) {
-                const lessonPath = path18.join(modPath, lessonDir);
-                const lstat = await fs15.stat(lessonPath);
+                const lessonPath = path17.join(modPath, lessonDir);
+                const lstat = await fs14.stat(lessonPath);
                 if (lstat.isDirectory()) exerciseCount++;
               }
             }
           }
         } catch {
         }
-        const generatedDir = path18.join(workspacePath, "generated");
+        const generatedDir = path17.join(workspacePath, "generated");
         let artifactCount = 0;
         try {
-          const files = await fs15.readdir(generatedDir);
+          const files = await fs14.readdir(generatedDir);
           artifactCount = files.length;
         } catch {
         }
-        const diagramsDir = path18.join(workspacePath, "diagrams");
+        const diagramsDir = path17.join(workspacePath, "diagrams");
         let diagramCount = 0;
         try {
-          const files = await fs15.readdir(diagramsDir);
+          const files = await fs14.readdir(diagramsDir);
           diagramCount = files.length;
         } catch {
         }
@@ -21036,9 +21023,9 @@ Pr\xF3ximo passo: tostudy export
 
 // src/commands/export.ts
 import { Command as Command18 } from "commander";
-import path19 from "node:path";
+import path18 from "node:path";
 import os9 from "node:os";
-import fs16 from "node:fs/promises";
+import fs15 from "node:fs/promises";
 var logger19, exportCommand;
 var init_export = __esm({
   "src/commands/export.ts"() {
@@ -21051,7 +21038,7 @@ var init_export = __esm({
     init_resolve();
     init_errors();
     logger19 = createLogger("cli:export");
-    exportCommand = new Command18("export").description("Extrair exerc\xEDcio atual para o workspace local").option("--tier <tier>", "Tier do exerc\xEDcio: guided, semiGuided, challenging", "guided").option("--path <dir>", "Diret\xF3rio base do workspace", path19.join(os9.homedir(), "study")).option("--json", "Output structured JSON").action(async (opts) => {
+    exportCommand = new Command18("export").description("Extrair exerc\xEDcio atual para o workspace local").option("--tier <tier>", "Tier do exerc\xEDcio: guided, semiGuided, challenging", "guided").option("--path <dir>", "Diret\xF3rio base do workspace", path18.join(os9.homedir(), "study")).option("--json", "Output structured JSON").action(async (opts) => {
       try {
         const session = await requireSession();
         const activeCourse = await requireActiveCourse();
@@ -21069,21 +21056,21 @@ var init_export = __esm({
           opts.path
         );
         if (ws.found && ws.source === "cwd" && ws.workspacePath) {
-          const configPath = path19.join(ws.workspacePath, ".ana-config.json");
+          const configPath = path18.join(ws.workspacePath, ".ana-config.json");
           let hasConfig = false;
           try {
-            await fs16.access(configPath);
+            await fs15.access(configPath);
             hasConfig = true;
           } catch {
           }
           if (!hasConfig) {
             const slug = courseSlug(activeCourse.courseTitle);
             logger19.info("Auto-initializing workspace", { workspacePath: ws.workspacePath });
-            await fs16.mkdir(ws.workspacePath, { recursive: true });
+            await fs15.mkdir(ws.workspacePath, { recursive: true });
             for (const dir of ["exercises", "generated", "notes", "diagrams"]) {
-              await fs16.mkdir(path19.join(ws.workspacePath, dir), { recursive: true });
+              await fs15.mkdir(path18.join(ws.workspacePath, dir), { recursive: true });
             }
-            await fs16.writeFile(
+            await fs15.writeFile(
               configPath,
               JSON.stringify(
                 {
@@ -21101,7 +21088,7 @@ var init_export = __esm({
               "utf-8"
             );
             await setCourseWorkspacePath(activeCourse.courseId, ws.workspacePath);
-            const isNamespaced = ws.workspacePath === path19.join(process.cwd(), ".tostudy");
+            const isNamespaced = ws.workspacePath === path18.join(process.cwd(), ".tostudy");
             process.stderr.write(
               isNamespaced ? `\u2728 Workspace inicializado em .tostudy/ (isolado do projeto).
 ` : `\u2728 Workspace inicializado nesta pasta.
@@ -21155,7 +21142,7 @@ ${result.files.map((f) => `  \u{1F4C4} ${f}`).join("\n")}
 // src/commands/open.ts
 import { Command as Command19 } from "commander";
 import { execFile as execFile3 } from "node:child_process";
-import path20 from "node:path";
+import path19 from "node:path";
 import os10 from "node:os";
 var logger20, openCommand;
 var init_open = __esm({
@@ -21167,7 +21154,7 @@ var init_open = __esm({
     init_resolve();
     init_errors();
     logger20 = createLogger("cli:open");
-    openCommand = new Command19("open").description("Abrir workspace do curso na IDE").option("--path <dir>", "Diret\xF3rio base do workspace", path20.join(os10.homedir(), "study")).action(async (opts) => {
+    openCommand = new Command19("open").description("Abrir workspace do curso na IDE").option("--path <dir>", "Diret\xF3rio base do workspace", path19.join(os10.homedir(), "study")).action(async (opts) => {
       try {
         const activeCourse = await requireActiveCourse();
         const onboardingState = await getCourseOnboardingState(activeCourse.courseId);
@@ -21221,24 +21208,24 @@ var init_types = __esm({
 });
 
 // ../../packages/tostudy-core/src/vault/write-vault.ts
-import fs17 from "node:fs/promises";
-import path21 from "node:path";
+import fs16 from "node:fs/promises";
+import path20 from "node:path";
 async function writeVaultFiles(files, outputPath, courseId, courseSlug2) {
   for (const file2 of files) {
-    const fullPath = path21.join(outputPath, file2.relativePath);
-    await fs17.mkdir(path21.dirname(fullPath), { recursive: true });
-    await fs17.writeFile(fullPath, file2.content, "utf-8");
+    const fullPath = path20.join(outputPath, file2.relativePath);
+    await fs16.mkdir(path20.dirname(fullPath), { recursive: true });
+    await fs16.writeFile(fullPath, file2.content, "utf-8");
   }
-  const vaultPath = path21.join(outputPath, courseSlug2);
+  const vaultPath = path20.join(outputPath, courseSlug2);
   const marker = {
     courseId,
     courseSlug: courseSlug2,
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     version: VAULT_MARKER_VERSION
   };
-  await fs17.mkdir(vaultPath, { recursive: true });
-  await fs17.writeFile(
-    path21.join(vaultPath, VAULT_MARKER_FILENAME),
+  await fs16.mkdir(vaultPath, { recursive: true });
+  await fs16.writeFile(
+    path20.join(vaultPath, VAULT_MARKER_FILENAME),
     JSON.stringify(marker, null, 2),
     "utf-8"
   );
@@ -21263,9 +21250,9 @@ var init_vault = __esm({
 
 // src/commands/vault.ts
 import { Command as Command20 } from "commander";
-import path22 from "node:path";
+import path21 from "node:path";
 import os11 from "node:os";
-import fs18 from "node:fs/promises";
+import fs17 from "node:fs/promises";
 var logger21, vaultCommand;
 var init_vault2 = __esm({
   "src/commands/vault.ts"() {
@@ -21281,7 +21268,7 @@ var init_vault2 = __esm({
     init_errors();
     logger21 = createLogger("cli:vault");
     vaultCommand = new Command20("vault").description("Gerenciar vault Obsidian do curso");
-    vaultCommand.command("init").description("Gerar vault Obsidian para o curso ativo").option("--path <dir>", "Diret\xF3rio base do workspace", path22.join(os11.homedir(), "study")).option("--json", "Output structured JSON").action(async (opts) => {
+    vaultCommand.command("init").description("Gerar vault Obsidian para o curso ativo").option("--path <dir>", "Diret\xF3rio base do workspace", path21.join(os11.homedir(), "study")).option("--json", "Output structured JSON").action(async (opts) => {
       try {
         const session = await requireSession();
         const activeCourse = await requireActiveCourse();
@@ -21362,7 +21349,7 @@ Para visualizar:
         process.exit(1);
       }
     });
-    vaultCommand.command("sync").description("Sincronizar progresso do curso com o vault local").option("--path <dir>", "Diret\xF3rio base do workspace", path22.join(os11.homedir(), "study")).option("--json", "Output structured JSON").action(async (opts) => {
+    vaultCommand.command("sync").description("Sincronizar progresso do curso com o vault local").option("--path <dir>", "Diret\xF3rio base do workspace", path21.join(os11.homedir(), "study")).option("--json", "Output structured JSON").action(async (opts) => {
       try {
         const session = await requireSession();
         const activeCourse = await requireActiveCourse();
@@ -21388,8 +21375,8 @@ Para visualizar:
         const data = createHttpProvider(session.apiUrl, session.token);
         const deps = { data, logger: logger21 };
         const progress = await getProgress({ enrollmentId: activeCourse.enrollmentId }, deps);
-        const markerPath = path22.join(vaultPath, ".ana-vault.json");
-        const markerRaw = await fs18.readFile(markerPath, "utf-8");
+        const markerPath = path21.join(vaultPath, ".ana-vault.json");
+        const markerRaw = await fs17.readFile(markerPath, "utf-8");
         const marker = JSON.parse(markerRaw);
         marker.lastSyncedAt = (/* @__PURE__ */ new Date()).toISOString();
         marker.progress = {
@@ -21397,10 +21384,10 @@ Para visualizar:
           currentModule: progress.currentModule.title,
           currentLesson: progress.currentLesson.title
         };
-        await fs18.writeFile(markerPath, JSON.stringify(marker, null, 2), "utf-8");
-        const courseIndexPath = path22.join(vaultPath, slug, "index.md");
+        await fs17.writeFile(markerPath, JSON.stringify(marker, null, 2), "utf-8");
+        const courseIndexPath = path21.join(vaultPath, slug, "index.md");
         try {
-          let indexContent = await fs18.readFile(courseIndexPath, "utf-8");
+          let indexContent = await fs17.readFile(courseIndexPath, "utf-8");
           indexContent = indexContent.replace(/\n---\n\n> 📊 Progresso:.*\n/g, "");
           const titleEnd = indexContent.indexOf("\n");
           if (titleEnd !== -1) {
@@ -21411,7 +21398,7 @@ Para visualizar:
 `;
             indexContent = indexContent.slice(0, titleEnd) + banner + indexContent.slice(titleEnd);
           }
-          await fs18.writeFile(courseIndexPath, indexContent, "utf-8");
+          await fs17.writeFile(courseIndexPath, indexContent, "utf-8");
         } catch {
         }
         const syncedAt = marker.lastSyncedAt;
@@ -21731,16 +21718,16 @@ var init_brief_open = __esm({
 });
 
 // src/sessions/storage.ts
-import fs19 from "node:fs";
-import path23 from "node:path";
+import fs18 from "node:fs";
+import path22 from "node:path";
 function sessionsDir(workspacePath) {
-  return path23.join(workspacePath, ".tostudy", "sessions");
+  return path22.join(workspacePath, ".tostudy", "sessions");
 }
 async function saveModuleSummary(workspacePath, input2) {
   const dir = sessionsDir(workspacePath);
-  fs19.mkdirSync(dir, { recursive: true });
+  fs18.mkdirSync(dir, { recursive: true });
   const filename = `module-${input2.moduleId}-summary.md`;
-  const filePath = path23.join(dir, filename);
+  const filePath = path22.join(dir, filename);
   const header = [
     "---",
     `moduleId: ${input2.moduleId}`,
@@ -21749,17 +21736,17 @@ async function saveModuleSummary(workspacePath, input2) {
     "---",
     ""
   ].join("\n");
-  fs19.writeFileSync(filePath, header + input2.summary, { mode: 384 });
+  fs18.writeFileSync(filePath, header + input2.summary, { mode: 384 });
   logger25.debug("Module summary saved", { moduleId: input2.moduleId, path: filePath });
   return filePath;
 }
 async function loadSessionContext(workspacePath) {
   const dir = sessionsDir(workspacePath);
-  if (!fs19.existsSync(dir)) return { moduleSummaries: [] };
-  const files = fs19.readdirSync(dir).filter((f) => f.startsWith("module-") && f.endsWith("-summary.md")).sort();
+  if (!fs18.existsSync(dir)) return { moduleSummaries: [] };
+  const files = fs18.readdirSync(dir).filter((f) => f.startsWith("module-") && f.endsWith("-summary.md")).sort();
   const summaries = [];
   for (const file2 of files) {
-    const content = fs19.readFileSync(path23.join(dir, file2), "utf-8");
+    const content = fs18.readFileSync(path22.join(dir, file2), "utf-8");
     const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
     if (!frontmatterMatch) continue;
     const meta3 = frontmatterMatch[1];
@@ -21781,7 +21768,7 @@ var init_storage = __esm({
 });
 
 // src/commands/compact.ts
-import fs20 from "node:fs";
+import fs19 from "node:fs";
 import { Command as Command26 } from "commander";
 var logger26, compactCommand;
 var init_compact = __esm({
@@ -21801,7 +21788,7 @@ var init_compact = __esm({
           if (opts.json) jsonError("no_workspace");
           error("Nenhum workspace encontrado.");
         }
-        const summary = fs20.readFileSync("/dev/stdin", "utf-8").trim();
+        const summary = fs19.readFileSync("/dev/stdin", "utf-8").trim();
         if (!summary) {
           if (opts.json) jsonError("empty_summary", { message: "Summary vazio" });
           error("Summary vazio. Envie o conte\xFAdo via stdin.");
@@ -23055,11 +23042,11 @@ __export(auto_updater_exports, {
   detectManager: () => detectManager,
   maybeAutoUpdate: () => maybeAutoUpdate
 });
-import fs21 from "node:fs";
-import path24 from "node:path";
+import fs20 from "node:fs";
+import path23 from "node:path";
 import { spawn as spawn2 } from "node:child_process";
 function detectManager(entryRealPath) {
-  const p = entryRealPath.split(path24.sep).join("/");
+  const p = entryRealPath.split(path23.sep).join("/");
   if (p.includes("/pnpm/")) return { cmd: "pnpm", args: ["add", "-g", `${PACKAGE_NAME2}@latest`] };
   if (p.includes("/.bun/")) return { cmd: "bun", args: ["add", "-g", `${PACKAGE_NAME2}@latest`] };
   if (p.includes(`/node_modules/${PACKAGE_NAME2}/`))
@@ -23067,10 +23054,10 @@ function detectManager(entryRealPath) {
   return null;
 }
 function installDir(entryRealPath) {
-  const normalized = entryRealPath.split(path24.sep).join("/");
+  const normalized = entryRealPath.split(path23.sep).join("/");
   const marker = `/node_modules/${PACKAGE_NAME2}/`;
   const idx = normalized.indexOf(marker);
-  if (idx === -1) return path24.dirname(entryRealPath);
+  if (idx === -1) return path23.dirname(entryRealPath);
   return entryRealPath.slice(0, idx + marker.length - 1);
 }
 function maybeAutoUpdate(currentVersion, opts = {}) {
@@ -23086,10 +23073,10 @@ function maybeAutoUpdate(currentVersion, opts = {}) {
     if (cache.attemptedVersion === cache.latest) return;
     const entryPath = opts.entryPath ?? argv[1];
     if (!entryPath) return;
-    const real = fs21.realpathSync(entryPath);
+    const real = fs20.realpathSync(entryPath);
     const mgr = detectManager(real);
     if (!mgr) return;
-    fs21.accessSync(installDir(real), fs21.constants.W_OK);
+    fs20.accessSync(installDir(real), fs20.constants.W_OK);
     writeCache({ ...cache, attemptedVersion: cache.latest }, configDir);
     process.stderr.write(
       `
@@ -23132,6 +23119,18 @@ Update at https://nodejs.org and run the command again.
   );
   process.exit(1);
 }
+if (!process.env["TOSTUDY_LOCALE"]) {
+  try {
+    const { readFileSync: readFileSync4 } = await import("node:fs");
+    const { join: join3 } = await import("node:path");
+    const { homedir: homedir2 } = await import("node:os");
+    const xdg = process.env["XDG_CONFIG_HOME"];
+    const dir = process.platform === "linux" && xdg ? join3(xdg, "tostudy") : join3(homedir2(), ".tostudy");
+    const { locale } = JSON.parse(readFileSync4(join3(dir, "config.json"), "utf-8"));
+    if (locale === "pt-BR" || locale === "en-US") process.env["TOSTUDY_LOCALE"] = locale;
+  } catch {
+  }
+}
 var { createProgram: createProgram2, CLI_VERSION: CLI_VERSION2 } = await Promise.resolve().then(() => (init_cli(), cli_exports));
 var { checkForUpdates: checkForUpdates2 } = await Promise.resolve().then(() => (init_update_checker(), update_checker_exports));
 var { maybeAutoUpdate: maybeAutoUpdate2 } = await Promise.resolve().then(() => (init_auto_updater(), auto_updater_exports));