fastws-cli 0.0.2__tar.gz → 0.0.4__tar.gz

fastws_cli-0.0.4/CHANGELOG.md

@@ -0,0 +1,17 @@
+<!-- do not remove -->
+
+## 0.0.4
+
+### 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.2/fastws_cli.egg-info → fastws_cli-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastws-cli
-Version: 0.0.2
+Version: 0.0.4
 Summary: Fast workspace tools for multi-repo management
 Author: Jeremy Howard
 License: Apache-2.0
@@ -12,6 +12,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: fastcore>=1.5.29
 Requires-Dist: fastgit>=0.0.2
+Requires-Dist: tomli; python_version < "3.11"
 Provides-Extra: dev
 Requires-Dist: fastship; extra == "dev"
 Requires-Dist: build; extra == "dev"
@@ -41,37 +42,57 @@ AnswerDotAI/fastws
 
 ## Commands
 
-### `ws_clone`
+### `ws-clone`
 
 Clone all repos from your repos file:
 
 ```bash
-ws_clone
-ws_clone --repos-file myrepos.txt
-ws_clone --workers 8
+ws-clone
+ws-clone --repos-file myrepos.txt
+ws-clone --workers 8
 ```
 
-### `ws_pull`
+### `ws-pull`
 
 Pull updates for all repos (parallel):
 
 ```bash
-ws_pull
+ws-pull
 ```
 
-### `ws_status`
+### `ws-status`
 
 Show uncommitted changes and unpushed commits:
 
 ```bash
-ws_status
+ws-status
 ```
 
-### `ws_branches`
+### `ws-branches`
 
 Check if all repos are on the expected branch:
 
 ```bash
-ws_branches
-ws_branches --expected develop
+ws-branches
+ws-branches --expected develop
+```
+
+### `ws-sync`
+
+Sync the workspace metadata, install updates, and refresh Pyright editable paths.
+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.
+
+```bash
+ws-sync
+ws-sync --workspace ~/aai-ws
+```
+
+### `ws-add`
+
+Add a repo to `repos.txt`, then run `ws-sync`:
+
+```bash
+ws-add AnswerDotAI/fastws
+ws-add answerdotai/fastws
 ```

fastws_cli-0.0.4/README.md

@@ -0,0 +1,77 @@
+# 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-branches`
+
+Check if all repos are on the expected branch:
+
+```bash
+ws-branches
+ws-branches --expected develop
+```
+
+### `ws-sync`
+
+Sync the workspace metadata, install updates, and refresh Pyright editable paths.
+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.
+
+```bash
+ws-sync
+ws-sync --workspace ~/aai-ws
+```
+
+### `ws-add`
+
+Add a repo to `repos.txt`, then run `ws-sync`:
+
+```bash
+ws-add AnswerDotAI/fastws
+ws-add answerdotai/fastws
+```

fastws_cli-0.0.4/fastws/__init__.py

@@ -0,0 +1,5 @@
+__version__ = "0.0.4"
+
+
+from .core import *
+

fastws_cli-0.0.4/fastws/core.py

@@ -0,0 +1,355 @@
+"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"]
+
+import ast, fnmatch, os, re, shutil, subprocess
+from pathlib import Path
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+from fastcore.script import call_parse
+from fastgit import Git
+
+try: import tomllib
+except ModuleNotFoundError: import tomli as tomllib
+
+def _load_repos(repos_file: str = "repos.txt") -> list[str]:
+    p = Path(repos_file)
+    if not p.exists(): raise SystemExit(f"File not found: {repos_file}")
+    return [line.strip() for line in p.read_text().splitlines() if line.strip() and not line.startswith("#")]
+
+def _repo_dir(repo: str) -> str: return repo.split("/")[-1]
+
+def _resolve_path(root: Path, path: str) -> Path:
+    p = Path(path)
+    return p if p.is_absolute() else root/p
+
+def _repo_key(repo: str) -> str: return repo.strip().rstrip("/").removesuffix(".git").casefold()
+
+def _pkg_key(name: str) -> str: return name.casefold()
+
+def _dep_key(dep: str) -> str:
+    dep = dep.split(";", 1)[0].strip()
+    dep = re.split(r"[\s<>=!~]", dep, maxsplit=1)[0]
+    return dep.split("[", 1)[0].casefold()
+
+def _ws_root(workspace: str = "", repos_file: str = "repos.txt", pyproject_file: str = "pyproject.toml",
+    template_file: str = "pyproject.tmpl") -> Path:
+    if workspace: return Path(workspace).expanduser().resolve()
+    for env_name in "UV_PROJECT_ENVIRONMENT","VIRTUAL_ENV":
+        if not (env := os.environ.get(env_name)): continue
+        root = Path(env).expanduser().resolve().parent
+        if any((_resolve_path(root, repos_file).exists(), _resolve_path(root, pyproject_file).exists(), _resolve_path(root, template_file).exists())):
+            return root
+    return Path.cwd().resolve()
+
+def _parse_github_repo(remote: str) -> str|None:
+    m = re.search(r"github\.com[:/](?P<owner>[^/]+)/(?P<repo>[^/]+?)(?:\.git)?/?$", remote.strip())
+    return f"{m['owner']}/{m['repo']}" if m else None
+
+def _normalize_repo(repo: str) -> str:
+    repo = repo.strip().rstrip("/").removesuffix(".git")
+    if parsed := _parse_github_repo(repo): return parsed
+    if re.fullmatch(r"[^/\s]+/[^/\s]+", repo): return repo
+    raise SystemExit(f"Invalid repo: {repo}. Expected owner/repo or GitHub URL")
+
+def _ws_cfg(root: Path):
+    pyproject = root/"pyproject.toml"
+    if not pyproject.exists(): return ["./*"], []
+    try: data = tomllib.loads(pyproject.read_text())
+    except tomllib.TOMLDecodeError: return ["./*"], []
+    ws = data.get("tool", {}).get("uv", {}).get("workspace", {})
+    members = ws.get("members") or ["./*"]
+    exclude = ws.get("exclude") or []
+    return members, exclude
+
+def _matches_ws(name: str, pattern: str) -> bool:
+    pattern = pattern.strip()
+    return any(fnmatch.fnmatch(candidate, normalized) for candidate in (name, f"./{name}") for normalized in (pattern, pattern.removeprefix("./")))
+
+def _is_ws_dir(d: Path, members, exclude) -> bool:
+    return d.is_dir() and not d.name.startswith(".") and any(_matches_ws(d.name, o) for o in members) and not any(_matches_ws(d.name, o) for o in exclude)
+
+def _ws_dirs(root: Path) -> list[Path]:
+    members, exclude = _ws_cfg(root)
+    return [d for d in sorted(root.iterdir()) if _is_ws_dir(d, members, exclude)]
+
+def _discover_ws_repos(root: Path) -> list[str]:
+    repos = []
+    for d in (o for o in _ws_dirs(root) if (o/'.git').exists()):
+        try: res = subprocess.run(["git", "-C", str(d), "remote", "get-url", "origin"], check=True, capture_output=True, text=True)
+        except subprocess.CalledProcessError: continue
+        if repo := _parse_github_repo(res.stdout): repos.append(repo)
+    return repos
+
+def _update_repos_file(repos_path: Path, repos: list[str]) -> list[str]:
+    existing = _load_repos(repos_path) if repos_path.exists() else []
+    seen = {_repo_key(repo) for repo in existing}
+    missing = []
+    for repo in repos:
+        if (key := _repo_key(repo)) in seen: continue
+        seen.add(key)
+        missing.append(repo)
+    if not missing: return []
+    content = repos_path.read_text() if repos_path.exists() else ""
+    if content and not content.endswith("\n"): content += "\n"
+    repos_path.write_text(content + "\n".join(missing) + "\n")
+    return missing
+
+def _read_pyproject_name(path: Path) -> str|None:
+    try: data = tomllib.loads(path.read_text())
+    except tomllib.TOMLDecodeError:
+        print(f"Skipping invalid TOML: {path}")
+        return None
+    name = data.get("project", {}).get("name")
+    return name if isinstance(name, str) and name and "{" not in name and "}" not in name else None
+
+def _ws_projects(root: Path) -> list[str]:
+    return [name for d in (o for o in _ws_dirs(root) if (o/"pyproject.toml").exists())
+        if (name := _read_pyproject_name(d/"pyproject.toml"))]
+
+def _table_span(content: str, name: str) -> tuple[int,int]|None:
+    m = re.search(rf"(?m)^\[{re.escape(name)}\]\s*$", content)
+    if not m: return None
+    n = re.search(r"(?m)^\[", content[m.end():])
+    end = m.end()+n.start() if n else len(content)
+    return m.start(), end
+
+def _replace_table(content: str, name: str, body: str) -> str:
+    table = f"[{name}]\n{body.rstrip()}\n\n"
+    if not (span := _table_span(content, name)): return content.rstrip() + "\n\n" + table
+    start,end = span
+    return content[:start] + table + content[end:]
+
+def _find_array_end(content: str, start: int) -> int:
+    depth = 0
+    in_str = escaped = False
+    for i,ch in enumerate(content[start:], start):
+        if in_str:
+            if escaped: escaped = False
+            elif ch == "\\": escaped = True
+            elif ch == '"': in_str = False
+            continue
+        if ch == '"': in_str = True
+        elif ch == "[": depth += 1
+        elif ch == "]":
+            depth -= 1
+            if depth == 0: return i
+    raise ValueError("Unterminated TOML array")
+
+def _replace_project_dependencies(content: str, deps: list[str]) -> str:
+    if not (span := _table_span(content, "project")): raise SystemExit("Missing [project] table in pyproject.toml")
+    start,end = span
+    section = content[start:end]
+    dep_block = "dependencies = [\n" + "".join(f'    "{dep}",\n' for dep in deps) + "]"
+    if m := re.search(r"(?m)^dependencies\s*=\s*\[", section):
+        arr_start = m.end()-1
+        arr_end = _find_array_end(section, arr_start)
+        section = section[:m.start()] + dep_block + section[arr_end+1:]
+    else: section = section.rstrip() + "\n" + dep_block + "\n"
+    return content[:start] + section + content[end:]
+
+def _sync_ws_pyproject(pyproject_path: Path, template_path: Path, projects: list[str]) -> list[str]:
+    if not pyproject_path.exists():
+        if not template_path.exists(): raise SystemExit(f"File not found: {template_path}")
+        shutil.copyfile(template_path, pyproject_path)
+    content = pyproject_path.read_text()
+    data = tomllib.loads(content)
+    sources = dict(data.get("tool", {}).get("uv", {}).get("sources", {}))
+    source_keys = {_pkg_key(proj) for proj in sources}
+    missing = [proj for proj in projects if _pkg_key(proj) not in source_keys]
+    if not missing: return []
+    for proj in missing: sources[proj] = {"workspace": True}
+    deps = list(data.get("project", {}).get("dependencies", []))
+    dep_keys = {_dep_key(dep) for dep in deps}
+    for proj in missing:
+        if _pkg_key(proj) in dep_keys: continue
+        deps.append(proj)
+        dep_keys.add(_pkg_key(proj))
+    source_lines = "\n".join(f"{proj} = {{ workspace = true }}" for proj in sources)
+    content = _replace_table(content, "tool.uv.sources", source_lines)
+    content = _replace_project_dependencies(content, deps)
+    pyproject_path.write_text(content)
+    return missing
+
+def _editable_mapping(path: Path) -> dict[str,str]:
+    tree = ast.parse(path.read_text(), filename=str(path))
+    for node in tree.body:
+        if isinstance(node, ast.Assign) and any(isinstance(o, ast.Name) and o.id == "MAPPING" for o in node.targets):
+            data = ast.literal_eval(node.value)
+            if isinstance(data, dict): return {str(k): str(v) for k,v in data.items()}
+        if isinstance(node, ast.AnnAssign) and isinstance(node.target, ast.Name) and node.target.id == "MAPPING":
+            data = ast.literal_eval(node.value)
+            if isinstance(data, dict): return {str(k): str(v) for k,v in data.items()}
+    return {}
+
+def _site_packages(root: Path) -> Path|None:
+    envs = []
+    if uv_env := os.environ.get("UV_PROJECT_ENVIRONMENT"): envs.append(Path(uv_env))
+    envs.append(root/".venv")
+    if virtual_env := os.environ.get("VIRTUAL_ENV"): envs.append(Path(virtual_env))
+    for env in envs:
+        candidates = sorted(env.glob("lib/python*/site-packages")) + sorted(env.glob("Lib/site-packages"))
+        if candidates: return candidates[0]
+    return None
+
+def _write_pyright_pth_files(root: Path) -> list[Path]:
+    site = _site_packages(root)
+    if not site:
+        print("No site-packages directory found for editable Pyright paths")
+        return []
+    created = []
+    for finder in sorted(site.glob("__editable__*_finder.py")):
+        for pkg,path in _editable_mapping(finder).items():
+            pth = site/f"_pyright_editable_{pkg}.pth"
+            pth.write_text(str(Path(path).parent) + "\n")
+            created.append(pth)
+    return created
+
+def _clone_one(repo: str) -> str:
+    d = _repo_dir(repo)
+    if Path(d).exists(): return f"✓ {d}: already exists"
+    try:
+        subprocess.run(["git", "clone", f"git@github.com:{repo}.git"], check=True, capture_output=True)
+        return f"✓ {d}: cloned"
+    except subprocess.CalledProcessError as e: return f"✗ {d}: {e.stderr.decode().strip()}"
+
+def _pull_one(repo: str) -> str:
+    d = _repo_dir(repo)
+    if not Path(d).exists(): return f"✗ {d}: directory not found"
+    try:
+        res = subprocess.run(["git", "-C", d, "pull", "-q", "--stat"], check=True, capture_output=True, text=True)
+        return f"✓ {d}" + (f"\n{res.stdout.strip()}" if res.stdout.strip() else "")
+    except subprocess.CalledProcessError as e: return f"✗ {d}: {e.stderr.strip()}"
+
+def ws_clone(
+    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."
+    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())
+
+@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
+): ws_clone(repos_file, workers)
+
+def ws_pull(
+    repos_file: str = "repos.txt",  # File containing repo list
+    workers: int = 16,  # Number of parallel workers
+):
+    "Pull updates for all repos."
+    repos = _load_repos(repos_file)
+    with ThreadPoolExecutor(max_workers=workers) as ex:
+        for result in as_completed([ex.submit(_pull_one, r) for r in repos]): print(result.result())
+
+@call_parse
+def ws_pull_cli(
+    repos_file: str = "repos.txt",  # File containing repo list
+    workers: int = 16,  # Number of parallel workers
+): ws_pull(repos_file, workers)
+
+def ws_status(
+    repos_file: str = "repos.txt",  # File containing repo list
+):
+    "Show uncommitted changes and unpushed commits across repos."
+    repos = _load_repos(repos_file)
+    for repo in repos:
+        d = _repo_dir(repo)
+        if not Path(d).exists(): continue
+        g = Git(d)
+        if not g.exists: continue
+        changes = g.status('-s') or ""
+        if isinstance(changes, list): changes = "\n".join(changes)
+        unpushed = ""
+        try: unpushed = g.log('--branches', '--not', '--remotes', 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)
+
+@call_parse
+def ws_status_cli(
+    repos_file: str = "repos.txt",  # File containing repo list
+): ws_status(repos_file)
+
+def ws_branches(
+    repos_file: str = "repos.txt",  # File containing repo list
+    expected: str = "main",  # Expected branch name
+):
+    "Check if all repos are on the expected branch."
+    repos = _load_repos(repos_file)
+    for repo in repos:
+        d = _repo_dir(repo)
+        if not Path(d).exists():
+            print(f"⚠️  {d}: directory not found")
+            continue
+        g = Git(d)
+        if not g.exists:
+            print(f"⚠️  {d}: not a git repo")
+            continue
+        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
+): ws_branches(repos_file, expected)
+
+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
+):
+    "Sync workspace metadata, run uv sync -U, and refresh Pyright editable paths."
+    root = _ws_root(workspace, repos_file, pyproject_file, template_file)
+    repos_path = _resolve_path(root, repos_file)
+    pyproject_path = _resolve_path(root, pyproject_file)
+    template_path = _resolve_path(root, template_file)
+
+    if missing_repos := _update_repos_file(repos_path, _discover_ws_repos(root)): print(f"Added repos: {', '.join(missing_repos)}")
+
+    if missing_projects := _sync_ws_pyproject(pyproject_path, template_path, _ws_projects(root)): print(f"Added workspace projects: {', '.join(missing_projects)}")
+
+    subprocess.run(["uv", "sync", "-U"], check=True, cwd=root)
+    _write_pyright_pth_files(root)
+
+@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
+): ws_sync(workspace, repos_file, pyproject_file, template_file)
+
+def ws_add(
+    repo: str,  # Repo to add, 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."
+    root = _ws_root(workspace, repos_file, pyproject_file, template_file)
+    repos_path = _resolve_path(root, repos_file)
+    repo = _normalize_repo(repo)
+    added = _update_repos_file(repos_path, [repo])
+    if added: print(f"Added repo: {repo}")
+    else: print(f"Repo already present: {repo}")
+    ws_sync(str(root), repos_file, pyproject_file, template_file)
+
+@call_parse
+def ws_add_cli(
+    repo: str,  # Repo to add, 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
+): ws_add(repo, workspace, repos_file, pyproject_file, template_file)

{fastws_cli-0.0.2 → fastws_cli-0.0.4/fastws_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastws-cli
-Version: 0.0.2
+Version: 0.0.4
 Summary: Fast workspace tools for multi-repo management
 Author: Jeremy Howard
 License: Apache-2.0
@@ -12,6 +12,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: fastcore>=1.5.29
 Requires-Dist: fastgit>=0.0.2
+Requires-Dist: tomli; python_version < "3.11"
 Provides-Extra: dev
 Requires-Dist: fastship; extra == "dev"
 Requires-Dist: build; extra == "dev"
@@ -41,37 +42,57 @@ AnswerDotAI/fastws
 
 ## Commands
 
-### `ws_clone`
+### `ws-clone`
 
 Clone all repos from your repos file:
 
 ```bash
-ws_clone
-ws_clone --repos-file myrepos.txt
-ws_clone --workers 8
+ws-clone
+ws-clone --repos-file myrepos.txt
+ws-clone --workers 8
 ```
 
-### `ws_pull`
+### `ws-pull`
 
 Pull updates for all repos (parallel):
 
 ```bash
-ws_pull
+ws-pull
 ```
 
-### `ws_status`
+### `ws-status`
 
 Show uncommitted changes and unpushed commits:
 
 ```bash
-ws_status
+ws-status
 ```
 
-### `ws_branches`
+### `ws-branches`
 
 Check if all repos are on the expected branch:
 
 ```bash
-ws_branches
-ws_branches --expected develop
+ws-branches
+ws-branches --expected develop
+```
+
+### `ws-sync`
+
+Sync the workspace metadata, install updates, and refresh Pyright editable paths.
+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.
+
+```bash
+ws-sync
+ws-sync --workspace ~/aai-ws
+```
+
+### `ws-add`
+
+Add a repo to `repos.txt`, then run `ws-sync`:
+
+```bash
+ws-add AnswerDotAI/fastws
+ws-add answerdotai/fastws
 ```

{fastws_cli-0.0.2 → fastws_cli-0.0.4}/fastws_cli.egg-info/SOURCES.txt

@@ -10,4 +10,5 @@ fastws_cli.egg-info/SOURCES.txt
 fastws_cli.egg-info/dependency_links.txt
 fastws_cli.egg-info/entry_points.txt
 fastws_cli.egg-info/requires.txt
-fastws_cli.egg-info/top_level.txt
+fastws_cli.egg-info/top_level.txt
+tests/test_sync.py

fastws_cli-0.0.4/fastws_cli.egg-info/entry_points.txt

@@ -0,0 +1,7 @@
+[console_scripts]
+ws-add = fastws.core:ws_add_cli
+ws-branches = fastws.core:ws_branches_cli
+ws-clone = fastws.core:ws_clone_cli
+ws-pull = fastws.core:ws_pull_cli
+ws-status = fastws.core:ws_status_cli
+ws-sync = fastws.core:ws_sync_cli

{fastws_cli-0.0.2 → fastws_cli-0.0.4}/fastws_cli.egg-info/requires.txt

@@ -1,6 +1,9 @@
 fastcore>=1.5.29
 fastgit>=0.0.2
 
+[:python_version < "3.11"]
+tomli
+
 [dev]
 fastship
 build

{fastws_cli-0.0.2 → fastws_cli-0.0.4}/pyproject.toml

@@ -18,6 +18,7 @@ classifiers = [
 dependencies = [
   "fastcore>=1.5.29",
   "fastgit>=0.0.2",
+  "tomli; python_version < '3.11'",
 ]
 
 [project.optional-dependencies]
@@ -28,10 +29,12 @@ dev = [
 ]
 
 [project.scripts]
-ws_clone = "fastws.core:ws_clone_cli"
-ws_pull = "fastws.core:ws_pull_cli"
-ws_status = "fastws.core:ws_status_cli"
-ws_branches = "fastws.core:ws_branches_cli"
+ws-clone = "fastws.core:ws_clone_cli"
+ws-pull = "fastws.core:ws_pull_cli"
+ws-status = "fastws.core:ws_status_cli"
+ws-branches = "fastws.core:ws_branches_cli"
+ws-sync = "fastws.core:ws_sync_cli"
+ws-add = "fastws.core:ws_add_cli"
 
 [project.urls]
 Homepage = "https://github.com/AnswerDotAI/fastws"

fastws_cli-0.0.4/tests/test_sync.py

@@ -0,0 +1,168 @@
+from pathlib import Path
+
+import fastws.core as core
+
+
+def test_update_repos_file_appends_missing_entries(tmp_path):
+    repos_path = tmp_path/"repos.txt"
+    repos_path.write_text("AnswerDotAI/existing\n")
+
+    added = core._update_repos_file(repos_path, ["AnswerDotAI/existing", "fastai/fastai"])
+
+    assert added == ["fastai/fastai"]
+    assert repos_path.read_text() == "AnswerDotAI/existing\nfastai/fastai\n"
+
+
+def test_update_repos_file_is_case_insensitive(tmp_path):
+    repos_path = tmp_path/"repos.txt"
+    repos_path.write_text("AnswerDotAI/fastws\n")
+
+    added = core._update_repos_file(repos_path, ["answerdotai/fastws"])
+
+    assert added == []
+    assert repos_path.read_text() == "AnswerDotAI/fastws\n"
+
+
+def test_sync_workspace_pyproject_copies_template_and_adds_projects(tmp_path):
+    (tmp_path/"pyproject.tmpl").write_text('[project]\nname = "uvws"\ndependencies = [\n    "ipython>=8.34.0",\n]\n\n[tool.uv.sources]\n\n')
+    alpha = tmp_path/"alpha"
+    beta = tmp_path/"beta"
+    alpha.mkdir()
+    beta.mkdir()
+    (alpha/"pyproject.toml").write_text('[project]\nname = "alpha"\n')
+    (beta/"pyproject.toml").write_text('[project]\nname = "beta"\n')
+
+    added = core._sync_ws_pyproject(tmp_path/"pyproject.toml", tmp_path/"pyproject.tmpl", ["alpha", "beta"])
+    content = (tmp_path/"pyproject.toml").read_text()
+
+    assert added == ["alpha", "beta"]
+    assert 'alpha = { workspace = true }' in content
+    assert 'beta = { workspace = true }' in content
+    assert '"alpha"' in content
+    assert '"beta"' in content
+
+
+def test_sync_workspace_pyproject_skips_case_only_source_differences(tmp_path):
+    pyproject = tmp_path/"pyproject.toml"
+    pyproject.write_text('[project]\nname = "uvws"\ndependencies = ["FastWS"]\n\n[tool.uv.sources]\nFastWS = { workspace = true }\n')
+
+    added = core._sync_ws_pyproject(pyproject, tmp_path/"pyproject.tmpl", ["fastws"])
+
+    assert added == []
+    assert pyproject.read_text() == '[project]\nname = "uvws"\ndependencies = ["FastWS"]\n\n[tool.uv.sources]\nFastWS = { workspace = true }\n'
+
+
+def test_workspace_projects_skip_excluded_dirs_and_template_names(tmp_path):
+    (tmp_path/"pyproject.toml").write_text('[tool.uv.workspace]\nmembers = ["./*"]\nexclude = ["skip-*"]\n')
+    keep = tmp_path/"keep"
+    skip = tmp_path/"skip-template"
+    templ = tmp_path/"template"
+    keep.mkdir()
+    skip.mkdir()
+    templ.mkdir()
+    (keep/"pyproject.toml").write_text('[project]\nname = "keepme"\n')
+    (skip/"pyproject.toml").write_text('[project]\nname = "skipme"\n')
+    (templ/"pyproject.toml").write_text('[project]\nname = "{repo}"\n')
+
+    assert core._ws_projects(tmp_path) == ["keepme"]
+
+
+def test_write_pyright_pth_files_from_editable_finder(tmp_path):
+    site = tmp_path/".venv"/"lib"/"python3.12"/"site-packages"
+    site.mkdir(parents=True)
+    (site/"__editable___demo_finder.py").write_text("MAPPING: dict[str, str] = {'demo': '/tmp/workspace/src/demo/__init__.py', 'tool': '/tmp/workspace/tool.py'}\n")
+
+    created = core._write_pyright_pth_files(tmp_path)
+
+    assert [p.name for p in created] == ["_pyright_editable_demo.pth", "_pyright_editable_tool.pth"]
+    assert (site/"_pyright_editable_demo.pth").read_text() == "/tmp/workspace/src/demo\n"
+    assert (site/"_pyright_editable_tool.pth").read_text() == "/tmp/workspace\n"
+
+
+def test_ws_sync_updates_workspace_and_runs_uv(tmp_path, monkeypatch):
+    (tmp_path/"repos.txt").write_text("AnswerDotAI/existing\n")
+    (tmp_path/"pyproject.tmpl").write_text('[project]\nname = "uvws"\ndependencies = [\n]\n\n[tool.uv.sources]\n\n')
+    pkg = tmp_path/"newpkg"
+    repo = tmp_path/"repo1"
+    pkg.mkdir()
+    repo.mkdir()
+    (pkg/"pyproject.toml").write_text('[project]\nname = "newpkg"\n')
+    (repo/".git").write_text("gitdir: .git/worktrees/repo1\n")
+    site = tmp_path/".venv"/"lib"/"python3.12"/"site-packages"
+    site.mkdir(parents=True)
+    (site/"__editable___newpkg_finder.py").write_text("MAPPING: dict[str, str] = {'newpkg': '/tmp/ws/src/newpkg/__init__.py'}\n")
+    calls = []
+
+    def fake_run(cmd, **kwargs):
+        calls.append((cmd, kwargs))
+        if cmd[:5] == ["git", "-C", str(repo), "remote", "get-url"]:
+            class Res: stdout = "git@github.com:AnswerDotAI/repo1.git\n"
+            return Res()
+        if cmd == ["uv", "sync", "-U"]:
+            class Res: stdout = ""
+            return Res()
+        raise AssertionError(f"Unexpected command: {cmd}")
+
+    monkeypatch.setattr(core.subprocess, "run", fake_run)
+
+    core.ws_sync(workspace=str(tmp_path))
+
+    assert "AnswerDotAI/repo1" in (tmp_path/"repos.txt").read_text()
+    pyproject = (tmp_path/"pyproject.toml").read_text()
+    assert 'newpkg = { workspace = true }' in pyproject
+    assert '"newpkg"' in pyproject
+    assert (site/"_pyright_editable_newpkg.pth").read_text() == "/tmp/ws/src/newpkg\n"
+    assert any(cmd == ["uv", "sync", "-U"] and kwargs["cwd"] == tmp_path for cmd,kwargs in calls)
+
+
+def test_ws_sync_uses_active_venv_parent_by_default(tmp_path, monkeypatch):
+    workspace = tmp_path/"workspace"
+    elsewhere = tmp_path/"elsewhere"
+    workspace.mkdir()
+    elsewhere.mkdir()
+    (workspace/"repos.txt").write_text("AnswerDotAI/existing\n")
+    (workspace/"pyproject.tmpl").write_text('[project]\nname = "uvws"\ndependencies = [\n]\n\n[tool.uv.sources]\n\n')
+    pkg = workspace/"newpkg"
+    repo = workspace/"repo1"
+    pkg.mkdir()
+    repo.mkdir()
+    (pkg/"pyproject.toml").write_text('[project]\nname = "newpkg"\n')
+    (repo/".git").write_text("gitdir: .git/worktrees/repo1\n")
+    site = workspace/".venv"/"lib"/"python3.12"/"site-packages"
+    site.mkdir(parents=True)
+    (site/"__editable___newpkg_finder.py").write_text("MAPPING: dict[str, str] = {'newpkg': '/tmp/ws/src/newpkg/__init__.py'}\n")
+    calls = []
+
+    def fake_run(cmd, **kwargs):
+        calls.append((cmd, kwargs))
+        if cmd[:5] == ["git", "-C", str(repo), "remote", "get-url"]:
+            class Res: stdout = "git@github.com:AnswerDotAI/repo1.git\n"
+            return Res()
+        if cmd == ["uv", "sync", "-U"]:
+            class Res: stdout = ""
+            return Res()
+        raise AssertionError(f"Unexpected command: {cmd}")
+
+    monkeypatch.setattr(core.subprocess, "run", fake_run)
+    monkeypatch.setenv("VIRTUAL_ENV", str(workspace/".venv"))
+    monkeypatch.chdir(elsewhere)
+
+    core.ws_sync()
+
+    assert "AnswerDotAI/repo1" in (workspace/"repos.txt").read_text()
+    assert any(cmd == ["uv", "sync", "-U"] and kwargs["cwd"] == workspace for cmd,kwargs in calls)
+
+
+def test_ws_add_updates_repos_then_runs_sync(tmp_path, monkeypatch):
+    (tmp_path/"repos.txt").write_text("AnswerDotAI/existing\n")
+    calls = []
+
+    def fake_sync(workspace, repos_file, pyproject_file, template_file):
+        calls.append((workspace, repos_file, pyproject_file, template_file))
+
+    monkeypatch.setattr(core, "ws_sync", fake_sync)
+
+    core.ws_add("answerdotai/fastws", workspace=str(tmp_path))
+
+    assert (tmp_path/"repos.txt").read_text() == "AnswerDotAI/existing\nanswerdotai/fastws\n"
+    assert calls == [(str(tmp_path), "repos.txt", "pyproject.toml", "pyproject.tmpl")]

fastws_cli-0.0.2/CHANGELOG.md

@@ -1,6 +0,0 @@
-<!-- do not remove -->
-
-## 0.0.2
-
-- init release
-

fastws_cli-0.0.2/README.md

@@ -1,57 +0,0 @@
-# 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_branches`
-
-Check if all repos are on the expected branch:
-
-```bash
-ws_branches
-ws_branches --expected develop
-```

fastws_cli-0.0.2/fastws/__init__.py

@@ -1,3 +0,0 @@
-__version__ = "0.0.2"
-
-from .core import *

fastws_cli-0.0.2/fastws/core.py

@@ -1,115 +0,0 @@
-"Fast workspace tools for multi-repo management."
-
-from __future__ import annotations
-
-__all__ = ["ws_clone", "ws_clone_cli", "ws_pull", "ws_pull_cli", "ws_status", "ws_status_cli", "ws_branches", "ws_branches_cli"]
-
-import subprocess
-from pathlib import Path
-from concurrent.futures import ThreadPoolExecutor, as_completed
-
-from fastcore.script import call_parse
-from fastgit import Git
-
-def _load_repos(repos_file: str = "repos.txt") -> list[str]:
-    p = Path(repos_file)
-    if not p.exists(): raise SystemExit(f"File not found: {repos_file}")
-    return [line.strip() for line in p.read_text().splitlines() if line.strip() and not line.startswith("#")]
-
-def _repo_dir(repo: str) -> str: return repo.split("/")[-1]
-
-def _clone_one(repo: str) -> str:
-    d = _repo_dir(repo)
-    if Path(d).exists(): return f"✓ {d}: already exists"
-    try:
-        subprocess.run(["git", "clone", f"git@github.com:{repo}.git"], check=True, capture_output=True)
-        return f"✓ {d}: cloned"
-    except subprocess.CalledProcessError as e: return f"✗ {d}: {e.stderr.decode().strip()}"
-
-def _pull_one(repo: str) -> str:
-    d = _repo_dir(repo)
-    if not Path(d).exists(): return f"✗ {d}: directory not found"
-    try:
-        res = subprocess.run(["git", "-C", d, "pull", "-q", "--stat"], check=True, capture_output=True, text=True)
-        return f"✓ {d}" + (f"\n{res.stdout.strip()}" if res.stdout.strip() else "")
-    except subprocess.CalledProcessError as e: return f"✗ {d}: {e.stderr.strip()}"
-
-def ws_clone(
-    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."
-    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())
-
-@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
-): ws_clone(repos_file, workers)
-
-def ws_pull(
-    repos_file: str = "repos.txt",  # File containing repo list
-    workers: int = 16,  # Number of parallel workers
-):
-    "Pull updates for all repos."
-    repos = _load_repos(repos_file)
-    with ThreadPoolExecutor(max_workers=workers) as ex:
-        for result in as_completed([ex.submit(_pull_one, r) for r in repos]): print(result.result())
-
-@call_parse
-def ws_pull_cli(
-    repos_file: str = "repos.txt",  # File containing repo list
-    workers: int = 16,  # Number of parallel workers
-): ws_pull(repos_file, workers)
-
-def ws_status(
-    repos_file: str = "repos.txt",  # File containing repo list
-):
-    "Show uncommitted changes and unpushed commits across repos."
-    repos = _load_repos(repos_file)
-    for repo in repos:
-        d = _repo_dir(repo)
-        if not Path(d).exists(): continue
-        g = Git(d)
-        if not g.exists: continue
-        changes = g.status('-s') or ""
-        if isinstance(changes, list): changes = "\n".join(changes)
-        unpushed = ""
-        try: unpushed = g.log('--branches', '--not', '--remotes', 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)
-
-@call_parse
-def ws_status_cli(
-    repos_file: str = "repos.txt",  # File containing repo list
-): ws_status(repos_file)
-
-def ws_branches(
-    repos_file: str = "repos.txt",  # File containing repo list
-    expected: str = "main",  # Expected branch name
-):
-    "Check if all repos are on the expected branch."
-    repos = _load_repos(repos_file)
-    for repo in repos:
-        d = _repo_dir(repo)
-        if not Path(d).exists():
-            print(f"⚠️  {d}: directory not found")
-            continue
-        g = Git(d)
-        if not g.exists:
-            print(f"⚠️  {d}: not a git repo")
-            continue
-        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
-): ws_branches(repos_file, expected)

fastws_cli-0.0.2/fastws_cli.egg-info/entry_points.txt

@@ -1,5 +0,0 @@
-[console_scripts]
-ws_branches = fastws.core:ws_branches_cli
-ws_clone = fastws.core:ws_clone_cli
-ws_pull = fastws.core:ws_pull_cli
-ws_status = fastws.core:ws_status_cli