dayhoff-tools 1.1.10__py3-none-any.whl → 1.13.12__py3-none-any.whl

dayhoff_tools/cli/utility_commands.py

@@ -9,7 +9,8 @@ from pathlib import Path
 
 import toml
 import typer
-import yaml
+
+# Import cloud helper lazily inside functions to avoid heavy deps at module load
 
 
 def test_github_actions_locally():
@@ -23,108 +24,6 @@ def test_github_actions_locally():
         print(f"Error occurred while running the script: {e}")
 
 
-def get_ancestry(filepath: str) -> None:
-    """Take a .dvc file created from import, and generate an ancestry entry
-    that can be manually copied into other .dvc files."""
-    with open(filepath, "r") as file:
-        assert filepath.endswith(".dvc"), "ERROR: Not a .dvc file"
-        ancestor_content = yaml.safe_load(file)
-
-        error_msg = "Unexpected file structure. Are you sure this is a .dvc file generated from `dvc import`?"
-        assert "deps" in ancestor_content, error_msg
-
-        error_msg = "Please only reference data imported from main branches."
-        assert "rev" not in ancestor_content["deps"][0]["repo"], error_msg
-
-        ancestor_info = {
-            "name": os.path.basename(ancestor_content["outs"][0]["path"]),
-            "file_md5_hash": ancestor_content["outs"][0]["md5"],
-            "size": ancestor_content["outs"][0]["size"],
-            "repo_url": ancestor_content["deps"][0]["repo"]["url"],
-            "repo_path": ancestor_content["deps"][0]["path"],
-            "commit_hash": ancestor_content["deps"][0]["repo"]["rev_lock"],
-        }
-        print()
-        yaml.safe_dump(
-            [ancestor_info], sys.stdout, default_flow_style=False, sort_keys=False
-        )
-
-
-def import_from_warehouse_typer() -> None:
-    """Import a file from warehouse.
-    This is a thin wrapper around `cli.utils.import_from_warehouse`,
-    with interactive prompts using questionary.
-    """
-    # Import only when the function is called
-    import questionary
-    from dayhoff_tools.warehouse import import_from_warehouse
-
-    # Ensure execution from root
-    cwd = Path(os.getcwd())
-    if cwd.parent.name != "workspaces" or str(cwd.parent.parent) != cwd.root:
-        raise Exception(
-            f"This command must be executed from the repo's root directory (/workspaces/reponame). Current directory: {cwd}"
-        )
-
-    # Use questionary for prompts instead of typer
-    warehouse_path = questionary.text("Warehouse path:").ask()
-
-    # Provide multiple-choice options for output folder
-    output_folder_choice = questionary.select(
-        "Output folder:",
-        choices=["data/imports", "same_as_warehouse", "Custom path..."],
-    ).ask()
-
-    # If custom path is selected, ask for the path
-    if output_folder_choice == "Custom path...":
-        output_folder = questionary.text("Enter custom output folder:").ask()
-    else:
-        output_folder = output_folder_choice
-
-    branch = questionary.text("Branch (default: main):", default="main").ask()
-
-    final_path = import_from_warehouse(
-        warehouse_path=warehouse_path,
-        output_folder=output_folder,
-        branch=branch,
-    )
-
-
-def add_to_warehouse_typer() -> None:
-    """Add a new data file to warehouse, and expand its .dvc file with
-    metadata, including ancestor files."""
-    # Import only when the function is called
-    import questionary
-    from dayhoff_tools.warehouse import add_to_warehouse
-
-    # Ensure execution from root
-    cwd = Path(os.getcwd())
-    if cwd.parent.name != "workspaces" or str(cwd.parent.parent) != cwd.root:
-        raise Exception(
-            f"This command must be executed from the repo's root directory (/workspaces/reponame). Current directory: {cwd}"
-        )
-
-    # Prompt for the data file path
-    warehouse_path = questionary.text("Data file to be registered:").ask()
-
-    # Prompt for the ancestor .dvc file paths
-    ancestor_dvc_paths = []
-    print("\nEnter the path of all ancestor .dvc files (or hit Enter to finish).")
-    print("These files must be generated by `dvc import` or `dh wimport`.")
-    while True:
-        ancestor_path = questionary.text("Ancestor path: ").ask()
-        if ancestor_path:
-            ancestor_dvc_paths.append(ancestor_path)
-        else:
-            print()
-            break
-
-    dvc_path = add_to_warehouse(
-        warehouse_path=warehouse_path,
-        ancestor_dvc_paths=ancestor_dvc_paths,
-    )
-
-
 def delete_local_branch(branch_name: str, folder_path: str):
     """Delete a local Git branch after fetching with pruning.
 
@@ -211,7 +110,24 @@ def build_and_upload_wheel(bump_part: str = "patch"):
     publish_cmd = ["uv", "publish", "--token", token]
     print("Using UV_PUBLISH_TOKEN for authentication.")
 
-    pyproject_path = "pyproject.toml"
+    # Find the primary manifest (prefer AWS, then Mac, then Workstation)
+    pyproject_path = None
+    for candidate in [
+        "pyproject.aws.toml",
+        "pyproject.mac.toml",
+        "pyproject.workstation.toml",
+    ]:
+        if Path(candidate).exists():
+            pyproject_path = candidate
+            break
+
+    if not pyproject_path:
+        print(
+            "Error: No platform-specific manifest found (pyproject.aws.toml, pyproject.mac.toml, or pyproject.workstation.toml)"
+        )
+        return
+
+    print(f"Using manifest: {pyproject_path}")
     current_version = None  # Initialize in case the first try block fails
 
     try:
@@ -273,23 +189,91 @@ def build_and_upload_wheel(bump_part: str = "patch"):
         with open(pyproject_path, "w") as f:
             f.write(new_content)
         print(f"Updated {pyproject_path} with version {new_version}")
+
+        # Mirror version in all other platform manifests (best-effort)
+        other_manifests = []
+        for candidate in [
+            "pyproject.aws.toml",
+            "pyproject.mac.toml",
+            "pyproject.workstation.toml",
+        ]:
+            if Path(candidate).exists() and candidate != pyproject_path:
+                other_manifests.append(Path(candidate))
+
+        for manifest_path in other_manifests:
+            try:
+                content = manifest_path.read_text()
+                pattern = re.compile(
+                    f'^version\s*=\s*"{re.escape(current_version)}"', re.MULTILINE
+                )
+                new_content, replacements = pattern.subn(
+                    f'version = "{new_version}"', content
+                )
+                if replacements > 0:
+                    manifest_path.write_text(new_content)
+                    print(f"Updated {manifest_path} with version {new_version}")
+            except Exception as e:
+                print(f"Warning: Could not update {manifest_path}: {e}")
         # --- End Version Bumping Logic ---
 
         # Build wheel and sdist
-        build_cmd = ["uv", "build"]
-        # Print command in blue
-        print(f"Running command: {BLUE}{' '.join(build_cmd)}{RESET}")
-        subprocess.run(build_cmd, check=True)
-
-        # Upload using uv publish with explicit arguments
-        # Print masked command in blue
-        print(f"Running command: {BLUE}{' '.join(publish_cmd_safe_print)}{RESET}")
-        subprocess.run(
-            publish_cmd,  # Use the actual command with token
-            check=True,
-        )
+        # UV expects pyproject.toml, so temporarily copy the platform manifest
+        backup_created = False
+        temp_pyproject_created = False
+        if pyproject_path != "pyproject.toml":
+            if Path("pyproject.toml").exists():
+                Path("pyproject.toml").rename("pyproject.toml.build.bak")
+                backup_created = True
+            Path(pyproject_path).read_text()
+            with open("pyproject.toml", "w") as f:
+                f.write(Path(pyproject_path).read_text())
+            temp_pyproject_created = True
 
-        print(f"Successfully built and uploaded version {new_version} to PyPI")
+        try:
+            build_cmd = ["uv", "build"]
+            # Print command in blue
+            print(f"Running command: {BLUE}{' '.join(build_cmd)}{RESET}")
+            subprocess.run(build_cmd, check=True)
+
+            # Upload using uv publish with explicit arguments
+            # Print masked command in blue
+            print(f"Running command: {BLUE}{' '.join(publish_cmd_safe_print)}{RESET}")
+            subprocess.run(
+                publish_cmd,  # Use the actual command with token
+                check=True,
+            )
+
+            print(f"Successfully built and uploaded version {new_version} to PyPI")
+
+            # Re-install DHT in current venv when building from DHT itself
+            # (Keep temp pyproject.toml until after this step)
+            try:
+                proj_name = None
+                try:
+                    proj_toml = toml.load(pyproject_path)
+                    proj_name = (
+                        proj_toml.get("project", {}).get("name")
+                        if isinstance(proj_toml, dict)
+                        else None
+                    )
+                except Exception:
+                    pass
+                if proj_name == "dayhoff-tools":
+                    print("Re-installing dayhoff-tools into the active environment…")
+                    reinstall_cmd = ["uv", "pip", "install", "-e", ".[full]"]
+                    print(f"Running command: {BLUE}{' '.join(reinstall_cmd)}{RESET}")
+                    subprocess.run(reinstall_cmd, check=True)
+                    print("dayhoff-tools reinstalled in the current environment.")
+            except subprocess.CalledProcessError as e:
+                print(f"Warning: Failed to reinstall dayhoff-tools locally: {e}")
+
+        finally:
+            # Restore original state (always clean up, even if errors occurred)
+            if temp_pyproject_created:
+                if Path("pyproject.toml").exists():
+                    Path("pyproject.toml").unlink()
+                if backup_created and Path("pyproject.toml.build.bak").exists():
+                    Path("pyproject.toml.build.bak").rename("pyproject.toml")
 
     except FileNotFoundError:
         print(f"Error: {pyproject_path} not found.")
@@ -319,6 +303,26 @@ def build_and_upload_wheel(bump_part: str = "patch"):
                     print(
                         f"Warning: Could not find version {new_version} to revert in {pyproject_path}."
                     )
+
+                # Also revert other platform manifests
+                for candidate in [
+                    "pyproject.aws.toml",
+                    "pyproject.mac.toml",
+                    "pyproject.workstation.toml",
+                ]:
+                    if Path(candidate).exists() and candidate != pyproject_path:
+                        try:
+                            content_revert = Path(candidate).read_text()
+                            reverted, num = pattern_revert.subn(
+                                f'version = "{current_version}"', content_revert
+                            )
+                            if num > 0:
+                                Path(candidate).write_text(reverted)
+                                print(f"Successfully reverted version in {candidate}.")
+                        except Exception as e2:
+                            print(
+                                f"Warning: Failed to revert version change in {candidate}: {e2}"
+                            )
             except Exception as revert_e:
                 print(
                     f"Warning: Failed to revert version change in {pyproject_path}: {revert_e}"
@@ -348,6 +352,25 @@ def build_and_upload_wheel(bump_part: str = "patch"):
                     print(
                         f"Warning: Could not find version {new_version} to revert in {pyproject_path}."
                     )
+                # Also revert other platform manifests
+                for candidate in [
+                    "pyproject.aws.toml",
+                    "pyproject.mac.toml",
+                    "pyproject.workstation.toml",
+                ]:
+                    if Path(candidate).exists() and candidate != pyproject_path:
+                        try:
+                            content_revert = Path(candidate).read_text()
+                            reverted, num = pattern_revert.subn(
+                                f'version = "{current_version}"', content_revert
+                            )
+                            if num > 0:
+                                Path(candidate).write_text(reverted)
+                                print(f"Successfully reverted version in {candidate}.")
+                        except Exception as e2:
+                            print(
+                                f"Warning: Failed to revert version change in {candidate}: {e2}"
+                            )
             except Exception as revert_e:
                 print(
                     f"Warning: Failed to revert version change in {pyproject_path}: {revert_e}"
@@ -357,40 +380,319 @@ def build_and_upload_wheel(bump_part: str = "patch"):
 # --- Dependency Management Commands ---
 
 
-def install_dependencies(
+def sync_with_toml(
     install_project: bool = typer.Option(
         False,
         "--install-project",
         "-p",
-        help="Install the local project package itself into the environment.",
+        help="Install the local project package itself (with 'full' extras) into the environment.",
     ),
 ):
-    """Install dependencies based on pyproject.toml.
-
-    Ensures uv.lock matches pyproject.toml and syncs the environment.
-    This is the command to run after changing pyproject.toml manually
-    or cloning/pulling a repository.
+    """Sync environment with platform-specific TOML manifest (install/update dependencies).
+
+    Behavior by platform:
+    - Workstation (STUDIO_PLATFORM=workstation) with pyproject.workstation.toml:
+      * Uses pip with constraints.txt to preserve NGC PyTorch
+      * Parses dependencies directly from pyproject.workstation.toml
+      * Installs into .venv_workstation with --system-site-packages
+    - Mac (STUDIO_PLATFORM=mac) with pyproject.mac.toml:
+      * Ensure `.mac_uv_project/pyproject.toml` is a copy of `pyproject.mac.toml`
+      * Run `uv lock` and `uv sync` in `.mac_uv_project` targeting active venv with `--active`
+      * If `install_project` is true, install the project from repo root into the active env (editable, [full])
+    - AWS (default) with pyproject.aws.toml:
+      * Uses UV in temp directory `.aws_uv_project` similar to Mac
+      * Run `uv lock` and `uv sync` targeting active venv
     """
     # ANSI color codes
     BLUE = "\033[94m"
     RESET = "\033[0m"
 
     try:
-        # Step 1: Ensure lock file matches pyproject.toml
-        print("Ensuring lock file matches pyproject.toml...")
-        lock_cmd = ["uv", "lock"]
-        print(f"Running command: {BLUE}{' '.join(lock_cmd)}{RESET}")
-        subprocess.run(lock_cmd, check=True, capture_output=True)
+        platform = os.environ.get("STUDIO_PLATFORM", "aws")
 
-        # Step 2: Sync environment
-        print("Syncing environment with lock file...")
-        sync_cmd = ["uv", "sync", "--all-groups"]
-        if not install_project:
-            sync_cmd.append("--no-install-project")
-        print(f"Running command: {BLUE}{' '.join(sync_cmd)}{RESET}")
-        subprocess.run(sync_cmd, check=True)
+        # Workstation platform: use pip with constraints
+        if platform == "workstation" and Path("pyproject.workstation.toml").exists():
+            print(
+                "Installing dependencies for workstation platform (using pip + constraints)..."
+            )
+
+            # Check for constraints.txt
+            if not Path("constraints.txt").exists():
+                print(
+                    "Error: constraints.txt not found. Run direnv to generate it first."
+                )
+                sys.exit(1)
+
+            # Parse and install dependencies from pyproject.workstation.toml
+            import re
+
+            with open("pyproject.workstation.toml", "r") as f:
+                content = f.read()
+
+            # Extract dependencies list using line-by-line parsing to handle [] in package names
+            lines = content.split("\n")
+            in_deps = False
+            deps_lines = []
+
+            for line in lines:
+                if re.match(r"\s*dependencies\s*=\s*\[", line):
+                    in_deps = True
+                    continue
+                if in_deps:
+                    if re.match(r"^\s*\]\s*$", line):
+                        break
+                    deps_lines.append(line)
+
+            deps = []
+            for line in deps_lines:
+                line = line.strip()
+                if line.startswith('"') or line.startswith("'"):
+                    dep = re.sub(r'["\']', "", line)
+                    dep = re.sub(r",?\s*#.*$", "", dep)
+                    dep = dep.strip().rstrip(",")
+                    if dep:
+                        deps.append(dep)
+
+            if deps:
+                pip_cmd = (
+                    [sys.executable, "-m", "pip", "install"]
+                    + deps
+                    + ["-c", "constraints.txt"]
+                )
+                print(
+                    f"Running command: {BLUE}{' '.join(pip_cmd[:5])} ... -c constraints.txt{RESET}"
+                )
+                subprocess.run(pip_cmd, check=True)
+
+            # Install dev dependencies using line-by-line parsing
+            in_dev_groups = False
+            in_dev_list = False
+            dev_lines = []
+
+            for line in lines:
+                if re.match(r"\s*\[dependency-groups\]", line):
+                    in_dev_groups = True
+                    continue
+                if in_dev_groups and re.match(r"\s*dev\s*=\s*\[", line):
+                    in_dev_list = True
+                    continue
+                if in_dev_list:
+                    if re.match(r"^\s*\]\s*$", line):
+                        break
+                    dev_lines.append(line)
+
+            dev_deps = []
+            for line in dev_lines:
+                line = line.strip()
+                if line.startswith('"') or line.startswith("'"):
+                    dep = re.sub(r'["\']', "", line)
+                    dep = re.sub(r",?\s*#.*$", "", dep)
+                    dep = dep.strip().rstrip(",")
+                    if dep:
+                        dev_deps.append(dep)
+
+            if dev_deps:
+                print("Installing dev dependencies...")
+                pip_cmd = (
+                    [sys.executable, "-m", "pip", "install"]
+                    + dev_deps
+                    + ["-c", "constraints.txt"]
+                )
+                print(
+                    f"Running command: {BLUE}{' '.join(pip_cmd[:5])} ... -c constraints.txt{RESET}"
+                )
+                subprocess.run(pip_cmd, check=True)
+
+            # Install project if requested
+            if install_project:
+                repo_name = Path.cwd().name
+                if repo_name == "dayhoff-tools":
+                    pip_cmd = [
+                        sys.executable,
+                        "-m",
+                        "pip",
+                        "install",
+                        "-e",
+                        ".[full]",
+                        "-c",
+                        "constraints.txt",
+                    ]
+                else:
+                    pip_cmd = [
+                        sys.executable,
+                        "-m",
+                        "pip",
+                        "install",
+                        "-e",
+                        ".",
+                        "-c",
+                        "constraints.txt",
+                    ]
+                print(f"Running command: {BLUE}{' '.join(pip_cmd)}{RESET}")
+                subprocess.run(pip_cmd, check=True)
+
+            print("✅ Dependencies installed successfully (workstation)")
+            return
 
-        print("Dependencies installed/synced successfully.")
+        # Mac platform: use UV with pyproject.mac.toml
+        is_mac = platform == "mac"
+        mac_manifest = Path("pyproject.mac.toml")
+        if is_mac and mac_manifest.exists():
+            # Mac devcontainer flow
+            mac_uv_dir = Path(".mac_uv_project")
+            mac_uv_dir.mkdir(parents=True, exist_ok=True)
+            mac_pyproject = mac_uv_dir / "pyproject.toml"
+            mac_pyproject.write_text(mac_manifest.read_text())
+
+            # Copy README.md if it exists (required by some build backends)
+            if Path("README.md").exists():
+                (mac_uv_dir / "README.md").write_text(Path("README.md").read_text())
+
+            # Ensure lock matches manifest (in mac temp dir)
+            print("Ensuring lock file matches pyproject.mac.toml (Mac devcon)…")
+            lock_cmd = ["uv", "lock"]
+            print(f"Running command: {BLUE}{' '.join(lock_cmd)}{RESET}")
+            subprocess.run(
+                lock_cmd, check=True, capture_output=True, cwd=str(mac_uv_dir)
+            )
+
+            # Sync into the active environment
+            if install_project:
+                print(
+                    "Syncing dependencies into ACTIVE env (project installed separately)…"
+                )
+                sync_cmd = [
+                    "uv",
+                    "sync",
+                    "--all-groups",
+                    "--no-install-project",
+                    "--active",
+                ]
+                print(f"Running command: {BLUE}{' '.join(sync_cmd)}{RESET}")
+                subprocess.run(sync_cmd, check=True, cwd=str(mac_uv_dir))
+
+                # Install project from repo root (where source code actually is)
+                # Temporarily create pyproject.toml at repo root for UV
+                print("Installing project with 'full' extras from repo root…")
+                temp_pyproject = False
+                backup_created = False
+                try:
+                    if not Path("pyproject.toml").exists():
+                        # Create temp pyproject.toml from platform manifest
+                        Path("pyproject.toml").write_text(mac_manifest.read_text())
+                        temp_pyproject = True
+                    elif Path("pyproject.toml").is_symlink():
+                        # Backup existing symlink
+                        Path("pyproject.toml").rename("pyproject.toml.sync.bak")
+                        Path("pyproject.toml").write_text(mac_manifest.read_text())
+                        backup_created = True
+
+                    pip_install_cmd = ["uv", "pip", "install", "-e", ".[full]"]
+                    print(f"Running command: {BLUE}{' '.join(pip_install_cmd)}{RESET}")
+                    subprocess.run(pip_install_cmd, check=True)
+                    print("Project installed with 'full' extras successfully.")
+                finally:
+                    # Clean up temp pyproject.toml
+                    if temp_pyproject and Path("pyproject.toml").exists():
+                        Path("pyproject.toml").unlink()
+                    if backup_created and Path("pyproject.toml.sync.bak").exists():
+                        Path("pyproject.toml.sync.bak").rename("pyproject.toml")
+            else:
+                print("Syncing dependencies into ACTIVE env (project not installed)…")
+                sync_cmd = [
+                    "uv",
+                    "sync",
+                    "--all-groups",
+                    "--no-install-project",
+                    "--active",
+                ]
+                print(f"Running command: {BLUE}{' '.join(sync_cmd)}{RESET}")
+                subprocess.run(sync_cmd, check=True, cwd=str(mac_uv_dir))
+                print("Dependencies synced successfully (project not installed).")
+        else:
+            # AWS platform (or fallback): use UV with pyproject.aws.toml
+            aws_manifest = Path("pyproject.aws.toml")
+            if aws_manifest.exists():
+                # AWS devcontainer flow (similar to Mac)
+                aws_uv_dir = Path(".aws_uv_project")
+                aws_uv_dir.mkdir(parents=True, exist_ok=True)
+                aws_pyproject = aws_uv_dir / "pyproject.toml"
+                aws_pyproject.write_text(aws_manifest.read_text())
+
+                # Copy README.md if it exists (required by some build backends)
+                if Path("README.md").exists():
+                    (aws_uv_dir / "README.md").write_text(Path("README.md").read_text())
+
+                # Ensure lock matches manifest (in aws temp dir)
+                print("Ensuring lock file matches pyproject.aws.toml (AWS devcon)…")
+                lock_cmd = ["uv", "lock"]
+                print(f"Running command: {BLUE}{' '.join(lock_cmd)}{RESET}")
+                subprocess.run(
+                    lock_cmd, check=True, capture_output=True, cwd=str(aws_uv_dir)
+                )
+
+                # Sync into the active environment
+                if install_project:
+                    print(
+                        "Syncing dependencies into ACTIVE env (project installed separately)…"
+                    )
+                    sync_cmd = [
+                        "uv",
+                        "sync",
+                        "--all-groups",
+                        "--no-install-project",
+                        "--active",
+                    ]
+                    print(f"Running command: {BLUE}{' '.join(sync_cmd)}{RESET}")
+                    subprocess.run(sync_cmd, check=True, cwd=str(aws_uv_dir))
+
+                    # Install project from repo root (where source code actually is)
+                    # Temporarily create pyproject.toml at repo root for UV
+                    print("Installing project with 'full' extras from repo root…")
+                    temp_pyproject = False
+                    backup_created = False
+                    try:
+                        if not Path("pyproject.toml").exists():
+                            # Create temp pyproject.toml from platform manifest
+                            Path("pyproject.toml").write_text(aws_manifest.read_text())
+                            temp_pyproject = True
+                        elif Path("pyproject.toml").is_symlink():
+                            # Backup existing symlink
+                            Path("pyproject.toml").rename("pyproject.toml.sync.bak")
+                            Path("pyproject.toml").write_text(aws_manifest.read_text())
+                            backup_created = True
+
+                        pip_install_cmd = ["uv", "pip", "install", "-e", ".[full]"]
+                        print(
+                            f"Running command: {BLUE}{' '.join(pip_install_cmd)}{RESET}"
+                        )
+                        subprocess.run(pip_install_cmd, check=True)
+                        print("Project installed with 'full' extras successfully.")
+                    finally:
+                        # Clean up temp pyproject.toml
+                        if temp_pyproject and Path("pyproject.toml").exists():
+                            Path("pyproject.toml").unlink()
+                        if backup_created and Path("pyproject.toml.sync.bak").exists():
+                            Path("pyproject.toml.sync.bak").rename("pyproject.toml")
+                else:
+                    print(
+                        "Syncing dependencies into ACTIVE env (project not installed)…"
+                    )
+                    sync_cmd = [
+                        "uv",
+                        "sync",
+                        "--all-groups",
+                        "--no-install-project",
+                        "--active",
+                    ]
+                    print(f"Running command: {BLUE}{' '.join(sync_cmd)}{RESET}")
+                    subprocess.run(sync_cmd, check=True, cwd=str(aws_uv_dir))
+                    print("Dependencies synced successfully (project not installed).")
+            else:
+                print(
+                    "Error: No platform-specific manifest found (pyproject.aws.toml, pyproject.mac.toml, or pyproject.workstation.toml)"
+                )
+                sys.exit(1)
 
     except subprocess.CalledProcessError as e:
         stderr_output = e.stderr.decode() if e.stderr else "No stderr output."
@@ -409,6 +711,365 @@ def install_dependencies(
         sys.exit(1)
 
 
+def _get_all_platform_manifests():
+    """Get list of all platform manifests that exist."""
+    manifest_files = []
+    for fname in [
+        "pyproject.aws.toml",
+        "pyproject.mac.toml",
+        "pyproject.workstation.toml",
+    ]:
+        if Path(fname).exists():
+            manifest_files.append(Path(fname))
+    return manifest_files
+
+
+def _resolve_package_version(package_name: str) -> str | None:
+    """Resolve a package version by running uv lock and parsing the lock file.
+
+    Args:
+        package_name: Name of the package to resolve
+
+    Returns:
+        Resolved version string, or None if resolution failed
+    """
+    import os
+
+    try:
+        # Determine which manifest to use (prefer Mac, then AWS)
+        platform = os.environ.get("STUDIO_PLATFORM", "aws")
+        manifest_path = None
+        uv_dir = None
+
+        if platform == "mac" and Path("pyproject.mac.toml").exists():
+            manifest_path = Path("pyproject.mac.toml")
+            uv_dir = Path(".mac_uv_project")
+        elif Path("pyproject.aws.toml").exists():
+            manifest_path = Path("pyproject.aws.toml")
+            uv_dir = Path(".aws_uv_project")
+        elif Path("pyproject.mac.toml").exists():
+            # Fallback to Mac if AWS doesn't exist
+            manifest_path = Path("pyproject.mac.toml")
+            uv_dir = Path(".mac_uv_project")
+        else:
+            return None
+
+        # Create temp directory and copy manifest
+        uv_dir.mkdir(parents=True, exist_ok=True)
+        (uv_dir / "pyproject.toml").write_text(manifest_path.read_text())
+
+        # Copy README if it exists
+        if Path("README.md").exists():
+            (uv_dir / "README.md").write_text(Path("README.md").read_text())
+
+        # Run uv lock (suppress output)
+        subprocess.run(["uv", "lock"], cwd=str(uv_dir), check=True, capture_output=True)
+
+        # Parse lock file
+        lock_file = uv_dir / "uv.lock"
+        if not lock_file.exists():
+            return None
+
+        lock_data = toml.load(lock_file)
+        for package in lock_data.get("package", []):
+            if package.get("name") == package_name:
+                return package.get("version")
+
+        return None
+
+    except Exception as e:
+        print(f"Warning: Failed to resolve version: {e}")
+        return None
+
+
+def _update_all_manifests_for_dayhoff_tools(new_version: str):
+    """Update dayhoff-tools constraint in all platform manifests."""
+    import re
+
+    manifest_files = _get_all_platform_manifests()
+
+    if not manifest_files:
+        print("Warning: No platform manifests found to update.")
+        return
+
+    package_name = "dayhoff-tools"
+    package_name_esc = re.escape(package_name)
+
+    # Regex to match the dependency line, with optional extras and version spec
+    pattern = re.compile(
+        rf"^(\s*['\"]){package_name_esc}(\[[^]]+\])?(?:[><=~^][^'\"]*)?(['\"].*)$",
+        re.MULTILINE,
+    )
+
+    new_constraint_text = f">={new_version}"
+
+    def _repl(match: re.Match):
+        prefix = match.group(1)
+        extras = match.group(2) or ""
+        suffix = match.group(3)
+        return f"{prefix}{package_name}{extras}{new_constraint_text}{suffix}"
+
+    # Update all manifest files
+    for manifest_file in manifest_files:
+        try:
+            print(f"Updating {manifest_file} version constraint...")
+            content = manifest_file.read_text()
+            new_content, num_replacements = pattern.subn(_repl, content)
+            if num_replacements > 0:
+                manifest_file.write_text(new_content)
+                print(
+                    f"Updated dayhoff-tools constraint in {manifest_file} to '{new_constraint_text}'"
+                )
+            else:
+                print(
+                    f"Warning: Could not find dayhoff-tools dependency line in {manifest_file}"
+                )
+        except Exception as e:
+            print(f"Error updating {manifest_file}: {e}")
+
+
+def add_dependency(
+    package: str,
+    dev: bool = typer.Option(
+        False, "--dev", "-d", help="Add to dev dependencies instead of main."
+    ),
+):
+    """Add a dependency to all platform-specific manifests.
+
+    Args:
+        package: Package specification (e.g., "numpy>=1.24.0" or "pandas")
+        dev: If True, add to [dependency-groups] dev instead of [project] dependencies
+    """
+    import re
+
+    # ANSI color codes
+    BLUE = "\033[94m"
+    RESET = "\033[0m"
+
+    manifest_files = _get_all_platform_manifests()
+
+    if not manifest_files:
+        print(
+            "Error: No platform-specific manifests found (pyproject.aws.toml, pyproject.mac.toml, or pyproject.workstation.toml)"
+        )
+        sys.exit(1)
+
+    # Determine section to add to
+    section_name = "dev dependencies" if dev else "main dependencies"
+    print(f"Adding '{package}' to {section_name} in all platform manifests...")
+
+    # Parse package name to check for duplicates and version specs
+    package_name = re.split(r"[<>=~!\[]", package)[0].strip()
+    has_version_spec = any(c in package for c in ["<", ">", "=", "~", "!"])
+
+    added_count = 0
+
+    for manifest_file in manifest_files:
+        try:
+            content = manifest_file.read_text()
+
+            # Check if package already exists
+            existing_check = re.search(
+                rf'^(\s*["\']){re.escape(package_name)}[<>=~!\[]',
+                content,
+                re.MULTILINE,
+            )
+            if existing_check:
+                print(
+                    f"⚠️  Package '{package_name}' already exists in {manifest_file}, skipping"
+                )
+                continue
+
+            if dev:
+                # Add to [dependency-groups] dev section
+                # Use line-by-line parsing to handle [] in dependency names like dayhoff-tools[full]
+                lines = content.split("\n")
+                in_dev_groups = False
+                in_dev_list = False
+                dev_start_idx = None
+                dev_end_idx = None
+
+                for idx, line in enumerate(lines):
+                    if re.match(r"\s*\[dependency-groups\]", line):
+                        in_dev_groups = True
+                        continue
+                    if in_dev_groups and re.match(r"\s*dev\s*=\s*\[", line):
+                        in_dev_list = True
+                        dev_start_idx = idx
+                        continue
+                    if in_dev_list and re.match(r"^\s*\]\s*$", line):
+                        dev_end_idx = idx
+                        break
+
+                if dev_start_idx is None or dev_end_idx is None:
+                    print(
+                        f"Warning: Could not find [dependency-groups] dev section in {manifest_file}"
+                    )
+                    continue
+
+                # Insert new dependency before the closing ]
+                new_dep = f'    "{package}",'
+                lines.insert(dev_end_idx, new_dep)
+                new_content = "\n".join(lines)
+            else:
+                # Add to [project] dependencies section
+                # Use line-by-line parsing to handle [] in dependency names like dayhoff-tools[full]
+                lines = content.split("\n")
+                in_deps = False
+                deps_start_idx = None
+                deps_end_idx = None
+
+                for idx, line in enumerate(lines):
+                    if re.match(r"\s*dependencies\s*=\s*\[", line):
+                        in_deps = True
+                        deps_start_idx = idx
+                        continue
+                    if in_deps and re.match(r"^\s*\]\s*$", line):
+                        deps_end_idx = idx
+                        break
+
+                if deps_start_idx is None or deps_end_idx is None:
+                    print(
+                        f"Warning: Could not find dependencies section in {manifest_file}"
+                    )
+                    continue
+
+                # Insert new dependency before the closing ]
+                new_dep = f'    "{package}",'
+                lines.insert(deps_end_idx, new_dep)
+                new_content = "\n".join(lines)
+
+            manifest_file.write_text(new_content)
+            print(f"✅ Added '{package}' to {manifest_file}")
+            added_count += 1
+
+        except Exception as e:
+            print(f"Error updating {manifest_file}: {e}")
+
+    # If nothing was added, exit early
+    if added_count == 0:
+        print(f"\n⚠️  Package '{package_name}' already exists in all manifests")
+        return
+
+    print(f"\n✅ Added '{package}' to {added_count} platform manifest(s)")
+
+    # If no version specified, resolve and add version constraint
+    if not has_version_spec:
+        print(f"\n🔍 Resolving version for '{package_name}'...")
+        resolved_version = _resolve_package_version(package_name)
+
+        if resolved_version:
+            print(f"📌 Resolved to version {resolved_version}")
+            print(
+                f"Updating manifests with version constraint '>={resolved_version}'..."
+            )
+
+            # Update all manifests to add version constraint
+            for manifest_file in manifest_files:
+                try:
+                    content = manifest_file.read_text()
+                    # Replace unversioned package with versioned one
+                    pattern = re.compile(
+                        rf'^(\s*["\']){re.escape(package_name)}(["\'],?)(.*)$',
+                        re.MULTILINE,
+                    )
+
+                    def replace_with_version(match):
+                        prefix = match.group(1)
+                        suffix = match.group(2)
+                        rest = match.group(3)
+                        return (
+                            f"{prefix}{package_name}>={resolved_version}{suffix}{rest}"
+                        )
+
+                    new_content = pattern.sub(replace_with_version, content)
+                    manifest_file.write_text(new_content)
+                    print(f"✅ Updated {manifest_file} with version constraint")
+                except Exception as e:
+                    print(f"Warning: Could not update version in {manifest_file}: {e}")
+
+            print(
+                f"\n✅ Added '{package_name}>={resolved_version}' to {added_count} platform manifest(s)"
+            )
+        else:
+            print(
+                f"⚠️  Could not resolve version for '{package_name}', left unversioned"
+            )
+
+    print(
+        f"\nRun {BLUE}dh tomlsync{RESET} to install the new dependency in your environment."
+    )
+
+
+def remove_dependency(
+    package: str,
+    dev: bool = typer.Option(
+        False, "--dev", "-d", help="Remove from dev dependencies instead of main."
+    ),
+):
+    """Remove a dependency from all platform-specific manifests.
+
+    Args:
+        package: Package name (e.g., "numpy" or "pandas")
+        dev: If True, remove from [dependency-groups] dev instead of [project] dependencies
+    """
+    import re
+
+    # ANSI color codes
+    BLUE = "\033[94m"
+    RESET = "\033[0m"
+
+    manifest_files = _get_all_platform_manifests()
+
+    if not manifest_files:
+        print(
+            "Error: No platform-specific manifests found (pyproject.aws.toml, pyproject.mac.toml, or pyproject.workstation.toml)"
+        )
+        sys.exit(1)
+
+    section_name = "dev dependencies" if dev else "main dependencies"
+    print(f"Removing '{package}' from {section_name} in all platform manifests...")
+
+    # Escape package name for regex
+    package_esc = re.escape(package)
+
+    removed_count = 0
+    for manifest_file in manifest_files:
+        try:
+            content = manifest_file.read_text()
+
+            # Pattern to match the dependency line (with optional version spec)
+            # Matches:  "package...",  or  "package...",\n (including the newline)
+            pattern = re.compile(
+                rf'^\s*["\']({package_esc}[<>=~!\[].+?|{package_esc})["\'],?\s*(?:#.*)?$\n?',
+                re.MULTILINE,
+            )
+
+            new_content, num_removed = pattern.subn("", content)
+
+            if num_removed > 0:
+                # Clean up any consecutive blank lines (more than one)
+                new_content = re.sub(r"\n\n\n+", "\n\n", new_content)
+                # Also clean up trailing whitespace on lines
+                new_content = re.sub(r"[ \t]+$", "", new_content, flags=re.MULTILINE)
+                manifest_file.write_text(new_content)
+                print(f"✅ Removed '{package}' from {manifest_file}")
+                removed_count += 1
+            else:
+                print(f"⚠️  Package '{package}' not found in {manifest_file}")
+
+        except Exception as e:
+            print(f"Error updating {manifest_file}: {e}")
+
+    if removed_count > 0:
+        print(f"\n✅ Removed '{package}' from {removed_count} platform manifest(s)")
+        print(
+            f"\nRun {BLUE}dh tomlsync{RESET} to uninstall the dependency from your environment."
+        )
+    else:
+        print(f"\n⚠️  Package '{package}' was not found in any manifests")
+
+
 def update_dependencies(
     update_all: bool = typer.Option(
         False,
@@ -417,21 +1078,73 @@ def update_dependencies(
         help="Update all dependencies instead of just dayhoff-tools.",
     ),
 ):
-    """Update dependencies to newer versions.
-
-    Default Action (no flags): Updates only 'dayhoff-tools' package to latest,
-                               updates pyproject.toml, and syncs.
-
-    Flags:
-    --all/-a: Updates all dependencies to latest compatible versions (`uv lock --upgrade`)
-              and syncs the environment. Overrides the default.
+    """Update dependencies to newer versions (platform-aware).
+
+    - Default Action (no flags): Updates only 'dayhoff-tools' package to latest,
+      updates ALL manifest files with the version constraint, and syncs.
+    - Flags:
+      --all/-a: Updates all dependencies and syncs.
+
+    Cross-platform behavior:
+    - Workstation: Uses pip to upgrade packages, regenerates constraints.txt
+    - Mac/AWS: Uses UV with platform-specific manifests (.mac_uv_project or .aws_uv_project)
+    - Always updates ALL platform manifests (pyproject.aws.toml, pyproject.mac.toml,
+      pyproject.workstation.toml) to ensure version consistency
     """
     # ANSI color codes
     BLUE = "\033[94m"
     RESET = "\033[0m"
 
+    platform = os.environ.get("STUDIO_PLATFORM", "aws")
+
+    # Workstation platform: use pip upgrade
+    if platform == "workstation" and Path("pyproject.workstation.toml").exists():
+        print("Updating dependencies for workstation platform (using pip)...")
+
+        if update_all:
+            print("Error: --all flag not supported on workstation platform yet.")
+            print("Use 'pip install --upgrade <package>' manually for now.")
+            sys.exit(1)
+
+        # Update dayhoff-tools only (default behavior)
+        print("Upgrading dayhoff-tools to latest version...")
+        upgrade_cmd = [
+            sys.executable,
+            "-m",
+            "pip",
+            "install",
+            "--upgrade",
+            "dayhoff-tools[full]",
+        ]
+        print(f"Running command: {BLUE}{' '.join(upgrade_cmd)}{RESET}")
+        subprocess.run(upgrade_cmd, check=True)
+
+        # Get new version
+        result = subprocess.run(
+            [sys.executable, "-m", "pip", "show", "dayhoff-tools"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        version_line = [
+            l for l in result.stdout.split("\n") if l.startswith("Version:")
+        ]
+        if version_line:
+            new_version = version_line[0].split(":", 1)[1].strip()
+            print(f"Updated to dayhoff-tools {new_version}")
+
+            # Update all platform manifests with new constraint
+            _update_all_manifests_for_dayhoff_tools(new_version)
+
+        print("✅ Dependencies updated successfully (workstation)")
+        return
+
+    # Mac/AWS platforms: use UV
+    mac_manifest = Path("pyproject.mac.toml")
+    aws_manifest = Path("pyproject.aws.toml")
+    mac_uv_dir = Path(".mac_uv_project")
+    aws_uv_dir = Path(".aws_uv_project")
     lock_file_path = Path("uv.lock")
-    pyproject_path = Path("pyproject.toml")
 
     # Determine action based on flags
     lock_cmd = ["uv", "lock"]
@@ -453,12 +1166,41 @@ def update_dependencies(
         )
 
     try:
+        # Choose working directory for uv operations based on platform
+        uv_cwd = None
+        manifest_path_for_constraint = None
+
+        if platform == "mac" and mac_manifest.exists():
+            mac_uv_dir.mkdir(parents=True, exist_ok=True)
+            (mac_uv_dir / "pyproject.toml").write_text(mac_manifest.read_text())
+            # Copy README.md if it exists (required by some build backends)
+            if Path("README.md").exists():
+                (mac_uv_dir / "README.md").write_text(Path("README.md").read_text())
+            uv_cwd = str(mac_uv_dir)
+            lock_file_path = mac_uv_dir / "uv.lock"
+            manifest_path_for_constraint = mac_manifest
+        elif aws_manifest.exists():
+            # AWS platform (default)
+            aws_uv_dir.mkdir(parents=True, exist_ok=True)
+            (aws_uv_dir / "pyproject.toml").write_text(aws_manifest.read_text())
+            # Copy README.md if it exists (required by some build backends)
+            if Path("README.md").exists():
+                (aws_uv_dir / "README.md").write_text(Path("README.md").read_text())
+            uv_cwd = str(aws_uv_dir)
+            lock_file_path = aws_uv_dir / "uv.lock"
+            manifest_path_for_constraint = aws_manifest
+        else:
+            print(
+                "Error: No platform-specific manifest found (pyproject.aws.toml or pyproject.mac.toml)"
+            )
+            sys.exit(1)
+
         # Step 1: Run the update lock command
         print(action_description)
         print(f"Running command: {BLUE}{' '.join(lock_cmd)}{RESET}")
-        subprocess.run(lock_cmd, check=True, capture_output=True)
+        subprocess.run(lock_cmd, check=True, capture_output=True, cwd=uv_cwd)
 
-        # Step 2: Update pyproject.toml only if doing the dayhoff update (default)
+        # Step 2: Update both manifest files if doing the dayhoff update (default)
         if run_pyproject_update:
             print(f"Reading {lock_file_path} to find new dayhoff-tools version...")
             if not lock_file_path.exists():
@@ -485,48 +1227,23 @@ def update_dependencies(
                 return
 
             print(f"Found dayhoff-tools version {locked_version} in lock file.")
-            print(f"Updating {pyproject_path} version constraint...")
-            try:
-                content = pyproject_path.read_text()
-                pattern = re.compile(
-                    "^(\s*['\"])dayhoff-tools(?:[><=~^][^'\"\[,]*)?(['\"].*)$",  # Match rest of line
-                    re.MULTILINE,
-                )
-                package_name = "dayhoff-tools"
-                new_constraint_text = f">={locked_version}"
-                replacement_string = f"\g<1>{package_name}{new_constraint_text}\g<2>"
-                new_content, num_replacements = pattern.subn(
-                    replacement_string, content
-                )
-                if num_replacements > 0:
-                    pyproject_path.write_text(new_content)
-                    print(
-                        f"Updated dayhoff-tools constraint in {pyproject_path} to '{new_constraint_text}'"
-                    )
-                else:
-                    print(
-                        f"Warning: Could not find dayhoff-tools dependency line in {pyproject_path} to update constraint."
-                    )
-            except FileNotFoundError:
-                print(f"Error: {pyproject_path} not found.")
-                return
-            except Exception as e:
-                print(f"Error updating {pyproject_path}: {e}")
-                print("Proceeding with sync despite pyproject.toml update error.")
+
+            # Update all platform manifest files to ensure consistency
+            _update_all_manifests_for_dayhoff_tools(locked_version)
 
         # Step 3: Sync environment
         print("Syncing environment with updated lock file...")
         # Always use --no-install-project for updates
-        sync_cmd = ["uv", "sync", "--all-groups", "--no-install-project"]
+        sync_cmd = ["uv", "sync", "--all-groups", "--no-install-project", "--active"]
         print(f"Running command: {BLUE}{' '.join(sync_cmd)}{RESET}")
-        subprocess.run(sync_cmd, check=True)
+        subprocess.run(sync_cmd, check=True, cwd=uv_cwd)
 
         # Final status message
         if update_all:
             print("All dependencies updated and environment synced successfully.")
         else:  # Default case (dayhoff update)
             print(
-                "dayhoff-tools updated, pyproject.toml modified, and environment synced successfully."
+                "dayhoff-tools updated, manifest files modified, and environment synced successfully."
             )
 
     except subprocess.CalledProcessError as e: