@tostudy-ai/cli 0.16.1 → 0.16.3

package/dist/cli.js

@@ -1304,8 +1304,68 @@ var init_session_store = __esm({
   }
 });
 
+// ../../packages/tostudy-core/src/slug.ts
+function slugify(text, maxLength = 60) {
+  return text.toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, maxLength).replace(/-+$/, "");
+}
+var init_slug = __esm({
+  "../../packages/tostudy-core/src/slug.ts"() {
+    "use strict";
+  }
+});
+
+// ../../packages/tostudy-core/src/lessons/workspace-tokens.ts
+function resolveWorkspaceTokensInText(text, paths) {
+  return text.replace(WORKSPACE_TOKEN, () => paths.workspace).replace(VAULT_TOKEN, () => paths.vault);
+}
+function resolveWorkspaceTokens(value, paths) {
+  if (typeof value === "string") {
+    return resolveWorkspaceTokensInText(value, paths);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => resolveWorkspaceTokens(item, paths));
+  }
+  if (value !== null && typeof value === "object") {
+    const out = {};
+    for (const [key, item] of Object.entries(value)) {
+      out[key] = resolveWorkspaceTokens(item, paths);
+    }
+    return out;
+  }
+  return value;
+}
+var WORKSPACE_TOKEN, VAULT_TOKEN;
+var init_workspace_tokens = __esm({
+  "../../packages/tostudy-core/src/lessons/workspace-tokens.ts"() {
+    "use strict";
+    init_slug();
+    WORKSPACE_TOKEN = /\$WORKSPACE(?![A-Za-z0-9_])/g;
+    VAULT_TOKEN = /\$VAULT(?![A-Za-z0-9_])/g;
+  }
+});
+
 // src/output/formatter.ts
+var formatter_exports = {};
+__export(formatter_exports, {
+  error: () => error,
+  filterExerciseContent: () => filterExerciseContent,
+  formatCourseList: () => formatCourseList,
+  formatHint: () => formatHint,
+  formatLesson: () => formatLesson,
+  formatModuleStart: () => formatModuleStart,
+  formatMoreTheory: () => formatMoreTheory,
+  formatProgress: () => formatProgress,
+  formatValidation: () => formatValidation,
+  jsonError: () => jsonError,
+  output: () => output,
+  progressBar: () => progressBar,
+  setWorkspaceTokenPaths: () => setWorkspaceTokenPaths
+});
+function setWorkspaceTokenPaths(paths) {
+  workspaceTokenPaths = paths;
+}
 function output(data, opts) {
+  if (workspaceTokenPaths) data = resolveWorkspaceTokens(data, workspaceTokenPaths);
   if (opts.json) {
     process.stdout.write(JSON.stringify(data, null, 2) + "\n");
   } else if (typeof data === "string") {
@@ -1547,10 +1607,12 @@ function formatMoreTheory(data) {
   lines.push("", "\u2192 tostudy lesson           voltar ao exerc\xEDcio atual");
   return lines.join("\n");
 }
-var TIER_HEADERS, UNEVALUATED_CRITERION_SENTINEL;
+var workspaceTokenPaths, TIER_HEADERS, UNEVALUATED_CRITERION_SENTINEL;
 var init_formatter = __esm({
   "src/output/formatter.ts"() {
     "use strict";
+    init_workspace_tokens();
+    workspaceTokenPaths = null;
     TIER_HEADERS = [/^## Prática Guiada/im, /^## Prática Semi-?[Gg]uiada/im, /^## Desafio/im];
     UNEVALUATED_CRITERION_SENTINEL = "Crit\xE9rio n\xE3o avaliado explicitamente; tratado como n\xE3o atendido.";
   }
@@ -1978,16 +2040,6 @@ var init_instruction_template_v3 = __esm({
   }
 });
 
-// ../../packages/tostudy-core/src/slug.ts
-function slugify(text, maxLength = 60) {
-  return text.toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, maxLength).replace(/-+$/, "");
-}
-var init_slug = __esm({
-  "../../packages/tostudy-core/src/slug.ts"() {
-    "use strict";
-  }
-});
-
 // src/workspace/runtime-registry.ts
 var runtime_registry_exports = {};
 __export(runtime_registry_exports, {
@@ -2691,6 +2743,15 @@ var init_course_drift = __esm({
 });
 
 // src/onboarding/course-state.ts
+var course_state_exports = {};
+__export(course_state_exports, {
+  checkCourseDrift: () => checkCourseDrift,
+  clearAllCourseOnboarding: () => clearAllCourseOnboarding,
+  getCourseOnboardingState: () => getCourseOnboardingState,
+  saveCourseLearnerProfile: () => saveCourseLearnerProfile,
+  setCourseWorkspacePath: () => setCourseWorkspacePath,
+  setLastInitCourseId: () => setLastInitCourseId
+});
 import fs6 from "node:fs";
 async function getCourseOnboardingState(courseId, configDir) {
   const state = readCourseOnboardingState(configDir);
@@ -2834,6 +2895,120 @@ var init_logout = __esm({
   }
 });
 
+// src/workspace/resolve.ts
+var resolve_exports = {};
+__export(resolve_exports, {
+  cliWorkspacePaths: () => cliWorkspacePaths,
+  courseSlug: () => courseSlug,
+  findCwdWorkspaceUpwards: () => findCwdWorkspaceUpwards,
+  findExistingVault: () => findExistingVault,
+  isCwdWorkspace: () => isCwdWorkspace,
+  resolveActiveCourseFromWorkspace: () => resolveActiveCourseFromWorkspace,
+  resolveActiveCourseWithOverride: () => resolveActiveCourseWithOverride,
+  resolveCwdWorkspacePath: () => resolveCwdWorkspacePath,
+  resolveEffectiveWorkspace: () => resolveEffectiveWorkspace,
+  resolveVaultPath: () => resolveVaultPath,
+  resolveWorkspace: () => resolveWorkspace
+});
+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 = path9.join(basePath, slug);
+  try {
+    await fs7.access(path9.join(candidate, ".ana-config.json"));
+    return { found: true, workspacePath: candidate, source: "default" };
+  } catch {
+    return { found: false, workspacePath: null };
+  }
+}
+async function isCwdWorkspace(cwd = process.cwd()) {
+  return await resolveCwdWorkspacePath(cwd) !== null;
+}
+async function resolveCwdWorkspacePath(cwd = process.cwd()) {
+  const tostudyDir = path9.join(cwd, ".tostudy");
+  try {
+    const stat = await fs7.stat(tostudyDir);
+    if (stat.isDirectory()) return tostudyDir;
+  } catch {
+  }
+  try {
+    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 = 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 = path9.dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+function resolveVaultPath(workspacePath, slug) {
+  const base = path9.basename(workspacePath) === ".tostudy" ? path9.dirname(workspacePath) : workspacePath;
+  return path9.join(base, `vault-${slug}`);
+}
+function cliWorkspacePaths(workspacePath, courseTitle) {
+  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 fs7.access(path9.join(slugged, ".ana-vault.json"));
+    return slugged;
+  } catch {
+  }
+  const legacy = path9.join(workspacePath, "vault");
+  try {
+    await fs7.access(path9.join(legacy, ".ana-vault.json"));
+    return legacy;
+  } catch {
+    return null;
+  }
+}
+async function resolveEffectiveWorkspace(courseTitle, storedPath, cwd = process.cwd(), defaultBasePath = DEFAULT_BASE, homeDir = os6.homedir()) {
+  const cwdWorkspace = await findCwdWorkspaceUpwards(cwd, homeDir);
+  if (cwdWorkspace) {
+    return { found: true, workspacePath: cwdWorkspace, source: "cwd" };
+  }
+  if (storedPath) {
+    try {
+      await fs7.access(path9.join(storedPath, ".ana-config.json"));
+      return { found: true, workspacePath: storedPath, source: "stored" };
+    } catch {
+    }
+  }
+  const result = await resolveWorkspace(courseTitle, defaultBasePath);
+  if (result.found) {
+    return { ...result, source: "default" };
+  }
+  return { found: false, workspacePath: null };
+}
+async function resolveActiveCourseFromWorkspace(options = {}) {
+  const { findWorkspaceState: findWorkspaceState2 } = await Promise.resolve().then(() => (init_workspace_state(), workspace_state_exports));
+  const result = await findWorkspaceState2(options.cwd, options.homeDir);
+  return result?.state ?? null;
+}
+var DEFAULT_BASE, courseSlug, resolveActiveCourseWithOverride;
+var init_resolve = __esm({
+  "src/workspace/resolve.ts"() {
+    "use strict";
+    init_slug();
+    DEFAULT_BASE = path9.join(os6.homedir(), "study");
+    courseSlug = slugify;
+    resolveActiveCourseWithOverride = resolveActiveCourseFromWorkspace;
+  }
+});
+
 // src/auth/guards.ts
 async function refreshCliSession(session, configDir) {
   try {
@@ -2880,10 +3055,32 @@ async function requireSession(configDir) {
 async function requireActiveCourse() {
   const { findWorkspaceState: findWorkspaceState2 } = await Promise.resolve().then(() => (init_workspace_state(), workspace_state_exports));
   const result = await findWorkspaceState2();
-  if (result) return result.state;
+  if (result) {
+    await primeWorkspaceTokenPaths(result.state);
+    return result.state;
+  }
   process.stderr.write("Erro: Nenhum workspace configurado. Rode: tostudy setup\n");
   process.exit(3);
 }
+async function primeWorkspaceTokenPaths(state) {
+  try {
+    const [
+      { setWorkspaceTokenPaths: setWorkspaceTokenPaths2 },
+      { resolveEffectiveWorkspace: resolveEffectiveWorkspace2, cliWorkspacePaths: cliWorkspacePaths2 },
+      onboarding
+    ] = await Promise.all([
+      Promise.resolve().then(() => (init_formatter(), formatter_exports)),
+      Promise.resolve().then(() => (init_resolve(), resolve_exports)),
+      Promise.resolve().then(() => (init_course_state(), course_state_exports))
+    ]);
+    const stored = await onboarding.getCourseOnboardingState(state.courseId);
+    const ws = await resolveEffectiveWorkspace2(state.courseTitle, stored?.workspacePath);
+    setWorkspaceTokenPaths2(
+      ws.found && ws.workspacePath ? cliWorkspacePaths2(ws.workspacePath, state.courseTitle) : null
+    );
+  } catch {
+  }
+}
 var init_guards = __esm({
   "src/auth/guards.ts"() {
     "use strict";
@@ -2999,7 +3196,7 @@ var CLI_VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    CLI_VERSION = true ? "0.16.1" : "0.7.1";
+    CLI_VERSION = true ? "0.16.3" : "0.7.1";
   }
 });
 
@@ -3013,13 +3210,13 @@ __export(update_checker_exports, {
   readCache: () => readCache,
   writeCache: () => writeCache
 });
-import fs7 from "node:fs";
-import path9 from "node:path";
+import fs8 from "node:fs";
+import path10 from "node:path";
 function readCache(configDir) {
   try {
-    const p = path9.join(configDir ?? getConfigDir(), CACHE_FILE);
-    if (!fs7.existsSync(p)) return null;
-    return JSON.parse(fs7.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;
   }
@@ -3027,8 +3224,8 @@ function readCache(configDir) {
 function writeCache(cache, configDir) {
   try {
     const dir = configDir ?? getConfigDir();
-    fs7.mkdirSync(dir, { recursive: true });
-    fs7.writeFileSync(path9.join(dir, CACHE_FILE), JSON.stringify(cache));
+    fs8.mkdirSync(dir, { recursive: true });
+    fs8.writeFileSync(path10.join(dir, CACHE_FILE), JSON.stringify(cache));
   } catch {
   }
 }
@@ -3098,17 +3295,17 @@ var init_update_checker = __esm({
 });
 
 // src/learner-brief/cache.ts
-import fs8 from "node:fs";
-import path10 from "node:path";
+import fs9 from "node:fs";
+import path11 from "node:path";
 function resolveCachePath(configDir) {
-  return path10.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 (!fs8.existsSync(p)) return null;
+  if (!fs9.existsSync(p)) return null;
   try {
-    const raw = fs8.readFileSync(p, "utf-8");
+    const raw = fs9.readFileSync(p, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -3116,8 +3313,8 @@ async function readBriefCache(configDir) {
 }
 async function writeBriefCache(configDir, cache) {
   const dir = configDir ?? getConfigDir();
-  fs8.mkdirSync(dir, { recursive: true });
-  fs8.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"() {
@@ -3127,23 +3324,23 @@ var init_cache = __esm({
 });
 
 // src/tutor-persona/cache.ts
-import fs9 from "node:fs";
-import path11 from "node:path";
+import fs10 from "node:fs";
+import path12 from "node:path";
 function resolveCachePath2(configDir) {
-  return path11.join(configDir, "tutor-personalities.json");
+  return path12.join(configDir, "tutor-personalities.json");
 }
 function readAll(configDir) {
   const p = resolveCachePath2(configDir);
-  if (!fs9.existsSync(p)) return {};
+  if (!fs10.existsSync(p)) return {};
   try {
-    return JSON.parse(fs9.readFileSync(p, "utf-8"));
+    return JSON.parse(fs10.readFileSync(p, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeAll(configDir, cache) {
-  fs9.mkdirSync(configDir, { recursive: true });
-  fs9.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();
@@ -3413,97 +3610,6 @@ var init_courses2 = __esm({
   }
 });
 
-// src/workspace/resolve.ts
-import fs10 from "node:fs/promises";
-import path12 from "node:path";
-import os6 from "node:os";
-function courseSlug(title) {
-  return title.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 60);
-}
-async function resolveWorkspace(courseTitle, basePath = DEFAULT_BASE) {
-  const slug = courseSlug(courseTitle);
-  const candidate = path12.join(basePath, slug);
-  try {
-    await fs10.access(path12.join(candidate, ".ana-config.json"));
-    return { found: true, workspacePath: candidate, source: "default" };
-  } catch {
-    return { found: false, workspacePath: null };
-  }
-}
-async function isCwdWorkspace(cwd = process.cwd()) {
-  return await resolveCwdWorkspacePath(cwd) !== null;
-}
-async function resolveCwdWorkspacePath(cwd = process.cwd()) {
-  const tostudyDir = path12.join(cwd, ".tostudy");
-  try {
-    const stat = await fs10.stat(tostudyDir);
-    if (stat.isDirectory()) return tostudyDir;
-  } catch {
-  }
-  try {
-    await fs10.access(path12.join(cwd, ".ana-config.json"));
-    return cwd;
-  } catch {
-    return null;
-  }
-}
-async function findCwdWorkspaceUpwards(startCwd = process.cwd(), homeDir = os6.homedir()) {
-  const home = path12.resolve(homeDir);
-  let current = path12.resolve(startCwd);
-  while (true) {
-    if (current === home) return null;
-    const direct = await resolveCwdWorkspacePath(current);
-    if (direct) return direct;
-    const parent = path12.dirname(current);
-    if (parent === current) return null;
-    current = parent;
-  }
-}
-function resolveVaultPath(workspacePath, slug) {
-  const base = path12.basename(workspacePath) === ".tostudy" ? path12.dirname(workspacePath) : workspacePath;
-  return path12.join(base, `vault-${slug}`);
-}
-async function findExistingVault(workspacePath, slug) {
-  const slugged = resolveVaultPath(workspacePath, slug);
-  try {
-    await fs10.access(path12.join(slugged, ".ana-vault.json"));
-    return slugged;
-  } catch {
-  }
-  const legacy = path12.join(workspacePath, "vault");
-  try {
-    await fs10.access(path12.join(legacy, ".ana-vault.json"));
-    return legacy;
-  } catch {
-    return null;
-  }
-}
-async function resolveEffectiveWorkspace(courseTitle, storedPath, cwd = process.cwd(), defaultBasePath = DEFAULT_BASE, homeDir = os6.homedir()) {
-  const cwdWorkspace = await findCwdWorkspaceUpwards(cwd, homeDir);
-  if (cwdWorkspace) {
-    return { found: true, workspacePath: cwdWorkspace, source: "cwd" };
-  }
-  if (storedPath) {
-    try {
-      await fs10.access(path12.join(storedPath, ".ana-config.json"));
-      return { found: true, workspacePath: storedPath, source: "stored" };
-    } catch {
-    }
-  }
-  const result = await resolveWorkspace(courseTitle, defaultBasePath);
-  if (result.found) {
-    return { ...result, source: "default" };
-  }
-  return { found: false, workspacePath: null };
-}
-var DEFAULT_BASE;
-var init_resolve = __esm({
-  "src/workspace/resolve.ts"() {
-    "use strict";
-    DEFAULT_BASE = path12.join(os6.homedir(), "study");
-  }
-});
-
 // src/onboarding/status.ts
 async function getCourseOnboardingStatus(activeCourse, configDir, cwd = process.cwd()) {
   const onboardingState = await getCourseOnboardingState(activeCourse.courseId, configDir);
@@ -4187,6 +4293,7 @@ var init_lessons = __esm({
     init_get_hint();
     init_start_module();
     init_start_next_module();
+    init_workspace_tokens();
   }
 });
 
@@ -4431,12 +4538,6 @@ function adjustTimeEstimate(type, baseMinutes) {
 function isCheckpoint(title) {
   return /^checkpoint/i.test(title.trim());
 }
-function replacePlaceholders(text, workspacePath, courseTitle) {
-  const base = path13.basename(workspacePath) === ".tostudy" ? path13.dirname(workspacePath) : workspacePath;
-  const slug = courseSlug(courseTitle);
-  const vaultPath = resolveVaultPath(workspacePath, slug);
-  return text.replace(/\$WORKSPACE(?![A-Za-z0-9_])/g, () => base).replace(/\$VAULT(?![A-Za-z0-9_])/g, () => vaultPath);
-}
 function formatLessonContent(data, workspacePath, courseTitle) {
   const time3 = adjustTimeEstimate(data.type, data.estimatedTimeMinutes);
   const isPractical = data.type === "exercise" || isCheckpoint(data.title);
@@ -4488,6 +4589,7 @@ var init_lesson = __esm({
     init_course_state();
     init_formatter();
     init_resolve();
+    init_workspace_tokens();
     init_errors();
     logger13 = createLogger("cli:lesson");
     lessonCommand = new Command11("lesson").description("Show the content of the current lesson").option("--json", "Output structured JSON").option(
@@ -4523,22 +4625,6 @@ var init_lesson = __esm({
           activeCourse.courseTitle,
           onboardingState?.workspacePath
         );
-        if (ws.found && ws.workspacePath) {
-          if (content.content) {
-            content.content = replacePlaceholders(
-              content.content,
-              ws.workspacePath,
-              activeCourse.courseTitle
-            );
-          }
-          if (content.acceptanceCriteria) {
-            content.acceptanceCriteria = replacePlaceholders(
-              content.acceptanceCriteria,
-              ws.workspacePath,
-              activeCourse.courseTitle
-            );
-          }
-        }
         if (opts.json) {
           output(content, { json: true });
         } else {
@@ -20317,7 +20403,9 @@ function getStarterCode(structuredData) {
   return data?.starterCode ?? null;
 }
 async function extractExercise(input2) {
-  const { lessonData, exerciseTier, workspacePath } = input2;
+  const { exerciseTier, workspacePath } = input2;
+  const paths = input2.workspacePaths ?? { workspace: workspacePath, vault: "$VAULT" };
+  const lessonData = resolveWorkspaceTokens(input2.lessonData, paths);
   const moduleDir = `${padOrder(lessonData.moduleOrder)}-${lessonData.moduleSlug}`;
   const lessonDir = `${padOrder(lessonData.lessonOrder)}-${lessonData.lessonSlug}`;
   const exercisePath = path16.join(workspacePath, "exercises", moduleDir, lessonDir);
@@ -20435,6 +20523,7 @@ var init_extract_exercise = __esm({
   "../../packages/tostudy-core/src/workspace/extract-exercise.ts"() {
     "use strict";
     init_templates();
+    init_workspace_tokens();
   }
 });
 
@@ -20735,7 +20824,10 @@ var init_export = __esm({
         const result = await extractExercise({
           lessonData,
           exerciseTier: tier,
-          workspacePath: ws.workspacePath
+          workspacePath: ws.workspacePath,
+          // Same pair `output()` prints with (GH #1278), so the exercise files on
+          // disk and the lesson text on screen name the same folder (GH #1284).
+          workspacePaths: cliWorkspacePaths(ws.workspacePath, activeCourse.courseTitle)
         });
         if (opts.json) {
           process.stdout.write(JSON.stringify(result, null, 2) + "\n");
@@ -20885,6 +20977,7 @@ var init_vault2 = __esm({
     "use strict";
     init_dist();
     init_vault();
+    init_workspace_tokens();
     init_courses();
     init_http();
     init_guards();
@@ -20930,12 +21023,11 @@ var init_vault2 = __esm({
         if (!data.success) {
           throw new Error("API returned success: false");
         }
-        const result = await writeVaultFiles(
+        const files = resolveWorkspaceTokens(
           data.files,
-          vaultOutputPath,
-          activeCourse.courseId,
-          slug
+          cliWorkspacePaths(workspacePath, activeCourse.courseTitle)
         );
+        const result = await writeVaultFiles(files, vaultOutputPath, activeCourse.courseId, slug);
         logger21.info("Vault generated", {
           courseId: activeCourse.courseId,
           vaultPath: result.vaultPath,