fastws-cli 0.0.7__tar.gz → 0.0.8__tar.gz

fastws_cli-0.0.8/CHANGELOG.md

@@ -0,0 +1,47 @@
+<!-- do not remove -->
+
+## 0.0.8
+
+### New Features
+
+- Add ws-releases: report unreleased commits across the workspace, with configurable skip patterns and repo exclusions ([#17](https://github.com/AnswerDotAI/fastws/pull/17)), thanks to [@jph00](https://github.com/jph00)
+- Add once-daily dependency floating to ws_sync (uv sync -U + cargo update), with --upgrade flag to force ([#15](https://github.com/AnswerDotAI/fastws/issues/15))
+- ws-sync skips uv sync for member dirs lacking pyproject.toml; ws-add resolves local folder names via origin remote ([#12](https://github.com/AnswerDotAI/fastws/issues/12))
+- Allow bare folder name in ws-remove; separate directory deletion confirmation from metadata removal ([#9](https://github.com/AnswerDotAI/fastws/issues/9))
+- Add `ws-remove` command to delete a repo from the workspace; refactor CLI wrappers with `@delegates` ([#8](https://github.com/AnswerDotAI/fastws/issues/8))
+- Add [dev] extra to workspace dependencies and filter spurious warnings ([#7](https://github.com/AnswerDotAI/fastws/pull/7)), thanks to [@RensDimmendaal](https://github.com/RensDimmendaal)
+- add --workers flag to ws-sync ([#6](https://github.com/AnswerDotAI/fastws/pull/6)), thanks to [@RensDimmendaal](https://github.com/RensDimmendaal)
+
+### Bugs Squashed
+
+- Preserving existing tool.uv.sources entries during ws-sync ([#14](https://github.com/AnswerDotAI/fastws/pull/14)), thanks to [@kafkasl](https://github.com/kafkasl)
+
+
+## 0.0.7
+
+### New Features
+
+- Refactor Pyright editable path setup to write pyrightconfig.json instead of .pth files ([#4](https://github.com/AnswerDotAI/fastws/issues/4))
+
+
+## 0.0.6
+
+### New Features
+
+- Add root-aware clone/pull helpers, auto-pull in ws-sync, and docstrings to CLI entry points ([#2](https://github.com/AnswerDotAI/fastws/issues/2))
+
+
+## 0.0.5
+
+### New Features
+
+- Add ws-sync and ws-add commands with workspace metadata sync and Pyright editable path support ([#1](https://github.com/AnswerDotAI/fastws/issues/1))
+
+
+## 0.0.3
+
+- change names
+
+## 0.0.2
+
+- init release

fastws_cli-0.0.8/PKG-INFO

@@ -0,0 +1,154 @@
+Metadata-Version: 2.4
+Name: fastws-cli
+Version: 0.0.8
+Summary: Fast workspace tools for multi-repo management
+Author: Jeremy Howard
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/AnswerDotAI/fastws
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastcore>=1.14.3
+Requires-Dist: fastgit>=0.0.7
+Requires-Dist: ghapi>=1.0.7
+Requires-Dist: packaging
+Requires-Dist: tomli; python_version < "3.11"
+Provides-Extra: dev
+Requires-Dist: fastship; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: license-file
+
+# fastws
+
+Fast workspace tools for multi-repo management.
+
+## Install
+
+```bash
+pip install fastws-cli
+```
+
+## Setup
+
+Create a `repos.txt` file listing your repos (one per line):
+
+```
+AnswerDotAI/fastcore
+AnswerDotAI/fastgit
+AnswerDotAI/fastship
+AnswerDotAI/fastws
+```
+
+## Commands
+
+### `ws-clone`
+
+Clone all repos from your repos file:
+
+```bash
+ws-clone
+ws-clone --repos-file myrepos.txt
+ws-clone --workers 8
+```
+
+### `ws-pull`
+
+Pull updates for all repos (parallel):
+
+```bash
+ws-pull
+```
+
+### `ws-status`
+
+Show uncommitted changes and unpushed commits:
+
+```bash
+ws-status
+ws-status --branches
+```
+
+### `ws-branches`
+
+Check if all repos are on the expected branch:
+
+```bash
+ws-branches
+ws-branches --expected develop
+```
+
+### `ws-sync`
+
+Sync the workspace metadata, pull local repos, and install updates.
+By default it uses the active venv parent as the workspace root, so you do not need to `cd` first.
+It respects `tool.uv.workspace.members` and `exclude` when scanning local projects, and if any
+member directory isn't a Python project yet (no `pyproject.toml`, e.g. a fresh empty clone), it
+warns and skips the `uv sync` step instead of letting uv fail on the whole workspace.
+
+At most once per day (tracked by a stamp file inside the workspace's `.git`, so git never
+sees it), the sync also floats dependencies: `uv sync -U` instead of plain `uv sync`, plus
+a parallel `cargo update` in every member with a `Cargo.toml`, printing what moved. Pass
+`--upgrade` to force that pass regardless of when it last ran.
+
+```bash
+ws-sync
+ws-sync --workspace ~/aai-ws
+ws-sync --upgrade
+```
+
+### `ws-add`
+
+Add a repo to `repos.txt`, then run `ws-sync`. Given `owner/repo`, it clones; given the
+name of an existing local folder (e.g. one just scaffolded with `nbdev-new` or `ship-new`),
+it resolves `owner/repo` from the folder's `origin` remote instead, telling you exactly
+what's missing if the folder has no git repo, no GitHub origin, or no `pyproject.toml`:
+
+```bash
+ws-add AnswerDotAI/fastws
+ws-add answerdotai/fastws
+ws-add fastws  # existing local folder, resolved via its origin remote
+```
+
+### `ws-remove`
+
+Remove a repo: delete its clone, and drop it from `repos.txt` and the workspace
+`pyproject.toml`, then run `uv sync`. It refuses if the directory has uncommitted
+changes, unpushed commits, no `origin` remote, or isn't a clean git checkout, and
+always prompts for confirmation before deleting anything:
+
+```bash
+ws-remove AnswerDotAI/fastws
+ws-remove fastws  # bare folder name also works if the directory exists
+```
+
+### `ws-releases`
+
+Report repos with commits since their newest GitHub release, so nothing reviewed sits unshipped:
+
+```bash
+ws-releases                 # sweep every repo in repos.txt
+ws-releases solveit         # only solveit's transitive workspace dependencies
+ws-releases --skip 'wip'    # extra start-of-message regex for commits that need no release
+```
+
+Each pending repo lists its unreleased commit summaries; repos with no releases yet get one quiet `no releases:` line, and fully-released repos appear in `up to date:`. The newest release is picked by version number (publish timestamps can be out of order), and repos whose default branch isn't `main` are handled automatically.
+
+Commits whose message matches a start-anchored regex from the skip set need no release and aren't reported. The built-in set covers version bumps and housekeeping (`bump`, `nbdev regen`, `.gitignore`, `docs`, `CI`, ...: `DEFAULT_SKIP` in `fastws.releases`); `[tool.fastws]` in the workspace root `pyproject.toml` adds to it, and names repos that should never be swept (apps that deploy rather than release):
+
+```toml
+[tool.fastws]
+release_skip = ["docs only"]
+release_exclude = ["solveit", "md_site"]
+```
+
+From Python (the primary interface - the CLI is a thin wrapper over `fastws.releases`):
+
+```python
+from fastws import check_releases, check_release
+await check_releases()            # ReleaseReport: the repr is the report
+await check_releases('solveit')   # dependency-closure mode
+await check_release('mdhtml')     # one repo: list of unreleased commit summaries (None = no releases)
+```

fastws_cli-0.0.8/README.md

@@ -0,0 +1,131 @@
+# fastws
+
+Fast workspace tools for multi-repo management.
+
+## Install
+
+```bash
+pip install fastws-cli
+```
+
+## Setup
+
+Create a `repos.txt` file listing your repos (one per line):
+
+```
+AnswerDotAI/fastcore
+AnswerDotAI/fastgit
+AnswerDotAI/fastship
+AnswerDotAI/fastws
+```
+
+## Commands
+
+### `ws-clone`
+
+Clone all repos from your repos file:
+
+```bash
+ws-clone
+ws-clone --repos-file myrepos.txt
+ws-clone --workers 8
+```
+
+### `ws-pull`
+
+Pull updates for all repos (parallel):
+
+```bash
+ws-pull
+```
+
+### `ws-status`
+
+Show uncommitted changes and unpushed commits:
+
+```bash
+ws-status
+ws-status --branches
+```
+
+### `ws-branches`
+
+Check if all repos are on the expected branch:
+
+```bash
+ws-branches
+ws-branches --expected develop
+```
+
+### `ws-sync`
+
+Sync the workspace metadata, pull local repos, and install updates.
+By default it uses the active venv parent as the workspace root, so you do not need to `cd` first.
+It respects `tool.uv.workspace.members` and `exclude` when scanning local projects, and if any
+member directory isn't a Python project yet (no `pyproject.toml`, e.g. a fresh empty clone), it
+warns and skips the `uv sync` step instead of letting uv fail on the whole workspace.
+
+At most once per day (tracked by a stamp file inside the workspace's `.git`, so git never
+sees it), the sync also floats dependencies: `uv sync -U` instead of plain `uv sync`, plus
+a parallel `cargo update` in every member with a `Cargo.toml`, printing what moved. Pass
+`--upgrade` to force that pass regardless of when it last ran.
+
+```bash
+ws-sync
+ws-sync --workspace ~/aai-ws
+ws-sync --upgrade
+```
+
+### `ws-add`
+
+Add a repo to `repos.txt`, then run `ws-sync`. Given `owner/repo`, it clones; given the
+name of an existing local folder (e.g. one just scaffolded with `nbdev-new` or `ship-new`),
+it resolves `owner/repo` from the folder's `origin` remote instead, telling you exactly
+what's missing if the folder has no git repo, no GitHub origin, or no `pyproject.toml`:
+
+```bash
+ws-add AnswerDotAI/fastws
+ws-add answerdotai/fastws
+ws-add fastws  # existing local folder, resolved via its origin remote
+```
+
+### `ws-remove`
+
+Remove a repo: delete its clone, and drop it from `repos.txt` and the workspace
+`pyproject.toml`, then run `uv sync`. It refuses if the directory has uncommitted
+changes, unpushed commits, no `origin` remote, or isn't a clean git checkout, and
+always prompts for confirmation before deleting anything:
+
+```bash
+ws-remove AnswerDotAI/fastws
+ws-remove fastws  # bare folder name also works if the directory exists
+```
+
+### `ws-releases`
+
+Report repos with commits since their newest GitHub release, so nothing reviewed sits unshipped:
+
+```bash
+ws-releases                 # sweep every repo in repos.txt
+ws-releases solveit         # only solveit's transitive workspace dependencies
+ws-releases --skip 'wip'    # extra start-of-message regex for commits that need no release
+```
+
+Each pending repo lists its unreleased commit summaries; repos with no releases yet get one quiet `no releases:` line, and fully-released repos appear in `up to date:`. The newest release is picked by version number (publish timestamps can be out of order), and repos whose default branch isn't `main` are handled automatically.
+
+Commits whose message matches a start-anchored regex from the skip set need no release and aren't reported. The built-in set covers version bumps and housekeeping (`bump`, `nbdev regen`, `.gitignore`, `docs`, `CI`, ...: `DEFAULT_SKIP` in `fastws.releases`); `[tool.fastws]` in the workspace root `pyproject.toml` adds to it, and names repos that should never be swept (apps that deploy rather than release):
+
+```toml
+[tool.fastws]
+release_skip = ["docs only"]
+release_exclude = ["solveit", "md_site"]
+```
+
+From Python (the primary interface - the CLI is a thin wrapper over `fastws.releases`):
+
+```python
+from fastws import check_releases, check_release
+await check_releases()            # ReleaseReport: the repr is the report
+await check_releases('solveit')   # dependency-closure mode
+await check_release('mdhtml')     # one repo: list of unreleased commit summaries (None = no releases)
+```

fastws_cli-0.0.8/fastws/__init__.py

@@ -0,0 +1,7 @@
+__version__ = "0.0.8"
+
+
+
+from .core import *
+from .releases import *
+

{fastws_cli-0.0.7 → fastws_cli-0.0.8}/fastws/core.py

@@ -1,9 +1,8 @@
 "Fast workspace tools for multi-repo management."
 
-__all__ = ["ws_clone", "ws_clone_cli", "ws_pull", "ws_pull_cli", "ws_status", "ws_status_cli", "ws_branches", "ws_branches_cli",
-    "ws_sync", "ws_sync_cli", "ws_add", "ws_add_cli"]
+__all__ = ["ws_clone", "ws_pull", "ws_status", "ws_branches", "ws_sync", "ws_add", "ws_remove"]
 
-import ast, fnmatch, json, os, re, shutil, subprocess
+import ast, fnmatch, json, os, re, shutil, subprocess, time
 from pathlib import Path
 from concurrent.futures import ThreadPoolExecutor, as_completed
 
@@ -96,6 +95,31 @@ def _update_repos_file(repos_path: Path, repos: list[str]) -> list[str]:
     repos_path.write_text(content + "\n".join(missing) + "\n")
     return missing
 
+def _remove_from_repos_file(repos_path: Path, repo: str) -> bool:
+    if not repos_path.exists(): return False
+    key = _repo_key(repo)
+    lines = repos_path.read_text().splitlines()
+    kept = [l for l in lines if l.startswith("#") or not l.strip() or _repo_key(l) != key]
+    if len(kept) == len(lines): return False
+    repos_path.write_text("\n".join(kept) + ("\n" if kept else ""))
+    return True
+
+def _remove_from_pyproject(pyproject_path: Path, names: list[str]) -> list[str]:
+    if not pyproject_path.exists(): return []
+    content = pyproject_path.read_text()
+    data = tomllib.loads(content)
+    sources = dict(data.get("tool", {}).get("uv", {}).get("sources", {}))
+    deps = list(data.get("project", {}).get("dependencies", []))
+    targets = {_pkg_key(n) for n in names}
+    removed = sorted({_pkg_key(s) for s in sources if _pkg_key(s) in targets} | {_dep_key(d) for d in deps if _dep_key(d) in targets})
+    if not removed: return []
+    sources = {k:v for k,v in sources.items() if _pkg_key(k) not in targets}
+    deps = [d for d in deps if _dep_key(d) not in targets]
+    content = _replace_table(content, "tool.uv.sources", "\n".join(f"{k} = {{ workspace = true }}" for k in sources))
+    content = _replace_project_dependencies(content, deps)
+    pyproject_path.write_text(content)
+    return removed
+
 def _read_pyproject_name(path: Path) -> str|None:
     try: data = tomllib.loads(path.read_text())
     except tomllib.TOMLDecodeError:
@@ -207,7 +231,7 @@ def _write_pyright_config(root: Path):
 
 def _clone_one(repo: str, root: str = ".") -> str:
     d = Path(root)/_repo_dir(repo)
-    if d.exists(): return f"✓ {d.name}: already exists"
+    if d.exists(): return
     try:
         subprocess.run(["git", "clone", f"git@github.com:{repo}.git", str(d)], check=True, capture_output=True)
         return f"✓ {d.name}: cloned"
@@ -225,6 +249,7 @@ def _pull(repos: list[str], workers: int = 16, root: str = "."):
     with ThreadPoolExecutor(max_workers=workers) as ex:
         for result in as_completed([ex.submit(_pull_one, r, root) for r in repos]): print(result.result())
 
+@call_parse
 def ws_clone(
     repos_file: str = "repos.txt",  # File containing repo list (one per line: owner/repo)
     workers: int = 16,  # Number of parallel workers
@@ -232,16 +257,10 @@ def ws_clone(
     "Clone all repos from a repos file."
     repos = _load_repos(repos_file)
     with ThreadPoolExecutor(max_workers=workers) as ex:
-        for result in as_completed([ex.submit(_clone_one, r) for r in repos]): print(result.result())
+        for result in as_completed([ex.submit(_clone_one, r) for r in repos]):
+            if result.result(): print(result.result())
 
 @call_parse
-def ws_clone_cli(
-    repos_file: str = "repos.txt",  # File containing repo list (one per line: owner/repo)
-    workers: int = 16,  # Number of parallel workers
-):
-    "Clone all repos from a repos file."
-    ws_clone(repos_file, workers)
-
 def ws_pull(
     repos_file: str = "repos.txt",  # File containing repo list
     workers: int = 16,  # Number of parallel workers
@@ -250,13 +269,6 @@ def ws_pull(
     _pull(_load_repos(repos_file), workers)
 
 @call_parse
-def ws_pull_cli(
-    repos_file: str = "repos.txt",  # File containing repo list
-    workers: int = 16,  # Number of parallel workers
-):
-    "Pull updates for all repos."
-    ws_pull(repos_file, workers)
-
 def ws_status(
     repos_file: str = "repos.txt",  # File containing repo list
     branches: bool = False,  # Show unpushed commit details
@@ -269,27 +281,17 @@ def ws_status(
         g = Git(d)
         if not g.exists: continue
         changes = g.status('-s') or ""
-        if isinstance(changes, list): changes = "\n".join(changes)
         unpushed = ""
         try:
             if branches: unpushed = g.log('--branches', '--not', '--remotes', format='%h %s') or ""
-            elif (branch := g.branch(show_current=True).strip()) in ('main', 'master'):
-                unpushed = g.log('@{upstream}..HEAD', '-1', format='%h %s') or ""
+            elif (branch := g.branch(show_current=True).strip()) in ('main', 'master'): unpushed = g.log('@{upstream}..HEAD', '-1', format='%h %s') or ""
         except Exception: pass
-        if isinstance(unpushed, list): unpushed = "\n".join(unpushed)
         if changes or unpushed:
             print(f"\n=== {d} ===")
             if changes: print(changes)
             if unpushed: print(unpushed if branches else "unpushed commits")
 
 @call_parse
-def ws_status_cli(
-    repos_file: str = "repos.txt",  # File containing repo list
-    branches: bool = False,  # Show unpushed commit details
-):
-    "Show uncommitted changes and optionally unpushed commit details across repos."
-    ws_status(repos_file, branches)
-
 def ws_branches(
     repos_file: str = "repos.txt",  # File containing repo list
     expected: str = "main",  # Expected branch name
@@ -308,21 +310,41 @@ def ws_branches(
         branch = g.branch(show_current=True).strip()
         print(f"✓ {d}: OK (on {expected})" if branch == expected else f"⚠️  {d}: WARNING (on {branch})")
 
-@call_parse
-def ws_branches_cli(
-    repos_file: str = "repos.txt",  # File containing repo list
-    expected: str = "main",  # Expected branch name
-):
-    "Check if all repos are on the expected branch."
-    ws_branches(repos_file, expected)
+def _upgrade_stamp(root: Path) -> Path:
+    "Stamp whose mtime records the last dependency upgrade; kept inside .git (never tracked) when the root is a git repo."
+    gitdir = root/".git"
+    return gitdir/"fastws-upgraded" if gitdir.is_dir() else root/".fastws-upgraded"
+
+def _should_upgrade(root: Path, max_age: float = 86400) -> bool:
+    "True when this workspace hasn't upgraded dependencies within `max_age` seconds."
+    stamp = _upgrade_stamp(root)
+    return not stamp.exists() or time.time() - stamp.stat().st_mtime > max_age
+
+def _cargo_update(root: Path, workers: int = 16):
+    "Float each member crate's Cargo.lock to latest matching versions, in parallel; prints what moved."
+    crates = [d for d in _ws_dirs(root) if (d/"Cargo.toml").exists()]
+    if not crates: return
 
+    def upd(d):
+        res = subprocess.run(["cargo", "update"], cwd=d, capture_output=True, text=True)
+        return d.name, res.returncode, (res.stdout or "") + (res.stderr or "")
+
+    with ThreadPoolExecutor(max_workers=workers) as ex:
+        for name, code, out in ex.map(upd, crates):
+            if code: print(f"⚠️  {name}: cargo update failed\n{out}")
+            elif lines := [l for l in out.splitlines() if l.lstrip().startswith(("Updating ", "Adding ", "Removing "))]:
+                print(f"{name}:\n" + "\n".join(lines))
+
+@call_parse
 def ws_sync(
     workspace: str = "",  # Workspace root; defaults to active venv parent when available
     repos_file: str = "repos.txt",  # Repo list to update from local git remotes
     pyproject_file: str = "pyproject.toml",  # Workspace pyproject to update
     template_file: str = "pyproject.tmpl",  # Template copied when pyproject.toml is missing
+    workers: int = 16,  # Number of parallel workers
+    upgrade: bool = False,  # Force the once-daily dependency upgrade pass
 ):
-    "Sync workspace metadata, run uv sync -U, and update Pyright config."
+    "Sync workspace metadata and run uv sync; at most once per day (or with `upgrade`), float dependencies with uv sync -U plus cargo update in member crates."
     root = _ws_root(workspace, repos_file, pyproject_file, template_file)
     repos_path = _resolve_path(root, repos_file)
     pyproject_path = _resolve_path(root, pyproject_file)
@@ -330,47 +352,107 @@ def ws_sync(
     repos = _discover_ws_repos(root)
 
     if missing_repos := _update_repos_file(repos_path, repos): print(f"Added repos: {', '.join(missing_repos)}")
-    _pull(repos, root=str(root))
+    _pull(repos, workers=workers, root=str(root))
 
     if missing_projects := _sync_ws_pyproject(pyproject_path, template_path, _ws_projects(root)): print(f"Added workspace projects: {', '.join(missing_projects)}")
 
-    _write_pyright_config(root)
-    subprocess.run(["uv", "sync", "-U"], check=True, cwd=root)
+    if bad := [d.name for d in _ws_dirs(root) if not (d/"pyproject.toml").exists()]:
+        print(f"⚠️  Skipping uv sync, not Python projects yet (scaffold with e.g. nbdev-new or ship-new, or remove): {', '.join(bad)}")
+        return
+    up = upgrade or _should_upgrade(root)
+    subprocess.run(["uv", "sync", "-U"] if up else ["uv", "sync"], check=True, cwd=root)
+    if up:
+        _cargo_update(root, workers=workers)
+        _upgrade_stamp(root).touch()
 
 @call_parse
-def ws_sync_cli(
-    workspace: str = "",  # Workspace root; defaults to active venv parent when available
-    repos_file: str = "repos.txt",  # Repo list to update from local git remotes
-    pyproject_file: str = "pyproject.toml",  # Workspace pyproject to update
-    template_file: str = "pyproject.tmpl",  # Template copied when pyproject.toml is missing
-):
-    "Sync workspace metadata, run uv sync -U, and update Pyright config."
-    ws_sync(workspace, repos_file, pyproject_file, template_file)
-
 def ws_add(
-    repo: str,  # Repo to add, e.g. AnswerDotAI/fastws
+    repo: str,  # Repo to add (owner/repo to clone), or an existing local folder name
     workspace: str = "",  # Workspace root; defaults to active venv parent when available
     repos_file: str = "repos.txt",  # Repo list to update
     pyproject_file: str = "pyproject.toml",  # Workspace pyproject to update
     template_file: str = "pyproject.tmpl",  # Template copied when pyproject.toml is missing
 ):
-    "Add a repo to repos.txt and then run ws-sync."
+    "Add a repo to repos.txt (a local folder resolves via its origin remote) and then run ws-sync."
     root = _ws_root(workspace, repos_file, pyproject_file, template_file)
     repos_path = _resolve_path(root, repos_file)
-    repo = _normalize_repo(repo)
+    repo, local = _resolve_add_target(root, repo)
     added = _update_repos_file(repos_path, [repo])
     if added: print(f"Added repo: {repo}")
     else: print(f"Repo already present: {repo}")
-    print(_clone_one(repo, str(root)))
+    if not local: print(_clone_one(repo, str(root)))
     ws_sync(str(root), repos_file, pyproject_file, template_file)
 
+def _is_repo_spec(repo: str) -> bool:
+    repo = repo.strip().rstrip("/").removesuffix(".git")
+    return bool(_parse_github_repo(repo) or re.fullmatch(r"[^/\s]+/[^/\s]+", repo))
+
+def _resolve_add_target(root: Path, repo: str) -> tuple[str, bool]:
+    "Canonical owner/repo for `repo` and whether it named a local folder, which must be a git repo with a GitHub origin and a pyproject.toml"
+    if _is_repo_spec(repo): return _normalize_repo(repo), False
+    d = root/repo
+    if not d.is_dir(): return _normalize_repo(repo), False  # invalid spec and no such folder: raise the standard error
+    if not (d/".git").exists(): raise SystemExit(f"{d.name} is not a git repository: `git init` it and create a remote, e.g. `gh repo create <owner>/{d.name} --source={d} --push`")
+    res = subprocess.run(["git", "-C", str(d), "remote", "get-url", "origin"], capture_output=True, text=True)
+    if res.returncode != 0 or not (parsed := _parse_github_repo(res.stdout)):
+        raise SystemExit(f"{d.name} has no GitHub 'origin' remote: create one, e.g. `gh repo create <owner>/{d.name} --source={d} --push`")
+    if not (d/"pyproject.toml").exists():
+        raise SystemExit(f"{d.name} has no pyproject.toml: scaffold it first (e.g. `nbdev-new` or `ship-new`), then re-run ws-add")
+    return parsed, True
+
+def _resolve_removal_target(root: Path, repo: str, repos_path: Path) -> str:
+    "Canonical owner/repo for `repo`, matching an existing folder name when `repo` isn't a valid spec."
+    if _is_repo_spec(repo): return _normalize_repo(repo)
+    if not (root/repo).is_dir(): return _normalize_repo(repo)  # invalid spec and no such folder: raise
+    for r in (_load_repos(repos_path) if repos_path.exists() else []):
+        if _repo_dir(r).casefold() == repo.casefold(): return r
+    if (root/repo/".git").exists():
+        res = subprocess.run(["git", "-C", str(root/repo), "remote", "get-url", "origin"], capture_output=True, text=True)
+        if res.returncode == 0 and (parsed := _parse_github_repo(res.stdout)): return parsed
+    return repo
+
+def _resolve_repo_dir(root: Path, repo: str) -> Path:
+    root = root.resolve()
+    d = root/_repo_dir(repo)
+    if d.is_symlink(): raise SystemExit(f"Refusing to remove {d}: it is a symlink")
+    if (rd := d.resolve()) == root or rd.parent != root: raise SystemExit(f"Refusing to remove {d}: not directly inside {root}")
+    return d
+
+def _git_out(d: Path, *args: str) -> str:
+    return subprocess.run(["git", "-C", str(d), *args], check=True, capture_output=True, text=True).stdout
+
+def _repo_safety_issues(d: Path) -> list[str]:
+    if not (d/".git").exists(): return [f"{d.name} is not a git repository"]
+    issues = []
+    if subprocess.run(["git", "-C", str(d), "remote", "get-url", "origin"], capture_output=True, text=True).returncode != 0:
+        issues.append(f"{d.name} has no 'origin' remote")
+    if _git_out(d, "status", "--porcelain").strip(): issues.append(f"{d.name} has uncommitted changes")
+    if _git_out(d, "log", "--branches", "--not", "--remotes", "--format=%h").strip(): issues.append(f"{d.name} has unpushed commits")
+    return issues
+
 @call_parse
-def ws_add_cli(
-    repo: str,  # Repo to add, e.g. AnswerDotAI/fastws
+def ws_remove(
+    repo: str,  # Repo to remove, e.g. AnswerDotAI/fastws
     workspace: str = "",  # Workspace root; defaults to active venv parent when available
     repos_file: str = "repos.txt",  # Repo list to update
     pyproject_file: str = "pyproject.toml",  # Workspace pyproject to update
     template_file: str = "pyproject.tmpl",  # Template copied when pyproject.toml is missing
 ):
-    "Add a repo to repos.txt and then run ws-sync."
-    ws_add(repo, workspace, repos_file, pyproject_file, template_file)
+    "Remove a repo: delete its clone and drop it from repos.txt and the workspace pyproject."
+    root = _ws_root(workspace, repos_file, pyproject_file, template_file)
+    repos_path = _resolve_path(root, repos_file)
+    pyproject_path = _resolve_path(root, pyproject_file)
+    repo = _resolve_removal_target(root, repo, repos_path)
+    d = _resolve_repo_dir(root, repo)
+    name = _read_pyproject_name(d/"pyproject.toml") if (d/"pyproject.toml").exists() else None
+    names = [name] if name else [d.name]
+    in_repos = _repo_key(repo) in {_repo_key(r) for r in (_load_repos(repos_path) if repos_path.exists() else [])}
+    if not d.exists() and not in_repos: raise SystemExit(f"Nothing to remove for {repo}")
+    if d.exists() and (issues := _repo_safety_issues(d)): raise SystemExit("Refusing to remove:\n" + "\n".join(f"  - {i}" for i in issues))
+    _remove_from_repos_file(repos_path, repo)
+    _remove_from_pyproject(pyproject_path, names)
+    if d.exists():
+        try: ans = input(f"Remove directory {d}? [y/N] ")
+        except EOFError: ans = ""
+        if ans.strip().lower() in ("y", "yes"): shutil.rmtree(d)
+    subprocess.run(["uv", "sync"], check=True, cwd=root)