ai-hero-cli 0.1.0 → 0.1.1

package/bin.cjs

@@ -83385,7 +83385,195 @@ var LessonEntrypointNotFoundError = class extends Data_exports.TaggedError(
 ) {
 };
 var runLesson = Effect_exports.fn("runLesson")(function* (opts) {
-  return yield* runLessonSimple(opts);
+  const { cwd, envFilePath, lesson, root } = opts;
+  const service2 = yield* LessonParserService;
+  const lessons = yield* service2.getLessonsFromRepo(root);
+  const foundLessonIndex = lessons.findIndex(
+    (l) => l.num === lesson
+  );
+  if (foundLessonIndex === -1) {
+    return yield* new LessonNotFoundError({
+      lesson,
+      message: `Lesson ${lesson} not found`
+    });
+  }
+  const foundLesson = lessons[foundLessonIndex];
+  const previousLesson = lessons[foundLessonIndex - 1];
+  const nextLesson = lessons[foundLessonIndex + 1];
+  const subfolders = yield* foundLesson.subfolders();
+  if (subfolders.length === 0) {
+    return yield* new LessonEntrypointNotFoundError({
+      lesson,
+      message: `No subfolders found for lesson ${lesson}`
+    });
+  }
+  let subfolderIndex = opts.forceSubfolderIndex;
+  if (subfolderIndex === void 0) {
+    if (subfolders.length === 1) {
+      subfolderIndex = 0;
+    } else {
+      const result2 = yield* selectSubfolderIndex({
+        lesson: foundLesson
+      });
+      subfolderIndex = result2.subfolderIndex;
+    }
+  }
+  const subfolder = subfolders[subfolderIndex];
+  let nextExerciseToRun;
+  const nextSubfolder = subfolders[subfolderIndex + 1];
+  if (nextSubfolder) {
+    nextExerciseToRun = {
+      lessonNumber: foundLesson.num,
+      lessonName: foundLesson.name,
+      subfolderIndex: subfolderIndex + 1,
+      subfolder: nextSubfolder
+    };
+  } else if (nextLesson) {
+    nextExerciseToRun = {
+      lessonNumber: nextLesson.num,
+      lessonName: nextLesson.name,
+      subfolderIndex: 0,
+      subfolder: (yield* nextLesson.subfolders())[0]
+    };
+  } else {
+    nextExerciseToRun = void 0;
+  }
+  let previousExerciseToRun;
+  if (subfolderIndex > 0) {
+    previousExerciseToRun = {
+      lessonNumber: foundLesson.num,
+      lessonName: foundLesson.name,
+      subfolderIndex: subfolderIndex - 1,
+      subfolder: subfolders[subfolderIndex - 1]
+    };
+  } else if (previousLesson) {
+    const previousLessonSubfolders = yield* previousLesson.subfolders();
+    const previousLessonLastSubfolderIndex = previousLessonSubfolders.length - 1;
+    previousExerciseToRun = {
+      lessonNumber: previousLesson.num,
+      lessonName: previousLesson.name,
+      subfolderIndex: previousLessonLastSubfolderIndex,
+      subfolder: previousLessonSubfolders[previousLessonLastSubfolderIndex]
+    };
+  } else {
+    previousExerciseToRun = void 0;
+  }
+  const { mainFile, readmeFile } = yield* getMainAndReadmeFiles({
+    lesson: foundLesson,
+    subfolder
+  });
+  yield* Console_exports.clear;
+  yield* Console_exports.log(
+    util.styleText(
+      "bold",
+      `Running ${foundLesson.num} ${subfolder}...`
+    )
+  );
+  yield* Console_exports.log(
+    util.styleText(
+      "dim",
+      "  Press n + enter to go to the next exercise"
+    )
+  );
+  yield* Console_exports.log(
+    util.styleText("dim", "  Press h + enter for more shortcuts\n")
+  );
+  if (readmeFile) {
+    yield* logReadmeFile({ readmeFile });
+  }
+  const result = yield* Effect_exports.try({
+    try: () => ChildProcess.execSync(
+      `pnpm tsx --env-file="${envFilePath}" "${mainFile}"`,
+      {
+        stdio: "inherit",
+        cwd
+      }
+    ),
+    catch: (error4) => new RunLessonSimpleError({ cause: error4 })
+  }).pipe(
+    Effect_exports.map(() => "success"),
+    Effect_exports.catchAll(() => Effect_exports.succeed("failed"))
+  );
+  const isExplainer = yield* foundLesson.isExplainer();
+  if (isExplainer && readmeFile) {
+    yield* logReadmeFile({ readmeFile });
+  }
+  const lessonNoun = isExplainer ? {
+    successMessage: `Explainer executed! Once you've read the readme and understand the code, you can go to the next exercise.`,
+    failureMessage: `Looks like the explainer errored! Want to try again?`,
+    lowercase: "explainer"
+  } : {
+    successMessage: "Exercise complete! What's next?",
+    failureMessage: `Looks like the exercise errored! Want to try again?`,
+    lowercase: "exercise"
+  };
+  const { choice: choice6 } = yield* runPrompt(
+    () => (0, import_prompts.default)([
+      {
+        type: "select",
+        name: "choice",
+        message: result === "success" ? lessonNoun.successMessage : lessonNoun.failureMessage,
+        choices: [
+          {
+            title: result === "failed" ? `\u{1F504} Run the ${lessonNoun.lowercase} again` : `\u{1F504} Try the ${lessonNoun.lowercase} again`,
+            value: "run-again"
+          },
+          ...nextExerciseToRun ? [
+            {
+              title: `\u27A1\uFE0F  Run the next exercise: ${nextExerciseToRun?.lessonNumber}-${nextExerciseToRun?.lessonName} ${nextExerciseToRun?.subfolder}`,
+              value: "next-exercise"
+            }
+          ] : [],
+          ...previousExerciseToRun ? [
+            {
+              title: `\u2B05\uFE0F  Run the previous exercise: ${previousExerciseToRun?.lessonNumber}-${previousExerciseToRun?.lessonName} ${previousExerciseToRun?.subfolder}`,
+              value: "previous-exercise"
+            }
+          ] : [],
+          {
+            title: "\u{1F4CB} Choose a new exercise",
+            value: "choose-exercise"
+          },
+          {
+            title: "\u2705 Finish",
+            value: "finish"
+          }
+        ]
+      }
+    ])
+  );
+  if (choice6 === "run-again") {
+    return yield* runLesson({
+      lesson,
+      root,
+      envFilePath,
+      cwd,
+      // Run the same exercise again, with the same subfolder index
+      forceSubfolderIndex: subfolderIndex
+    });
+  } else if (choice6 === "choose-exercise") {
+    return yield* chooseLessonAndRunIt({
+      root,
+      envFilePath,
+      cwd
+    });
+  } else if (choice6 === "next-exercise" && nextExerciseToRun) {
+    return yield* runLesson({
+      lesson: nextExerciseToRun.lessonNumber,
+      root,
+      envFilePath,
+      cwd,
+      forceSubfolderIndex: nextExerciseToRun.subfolderIndex
+    });
+  } else if (choice6 === "previous-exercise" && previousExerciseToRun) {
+    return yield* runLesson({
+      lesson: previousExerciseToRun.lessonNumber,
+      root,
+      envFilePath,
+      cwd,
+      forceSubfolderIndex: previousExerciseToRun.subfolderIndex
+    });
+  }
 });
 var logReadmeFile = Effect_exports.fn("logReadmeFile")(
   function* (opts) {
@@ -83466,10 +83654,8 @@ var exercise = Command_exports2.make(
   ({ cwd, debug: debug3, envFilePath, lesson, root, simple: simple3 }) => {
     return Effect_exports.gen(function* () {
       if (simple3) {
-        return yield* Effect_exports.fail(
-          new Error(
-            "Simple is now the default mode, so you no longer need to include the --simple flag"
-          )
+        return yield* Console_exports.log(
+          "Simple mode is now the default mode! No need to use the --simple flag."
         );
       }
       const resolvedEnvFilePath = path4__namespace.relative(
@@ -83501,20 +83687,6 @@ var exercise = Command_exports2.make(
     });
   }
 );
-var findLesson = Effect_exports.fn("findLesson")(function* (opts) {
-  const service2 = yield* LessonParserService;
-  const lessons = yield* service2.getLessonsFromRepo(opts.root);
-  const foundLessonIndex = lessons.findIndex(
-    (l) => l.num === opts.lesson
-  );
-  if (foundLessonIndex === -1) {
-    return yield* new LessonNotFoundError({
-      lesson: opts.lesson,
-      message: `Lesson ${opts.lesson} not found`
-    });
-  }
-  return lessons[foundLessonIndex];
-});
 var selectSubfolderIndex = Effect_exports.fn("selectSubfolder")(
   function* (opts) {
     const subfolders = yield* opts.lesson.subfolders();
@@ -83568,36 +83740,10 @@ var getMainAndReadmeFiles = Effect_exports.fn("getMainAndReadmeFiles")(
     return { mainFile, readmeFile };
   }
 );
-var runLessonSimple = (opts) => Effect_exports.gen(function* () {
-  const { cwd, envFilePath, lesson, root } = opts;
-  const foundLesson = yield* findLesson({
-    lesson,
-    root
-  });
-  const { subfolder } = yield* selectSubfolderIndex({
-    lesson: foundLesson
-  });
-  const { mainFile, readmeFile } = yield* getMainAndReadmeFiles({
-    lesson: foundLesson,
-    subfolder
-  });
-  if (readmeFile) {
-    yield* logReadmeFile({ readmeFile });
-  }
-  yield* Console_exports.log(
-    util.styleText("bold", `Running ${lesson} ${subfolder}...`)
-  );
-  ChildProcess.execSync(
-    `pnpm tsx --env-file="${envFilePath}" "${mainFile}"`,
-    {
-      stdio: "inherit",
-      cwd
-    }
-  );
-  if ((yield* foundLesson.isExplainer()) && readmeFile) {
-    yield* logReadmeFile({ readmeFile });
-  }
-});
+var RunLessonSimpleError = class extends Data_exports.TaggedError(
+  "RunLessonSimpleError"
+) {
+};
 var notFound2 = Symbol("notFound");
 var getNumberFromPathSegment = (path11) => {
   const numberSegment = path11.split("-")[0];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-hero-cli",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "type": "module",
   "description": "The CLI used to run exercises for the AI Hero course",
   "bin": "bin.cjs",