rbx.cp 0.6.0__py3-none-any.whl → 0.6.1__py3-none-any.whl

rbx/box/presets/__init__.py

@@ -3,34 +3,28 @@ import shutil
 import tempfile
 from typing import Annotated, Iterable, List, Optional, Sequence, Union
 
-import rich
-import rich.prompt
 import typer
-from iso639.language import functools
 
 from rbx import console, utils
-from rbx.box import cd, git_utils
-from rbx.box.environment import get_environment_path
+from rbx.box import cd
 from rbx.box.presets.fetch import PresetFetchInfo, get_preset_fetch_info
 from rbx.box.presets.lock_schema import LockedAsset, PresetLock
 from rbx.box.presets.schema import Preset, TrackedAsset
 from rbx.config import get_default_app_path
-from rbx.grading.judge.digester import digest_cooperatively, digest_file
+from rbx.grading.judge.digester import digest_cooperatively
 
 app = typer.Typer(no_args_is_help=True)
 
-LOCAL = 'local'
 
-
-def find_preset_yaml(root: pathlib.Path = pathlib.Path()) -> Optional[pathlib.Path]:
+def _find_preset_yaml(root: pathlib.Path = pathlib.Path()) -> Optional[pathlib.Path]:
     found = root / 'preset.rbx.yml'
     if found.exists():
         return found
     return None
 
 
-def get_preset_yaml(root: pathlib.Path = pathlib.Path()) -> Preset:
-    found = find_preset_yaml(root)
+def _get_preset_yaml(root: pathlib.Path = pathlib.Path()) -> Preset:
+    found = _find_preset_yaml(root)
     if not found:
         console.console.print(
             f'[error][item]preset.rbx.yml[/item] not found in [item]{root.absolute()}[/item][/error]'
@@ -39,7 +33,7 @@ def get_preset_yaml(root: pathlib.Path = pathlib.Path()) -> Preset:
     return utils.model_from_yaml(Preset, found.read_text())
 
 
-def find_preset_lock(root: pathlib.Path = pathlib.Path()) -> Optional[pathlib.Path]:
+def _find_preset_lock(root: pathlib.Path = pathlib.Path()) -> Optional[pathlib.Path]:
     root = root.resolve()
     problem_yaml_path = root / '.preset-lock.yml'
     if not problem_yaml_path.is_file():
@@ -47,8 +41,8 @@ def find_preset_lock(root: pathlib.Path = pathlib.Path()) -> Optional[pathlib.Pa
     return problem_yaml_path
 
 
-def get_preset_lock(root: pathlib.Path = pathlib.Path()) -> Optional[PresetLock]:
-    found = find_preset_lock(root)
+def _get_preset_lock(root: pathlib.Path = pathlib.Path()) -> Optional[PresetLock]:
+    found = _find_preset_lock(root)
     if not found:
         return None
     return utils.model_from_yaml(PresetLock, found.read_text())
@@ -77,34 +71,22 @@ def _find_local_preset(root: pathlib.Path) -> Optional[pathlib.Path]:
     return problem_yaml_path.parent
 
 
-def get_preset_installation_path(
-    name: str, root: pathlib.Path = pathlib.Path()
-) -> pathlib.Path:
-    if name == LOCAL:
-        local_path = _find_local_preset(root)
-        if local_path is None:
-            console.console.print('[error]Local preset was not found.[/error]')
-            raise typer.Exit(1)
-        return local_path
-    nested_preset_path = _find_nested_preset(root)
-    if nested_preset_path is not None:
-        nested_preset = utils.model_from_yaml(
-            Preset, (nested_preset_path / 'preset.rbx.yml').read_text()
-        )
-        if nested_preset.name == name:
-            return nested_preset_path
-    return utils.get_app_path() / 'presets' / name
-
+def _is_installed_preset(root: pathlib.Path = pathlib.Path()) -> bool:
+    preset_path = _find_local_preset(root)
+    if preset_path is None:
+        return False
+    resolved_path = preset_path.resolve()
+    return resolved_path.name == '.local.rbx'
 
-def _find_installed_presets() -> List[str]:
-    folder = utils.get_app_path() / 'presets'
 
-    res = []
-    if get_preset_installation_path('local'):
-        res.append('local')
-    for yml in folder.glob('*/preset.rbx.yml'):
-        res.append(yml.parent.name)
-    return res
+def _is_active_preset_nested(root: pathlib.Path = pathlib.Path()) -> bool:
+    preset_path = _find_local_preset(root)
+    if preset_path is None:
+        return False
+    nested_preset_path = _find_nested_preset(root)
+    if nested_preset_path is None:
+        return False
+    return nested_preset_path == preset_path
 
 
 def _is_contest(root: pathlib.Path = pathlib.Path()) -> bool:
@@ -121,24 +103,6 @@ def _check_is_valid_package(root: pathlib.Path = pathlib.Path()):
         raise typer.Exit(1)
 
 
-def _get_preset_package_path(
-    name: str, is_contest: bool, root: pathlib.Path = pathlib.Path()
-) -> pathlib.Path:
-    preset_path = get_preset_installation_path(name, root)
-    preset = get_installed_preset(name, root)
-
-    if is_contest:
-        assert (
-            preset.contest is not None
-        ), 'Preset does not have a contest package definition.'
-        return preset_path / preset.contest
-
-    assert (
-        preset.problem is not None
-    ), 'Preset does not have a problem package definition,'
-    return preset_path / preset.problem
-
-
 def _process_globbing(
     assets: Iterable[TrackedAsset], preset_dir: pathlib.Path
 ) -> List[TrackedAsset]:
@@ -154,9 +118,12 @@ def _process_globbing(
     return res
 
 
-def _get_preset_tracked_assets(name: str, is_contest: bool) -> List[TrackedAsset]:
-    preset = get_installed_preset(name)
-    preset_path = get_preset_installation_path(name)
+def _get_preset_tracked_assets(
+    root: pathlib.Path, is_contest: bool
+) -> List[TrackedAsset]:
+    preset = get_active_preset(root)
+    preset_path = _find_local_preset(root)
+    assert preset_path is not None
 
     if is_contest:
         assert (
@@ -222,7 +189,6 @@ def _find_modified_assets(
 
 
 def _copy_updated_assets(
-    preset_name: str,
     preset_lock: PresetLock,
     is_contest: bool,
     root: pathlib.Path = pathlib.Path(),
@@ -232,9 +198,11 @@ def _copy_updated_assets(
         preset_lock.assets, current_package_snapshot
     )
 
-    preset_package_path = _get_preset_package_path(preset_name, is_contest=is_contest)
+    preset = get_active_preset(root)
+    preset_package_path = _get_active_preset_package_path(root, is_contest)
+
     preset_tracked_assets = _get_preset_tracked_assets(
-        preset_name, is_contest=is_contest
+        preset_package_path, is_contest=is_contest
     )
     current_preset_snapshot = _build_package_locked_assets(
         preset_tracked_assets, preset_package_path
@@ -246,137 +214,151 @@ def _copy_updated_assets(
         dst_path = root / asset.path
         shutil.copyfile(str(src_path), str(dst_path))
         console.console.print(
-            f'Updated [item]{asset.path}[/item] from preset [item]{preset_name}[/item].'
+            f'Updated [item]{asset.path}[/item] from preset [item]{preset.name}[/item].'
         )
 
 
-def _try_installing_from_resources(name: str) -> bool:
-    if name == LOCAL:
-        return False
-    rsrc_preset_path = get_default_app_path() / 'presets' / name
-    if not rsrc_preset_path.exists():
-        return False
-    yaml_path = rsrc_preset_path / 'preset.rbx.yml'
-    if not yaml_path.is_file():
-        return False
-    console.console.print(f'Installing preset [item]{name}[/item] from resources...')
-    _install(rsrc_preset_path, force=True)
-    return True
-
+def get_active_preset_or_null(root: pathlib.Path = pathlib.Path()) -> Optional[Preset]:
+    local_preset = _find_local_preset(root)
+    if local_preset is not None:
+        return _get_preset_yaml(local_preset)
+    return None
 
-@functools.cache
-def _install_from_resources_just_once(name: str) -> bool:
-    # Send all output to the void since we don't wanna be verbose here.
-    with console.console.capture():
-        return _try_installing_from_resources(name)
 
+def get_active_preset(root: pathlib.Path = pathlib.Path()) -> Preset:
+    preset = get_active_preset_or_null(root)
+    if preset is None:
+        console.console.print('[error]No preset is active.[/error]')
+        raise typer.Exit(1)
+    return preset
 
-def get_installed_preset_or_null(
-    name: str, root: pathlib.Path = pathlib.Path()
-) -> Optional[Preset]:
-    installation_path = get_preset_installation_path(name, root) / 'preset.rbx.yml'
-    if not installation_path.is_file():
-        if not _try_installing_from_resources(name):
-            return None
-    elif name == 'default':
-        _install_from_resources_just_once(name)
 
-    return utils.model_from_yaml(Preset, installation_path.read_text())
+def get_active_preset_path(root: pathlib.Path = pathlib.Path()) -> pathlib.Path:
+    preset_path = _find_local_preset(root)
+    if preset_path is None:
+        console.console.print('[error]No preset is active.[/error]')
+        raise typer.Exit(1)
+    return preset_path
 
 
-def get_installed_preset(name: str, root: pathlib.Path = pathlib.Path()) -> Preset:
-    preset = get_installed_preset_or_null(name, root)
-    if preset is None:
+def get_preset_environment_path(
+    root: pathlib.Path = pathlib.Path(),
+) -> Optional[pathlib.Path]:
+    preset = get_active_preset_or_null(root)
+    if preset is None or preset.env is None:
+        return None
+    preset_path = get_active_preset_path(root)
+    env_path = preset_path / preset.env
+    if not env_path.is_file():
         console.console.print(
-            f'[error]Preset [item]{name}[/item] is not installed.[/error]'
+            f'[error]Preset [item]{preset.name}[/item] environment file [item]{preset.env}[/item] does not exist.[/error]'
         )
         raise typer.Exit(1)
-    return preset
+    return env_path
 
 
-def optionally_install_environment_from_preset(
-    preset: Preset, root: pathlib.Path = pathlib.Path()
-):
-    if preset.env is None:
-        return
-    env_path = get_environment_path(preset.name)
-    preset_env_path = root / preset.env
-    if env_path.is_file():
-        if digest_file(preset_env_path) == digest_file(env_path):
-            return
-        import questionary
-
-        overwrite = questionary.confirm(
-            'Preset environment file has changed. Overwrite?',
-            default=False,
-        ).ask()
-        if not overwrite:
-            return
+def _get_active_preset_package_path(
+    root: pathlib.Path = pathlib.Path(),
+    is_contest: bool = False,
+) -> pathlib.Path:
+    preset = get_active_preset(root)
+    preset_path = _find_local_preset(root)
+    assert preset_path is not None
+    if is_contest:
+        assert (
+            preset.contest is not None
+        ), 'Preset does not have a contest package definition.'
+        return preset_path / preset.contest
+    assert (
+        preset.problem is not None
+    ), 'Preset does not have a problem package definition.'
+    return preset_path / preset.problem
+
+
+def get_preset_fetch_info_with_fallback(
+    uri: Optional[str],
+) -> Optional[PresetFetchInfo]:
+    if uri is None:
+        # Use active preset if any, otherwise use the default preset.
+        if get_active_preset_or_null() is not None:
+            return None
+        default_preset = get_preset_fetch_info('default')
+        if default_preset is None:
+            console.console.print(
+                '[error]Internal error: could not find [item]default[/item] preset.[/error]'
+            )
+            raise typer.Exit(1)
+        return default_preset
+    return get_preset_fetch_info(uri)
+
+
+def _clean_copied_package_dir(dest: pathlib.Path):
+    for box_dir in dest.rglob('.box'):
+        shutil.rmtree(str(box_dir), ignore_errors=True)
+    for lock in dest.rglob('.preset-lock.yml'):
+        lock.unlink(missing_ok=True)
 
-    console.console.print(
-        f'[success]Overwriting the existing environment based on [item]{preset.env}[/item].'
-    )
-    env_path.parent.mkdir(parents=True, exist_ok=True)
-    shutil.copyfile(str(preset_env_path), env_path)
 
+def _clean_copied_contest_dir(dest: pathlib.Path, delete_local_rbx: bool = True):
+    shutil.rmtree(str(dest / 'build'), ignore_errors=True)
+    if delete_local_rbx:
+        shutil.rmtree(str(dest / '.local.rbx'), ignore_errors=True)
+    _clean_copied_package_dir(dest)
 
-def _install(root: pathlib.Path = pathlib.Path(), force: bool = False):
-    preset = get_preset_yaml(root)
 
-    if preset.name == LOCAL:
-        console.console.print('[error]Naming a preset "local" is prohibited.[/error]')
+def _clean_copied_problem_dir(dest: pathlib.Path):
+    shutil.rmtree(str(dest / 'build'), ignore_errors=True)
+    _clean_copied_package_dir(dest)
 
-    console.console.print(f'Installing preset [item]{preset.name}[/item]...')
-    installation_path = get_preset_installation_path(preset.name)
 
-    if root.resolve().is_relative_to(installation_path.resolve()):
+def _install_preset_from_dir(
+    src: pathlib.Path,
+    dest: pathlib.Path,
+    ensure_contest: bool = False,
+    ensure_problem: bool = False,
+    update: bool = False,
+    override_uri: Optional[str] = None,
+):
+    preset = _get_preset_yaml(src)
+
+    if ensure_contest and preset.contest is None:
         console.console.print(
-            '[error]Current folder is nested into the preset installation path, cannot install it.[/error]'
+            f'[error]Preset [item]{preset.name}[/item] does not have a contest package definition.[/error]'
         )
         raise typer.Exit(1)
-
-    if preset.env is not None:
+    if ensure_problem and preset.problem is None:
         console.console.print(
-            f'[item]{preset.name}[/item]: Copying environment file...'
+            f'[error]Preset [item]{preset.name}[/item] does not have a problem package definition.[/error]'
         )
-        should_copy_env = True
-        if get_environment_path(preset.name).exists():
-            res = force or rich.prompt.Confirm.ask(
-                f'Environment [item]{preset.name}[/item] already exists. Overwrite?',
-                console=console.console,
-            )
-            if not res:
-                should_copy_env = False
-
-        if should_copy_env:
-            get_environment_path(preset.name).parent.mkdir(parents=True, exist_ok=True)
-            shutil.rmtree(get_environment_path(preset.name), ignore_errors=True)
-            shutil.copyfile(str(root / preset.env), get_environment_path(preset.name))
-
-    console.console.print(f'[item]{preset.name}[/item]: Copying preset folder...')
-    installation_path.parent.mkdir(parents=True, exist_ok=True)
-    if installation_path.exists():
-        res = force or rich.prompt.Confirm.ask(
-            f'Preset [item]{preset.name}[/item] is already installed. Overwrite?',
-            console=console.console,
-        )
-        if not res:
-            raise typer.Exit(1)
-    shutil.rmtree(str(installation_path), ignore_errors=True)
-    copy_tree_normalizing_gitdir(root, installation_path)
-    shutil.rmtree(str(installation_path / 'build'), ignore_errors=True)
-    shutil.rmtree(str(installation_path / '.box'), ignore_errors=True)
-    shutil.rmtree(str(installation_path / '.local.rbx'), ignore_errors=True)
+        raise typer.Exit(1)
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    copy_tree_normalizing_gitdir(src, dest, update=update)
 
+    # Override the uri of the preset.
+    if override_uri is not None:
+        preset.uri = override_uri
+        (dest / 'preset.rbx.yml').write_text(utils.model_to_yaml(preset))
 
-def install_from_local_dir(fetch_info: PresetFetchInfo, force: bool = False) -> str:
-    pd = pathlib.Path(fetch_info.inner_dir)
-    preset = get_preset_yaml(pd)
-    _install(pd, force=force)
-    return preset.name
+    # Clean up all cache and left over directories before copying
+    # to avoid conflicts.
+    shutil.rmtree(str(dest / 'build'), ignore_errors=True)
+    shutil.rmtree(str(dest / '.local.rbx'), ignore_errors=True)
+
+    if preset.contest is not None:
+        _clean_copied_contest_dir(dest / preset.contest)
+    if preset.problem is not None:
+        _clean_copied_problem_dir(dest / preset.problem)
 
+    _clean_copied_package_dir(dest)
 
-def install_from_remote(fetch_info: PresetFetchInfo, force: bool = False) -> str:
+
+def _install_preset_from_remote(
+    fetch_info: PresetFetchInfo,
+    dest: pathlib.Path,
+    ensure_contest: bool = False,
+    ensure_problem: bool = False,
+    update: bool = False,
+):
     import git
 
     assert fetch_info.fetch_uri is not None
@@ -387,37 +369,176 @@ def install_from_remote(fetch_info: PresetFetchInfo, force: bool = False) -> str
         git.Repo.clone_from(fetch_info.fetch_uri, d)
         pd = pathlib.Path(d)
         if fetch_info.inner_dir:
-            pd = pd / fetch_info.inner_dir
             console.console.print(
                 f'Installing preset from [item]{fetch_info.inner_dir}[/item].'
             )
-        preset = get_preset_yaml(pd)
-        preset.uri = fetch_info.uri
+            pd = pd / fetch_info.inner_dir
+        _install_preset_from_dir(
+            pd,
+            dest,
+            ensure_contest,
+            ensure_problem,
+            override_uri=fetch_info.fetch_uri,
+            update=update,
+        )
 
-        (pd / 'preset.rbx.yml').write_text(utils.model_to_yaml(preset))
-        _install(pd, force=force)
-        return preset.name
+
+def _install_preset_from_local_dir(
+    fetch_info: PresetFetchInfo,
+    dest: pathlib.Path,
+    ensure_contest: bool = False,
+    ensure_problem: bool = False,
+    update: bool = False,
+):
+    pd = pathlib.Path(fetch_info.inner_dir)
+    preset = _get_preset_yaml(pd)
+    console.console.print(
+        f'Installing local preset [item]{preset.name}[/item] into [item]{dest}[/item]...'
+    )
+    _install_preset_from_dir(
+        pd,
+        dest,
+        ensure_contest,
+        ensure_problem,
+        override_uri=str(pd.resolve()),
+        update=update,
+    )
 
 
-def generate_lock(
-    preset_name: Optional[str] = None, root: pathlib.Path = pathlib.Path()
+def _install_preset_from_resources(
+    fetch_info: PresetFetchInfo,
+    dest: pathlib.Path,
+    ensure_contest: bool = False,
+    ensure_problem: bool = False,
+    update: bool = False,
 ):
-    if preset_name is None:
-        preset_lock = get_preset_lock(root)
-        if preset_lock is None:
-            console.console.print(
-                '[error][item].preset-lock.yml[/item] not found. '
-                'Specify a preset argument to this function to create a lock from scratch.[/error]'
-            )
-            raise typer.Exit(1)
-        preset_name = preset_lock.preset_name
+    rsrc_preset_path = get_default_app_path() / 'presets' / fetch_info.name
+    if not rsrc_preset_path.exists():
+        return False
+    yaml_path = rsrc_preset_path / 'preset.rbx.yml'
+    if not yaml_path.is_file():
+        return False
+    console.console.print(
+        f'Installing preset [item]{fetch_info.name}[/item] from resources...'
+    )
+    _install_preset_from_dir(
+        rsrc_preset_path,
+        dest,
+        ensure_contest,
+        ensure_problem,
+        override_uri=str(rsrc_preset_path.resolve()),
+        update=update,
+    )
+    return True
+
+
+def _install_preset_from_fetch_info(
+    fetch_info: PresetFetchInfo,
+    dest: pathlib.Path,
+    ensure_contest: bool = False,
+    ensure_problem: bool = False,
+    update: bool = False,
+):
+    if fetch_info.is_remote():
+        _install_preset_from_remote(
+            fetch_info,
+            dest,
+            ensure_contest=ensure_contest,
+            ensure_problem=ensure_problem,
+            update=update,
+        )
+        return
+    if fetch_info.is_local_dir():
+        _install_preset_from_local_dir(
+            fetch_info,
+            dest,
+            ensure_contest=ensure_contest,
+            ensure_problem=ensure_problem,
+            update=update,
+        )
+        return
+    if _install_preset_from_resources(
+        fetch_info,
+        dest,
+        ensure_contest=ensure_contest,
+        ensure_problem=ensure_problem,
+        update=update,
+    ):
+        return
+    console.console.print(
+        f'[error]Preset [item]{fetch_info.name}[/item] not found.[/error]'
+    )
+    raise typer.Exit(1)
+
+
+def install_preset_at_package(fetch_info: PresetFetchInfo, dest_pkg: pathlib.Path):
+    _install_preset_from_fetch_info(fetch_info, dest_pkg / '.local.rbx')
+
+
+def install_contest(
+    dest_pkg: pathlib.Path, fetch_info: Optional[PresetFetchInfo] = None
+):
+    if fetch_info is not None:
+        _install_preset_from_fetch_info(
+            fetch_info,
+            dest_pkg / '.local.rbx',
+            ensure_contest=True,
+        )
+    preset = get_active_preset(dest_pkg)
+    preset_path = _find_local_preset(dest_pkg)
+    assert preset_path is not None
+    if preset.contest is None:
+        console.console.print(
+            f'[error]Preset [item]{preset.name}[/item] does not have a contest package definition.[/error]'
+        )
+        raise typer.Exit(1)
+
+    console.console.print(
+        f'Installing contest from [item]{preset_path / preset.contest}[/item] to [item]{dest_pkg}[/item]...'
+    )
+    shutil.copytree(
+        str(preset_path / preset.contest),
+        str(dest_pkg),
+        dirs_exist_ok=True,
+    )
+    _clean_copied_contest_dir(dest_pkg, delete_local_rbx=False)
+
+
+def install_problem(
+    dest_pkg: pathlib.Path, fetch_info: Optional[PresetFetchInfo] = None
+):
+    if fetch_info is not None:
+        _install_preset_from_fetch_info(
+            fetch_info,
+            dest_pkg / '.local.rbx',
+            ensure_problem=True,
+        )
+    preset = get_active_preset(dest_pkg)
+    preset_path = _find_local_preset(dest_pkg)
+    assert preset_path is not None
+    if preset.problem is None:
+        console.console.print(
+            f'[error]Preset [item]{preset.name}[/item] does not have a problem package definition.[/error]'
+        )
+        raise typer.Exit(1)
+
+    console.console.print(
+        f'Installing problem from [item]{preset_path / preset.problem}[/item] to [item]{dest_pkg}[/item]...'
+    )
+    shutil.copytree(
+        str(preset_path / preset.problem),
+        str(dest_pkg),
+        dirs_exist_ok=True,
+    )
+    _clean_copied_problem_dir(dest_pkg)
 
-    preset = get_installed_preset(preset_name, root)
 
-    tracked_assets = _get_preset_tracked_assets(preset_name, is_contest=_is_contest())
+def generate_lock(root: pathlib.Path = pathlib.Path()):
+    preset = get_active_preset(root)
+
+    tracked_assets = _get_preset_tracked_assets(root, is_contest=_is_contest(root))
     preset_lock = PresetLock(
-        name=preset.name if preset_name != LOCAL else LOCAL,
-        uri=preset.uri,
+        name=preset.name,
         assets=_build_package_locked_assets(tracked_assets, root),
     )
 
@@ -428,7 +549,7 @@ def generate_lock(
 
 
 def _sync(try_update: bool = False):
-    preset_lock = get_preset_lock()
+    preset_lock = _get_preset_lock()
     if preset_lock is None:
         console.console.print(
             '[error]Package does not have a [item].preset.lock.yml[/item] file and thus cannot be synced.[/error]'
@@ -438,28 +559,22 @@ def _sync(try_update: bool = False):
         )
         raise typer.Exit(1)
 
-    should_update = try_update and preset_lock.uri is not None
-    installed_preset = get_installed_preset_or_null(preset_lock.preset_name)
-    if installed_preset is None:
-        if not try_update or preset_lock.uri is None:
-            console.console.print(
-                f'[error]Preset [item]{preset_lock.preset_name}[/item] is not installed. Install it before trying to update.'
-            )
-            raise typer.Exit(1)
-        install(preset_lock.uri)
-    elif should_update:
-        update(preset_lock.name)
+    if try_update:
+        update()
 
     _copy_updated_assets(
-        preset_lock.preset_name,
         preset_lock,
         is_contest=_is_contest(),
     )
-    generate_lock(preset_lock.preset_name)
+    generate_lock()
+
 
+def copy_tree_normalizing_gitdir(
+    src_path: pathlib.Path, dst_path: pathlib.Path, update: bool = False
+):
+    from rbx.box import git_utils
 
-def copy_tree_normalizing_gitdir(src_path: pathlib.Path, dst_path: pathlib.Path):
-    shutil.copytree(str(src_path), str(dst_path))
+    shutil.copytree(str(src_path), str(dst_path), dirs_exist_ok=update)
     if not (src_path / '.git').is_file():
         return
 
@@ -522,79 +637,42 @@ def copy_local_preset(
     )
 
 
-@app.command(
-    'install', help='Install preset from current directory or from the given URI.'
-)
-def install(
-    uri: Optional[str] = typer.Argument(
-        None,
-        help='URI for the preset to install. Might be a Github repository, or even a local path.',
-    ),
-):
-    if uri is None:
-        _install()
+@app.command('update', help='Update preset of current package')
+def update():
+    preset = get_active_preset()
+    if _is_active_preset_nested():
+        console.console.print(
+            '[error]Your package is nested inside the active preset. Updating such a preset is not supported.[/error]'
+        )
+        return
+    if not _is_installed_preset():
+        console.console.print(
+            '[error]Your active preset is not installed in a [item].local.rbx[/item] directory. Updating such a preset is not supported.[/error]'
+        )
+        return
+    if preset.uri is None:
+        console.console.print(
+            f'[error]Preset [item]{preset.name}[/item] is not updateable because it does not have a remote URI.'
+        )
         return
 
-    fetch_info = get_preset_fetch_info(uri)
-    if fetch_info is None:
-        console.console.print(f'[error] Preset with URI {uri} not found.[/error]')
-        raise typer.Exit(1)
-    if not fetch_info.is_local_dir() and not fetch_info.is_remote():
-        console.console.print(f'[error]URI {uri} is invalid.[/error]')
-        raise typer.Exit(1)
-    if fetch_info.is_remote():
-        install_from_remote(fetch_info)
-    else:
-        install_from_local_dir(fetch_info)
+    import questionary
 
+    console.console.print(
+        f'Updating preset [item]{preset.name}[/item] from [item]{preset.uri}[/item]...'
+    )
+    if not questionary.confirm(
+        'Updating local preset from remote will remove all custom changes you made to the preset.',
+        default=False,
+    ).ask():
+        return
 
-@app.command('update', help='Update installed remote presets')
-def update(
-    name: Annotated[
-        Optional[str], typer.Argument(help='If set, update only this preset.')
-    ] = None,
-):
-    if not name:
-        presets = _find_installed_presets()
-    else:
-        presets = [name]
-
-    for preset_name in presets:
-        if preset_name == LOCAL:
-            import questionary
-
-            if not questionary.confirm(
-                'Updating local preset will remove all custom changes you made to the preset.',
-                default=False,
-            ).ask():
-                continue
-
-        preset = get_installed_preset_or_null(preset_name)
-        if preset is None:
-            console.console.print(
-                f'[error]Preset [item]{preset_name}[/item] is not installed.'
-            )
-            continue
-        if preset.uri is None:
-            console.console.print(
-                f'Skipping preset [item]{preset_name}[/item], not remote.'
-            )
-            continue
-        install_from_remote(preset.fetch_info, force=True)
-
-        if preset_name == LOCAL:
-            # Get global path to the preset.
-            preset_path = get_preset_installation_path(preset.name)
-            dest_path = '.local.rbx'
-            shutil.rmtree(dest_path, ignore_errors=True)
-            shutil.copytree(preset_path, dest_path)
-            console.console.print(
-                '[success]Local preset updated successfully.[/success]'
-            )
-        else:
-            console.console.print(
-                f'[success]Preset [item]{preset_name}[/item] updated successfully.[/success]'
-            )
+    preset_path = _find_local_preset(pathlib.Path.cwd())
+    assert preset_path is not None
+    _install_preset_from_fetch_info(preset.fetch_info, dest=preset_path, update=True)
+    console.console.print(
+        f'[success]Preset [item]{preset.name}[/item] updated successfully.[/success]'
+    )
 
 
 @app.command(
@@ -620,16 +698,19 @@ def sync(
     'lock', help='Generate a lock for this package, based on a existing preset.'
 )
 @cd.within_closest_package
-def lock(
-    preset: Annotated[
-        Optional[str],
-        typer.Argument(
-            help='Preset to generate a lock for. If unset, will default to the one in the existing .preset-lock.yml.',
-        ),
-    ] = None,
-):
+def lock():
     _check_is_valid_package()
-    generate_lock(preset)
+    generate_lock()
+
+
+@app.command('ls', help='List details about the active preset.')
+@cd.within_closest_package
+def ls():
+    preset = get_active_preset()
+    preset_path = _find_local_preset(pathlib.Path.cwd())
+    console.console.print(f'Preset: [item]{preset.name}[/item]')
+    console.console.print(f'Path: {preset_path}')
+    console.console.print(f'URI: {preset.uri}')
 
 
 @app.callback()