ai-hero-cli 0.2.15 → 0.3.1

package/bin.cjs

@@ -82665,6 +82665,68 @@ var isMailbox = (u) => hasProperty(u, TypeId29);
 var make66 = make65;
 var toChannel4 = toChannel3;
 
+// src/git-service/errors.ts
+var NotAGitRepoError = class extends Data_exports.TaggedError(
+  "NotAGitRepoError"
+) {
+};
+var FailedToFetchUpstreamError = class extends Data_exports.TaggedError(
+  "FailedToFetchUpstreamError"
+) {
+};
+var FailedToCreateBranchError = class extends Data_exports.TaggedError(
+  "FailedToCreateBranchError"
+) {
+};
+var FailedToDeleteBranchError = class extends Data_exports.TaggedError(
+  "FailedToDeleteBranchError"
+) {
+};
+var FailedToFetchOriginError = class extends Data_exports.TaggedError(
+  "FailedToFetchOriginError"
+) {
+};
+var InvalidRefError = class extends Data_exports.TaggedError(
+  "InvalidRefError"
+) {
+};
+var FailedToTrackBranchError = class extends Data_exports.TaggedError(
+  "FailedToTrackBranchError"
+) {
+};
+var FailedToResetError = class extends Data_exports.TaggedError(
+  "FailedToResetError"
+) {
+};
+var FailedToCommitError = class extends Data_exports.TaggedError(
+  "FailedToCommitError"
+) {
+};
+var CherryPickConflictError = class extends Data_exports.TaggedError(
+  "CherryPickConflictError"
+) {
+};
+var FailedToCheckoutError = class extends Data_exports.TaggedError(
+  "FailedToCheckoutError"
+) {
+};
+var FailedToPushError = class extends Data_exports.TaggedError(
+  "FailedToPushError"
+) {
+};
+var FailedToFetchError = class extends Data_exports.TaggedError(
+  "FailedToFetchError"
+) {
+};
+var MergeConflictError = class extends Data_exports.TaggedError(
+  "MergeConflictError"
+) {
+};
+var RebaseConflictError = class extends Data_exports.TaggedError(
+  "RebaseConflictError"
+) {
+};
+
 // node_modules/.pnpm/@effect+platform@0.90.2_effect@3.17.7/node_modules/@effect/platform/dist/esm/Command.js
 var Command_exports2 = {};
 __export(Command_exports2, {
@@ -83975,11 +84037,6 @@ __export(NodeFileSystem_exports2, {
   layer: () => layer13
 });
 var layer13 = layer6;
-var VALID_UPSTREAM_PATTERNS = [
-  "mattpocock",
-  "ai-hero-dev",
-  "total-typescript"
-];
 var GitServiceConfig = class extends Context_exports.Tag(
   "GitServiceConfig"
 )() {
@@ -83990,716 +84047,427 @@ var defaultGitServiceConfigLayer = Layer_exports.succeed(
     cwd: process.cwd()
   })
 );
-var NotAGitRepoError = class extends Data_exports.TaggedError(
-  "NotAGitRepoError"
-) {
-};
-var FailedToFetchUpstreamError = class extends Data_exports.TaggedError(
-  "FailedToFetchUpstreamError"
-) {
-};
-var FailedToCreateBranchError = class extends Data_exports.TaggedError(
-  "FailedToCreateBranchError"
-) {
-};
-var NoUpstreamFoundError = class extends Data_exports.TaggedError(
-  "NoUpstreamFoundError"
-) {
-};
-var FailedToDeleteBranchError = class extends Data_exports.TaggedError(
-  "FailedToDeleteBranchError"
-) {
-};
-var FailedToFetchOriginError = class extends Data_exports.TaggedError(
-  "FailedToFetchOriginError"
-) {
-};
-var InvalidRefError = class extends Data_exports.TaggedError(
-  "InvalidRefError"
-) {
-};
-var FailedToTrackBranchError = class extends Data_exports.TaggedError(
-  "FailedToTrackBranchError"
-) {
-};
-var FailedToResetError = class extends Data_exports.TaggedError(
-  "FailedToResetError"
-) {
-};
-var FailedToCommitError = class extends Data_exports.TaggedError(
-  "FailedToCommitError"
-) {
-};
-var CherryPickConflictError = class extends Data_exports.TaggedError(
-  "CherryPickConflictError"
-) {
-};
-var FailedToCheckoutError = class extends Data_exports.TaggedError(
-  "FailedToCheckoutError"
-) {
-};
-var FailedToPushError = class extends Data_exports.TaggedError(
-  "FailedToPushError"
-) {
-};
-var FailedToFetchError = class extends Data_exports.TaggedError(
-  "FailedToFetchError"
-) {
-};
-var MergeConflictError = class extends Data_exports.TaggedError(
-  "MergeConflictError"
-) {
-};
-var RebaseConflictError = class extends Data_exports.TaggedError(
-  "RebaseConflictError"
-) {
-};
-var NoParentCommitError = class extends Data_exports.TaggedError(
-  "NoParentCommitError"
-) {
-};
-var GitService = class extends Effect_exports.Service()(
-  "GitService",
-  {
-    effect: Effect_exports.gen(function* () {
-      const config3 = yield* GitServiceConfig;
-      const fs = yield* FileSystem_exports.FileSystem;
-      const runCommandWithString = Effect_exports.fn(
-        "runCommandWithString"
-      )(function* (...commandArgs) {
-        const cwd = config3.cwd;
-        const command2 = Command_exports2.make(...commandArgs).pipe(
-          Command_exports2.workingDirectory(cwd)
+var mapExitCode = (exitCode3, makeError) => {
+  if (exitCode3 !== 0) {
+    return Effect_exports.fail(makeError(exitCode3));
+  }
+  return Effect_exports.void;
+};
+var makeGitService = Effect_exports.gen(function* () {
+  const config3 = yield* GitServiceConfig;
+  const fs = yield* FileSystem_exports.FileSystem;
+  const runCommandWithString = Effect_exports.fn(
+    "runCommandWithString"
+  )(function* (...commandArgs) {
+    const cwd = config3.cwd;
+    const command2 = Command_exports2.make(...commandArgs).pipe(
+      Command_exports2.workingDirectory(cwd)
+    );
+    return (yield* Command_exports2.string(command2)).trim();
+  });
+  const runCommandWithExitCode = Effect_exports.fn(
+    "runCommandWithExitCode"
+  )(function* (...commandArgs) {
+    const cwd = config3.cwd;
+    const command2 = Command_exports2.make(...commandArgs).pipe(
+      Command_exports2.workingDirectory(cwd),
+      Command_exports2.stdout("inherit"),
+      Command_exports2.stderr("inherit")
+    );
+    return yield* Command_exports2.exitCode(command2);
+  });
+  const resetHard = Effect_exports.fn("resetHard")(function* (sha) {
+    const exitCode3 = yield* runCommandWithExitCode(
+      "git",
+      "reset",
+      "--hard",
+      sha
+    );
+    yield* mapExitCode(
+      exitCode3,
+      (code2) => new FailedToResetError({
+        sha,
+        message: `Failed to reset to ${sha} (exit code: ${code2})`
+      })
+    );
+  });
+  const resetHead = Effect_exports.fn("resetHead")(function* () {
+    yield* runCommandWithExitCode("git", "reset", "HEAD^");
+  });
+  const restoreStaged = Effect_exports.fn(
+    "restoreStaged"
+  )(function* () {
+    yield* runCommandWithExitCode(
+      "git",
+      "restore",
+      "--staged",
+      "."
+    );
+  });
+  return {
+    fetchOrigin: Effect_exports.fn("fetchOrigin")(function* () {
+      const exitCode3 = yield* runCommandWithExitCode(
+        "git",
+        "fetch",
+        "origin"
+      );
+      yield* mapExitCode(
+        exitCode3,
+        (code2) => new FailedToFetchOriginError({
+          message: `Failed to fetch from origin (exit code: ${code2})`
+        })
+      );
+    }),
+    revParse: Effect_exports.fn("revParse")(function* (ref) {
+      const result = yield* runCommandWithString(
+        "git",
+        "rev-parse",
+        ref
+      ).pipe(
+        Effect_exports.catchAll(
+          () => Effect_exports.fail(
+            new InvalidRefError({
+              ref,
+              message: `Failed to resolve ref: ${ref}`
+            })
+          )
+        )
+      );
+      return result;
+    }),
+    revListCount: Effect_exports.fn("revListCount")(function* (from, to) {
+      const countOutput = yield* runCommandWithString(
+        "git",
+        "rev-list",
+        "--count",
+        `${from}..${to}`
+      );
+      return parseInt(countOutput, 10);
+    }),
+    getStatusShort: Effect_exports.fn("getStatusShort")(
+      function* () {
+        return yield* runCommandWithString(
+          "git",
+          "status",
+          "--short"
         );
-        return (yield* Command_exports2.string(command2)).trim();
-      });
-      const runCommandWithExitCode = Effect_exports.fn(
-        "runCommandWithExitCode"
-      )(function* (...commandArgs) {
-        const cwd = config3.cwd;
-        const command2 = Command_exports2.make(...commandArgs).pipe(
-          Command_exports2.workingDirectory(cwd),
-          Command_exports2.stdout("inherit"),
-          Command_exports2.stderr("inherit")
+      }
+    ),
+    resetHard,
+    resetHead,
+    restoreStaged,
+    applyAsUnstagedChanges: Effect_exports.fn(
+      "applyAsUnstagedChanges"
+    )(function* (sha) {
+      yield* resetHard(sha);
+      yield* resetHead();
+      yield* restoreStaged();
+    }),
+    stageAll: Effect_exports.fn("stageAll")(function* () {
+      yield* runCommandWithExitCode("git", "add", ".");
+    }),
+    commit: Effect_exports.fn("commit")(function* (message) {
+      const exitCode3 = yield* runCommandWithExitCode(
+        "git",
+        "commit",
+        "-m",
+        message
+      );
+      yield* mapExitCode(
+        exitCode3,
+        (code2) => new FailedToCommitError({
+          message: `Failed to commit (exit code: ${code2})`
+        })
+      );
+    }),
+    cherryPick: Effect_exports.fn("cherryPick")(function* (range4) {
+      const exitCode3 = yield* runCommandWithExitCode(
+        "git",
+        "cherry-pick",
+        range4
+      );
+      yield* mapExitCode(
+        exitCode3,
+        () => new CherryPickConflictError({
+          range: range4,
+          message: `Cherry-pick conflict on range ${range4}`
+        })
+      );
+    }),
+    cherryPickContinue: Effect_exports.fn("cherryPickContinue")(
+      function* () {
+        const exitCode3 = yield* runCommandWithExitCode(
+          "git",
+          "cherry-pick",
+          "--continue"
         );
-        return yield* Command_exports2.exitCode(command2);
-      });
-      const detectUpstreamRemote = Effect_exports.fn(
-        "detectUpstreamRemote"
-      )(function* () {
-        const remotes = yield* runCommandWithString(
+        yield* mapExitCode(
+          exitCode3,
+          () => new CherryPickConflictError({
+            range: "continue",
+            message: "Cherry-pick continue encountered conflicts"
+          })
+        );
+      }
+    ),
+    cherryPickAbort: Effect_exports.fn("cherryPickAbort")(
+      function* () {
+        yield* runCommandWithExitCode(
           "git",
-          "remote",
-          "-v"
+          "cherry-pick",
+          "--abort"
         );
-        for (const line4 of remotes.split("\n")) {
-          const match18 = line4.match(/^(\S+)\s+(\S+)/);
-          if (match18) {
-            const remoteName = match18[1].trim();
-            const url2 = match18[2].trim();
-            if (VALID_UPSTREAM_PATTERNS.some(
-              (pattern2) => url2.includes(pattern2)
-            )) {
-              return { remoteName, url: url2 };
-            }
-          }
-        }
-        return yield* Effect_exports.fail(
-          new NoUpstreamFoundError({
-            message: `No valid upstream remote found.
-Looking for repos from usernames: ${VALID_UPSTREAM_PATTERNS.join(
-              ", "
-            )}
-
-Add upstream remote:
-  git remote add upstream https://github.com/<username>/<repo>.git`
+      }
+    ),
+    checkout: Effect_exports.fn("checkout")(function* (branch) {
+      const exitCode3 = yield* runCommandWithExitCode(
+        "git",
+        "checkout",
+        branch
+      );
+      yield* mapExitCode(
+        exitCode3,
+        (code2) => new FailedToCheckoutError({
+          branch,
+          message: `Failed to checkout ${branch} (exit code: ${code2})`
+        })
+      );
+    }),
+    pushForceWithLease: Effect_exports.fn("pushForceWithLease")(
+      function* (remote, branch) {
+        const exitCode3 = yield* runCommandWithExitCode(
+          "git",
+          "push",
+          remote,
+          branch,
+          "--force-with-lease"
+        );
+        yield* mapExitCode(
+          exitCode3,
+          (code2) => new FailedToPushError({
+            remote,
+            branch,
+            message: `Failed to push ${branch} to ${remote} (exit code: ${code2})`
           })
         );
-      });
+      }
+    ),
+    checkoutNewBranch: Effect_exports.fn("checkoutNewBranch")(
+      function* (branchName) {
+        const exitCode3 = yield* runCommandWithExitCode(
+          "git",
+          "checkout",
+          "-b",
+          branchName
+        );
+        yield* mapExitCode(
+          exitCode3,
+          (code2) => new FailedToCreateBranchError({
+            branchName,
+            message: `Failed to create branch ${branchName} (exit code: ${code2})`
+          })
+        );
+      }
+    ),
+    getLogOnelineReverse: Effect_exports.fn("getLogOnelineReverse")(
+      function* (range4) {
+        return yield* runCommandWithString(
+          "git",
+          "log",
+          "--oneline",
+          "--reverse",
+          range4
+        );
+      }
+    ),
+    getLogOneline: Effect_exports.fn("getLogOneline")(function* (branch) {
+      return yield* runCommandWithString(
+        "git",
+        "log",
+        branch,
+        "--oneline"
+      );
+    }),
+    checkoutNewBranchAt: Effect_exports.fn("checkoutNewBranchAt")(
+      function* (branchName, sha) {
+        const exitCode3 = yield* runCommandWithExitCode(
+          "git",
+          "checkout",
+          "-b",
+          branchName,
+          sha
+        );
+        yield* mapExitCode(
+          exitCode3,
+          (code2) => new FailedToCreateBranchError({
+            branchName,
+            message: `Failed to create branch ${branchName} at ${sha} (exit code: ${code2})`
+          })
+        );
+      }
+    ),
+    deleteBranch: Effect_exports.fn("deleteBranch")(function* (branchName) {
+      const exitCode3 = yield* runCommandWithExitCode(
+        "git",
+        "branch",
+        "-D",
+        branchName
+      );
+      yield* mapExitCode(
+        exitCode3,
+        (code2) => new FailedToDeleteBranchError({
+          branchName,
+          message: `Failed to delete branch ${branchName} (exit code: ${code2})`
+        })
+      );
+    }),
+    fetch: Effect_exports.fn("fetch")(function* (remote, branch) {
+      const exitCode3 = yield* runCommandWithExitCode(
+        "git",
+        "fetch",
+        remote,
+        branch
+      );
+      yield* mapExitCode(
+        exitCode3,
+        (code2) => new FailedToFetchError({
+          remote,
+          branch,
+          message: `Failed to fetch ${branch} from ${remote} (exit code: ${code2})`
+        })
+      );
+    }),
+    merge: Effect_exports.fn("merge")(function* (ref) {
+      const exitCode3 = yield* runCommandWithExitCode(
+        "git",
+        "merge",
+        ref,
+        "--allow-unrelated-histories"
+      );
+      yield* mapExitCode(
+        exitCode3,
+        () => new MergeConflictError({
+          ref,
+          message: `Merge conflicts detected when merging ${ref}`
+        })
+      );
+    }),
+    rebase: Effect_exports.fn("rebase")(function* (onto) {
+      const exitCode3 = yield* runCommandWithExitCode(
+        "git",
+        "rebase",
+        onto
+      );
+      yield* mapExitCode(
+        exitCode3,
+        () => new RebaseConflictError({
+          onto,
+          message: `Rebase conflicts detected when rebasing onto ${onto}`
+        })
+      );
+    }),
+    ensureIsGitRepo: Effect_exports.fn("ensureIsGitRepo")(
+      function* () {
+        const cwd = config3.cwd;
+        const gitDirPath = path6__namespace.join(cwd, ".git");
+        const exists4 = yield* fs.exists(gitDirPath);
+        if (!exists4) {
+          return yield* new NotAGitRepoError({
+            path: cwd,
+            message: `Current directory is not a git repository: ${cwd}`
+          });
+        }
+      }
+    ),
+    getUncommittedChanges: Effect_exports.fn(
+      "getUncommittedChanges"
+    )(function* () {
+      const statusOutput = yield* runCommandWithString(
+        "git",
+        "status",
+        "--porcelain"
+      );
       return {
-        /**
-         * Fetches the latest changes from the origin remote.
-         * This updates remote-tracking branches (e.g., origin/main) without
-         * modifying local branches or the working directory.
-         *
-         * @returns Effect that succeeds when fetch completes
-         * @throws FailedToFetchOriginError if fetch fails (network, auth, or remote issues)
-         */
-        fetchOrigin: Effect_exports.fn("fetchOrigin")(function* () {
-          const exitCode3 = yield* runCommandWithExitCode(
-            "git",
-            "fetch",
-            "origin"
-          );
-          if (exitCode3 !== 0) {
-            return yield* Effect_exports.fail(
-              new FailedToFetchOriginError({
-                message: `Failed to fetch from origin (exit code: ${exitCode3})`
-              })
-            );
-          }
-        }),
-        /**
-         * Resolves a git ref (branch name, tag, or partial SHA) to its full SHA.
-         * Uses `git rev-parse` which handles all ref types.
-         *
-         * @param ref - The ref to resolve (e.g., "main", "origin/main", "HEAD", or a SHA)
-         * @returns The full SHA of the resolved ref
-         * @throws InvalidRefError if the ref cannot be resolved
-         */
-        revParse: Effect_exports.fn("revParse")(function* (ref) {
-          const result = yield* runCommandWithString(
-            "git",
-            "rev-parse",
-            ref
-          ).pipe(
-            Effect_exports.catchAll(
-              () => Effect_exports.fail(
-                new InvalidRefError({
-                  ref,
-                  message: `Failed to resolve ref: ${ref}`
-                })
-              )
-            )
-          );
-          return result;
-        }),
-        /**
-         * Counts the number of commits between two refs.
-         * Uses `git rev-list --count from..to` which counts commits reachable
-         * from `to` but not from `from`.
-         *
-         * @param from - Starting ref (exclusive)
-         * @param to - Ending ref (inclusive)
-         * @returns Number of commits in the range
-         */
-        revListCount: Effect_exports.fn("revListCount")(function* (from, to) {
-          const countOutput = yield* runCommandWithString(
-            "git",
-            "rev-list",
-            "--count",
-            `${from}..${to}`
-          );
-          return parseInt(countOutput, 10);
-        }),
-        /**
-         * Gets the short status output from git.
-         * Uses `git status --short` which outputs one line per file with
-         * a two-letter status code (e.g., "M " for modified, "??" for untracked).
-         *
-         * @returns The short status output as a string
-         */
-        getStatusShort: Effect_exports.fn("getStatusShort")(
-          function* () {
-            return yield* runCommandWithString(
-              "git",
-              "status",
-              "--short"
-            );
-          }
-        ),
-        /**
-         * Performs a hard reset to the specified SHA.
-         * WARNING: This discards all uncommitted changes and moves HEAD to the target.
-         * Any uncommitted work in the working directory and staging area will be lost.
-         *
-         * @param sha - The commit SHA to reset to
-         * @returns Effect that succeeds when reset completes
-         * @throws FailedToResetError if the reset fails
-         */
-        resetHard: Effect_exports.fn("resetHard")(function* (sha) {
-          const exitCode3 = yield* runCommandWithExitCode(
-            "git",
-            "reset",
-            "--hard",
-            sha
-          );
-          if (exitCode3 !== 0) {
-            return yield* Effect_exports.fail(
-              new FailedToResetError({
-                sha,
-                message: `Failed to reset to ${sha} (exit code: ${exitCode3})`
-              })
-            );
-          }
-        }),
-        /**
-         * Performs a soft reset of the last commit (git reset HEAD^).
-         * This undoes the last commit but keeps all changes in the working directory.
-         * The changes from the undone commit become unstaged modifications.
-         *
-         * @returns Effect that succeeds when reset completes
-         */
-        resetHead: Effect_exports.fn("resetHead")(function* () {
-          yield* runCommandWithExitCode("git", "reset", "HEAD^");
-        }),
-        /**
-         * Unstages all staged files (git restore --staged .).
-         * This moves files from the staging area back to unstaged state
-         * without discarding any modifications.
-         *
-         * @returns Effect that succeeds when restore completes
-         */
-        restoreStaged: Effect_exports.fn("restoreStaged")(function* () {
-          yield* runCommandWithExitCode(
-            "git",
-            "restore",
-            "--staged",
-            "."
-          );
-        }),
-        /**
-         * Stages all changes in the working directory (git add .).
-         * This adds all modified, deleted, and new files to the staging area.
-         *
-         * @returns Effect that succeeds when staging completes
-         */
-        stageAll: Effect_exports.fn("stageAll")(function* () {
-          yield* runCommandWithExitCode("git", "add", ".");
-        }),
-        /**
-         * Creates a new commit with the specified message.
-         * All currently staged changes will be included in the commit.
-         *
-         * @param message - The commit message
-         * @returns Effect that succeeds when commit completes
-         * @throws FailedToCommitError if the commit fails (e.g., nothing staged, hook failure)
-         */
-        commit: Effect_exports.fn("commit")(function* (message) {
-          const exitCode3 = yield* runCommandWithExitCode(
-            "git",
-            "commit",
-            "-m",
-            message
-          );
-          if (exitCode3 !== 0) {
-            return yield* Effect_exports.fail(
-              new FailedToCommitError({
-                message: `Failed to commit (exit code: ${exitCode3})`
-              })
-            );
-          }
-        }),
-        /**
-         * Cherry-picks a range of commits onto the current branch.
-         * The range is specified as "from..to" where commits after "from"
-         * up to and including "to" are applied.
-         *
-         * @param range - The commit range to cherry-pick (e.g., "abc123..def456")
-         * @returns Effect that succeeds when cherry-pick completes
-         * @throws CherryPickConflictError if conflicts occur during cherry-pick
-         */
-        cherryPick: Effect_exports.fn("cherryPick")(function* (range4) {
-          const exitCode3 = yield* runCommandWithExitCode(
-            "git",
-            "cherry-pick",
-            range4
-          );
-          if (exitCode3 !== 0) {
-            return yield* Effect_exports.fail(
-              new CherryPickConflictError({
-                range: range4,
-                message: `Cherry-pick conflict on range ${range4}`
-              })
-            );
-          }
-        }),
-        /**
-         * Continues a cherry-pick after conflicts have been resolved.
-         * Call this after manually resolving conflicts and staging the changes.
-         *
-         * @returns Effect that succeeds when cherry-pick continues, or fails if more conflicts
-         * @throws CherryPickConflictError if additional conflicts occur
-         */
-        cherryPickContinue: Effect_exports.fn("cherryPickContinue")(
-          function* () {
-            const exitCode3 = yield* runCommandWithExitCode(
-              "git",
-              "cherry-pick",
-              "--continue"
-            );
-            if (exitCode3 !== 0) {
-              return yield* Effect_exports.fail(
-                new CherryPickConflictError({
-                  range: "continue",
-                  message: "Cherry-pick continue encountered conflicts"
-                })
-              );
-            }
-          }
-        ),
-        /**
-         * Aborts an in-progress cherry-pick operation.
-         * This restores the branch to its state before the cherry-pick started.
-         *
-         * @returns Effect that succeeds when abort completes
-         */
-        cherryPickAbort: Effect_exports.fn("cherryPickAbort")(
-          function* () {
-            yield* runCommandWithExitCode(
-              "git",
-              "cherry-pick",
-              "--abort"
-            );
-          }
-        ),
-        /**
-         * Switches to an existing branch.
-         * The working directory must be clean or have changes that don't
-         * conflict with the target branch.
-         *
-         * @param branch - The branch name to switch to
-         * @returns Effect that succeeds when checkout completes
-         * @throws FailedToCheckoutError if checkout fails (branch not found, conflicts)
-         */
-        checkout: Effect_exports.fn("checkout")(function* (branch) {
-          const exitCode3 = yield* runCommandWithExitCode(
-            "git",
-            "checkout",
-            branch
-          );
-          if (exitCode3 !== 0) {
-            return yield* Effect_exports.fail(
-              new FailedToCheckoutError({
-                branch,
-                message: `Failed to checkout ${branch} (exit code: ${exitCode3})`
-              })
-            );
-          }
-        }),
-        /**
-         * Force pushes a branch to a remote using --force-with-lease.
-         * This is safer than --force because it will fail if the remote has
-         * commits that aren't in your local branch, preventing accidental
-         * overwrites of others' work.
-         *
-         * @param remote - The remote name (e.g., "origin")
-         * @param branch - The branch to push
-         * @returns Effect that succeeds when push completes
-         * @throws FailedToPushError if push fails (rejected, network, auth issues)
-         */
-        pushForceWithLease: Effect_exports.fn("pushForceWithLease")(
-          function* (remote, branch) {
-            const exitCode3 = yield* runCommandWithExitCode(
-              "git",
-              "push",
-              remote,
-              branch,
-              "--force-with-lease"
-            );
-            if (exitCode3 !== 0) {
-              return yield* Effect_exports.fail(
-                new FailedToPushError({
-                  remote,
-                  branch,
-                  message: `Failed to push ${branch} to ${remote} (exit code: ${exitCode3})`
-                })
-              );
-            }
-          }
-        ),
-        /**
-         * Creates and switches to a new branch (git checkout -b).
-         * The branch is created at the current HEAD position.
-         *
-         * @param branchName - The name of the new branch to create
-         * @returns Effect that succeeds when branch is created and checked out
-         * @throws FailedToCreateBranchError if branch creation fails (e.g., branch already exists)
-         */
-        checkoutNewBranch: Effect_exports.fn("checkoutNewBranch")(
-          function* (branchName) {
-            const exitCode3 = yield* runCommandWithExitCode(
-              "git",
-              "checkout",
-              "-b",
-              branchName
-            );
-            if (exitCode3 !== 0) {
-              return yield* Effect_exports.fail(
-                new FailedToCreateBranchError({
-                  branchName,
-                  message: `Failed to create branch ${branchName} (exit code: ${exitCode3})`
-                })
-              );
-            }
-          }
-        ),
-        /**
-         * Gets commit log in oneline format, reversed (oldest first).
-         * Uses `git log --oneline --reverse` with a range specifier.
-         * Each line contains: <short-sha> <commit-message>
-         *
-         * @param range - The commit range (e.g., "main..feature" or "HEAD~5..HEAD")
-         * @returns The commit log output as a string
-         */
-        getLogOnelineReverse: Effect_exports.fn("getLogOnelineReverse")(
-          function* (range4) {
-            return yield* runCommandWithString(
-              "git",
-              "log",
-              "--oneline",
-              "--reverse",
-              range4
-            );
-          }
-        ),
-        /**
-         * Gets commit log in oneline format for a branch.
-         * Uses `git log <branch> --oneline`.
-         * Each line contains: <short-sha> <commit-message>
-         *
-         * @param branch - The branch to get log for (e.g., "main", "HEAD", "origin/main")
-         * @returns The commit log output as a string
-         */
-        getLogOneline: Effect_exports.fn("getLogOneline")(function* (branch) {
-          return yield* runCommandWithString(
-            "git",
-            "log",
-            branch,
-            "--oneline"
-          );
-        }),
-        /**
-         * Gets the parent commit SHA of a given commit.
-         * Uses `git rev-parse <sha>^` to resolve the parent ref.
-         *
-         * @param sha - The commit SHA to get the parent of
-         * @returns The full SHA of the parent commit
-         * @throws NoParentCommitError if the commit has no parent (e.g., initial commit)
-         */
-        getParentCommit: Effect_exports.fn("getParentCommit")(function* (sha) {
-          const parentSha = yield* runCommandWithString(
-            "git",
-            "rev-parse",
-            `${sha}^`
-          ).pipe(
-            Effect_exports.catchAll(
-              () => Effect_exports.fail(
-                new NoParentCommitError({ commitSha: sha })
-              )
-            )
-          );
-          return parentSha;
-        }),
-        /**
-         * Creates and switches to a new branch at a specific commit (git checkout -b <name> <sha>).
-         * Unlike checkoutNewBranch which creates at HEAD, this creates the branch
-         * at an arbitrary commit position.
-         *
-         * @param branchName - The name of the new branch to create
-         * @param sha - The commit SHA where the branch should be created
-         * @returns Effect that succeeds when branch is created and checked out
-         * @throws FailedToCreateBranchError if branch creation fails (e.g., branch already exists)
-         */
-        checkoutNewBranchAt: Effect_exports.fn("checkoutNewBranchAt")(
-          function* (branchName, sha) {
-            const exitCode3 = yield* runCommandWithExitCode(
-              "git",
-              "checkout",
-              "-b",
-              branchName,
-              sha
-            );
-            if (exitCode3 !== 0) {
-              return yield* Effect_exports.fail(
-                new FailedToCreateBranchError({
-                  branchName,
-                  message: `Failed to create branch ${branchName} at ${sha} (exit code: ${exitCode3})`
-                })
-              );
-            }
-          }
-        ),
-        /**
-         * Deletes a local branch.
-         * Uses `git branch -D` which force deletes even if not fully merged.
-         *
-         * @param branchName - The name of the branch to delete
-         * @returns Effect that succeeds when branch is deleted
-         * @throws FailedToDeleteBranchError if deletion fails
-         */
-        deleteBranch: Effect_exports.fn("deleteBranch")(function* (branchName) {
-          const exitCode3 = yield* runCommandWithExitCode(
-            "git",
-            "branch",
-            "-D",
-            branchName
-          );
-          if (exitCode3 !== 0) {
-            return yield* Effect_exports.fail(
-              new FailedToDeleteBranchError({
-                branchName,
-                message: `Failed to delete branch ${branchName} (exit code: ${exitCode3})`
-              })
-            );
-          }
-        }),
-        /**
-         * Fetches a specific branch from a remote.
-         * Updates the remote-tracking branch (e.g., origin/main) without
-         * modifying local branches or the working directory.
-         *
-         * @param remote - The remote name (e.g., "origin", "upstream")
-         * @param branch - The branch to fetch (e.g., "main")
-         * @returns Effect that succeeds when fetch completes
-         * @throws FailedToFetchError if fetch fails (network, auth, or remote/branch not found)
-         */
-        fetch: Effect_exports.fn("fetch")(function* (remote, branch) {
-          const exitCode3 = yield* runCommandWithExitCode(
-            "git",
-            "fetch",
-            remote,
-            branch
-          );
-          if (exitCode3 !== 0) {
-            return yield* Effect_exports.fail(
-              new FailedToFetchError({
-                remote,
-                branch,
-                message: `Failed to fetch ${branch} from ${remote} (exit code: ${exitCode3})`
-              })
-            );
-          }
-        }),
-        /**
-         * Merges a ref into the current branch.
-         * This creates a merge commit if necessary, or performs a fast-forward
-         * merge if the current branch is directly behind the target ref.
-         *
-         * @param ref - The ref to merge (e.g., "origin/main", a branch name, or SHA)
-         * @returns Effect that succeeds when merge completes
-         * @throws MergeConflictError if conflicts occur during merge
-         */
-        merge: Effect_exports.fn("merge")(function* (ref) {
-          const exitCode3 = yield* runCommandWithExitCode(
-            "git",
-            "merge",
-            ref
-          );
-          if (exitCode3 !== 0) {
-            return yield* Effect_exports.fail(
-              new MergeConflictError({
-                ref,
-                message: `Merge conflicts detected when merging ${ref}`
-              })
-            );
-          }
-        }),
-        /**
-         * Rebases the current branch onto another branch.
-         * This replays all commits from the current branch on top of the target branch.
-         * WARNING: Rebase rewrites commit history - all rebased commits get new SHAs.
-         * Never rebase commits that have been pushed to a shared remote unless you
-         * coordinate with all collaborators.
-         *
-         * @param onto - The branch to rebase onto (e.g., "main", "origin/main")
-         * @returns Effect that succeeds when rebase completes
-         * @throws RebaseConflictError if conflicts occur during rebase
-         */
-        rebase: Effect_exports.fn("rebase")(function* (onto) {
-          const exitCode3 = yield* runCommandWithExitCode(
-            "git",
-            "rebase",
-            onto
-          );
-          if (exitCode3 !== 0) {
-            return yield* Effect_exports.fail(
-              new RebaseConflictError({
-                onto,
-                message: `Rebase conflicts detected when rebasing onto ${onto}`
-              })
-            );
-          }
-        }),
-        ensureIsGitRepo: Effect_exports.fn("ensureIsGitRepo")(
-          function* () {
-            const cwd = config3.cwd;
-            const gitDirPath = path6__namespace.join(cwd, ".git");
-            const exists4 = yield* fs.exists(gitDirPath);
-            if (!exists4) {
-              return yield* new NotAGitRepoError({
-                path: cwd,
-                message: `Current directory is not a git repository: ${cwd}`
-              });
-            }
-          }
-        ),
-        getUncommittedChanges: Effect_exports.fn(
-          "getUncommittedChanges"
-        )(function* () {
-          const statusOutput = yield* runCommandWithString(
-            "git",
-            "status",
-            "--porcelain"
-          );
-          return {
-            hasUncommittedChanges: statusOutput !== "",
-            statusOutput
-          };
-        }),
-        /**
-         * This command needs to be run in every user-facing command that
-         * interacts with a branch. It ensures that the branch is connected
-         * to the upstream repository and that the local branch is tracking
-         * the upstream branch.
-         *
-         * This is to handle the case where the user has a fork of the
-         * upstream repository.
-         */
-        ensureUpstreamBranchConnected: Effect_exports.fn(
-          "ensureUpstreamBranchConnected"
-        )(function* (opts) {
-          const { targetBranch } = opts;
-          const { remoteName } = yield* detectUpstreamRemote();
-          const fetchExitCode = yield* runCommandWithExitCode(
-            "git",
-            "fetch",
-            remoteName,
-            targetBranch
-          );
-          if (fetchExitCode !== 0) {
-            return yield* Effect_exports.fail(
-              new FailedToFetchUpstreamError({
-                targetBranch,
-                message: `Failed to fetch upstream: ${fetchExitCode}`
-              })
-            );
-          }
+        hasUncommittedChanges: statusOutput !== "",
+        statusOutput
+      };
+    }),
+    ensureUpstreamBranchConnected: Effect_exports.fn(
+      "ensureUpstreamBranchConnected"
+    )(function* (opts) {
+      const { targetBranch } = opts;
+      const fetchExitCode = yield* runCommandWithExitCode(
+        "git",
+        "fetch",
+        "upstream",
+        targetBranch
+      );
+      if (fetchExitCode !== 0) {
+        return yield* Effect_exports.fail(
+          new FailedToFetchUpstreamError({
+            targetBranch,
+            message: `Failed to fetch upstream: ${fetchExitCode}`
+          })
+        );
+      }
+      yield* runCommandWithExitCode(
+        "git",
+        "branch",
+        "-D",
+        targetBranch
+      );
+      const trackBranchExitCode = yield* runCommandWithExitCode(
+        "git",
+        "branch",
+        "--track",
+        targetBranch,
+        `upstream/${targetBranch}`
+      );
+      if (trackBranchExitCode !== 0) {
+        return yield* Effect_exports.fail(
+          new FailedToTrackBranchError({
+            branchName: targetBranch,
+            message: `Failed to track branch.`
+          })
+        );
+      }
+    }),
+    getCurrentBranch: Effect_exports.fn("getCurrentBranch")(
+      function* () {
+        const currentBranch = (yield* runCommandWithString(
+          "git",
+          "branch",
+          "--show-current"
+        )).trim();
+        return currentBranch;
+      }
+    ),
+    setUpstreamRemote: Effect_exports.fn("setUpstreamRemote")(
+      function* (url2) {
+        const setUrlExitCode = yield* runCommandWithExitCode(
+          "git",
+          "remote",
+          "set-url",
+          "upstream",
+          url2
+        );
+        if (setUrlExitCode !== 0) {
           yield* runCommandWithExitCode(
             "git",
-            "branch",
-            "-D",
-            targetBranch
-          );
-          const trackBranchExitCode = yield* runCommandWithExitCode(
-            "git",
-            "branch",
-            "--track",
-            targetBranch,
-            `${remoteName}/${targetBranch}`
+            "remote",
+            "add",
+            "upstream",
+            url2
           );
-          if (trackBranchExitCode !== 0) {
-            return yield* Effect_exports.fail(
-              new FailedToTrackBranchError({
-                branchName: targetBranch,
-                message: `Failed to track branch.`
-              })
-            );
-          }
-        }),
-        getCurrentBranch: Effect_exports.fn("getCurrentBranch")(
-          function* () {
-            const currentBranch = (yield* runCommandWithString(
-              "git",
-              "branch",
-              "--show-current"
-            )).trim();
-            return currentBranch;
-          }
-        ),
-        detectUpstreamRemote
-      };
-    }),
+        }
+      }
+    )
+  };
+});
+var GitService = class extends Effect_exports.Service()(
+  "GitService",
+  {
+    effect: makeGitService,
     dependencies: [
       NodeFileSystem_exports2.layer,
       defaultGitServiceConfigLayer
@@ -84750,7 +84518,6 @@ var normalizeExerciseNumber = (str) => {
 var PromptService = class extends Effect_exports.Service()(
   "PromptService",
   {
-    // eslint-disable-next-line require-yield
     effect: Effect_exports.gen(function* () {
       const confirmReadyToCommit = Effect_exports.fn(
         "confirmReadyToCommit"
@@ -84822,27 +84589,6 @@ var PromptService = class extends Effect_exports.Service()(
         );
         return action;
       });
-      const selectProblemOrSolution = Effect_exports.fn(
-        "selectProblemOrSolution"
-      )(function* () {
-        const { action } = yield* runPrompt(
-          () => (0, import_prompts.prompt)([
-            {
-              type: "select",
-              name: "action",
-              message: "What would you like to do?",
-              choices: [
-                {
-                  title: "Start the exercise",
-                  value: "problem"
-                },
-                { title: "View final code", value: "solution" }
-              ]
-            }
-          ])
-        );
-        return action;
-      });
       const selectResetAction = Effect_exports.fn("selectResetAction")(
         function* (_branch) {
           const { action } = yield* runPrompt(
@@ -85013,14 +84759,17 @@ var PromptService = class extends Effect_exports.Service()(
                 type: "autocomplete",
                 name: "subfolderIndex",
                 message: "Select a subfolder",
-                choices: subfolders.map((subfolder, index) => ({
+                choices: subfolders.map((subfolder) => ({
                   title: subfolder,
-                  value: index
+                  // Use subfolder name as value instead of numeric index
+                  // to avoid prompts library treating 0 as falsy and
+                  // returning the title string instead (GitHub issue #42)
+                  value: subfolder
                 }))
               }
             ])
           );
-          return subfolderIndex;
+          return subfolders.indexOf(subfolderIndex);
         }
       );
       const selectExerciseAction = Effect_exports.fn(
@@ -85131,7 +84880,6 @@ var PromptService = class extends Effect_exports.Service()(
         confirmSaveToTargetBranch,
         confirmForcePush,
         selectCherryPickConflictAction,
-        selectProblemOrSolution,
         selectResetAction,
         confirmResetWithUncommittedChanges,
         inputBranchName,
@@ -85257,10 +85005,6 @@ var selectLessonCommit = ({
     lessonId: selectedLessonId
   };
 });
-var getParentCommit = ({ commitSha }) => Effect_exports.gen(function* () {
-  const gitService = yield* GitService;
-  return yield* gitService.getParentCommit(commitSha);
-});
 
 // src/constants.ts
 var DEFAULT_PROJECT_TARGET_BRANCH = "live-run-through";
@@ -85288,11 +85032,13 @@ var InvalidBranchOperationError = class extends Data_exports.TaggedError(
 };
 var runCherryPick = ({
   branch,
-  lessonId
+  lessonId,
+  upstream
 }) => Effect_exports.gen(function* () {
   const git = yield* GitService;
   const promptService = yield* PromptService;
   yield* git.ensureIsGitRepo();
+  yield* git.setUpstreamRemote(upstream);
   yield* git.ensureUpstreamBranchConnected({
     targetBranch: branch
   });
@@ -85342,9 +85088,15 @@ var cherryPick = Command_exports.make(
       ),
       Options_exports.withDefault(DEFAULT_PROJECT_TARGET_BRANCH)
     ),
+    upstream: Options_exports.text("upstream").pipe(
+      Options_exports.withDescription(
+        "Git URL or local path to the upstream exercise repo"
+      )
+    ),
     cwd: cwdOption
   },
-  ({ branch, cwd, lessonId }) => runCherryPick({ branch, lessonId }).pipe(
+  /* v8 ignore start - CLI error handlers are presentation logic */
+  ({ branch, cwd, lessonId, upstream }) => runCherryPick({ branch, lessonId, upstream }).pipe(
     Effect_exports.provideService(
       GitServiceConfig,
       GitServiceConfig.of({
@@ -85358,12 +85110,6 @@ var cherryPick = Command_exports.make(
           process.exitCode = 1;
         });
       },
-      NoUpstreamFoundError: (error4) => {
-        return Effect_exports.gen(function* () {
-          yield* Console_exports.error(`Error: ${error4.message}`);
-          process.exitCode = 1;
-        });
-      },
       CommitNotFoundError: (error4) => {
         return Effect_exports.gen(function* () {
           yield* Console_exports.error(
@@ -85402,6 +85148,7 @@ var cherryPick = Command_exports.make(
       });
     })
   )
+  /* v8 ignore stop */
 ).pipe(
   Command_exports.withDescription(
     "Cherry-pick a specific lesson commit onto current branch"
@@ -86084,6 +85831,7 @@ var updateCVM = Command_exports.make(
 );
 var createErrorTracker = () => {
   const groupedErrors = {};
+  const errors = [];
   return {
     addError: (lesson, error4) => {
       if (!groupedErrors[lesson.sectionPath]) {
@@ -86093,20 +85841,21 @@ var createErrorTracker = () => {
         groupedErrors[lesson.sectionPath][lesson.path] = [];
       }
       groupedErrors[lesson.sectionPath][lesson.path].push(error4);
+      errors.push({
+        sectionPath: lesson.sectionPath,
+        lessonPath: lesson.path,
+        error: error4
+      });
     },
+    getErrors: () => errors,
+    /* v8 ignore start */
     log: Effect_exports.gen(function* () {
-      for (const [section, exercises] of Object.entries(
-        groupedErrors
-      )) {
+      for (const [section, exercises] of Object.entries(groupedErrors)) {
         yield* Console_exports.log(util.styleText(["bold"], section));
-        for (const [exercise2, errors] of Object.entries(
-          exercises
-        )) {
+        for (const [exercise2, errors2] of Object.entries(exercises)) {
           yield* Console_exports.log(`  ${exercise2}`);
-          for (const error4 of errors) {
-            yield* Console_exports.log(
-              util.styleText(["red"], `    ${error4}`)
-            );
+          for (const error4 of errors2) {
+            yield* Console_exports.log(util.styleText(["red"], `    ${error4}`));
           }
         }
       }
@@ -86114,177 +85863,183 @@ var createErrorTracker = () => {
         process.exitCode = 1;
       }
     })
+    /* v8 ignore stop */
   };
 };
-var lint = Command_exports.make(
-  "lint",
-  {
-    root: rootOption,
-    cwd: cwdOption
-  },
-  Effect_exports.fn("lint")(
-    function* ({ cwd, root }) {
-      const existsCache = yield* Cache_exports.make({
-        capacity: 1e4,
-        timeToLive: Duration_exports.infinity,
-        lookup: (key) => Effect_exports.gen(function* () {
-          const exists4 = yield* fs.exists(key);
-          return exists4;
-        })
-      });
-      const allReadmeContents = [];
-      const errorTracker = createErrorTracker();
-      const lessonParser = yield* LessonParserService;
-      const fs = yield* FileSystem_exports.FileSystem;
-      const lessons = yield* lessonParser.getLessonsFromRepo(
-        root
+var runLint = (opts) => Effect_exports.gen(function* () {
+  const lessonParser = yield* LessonParserService;
+  const fs = yield* FileSystem_exports.FileSystem;
+  const existsCache = yield* Cache_exports.make({
+    capacity: 1e4,
+    timeToLive: Duration_exports.infinity,
+    lookup: (key) => Effect_exports.gen(function* () {
+      const exists4 = yield* fs.exists(key);
+      return exists4;
+    })
+  });
+  const allReadmeContents = [];
+  const errorTracker = createErrorTracker();
+  const lessons = yield* lessonParser.getLessonsFromRepo(opts.root);
+  for (const lesson of lessons) {
+    const subfolders = yield* lesson.subfolders();
+    if (subfolders.length === 0) {
+      errorTracker.addError(
+        lesson,
+        "No subfolders, like problem or solution, found in the exercise."
+      );
+      continue;
+    }
+    const folderForReadme = subfolders.find(
+      (folder) => folder === "problem" || folder === "explainer" || folder === "explainer.1"
+    );
+    if (!folderForReadme) {
+      errorTracker.addError(
+        lesson,
+        "No problem, explainer, or explainer.1 folder found in the exercise."
       );
-      for (const lesson of lessons) {
-        const subfolders = yield* lesson.subfolders();
-        if (subfolders.length === 0) {
+      continue;
+    }
+    const readmePath = path6__namespace.join(
+      lesson.absolutePath(),
+      folderForReadme,
+      "readme.md"
+    );
+    const readmeExists = yield* existsCache.get(readmePath);
+    if (!readmeExists) {
+      errorTracker.addError(
+        lesson,
+        "readme.md file not found in the exercise."
+      );
+    } else {
+      const readmeContent = yield* fs.readFileString(readmePath);
+      allReadmeContents.push(readmeContent);
+      if (readmeContent.trim().length === 0) {
+        errorTracker.addError(lesson, "readme.md file is empty");
+        continue;
+      }
+      if (readmeContent.includes("`pnpm run exercise ")) {
+        errorTracker.addError(
+          lesson,
+          "readme.md file contains a pnpm run exercise command. Please remove it."
+        );
+        continue;
+      }
+      const absoluteLinks = readmeContent.match(/\[[^\]]+\]\(\/[^)]+\)/gm) ?? [];
+      for (const link3 of absoluteLinks) {
+        const splitResult = link3.split("](");
+        const url2 = splitResult[1]?.slice(1, -1);
+        if (!url2) continue;
+        const linkExists = yield* existsCache.get(path6__namespace.join(opts.cwd, url2));
+        if (!linkExists) {
           errorTracker.addError(
             lesson,
-            "No subfolders, like problem or solution, found in the exercise."
+            `Broken absolute link in readme.md: ${url2}`
           );
-          continue;
         }
-        const folderForReadme = subfolders.find(
-          (folder) => folder === "problem" || folder === "explainer" || folder === "explainer.1"
+      }
+      const relativeLinks = readmeContent.match(/\[[^\]]+\]\(\.\/[^)]+\)/gm) ?? [];
+      for (const link3 of relativeLinks) {
+        const splitResult = link3.split("](");
+        const url2 = splitResult[1]?.slice(0, -1);
+        if (!url2) continue;
+        const linkExists = yield* existsCache.get(
+          path6__namespace.resolve(lesson.absolutePath(), folderForReadme, url2)
         );
-        if (!folderForReadme) {
+        if (!linkExists) {
           errorTracker.addError(
             lesson,
-            "No problem, explainer, or explainer.1 folder found in the exercise."
+            `Broken relative link in readme.md: ${url2}`
           );
-          continue;
         }
-        const readmePath = path6__namespace.join(
+      }
+    }
+    for (const subfolder of subfolders) {
+      const mainFilePath = path6__namespace.join(
+        lesson.absolutePath(),
+        subfolder,
+        "main.ts"
+      );
+      const mainFileExists = yield* existsCache.get(mainFilePath);
+      if (!mainFileExists) {
+        const readmeInSubfolderPath = path6__namespace.join(
           lesson.absolutePath(),
-          folderForReadme,
+          subfolder,
           "readme.md"
         );
-        const readmeExists = yield* existsCache.get(readmePath);
-        if (!readmeExists) {
-          errorTracker.addError(
-            lesson,
-            "readme.md file not found in the exercise."
-          );
-        } else {
-          const readmeContent = yield* fs.readFileString(
-            readmePath
-          );
-          allReadmeContents.push(readmeContent);
-          if (readmeContent.trim().length === 0) {
-            errorTracker.addError(
-              lesson,
-              "readme.md file is empty"
-            );
-            continue;
-          }
-          if (readmeContent.includes("`pnpm run exercise ")) {
-            errorTracker.addError(
-              lesson,
-              "readme.md file contains a pnpm run exercise command. Please remove it."
-            );
-            continue;
-          }
-          const absoluteLinks = readmeContent.match(/\[[^\]]+\]\(\/[^)]+\)/gm) ?? [];
-          for (const link3 of absoluteLinks) {
-            const splitResult = link3.split("](");
-            const url2 = splitResult[1]?.slice(1, -1);
-            if (!url2) continue;
-            const linkExists = yield* existsCache.get(
-              path6__namespace.join(cwd, url2)
-            );
-            if (!linkExists) {
-              errorTracker.addError(
-                lesson,
-                `Broken absolute link in readme.md: ${url2}`
-              );
-            }
-          }
-          const relativeLinks = readmeContent.match(/\[[^\]]+\]\(\.\/[^)]+\)/gm) ?? [];
-          for (const link3 of relativeLinks) {
-            const splitResult = link3.split("](");
-            const url2 = splitResult[1]?.slice(0, -1);
-            if (!url2) continue;
-            const linkExists = yield* existsCache.get(
-              path6__namespace.resolve(
-                lesson.absolutePath(),
-                folderForReadme,
-                url2
-              )
-            );
-            if (!linkExists) {
-              errorTracker.addError(
-                lesson,
-                `Broken relative link in readme.md: ${url2}`
-              );
-            }
-          }
-        }
-        for (const subfolder of subfolders) {
-          const mainFilePath = path6__namespace.join(
-            lesson.absolutePath(),
-            subfolder,
-            "main.ts"
-          );
-          const mainFileExists = yield* existsCache.get(
-            mainFilePath
-          );
-          if (!mainFileExists) {
-            const readmeInSubfolderPath = path6__namespace.join(
-              lesson.absolutePath(),
-              subfolder,
-              "readme.md"
-            );
-            const readmeInSubfolderExists = yield* existsCache.get(readmeInSubfolderPath);
-            if (!readmeInSubfolderExists) {
-              errorTracker.addError(
-                lesson,
-                `main.ts file not found in the ${subfolder} folder.`
-              );
-            }
-          } else {
-            const mainFileContent = yield* fs.readFileString(
-              mainFilePath
-            );
-            const lineCount = mainFileContent.trim().split("\n").length;
-            if (lineCount === 1) {
-              errorTracker.addError(
-                lesson,
-                `main.ts file in the ${subfolder} folder is too short (${lineCount} lines). Please use a readme-only exercise instead if you only need to show instructions.`
-              );
-            }
-          }
-        }
-        const files = yield* lesson.allFiles();
-        if (files.some((file6) => file6.includes(".gitkeep"))) {
+        const readmeInSubfolderExists = yield* existsCache.get(readmeInSubfolderPath);
+        if (!readmeInSubfolderExists) {
           errorTracker.addError(
             lesson,
-            ".gitkeep file found in the exercise."
+            `main.ts file not found in the ${subfolder} folder.`
           );
         }
-        if (files.some((file6) => file6.includes("speaker-notes.md"))) {
+      } else {
+        const mainFileContent = yield* fs.readFileString(mainFilePath);
+        const lineCount = mainFileContent.trim().split("\n").length;
+        if (lineCount === 1) {
           errorTracker.addError(
             lesson,
-            "speaker-notes.md file found in the exercise. This should not be exposed to users."
+            `main.ts file in the ${subfolder} folder is too short (${lineCount} lines). Please use a readme-only exercise instead if you only need to show instructions.`
           );
         }
       }
-      const readmeContents = allReadmeContents.join("\n");
-      const referenceLessons = lessons.filter(
-        (lesson) => lesson.sectionName === "reference"
+    }
+    const files = yield* lesson.allFiles();
+    if (files.some((file6) => file6.includes(".gitkeep"))) {
+      errorTracker.addError(lesson, ".gitkeep file found in the exercise.");
+    }
+    if (files.some((file6) => file6.includes("speaker-notes.md"))) {
+      errorTracker.addError(
+        lesson,
+        "speaker-notes.md file found in the exercise. This should not be exposed to users."
       );
-      for (const referenceLesson of referenceLessons) {
-        if (!readmeContents.includes(referenceLesson.path)) {
-          errorTracker.addError(
-            referenceLesson,
-            `${referenceLesson.path} is not referenced in any other exercise.`
-          );
+    }
+  }
+  const readmeContents = allReadmeContents.join("\n");
+  const referenceLessons = lessons.filter(
+    (lesson) => lesson.sectionName === "reference"
+  );
+  for (const referenceLesson of referenceLessons) {
+    if (!readmeContents.includes(referenceLesson.path)) {
+      errorTracker.addError(
+        referenceLesson,
+        `${referenceLesson.path} is not referenced in any other exercise.`
+      );
+    }
+  }
+  return errorTracker.getErrors();
+});
+var lint = Command_exports.make(
+  "lint",
+  {
+    root: rootOption,
+    cwd: cwdOption
+  },
+  Effect_exports.fn("lint")(
+    function* ({ cwd, root }) {
+      const errors = yield* runLint({ cwd, root });
+      const groupedErrors = {};
+      for (const error4 of errors) {
+        if (!groupedErrors[error4.sectionPath]) {
+          groupedErrors[error4.sectionPath] = {};
+        }
+        if (!groupedErrors[error4.sectionPath][error4.lessonPath]) {
+          groupedErrors[error4.sectionPath][error4.lessonPath] = [];
         }
+        groupedErrors[error4.sectionPath][error4.lessonPath].push(error4.error);
+      }
+      for (const [section, exercises] of Object.entries(groupedErrors)) {
+        yield* Console_exports.log(util.styleText(["bold"], section));
+        for (const [exercise2, errs] of Object.entries(exercises)) {
+          yield* Console_exports.log(`  ${exercise2}`);
+          for (const err of errs) {
+            yield* Console_exports.log(util.styleText(["red"], `    ${err}`));
+          }
+        }
+      }
+      if (errors.length > 0) {
+        process.exitCode = 1;
       }
-      yield* errorTracker.log;
     },
     Effect_exports.catchTags({
       InvalidPathError: (error4) => {
@@ -86307,6 +86062,37 @@ var lint = Command_exports.make(
     "Lint the repository to ensure it is formatted correctly"
   )
 );
+var runRename = (opts) => Effect_exports.gen(function* () {
+  const lessonParser = yield* LessonParserService;
+  const fs = yield* FileSystem_exports.FileSystem;
+  const lessons = yield* lessonParser.getLessonsFromRepo(opts.root);
+  const sections = /* @__PURE__ */ new Set();
+  for (const lesson of lessons) {
+    sections.add(lesson.sectionPath);
+  }
+  const sectionsAsArray = Array.from(sections).sort(
+    (a, b) => a.localeCompare(b)
+  );
+  let totalLessonsRenamed = 0;
+  for (const section of sectionsAsArray) {
+    const lessonsInSection = lessons.filter((lesson) => lesson.sectionPath === section).sort((a, b) => a.num - b.num);
+    const fullSectionPath = path6__namespace.resolve(opts.root, section);
+    yield* Effect_exports.forEach(lessonsInSection, (lesson, index) => {
+      return Effect_exports.gen(function* () {
+        const newLessonNum = (index + 1).toString().padStart(2, "0");
+        const sectionNum = lesson.sectionNum.toString().padStart(2, "0");
+        const newLessonDirname = `${sectionNum}.${newLessonNum}-${lesson.name}`;
+        const newLessonPath = path6__namespace.join(fullSectionPath, newLessonDirname);
+        if (newLessonPath === lesson.absolutePath()) {
+          return;
+        }
+        yield* fs.rename(lesson.absolutePath(), newLessonPath);
+        totalLessonsRenamed++;
+      });
+    });
+  }
+  return totalLessonsRenamed;
+});
 var rename4 = Command_exports.make(
   "rename",
   {
@@ -86314,48 +86100,8 @@ var rename4 = Command_exports.make(
   },
   Effect_exports.fn("rename")(
     function* ({ root }) {
-      const lessonParser = yield* LessonParserService;
-      const fs = yield* FileSystem_exports.FileSystem;
-      const lessons = yield* lessonParser.getLessonsFromRepo(
-        root
-      );
-      const sections = /* @__PURE__ */ new Set();
-      for (const lesson of lessons) {
-        sections.add(lesson.sectionPath);
-      }
-      const sectionsAsArray = Array.from(sections).sort(
-        (a, b) => a.localeCompare(b)
-      );
-      let totalLessonsRenamed = 0;
-      for (const section of sectionsAsArray) {
-        const lessonsInSection = lessons.filter((lesson) => lesson.sectionPath === section).sort((a, b) => a.num - b.num);
-        const fullSectionPath = path6__namespace.resolve(root, section);
-        yield* Effect_exports.forEach(
-          lessonsInSection,
-          (lesson, index) => {
-            return Effect_exports.gen(function* () {
-              const newLessonNum = (index + 1).toString().padStart(2, "0");
-              const sectionNum = lesson.sectionNum.toString().padStart(2, "0");
-              const newLessonDirname = `${sectionNum}.${newLessonNum}-${lesson.name}`;
-              const newLessonPath = path6__namespace.join(
-                fullSectionPath,
-                newLessonDirname
-              );
-              if (newLessonPath === lesson.absolutePath()) {
-                return;
-              }
-              yield* fs.rename(
-                lesson.absolutePath(),
-                newLessonPath
-              );
-              totalLessonsRenamed++;
-            });
-          }
-        );
-      }
-      yield* Console_exports.log(
-        `Renamed ${totalLessonsRenamed} lessons`
-      );
+      const totalLessonsRenamed = yield* runRename({ root });
+      yield* Console_exports.log(`Renamed ${totalLessonsRenamed} lessons`);
     },
     Effect_exports.catchTags({
       InvalidPathError: (error4) => {
@@ -87195,7 +86941,7 @@ var editCommit = Command_exports.make(
     yield* Console_exports.log(
       `Resetting to ${targetSha} (${commitLabel})...`
     );
-    const resetResult = yield* gitService.resetHard(targetSha).pipe(
+    const resetResult = yield* gitService.applyAsUnstagedChanges(targetSha).pipe(
       Effect_exports.map(() => ({ failed: false })),
       Effect_exports.catchTag(
         "FailedToResetError",
@@ -87207,11 +86953,6 @@ var editCommit = Command_exports.make(
       process.exitCode = 1;
       return;
     }
-    yield* Console_exports.log(
-      "Undoing commit and unstaging changes..."
-    );
-    yield* gitService.resetHead();
-    yield* gitService.restoreStaged();
     yield* Console_exports.log(
       "\u2713 Reset complete with unstaged changes"
     );
@@ -87529,7 +87270,7 @@ var applyDemoReset = (commitSha) => Effect_exports.gen(function* () {
   const git = yield* GitService;
   yield* Console_exports.log(`
 Resetting to ${commitSha}...`);
-  yield* git.resetHard(commitSha).pipe(
+  yield* git.applyAsUnstagedChanges(commitSha).pipe(
     Effect_exports.catchTag("FailedToResetError", () => {
       process.exitCode = 1;
       return Effect_exports.fail(
@@ -87540,10 +87281,6 @@ Resetting to ${commitSha}...`);
       );
     })
   );
-  yield* Console_exports.log("Undoing commit...");
-  yield* git.resetHead();
-  yield* Console_exports.log("Unstaging changes...");
-  yield* git.restoreStaged();
   yield* Console_exports.log(
     "\u2713 Commit applied with unstaged changes\n"
   );
@@ -87955,42 +87692,49 @@ var InvalidBranchOperationError2 = class extends Data_exports.TaggedError(
   "InvalidBranchOperationError"
 ) {
 };
+var UncommittedChangesError = class extends Data_exports.TaggedError(
+  "UncommittedChangesError"
+) {
+};
+var runPull = (opts) => Effect_exports.gen(function* () {
+  const git = yield* GitService;
+  yield* git.ensureIsGitRepo();
+  const currentBranch = yield* git.getCurrentBranch();
+  if (currentBranch === "main") {
+    return yield* new InvalidBranchOperationError2({
+      message: "Cannot pull when on main branch. Switch to a working branch first."
+    });
+  }
+  const { hasUncommittedChanges, statusOutput } = yield* git.getUncommittedChanges();
+  if (hasUncommittedChanges) {
+    return yield* new UncommittedChangesError({
+      statusOutput
+    });
+  }
+  yield* git.setUpstreamRemote(opts.upstream);
+  yield* Console_exports.log("Fetching main from upstream...");
+  yield* git.fetch("upstream", "main");
+  yield* Console_exports.log(
+    `Merging upstream/main into ${currentBranch}...`
+  );
+  yield* git.merge("upstream/main");
+  yield* Console_exports.log(
+    `
+\u2713 Successfully merged upstream/main into ${currentBranch}`
+  );
+});
 var pull = Command_exports.make(
   "pull",
   {
-    cwd: cwdOption
+    cwd: cwdOption,
+    upstream: Options_exports.text("upstream").pipe(
+      Options_exports.withDescription(
+        "Git URL or local path to the upstream exercise repo"
+      )
+    )
   },
-  ({ cwd }) => Effect_exports.gen(function* () {
-    const git = yield* GitService;
-    yield* git.ensureIsGitRepo();
-    const currentBranch = yield* git.getCurrentBranch();
-    if (currentBranch === "main") {
-      return yield* new InvalidBranchOperationError2({
-        message: "Cannot pull when on main branch. Switch to a working branch first."
-      });
-    }
-    const { hasUncommittedChanges, statusOutput } = yield* git.getUncommittedChanges();
-    if (hasUncommittedChanges) {
-      yield* Console_exports.error("You have uncommitted changes:\n");
-      yield* Console_exports.error(statusOutput);
-      yield* Console_exports.error(
-        "\nCommit or stash your changes before pulling:\n  git stash\n  ai-hero pull\n  git stash pop"
-      );
-      process.exitCode = 1;
-      return;
-    }
-    const { remoteName } = yield* git.detectUpstreamRemote();
-    yield* Console_exports.log(`Fetching main from ${remoteName}...`);
-    yield* git.fetch(remoteName, "main");
-    yield* Console_exports.log(
-      `Merging ${remoteName}/main into ${currentBranch}...`
-    );
-    yield* git.merge(`${remoteName}/main`);
-    yield* Console_exports.log(
-      `
-\u2713 Successfully merged ${remoteName}/main into ${currentBranch}`
-    );
-  }).pipe(
+  /* v8 ignore start - CLI error handlers are presentation logic */
+  ({ cwd, upstream }) => runPull({ upstream }).pipe(
     Effect_exports.provideService(
       GitServiceConfig,
       GitServiceConfig.of({
@@ -87998,13 +87742,17 @@ var pull = Command_exports.make(
       })
     ),
     Effect_exports.catchTags({
-      NotAGitRepoError: (error4) => {
+      UncommittedChangesError: (error4) => {
         return Effect_exports.gen(function* () {
-          yield* Console_exports.error(`Error: ${error4.message}`);
+          yield* Console_exports.error("You have uncommitted changes:\n");
+          yield* Console_exports.error(error4.statusOutput);
+          yield* Console_exports.error(
+            "\nCommit or stash your changes before pulling:\n  git stash\n  ai-hero pull\n  git stash pop"
+          );
           process.exitCode = 1;
         });
       },
-      NoUpstreamFoundError: (error4) => {
+      NotAGitRepoError: (error4) => {
         return Effect_exports.gen(function* () {
           yield* Console_exports.error(`Error: ${error4.message}`);
           process.exitCode = 1;
@@ -88038,6 +87786,7 @@ var pull = Command_exports.make(
       });
     })
   )
+  /* v8 ignore stop */
 ).pipe(
   Command_exports.withDescription(
     "Pull latest changes from upstream main"
@@ -88049,20 +87798,16 @@ var InvalidBranchOperationError3 = class extends Data_exports.TaggedError(
   "InvalidBranchOperationError"
 ) {
 };
-var InvalidOptionsError = class extends Data_exports.TaggedError(
-  "InvalidOptionsError"
-) {
-};
 var runReset = ({
   branch,
   demo,
   lessonId,
-  problem,
-  solution
+  upstream
 }) => Effect_exports.gen(function* () {
   const git = yield* GitService;
   const promptService = yield* PromptService;
   yield* git.ensureIsGitRepo();
+  yield* git.setUpstreamRemote(upstream);
   yield* git.ensureUpstreamBranchConnected({
     targetBranch: branch
   });
@@ -88072,32 +87817,7 @@ var runReset = ({
     promptMessage: "Which lesson do you want to reset to? (type to search)",
     excludeCurrentBranch: false
   });
-  let commitToUse = targetCommit.sha;
-  let stateDescription = "final code";
-  if (problem && solution) {
-    return yield* new InvalidOptionsError({
-      message: "Cannot use both --problem and --solution flags"
-    });
-  }
-  if (demo && (problem || solution)) {
-    return yield* new InvalidOptionsError({
-      message: "Cannot use --demo with --problem or --solution flags"
-    });
-  }
-  if (!problem && !solution && !demo) {
-    const state = yield* promptService.selectProblemOrSolution();
-    if (state === "problem") {
-      commitToUse = yield* getParentCommit({
-        commitSha: targetCommit.sha
-      });
-      stateDescription = "problem state";
-    }
-  } else if (problem) {
-    commitToUse = yield* getParentCommit({
-      commitSha: targetCommit.sha
-    });
-    stateDescription = "problem state";
-  }
+  const commitToUse = targetCommit.sha;
   const currentBranch = yield* git.getCurrentBranch();
   let action;
   if (currentBranch === "main") {
@@ -88124,7 +87844,7 @@ var runReset = ({
       "new"
     );
     yield* Console_exports.log(
-      `Creating branch ${branchName} from ${commitToUse} (${stateDescription})...`
+      `Creating branch ${branchName} from ${selectedLessonId}...`
     );
     yield* git.checkoutNewBranchAt(branchName, commitToUse);
     yield* Console_exports.log(
@@ -88143,21 +87863,17 @@ var runReset = ({
     }
   }
   yield* Console_exports.log(
-    `Resetting to ${commitToUse} (${stateDescription})...`
+    `Resetting to ${selectedLessonId}...`
   );
-  yield* git.resetHard(commitToUse);
   if (demo) {
+    yield* git.applyAsUnstagedChanges(commitToUse);
     yield* Console_exports.log(
-      "Undoing commit and unstaging changes..."
-    );
-    yield* git.resetHead();
-    yield* git.restoreStaged();
-    yield* Console_exports.log(
-      `\u2713 Demo mode: Reset to lesson ${selectedLessonId} with unstaged changes`
+      `\u2713 Demo mode: Reset to ${selectedLessonId} with unstaged changes`
     );
   } else {
+    yield* git.resetHard(commitToUse);
     yield* Console_exports.log(
-      `\u2713 Reset to lesson ${selectedLessonId} (${stateDescription})`
+      `\u2713 Reset to ${selectedLessonId}`
     );
   }
 });
@@ -88173,22 +87889,16 @@ var reset2 = Command_exports.make(
       ),
       Options_exports.withDefault(DEFAULT_PROJECT_TARGET_BRANCH)
     ),
-    problem: Options_exports.boolean("problem").pipe(
-      Options_exports.withAlias("p"),
-      Options_exports.withDescription(
-        "Reset to problem state (start the exercise)"
-      )
-    ),
-    solution: Options_exports.boolean("solution").pipe(
-      Options_exports.withAlias("s"),
+    demo: Options_exports.boolean("demo").pipe(Options_exports.withAlias("d")),
+    upstream: Options_exports.text("upstream").pipe(
       Options_exports.withDescription(
-        "Reset to solution state (final code)"
+        "Git URL or local path to the upstream exercise repo"
       )
     ),
-    demo: Options_exports.boolean("demo").pipe(Options_exports.withAlias("d")),
     cwd: cwdOption
   },
-  ({ branch, cwd, demo, lessonId, problem, solution }) => runReset({ branch, lessonId, problem, solution, demo }).pipe(
+  /* v8 ignore start - CLI error handlers are presentation logic */
+  ({ branch, cwd, demo, lessonId, upstream }) => runReset({ branch, lessonId, demo, upstream }).pipe(
     Effect_exports.provideService(
       GitServiceConfig,
       GitServiceConfig.of({
@@ -88196,26 +87906,12 @@ var reset2 = Command_exports.make(
       })
     ),
     Effect_exports.catchTags({
-      NoParentCommitError: (error4) => {
-        return Effect_exports.gen(function* () {
-          yield* Console_exports.error(
-            `Error: Commit ${error4.commitSha} has no parent commit. Repository may be in an invalid state.`
-          );
-          process.exitCode = 1;
-        });
-      },
       NotAGitRepoError: (error4) => {
         return Effect_exports.gen(function* () {
           yield* Console_exports.error(`Error: ${error4.message}`);
           process.exitCode = 1;
         });
       },
-      NoUpstreamFoundError: (error4) => {
-        return Effect_exports.gen(function* () {
-          yield* Console_exports.error(`Error: ${error4.message}`);
-          process.exitCode = 1;
-        });
-      },
       CommitNotFoundError: (error4) => {
         return Effect_exports.gen(function* () {
           yield* Console_exports.error(
@@ -88254,6 +87950,7 @@ var reset2 = Command_exports.make(
       });
     })
   )
+  /* v8 ignore stop */
 ).pipe(
   Command_exports.withDescription("Reset to a specific lesson commit")
 );