odoo-workspaces 1.1.0__py3-none-any.whl

odoo_workspaces-1.1.0.dist-info/METADATA

@@ -0,0 +1,267 @@
+Metadata-Version: 2.4
+Name: odoo-workspaces
+Version: 1.1.0
+Summary: Odoo workspace manager
+Author-email: Bruno BOI <boi@odoo.com>
+License: MIT
+Project-URL: Homepage, https://github.com/brboi/ow
+Project-URL: Repository, https://github.com/brboi/ow
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Version Control :: Git
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: argcomplete
+Requires-Dist: jinja2
+Requires-Dist: questionary
+Requires-Dist: tomli-w
+Dynamic: license-file
+
+# ow — Odoo Workspaces
+
+CLI tool that turns interactive prompts into ready-to-code Odoo workspaces using git worktrees.
+
+## Overview
+
+- **Git Optimized Commands** — Clone Odoo repos in minutes using shared bare repos
+- **Workspace generation** — each workspace is a folder with git worktrees and IDE configs, ready to open in VSCode or Zed
+- **Interactive setup** — `ow create` guides you through name, templates, repos, and variables
+- **Branch spec syntax** — concise `base..feature` notation to control detached vs attached worktrees
+- **Shared bare repos** — all workspaces share the same `.bare-git-repos/`, so fetching once updates refs for all
+- **Jinja2 template system** — generates `mise.toml`, `odoorc`, `odools.toml`, `pyrightconfig.json`, and IDE configs from customizable templates
+- **Per-workspace variables** — global `[vars]` with per-workspace overrides for ports, DB credentials, etc.
+- **Smart rebase** — two-step rebase (upstream then base), with conflict reporting and instructions
+- **Rich status** — behind/ahead counts with color-coded output
+- **Optional services** — Docker Compose stack with PostgreSQL, pgweb, and mailpit for local development
+- **Tab completion** — fish, bash, zsh via `argcomplete`
+- **Full transparency** — git commands that change your trees are printed to your terminal before execution
+
+## Prerequisites
+
+- **[mise](https://mise.jdx.dev/)** — manages Python, virtualenvs, and dependencies in generated workspaces
+- **Odoo system dependencies** — see [Odoo source install docs](https://www.odoo.com/documentation/master/administration/on_premise/source.html#dependencies) (includes wkhtmltopdf, PostgreSQL client libs, etc.)
+- **SSH** — configured for access to Odoo repositories
+- **Docker or Podman** (optional) — to run services like postgres, pgweb, mailpit (see `services/`)
+
+## Installation
+
+```sh
+pipx install odoo-workspaces   # recommended
+pip install odoo-workspaces    # or in an active venv
+```
+
+## Quick Start
+
+```sh
+ow init                              # initialize project (ow.toml, templates/, services/)
+# optionally edit ow.toml to add enterprise or dev remotes
+ow create                            # interactive form: name, templates, repos, vars
+cd workspaces/my_work && mise install
+code workspaces/my_work              # open in your IDE and enjoy
+```
+
+## Commands
+
+| Command | Flags | Description |
+|---------|-------|-------------|
+| `ow init` | `--force`, `--force-with-backup` | Initialize a new ow project |
+| `ow create` | `-n/--name`, `-t/--template`, `-r/--repo`, `-c/--configuration` | Create a workspace interactively |
+| `ow update` | `[workspace]` | Re-render templates and materialize worktrees |
+| `ow status` | `[workspace]` | Show branch status with behind/ahead counts |
+| `ow rebase` | `[workspace]` | Fetch and rebase all repos in a workspace |
+| `ow prune` | — | Clean up stale worktree references from bare repos |
+
+`ow` walks up from the current directory to find `ow.toml` (the project root). Commands that need a workspace resolve it from the `OW_WORKSPACE` environment variable (set automatically by `mise`), or by walking up for `.ow/config`.
+
+### `ow init`
+
+Initializes a new ow project in the current directory:
+
+- `ow.toml` — minimal config with the Odoo community remote
+- `workspaces/` — empty directory for future workspaces
+- `templates/` — copy of the bundled templates (customize freely)
+- `mise.toml` — Python + Node tooling for ow itself
+- `services/` — Docker Compose stack (postgres, pgweb, mailpit)
+
+Use `--force` to overwrite existing files, or `--force-with-backup` to back them up first (`.bak` suffix).
+
+### `ow create`
+
+Interactive form: workspace name → template selection → repo aliases + branch specs → variable defaults. After confirmation:
+
+1. Clones bare repos if needed
+2. Fetches required refs
+3. Creates worktrees
+4. Applies templates in order
+5. Writes `workspaces/<name>/.ow/config`
+6. Trusts `mise.toml` and prints a reminder to run `mise install`
+
+### `ow update`
+
+Re-renders templates and materializes worktrees for the current workspace. Also creates any missing worktrees and merges new vars from `ow.toml`. Useful after template changes or to regenerate workspace files.
+
+### `ow status`
+
+Fetches latest refs and displays branch status with color-coded behind/ahead counts:
+
+```
+[canary]
+    branches
+        community:  dev/master-canary ↓0 ↑0 (origin/master ↓34 ↑0)
+        enterprise: dev/master-canary ↓1 ↑1 (origin/master ↓12 ↑0)
+```
+
+### `ow rebase`
+
+Fetches and rebases all repos in a workspace. Before executing, displays a summary of the rebase situation for each repo and asks for confirmation. Handles detached worktrees, force-pushed upstreams (with or without a recoverable fork-point), and normal two-step rebases.
+
+### `ow prune`
+
+Cleans up stale worktree references from all bare repos. Run after manually removing a workspace directory:
+
+```sh
+rm -rf workspaces/my-workspace
+ow prune
+```
+
+## Configuration (`ow.toml`)
+
+### Remotes
+
+```toml
+[remotes]
+community.origin.url = "git@github.com:odoo/odoo.git"
+community.dev.url = "git@github.com:odoo-dev/odoo.git"
+community.dev.pushurl = "git@github.com:odoo-dev/odoo.git"
+community.dev.fetch = "+refs/heads/*:refs/remotes/dev/*"
+
+enterprise.origin.url = "git@github.com:odoo/enterprise.git"
+enterprise.dev.url = "git@github.com:odoo-dev/enterprise.git"
+```
+
+Each remote supports `url`, `pushurl` (optional), and `fetch` (optional refspec).
+
+### Variables
+
+```toml
+[vars]
+http_port = 8069
+db_host = "localhost"
+db_port = 5432
+db_user = "odoo"
+db_password = "odoo"
+```
+
+Templates use `{{ vars.key | default(fallback) }}` so undefined variables get safe defaults.
+
+### Branch Spec Syntax
+
+| Spec | Worktree mode |
+|------|---------------|
+| `master` | Detached HEAD at `origin/master` |
+| `origin/master` | Detached HEAD at `origin/master` |
+| `dev/master-phoenix` | Detached HEAD at `dev/master-phoenix` |
+| `master..master-feature` | Attached local branch `master-feature` tracking `origin/master` |
+| `dev/master-phoenix..fix` | Attached local branch `fix` tracking `dev/master-phoenix` |
+
+Without `..`, the worktree is detached (read-only tracking). With `..`, a local branch is created — this is what you want for feature development.
+
+## Template System
+
+Templates live in `templates/` at the project root. Each subdirectory is a bundle that can be applied to workspaces during `ow create`. Bundles are applied in order — later ones override files from earlier ones.
+
+| Bundle | Contents |
+|--------|----------|
+| `common/` | `mise.toml`, `odoorc`, `odools.toml`, `pyrightconfig.json`, `requirements-dev.txt` |
+| `vscode/.vscode/` | `settings.json`, `launch.json` |
+| `zed/.zed/` | `settings.json`, `debug.json` |
+| `bwrap/` | Sandbox scripts for AI coding assistants |
+
+Templates are Jinja2 (`.j2` extension); static files are copied as-is. `ow init` seeds `templates/` with the bundled defaults so you can customize them.
+
+To create a custom bundle:
+
+```sh
+mkdir -p templates/my-setup
+cp templates/common/odoorc.j2 templates/my-setup/
+# edit templates/my-setup/odoorc.j2
+```
+
+Then select it during `ow create` or add it to an existing workspace's `.ow/config`.
+
+## Services
+
+Optional containerized services for local development:
+
+```sh
+docker compose -f services/compose.yml up -d
+```
+
+| Service | Port | Description |
+|---------|------|-------------|
+| postgres | 5432 | PostgreSQL 17 with pgvector |
+| pgweb | 8081 | Web-based PostgreSQL browser |
+| mailpit | 8025 / 1025 | Email testing (web UI / SMTP) |
+
+Configure your workspaces to use them via `[vars]` in `ow.toml`:
+
+```toml
+[vars]
+db_host = "localhost"
+db_port = 5432
+smtp_server = "localhost"
+smtp_port = 1025
+```
+
+## Tab Completion
+
+Fish (one-time setup):
+```sh
+register-python-argcomplete --shell fish ow > ~/.config/fish/completions/ow.fish
+```
+
+Bash/Zsh:
+```sh
+activate-global-python-argcomplete
+```
+
+## Sandboxing AI Coding Assistants
+
+`ow` includes sandbox scripts for running AI coding assistants (Opencode, Claude Code) with filesystem isolation using [bubblewrap](https://github.com/containers/bubblewrap).
+
+Install bubblewrap:
+
+```sh
+sudo apt install bubblewrap   # Debian/Ubuntu
+sudo dnf install bubblewrap   # Fedora
+sudo pacman -S bubblewrap     # Arch
+```
+
+Add `bwrap` to your workspace templates during `ow create`. The scripts are automatically added to PATH via `mise`:
+
+```sh
+bwrap-opencode        # Launch Opencode sandboxed
+bwrap-claude          # Launch Claude Code sandboxed
+bwrap-opencode --add-dir ~/src/my-addon   # grant access to an extra directory
+```
+
+To work on `ow` itself, use the scripts at the project root:
+
+```sh
+./bwrap-opencode    # Launch Opencode sandboxed in ow directory
+./bwrap-claude      # Launch Claude Code sandboxed in ow directory
+```
+
+## Disclaimer
+
+This is a small personal project built with the help of [Claude](https://claude.ai). It scratches a very specific itch — managing multiple Odoo worktrees side by side — and comes with no warranty. Use at your own risk, and expect rough edges.
+
+## Want to contribute?
+
+Contributions are welcome! If something is broken, confusing, or missing — open an issue. If you have a fix or improvement in mind, PRs are appreciated.

odoo_workspaces-1.1.0.dist-info/RECORD

@@ -0,0 +1,33 @@
+odoo_workspaces-1.1.0.dist-info/licenses/LICENSE,sha256=dff2I-iCi_JfoTJMiVKI-ZoCmM1MGyRjYoIX7yyGfWU,1066
+ow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ow/__main__.py,sha256=nX3smmzh6e_U7whZr_JQ-SLDar2FC2gwaGqvRbdtsSM,6424
+ow/_version.py,sha256=UX5-1P4_Li7oZPBPGeO0iysPZY4KtG9cYeh9ikqsnO4,520
+ow/config.py,sha256=TJq-nwyBjBfl1qvqhNqq-xEojRwyXcwCaCai0g9u2jY,3628
+ow/git.py,sha256=qNAGsms8-lkTV7PbwnbMY3wT0KfBAklFxzj4f5ztKoY,17645
+ow/workspace.py,sha256=MIOEQ8U86k90a_8j71mlUdFuYRxu3WN_G13Oe4tBxqg,57488
+ow/services/compose.yml,sha256=kRJO29fSaZicIeaT8v4BKn0NSTJlbZ8_AxofEwHGi4o,699
+ow/services/volumes/.gitkeep,sha256=0p5uq5enOuX4NLuFg8Q2bhmdV5OusKALZw9GQMs_e4I,255
+ow/templates/bwrap/bwrap-claude.j2,sha256=D-atf4VKoyU8whgF9VR8czPDI1wdlBdLub2QfvXj0kU,5858
+ow/templates/bwrap/bwrap-opencode.j2,sha256=xibjHuKWRHCnZmfgllLFUXKxbfmChqfWxNbLxVhRpIA,4828
+ow/templates/common/mise.toml.j2,sha256=AS70CEUMFKhFmpQq6gG16OiHk1DoySusuJ06FNiHD30,554
+ow/templates/common/odools.toml.j2,sha256=8MDq27P7-HJSkZtMbB2QR80F8OOk87rfF9KD5ylpeig,210
+ow/templates/common/odoorc.j2,sha256=XoxsEgWNWw8R8343Ld_P1zxQK7yU9kFPUusUQsCYH68,512
+ow/templates/common/pyrightconfig.json.j2,sha256=7UCyqIdJcYTwxSppNigcc4JNgd-XVcCB4HM-FZjrX9c,330
+ow/templates/common/requirements-dev.txt,sha256=-azvCdZIbby4JA5EpvHLG644USUwZNih1nrj4aguklY,8
+ow/templates/vscode/.vscode/launch.json.j2,sha256=iHSiNsVqsKgFFKmZVEhVkqfbNooFqrptOTTgE7x79_g,1238
+ow/templates/vscode/.vscode/settings.json.j2,sha256=HicLCSRdGTEOEvgb1lp7pyc4bF0zt2dyxzuSKSazPtc,64
+ow/templates/zed/.zed/debug.json.j2,sha256=jxK82q0yLGgLaCEvuer-beXaHX2WJuiHeC4Lrcc0D88,1356
+ow/templates/zed/.zed/settings.json.j2,sha256=QHeX_dngaQXvGDopRq25vrwqp9QCl5i5ylP8Fy7lHfs,467
+ow/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ow/tests/conftest.py,sha256=N9R5qdh2hgHhBKh9BZaTKVEtfUOM2DB77nYENZLlqZg,3102
+ow/tests/test_cli.py,sha256=BwNPYh0C3Vxfqf984C92_QuUsqDMmxQVPvGIv6OewvY,13273
+ow/tests/test_commands.py,sha256=z0t0GQboIa50BSqQebbZncGQRsTWJ1yAZma7lqH3-Eg,25259
+ow/tests/test_config.py,sha256=9RZ9yF6knVoWWQAiCCPco3VHgmxFA2pUuiAetuAwGpo,8585
+ow/tests/test_git.py,sha256=_MZRSjod84OZiHuVcqALfbEouRQ4q4VHaA0DkqywrXM,53117
+ow/tests/test_resolve_workspace.py,sha256=e86CEGabDHb_z2SZTBG9u_Ep3PBUix62lWDg86xSgsw,4972
+ow/tests/test_workspace.py,sha256=QljlZJCOl703Z52jKHlswcsFL3PBZDbtgx57vEbTNao,41855
+odoo_workspaces-1.1.0.dist-info/METADATA,sha256=TsiL1BDK-HJzf6xYEMhtHJxn6TELngvrGSJhP7P2BQ0,10109
+odoo_workspaces-1.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+odoo_workspaces-1.1.0.dist-info/entry_points.txt,sha256=B-50333hmy1ubgaRVFLYx9TgweccCBemBGwV6sKulVs,40
+odoo_workspaces-1.1.0.dist-info/top_level.txt,sha256=J_l1r4EMChUJYIniVsADjPxnH3tNme05AuTLZCxb8ZM,3
+odoo_workspaces-1.1.0.dist-info/RECORD,,

odoo_workspaces-1.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

odoo_workspaces-1.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ow = ow.__main__:main

odoo_workspaces-1.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bruno BOI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

odoo_workspaces-1.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+ow

ow/__main__.py

@@ -0,0 +1,199 @@
+#!/usr/bin/env python3
+# PYTHON_ARGCOMPLETE_OK
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+import argcomplete
+
+from ow.config import Config, load_config, parse_branch_spec
+from ow.workspace import (
+    _available_templates,
+    cmd_create,
+    cmd_init,
+    cmd_prune,
+    cmd_rebase,
+    cmd_status,
+    cmd_update,
+)
+
+try:
+    from ow._version import version as __version__
+except ImportError:
+    __version__ = "dev"
+
+
+def find_root() -> Path:
+    current = Path.cwd()
+    while True:
+        if (current / "ow.toml").exists() or (current / "ow.toml.example").exists():
+            return current
+        if current.parent == current:
+            raise FileNotFoundError(
+                "ow.toml not found in current directory or any parent"
+            )
+        current = current.parent
+
+
+def _available_repo_aliases():
+    """Return repo aliases from ow.toml in declaration order."""
+    try:
+        root = find_root()
+        toml_path = root / "ow.toml"
+        if toml_path.exists():
+            cfg = load_config(toml_path)
+            return list(cfg.remotes.keys())
+    except FileNotFoundError:
+        pass
+    return []
+
+
+def _complete_gen_templates(prefix, parsed_args, **kwargs):
+    """Tab completion for -t/--template."""
+    try:
+        root = find_root()
+        config = Config(vars={}, remotes={}, root_dir=root)
+        templates = _available_templates(config)
+    except (FileNotFoundError, Exception):
+        templates = []
+    return [t for t in templates if t.startswith(prefix)]
+
+
+def _complete_gen_repos(prefix, parsed_args, **kwargs):
+    """Tab completion for -r/--repo — offers unused aliases."""
+    provided_aliases = set()
+    if parsed_args.repo:
+        for pair in parsed_args.repo:
+            provided_aliases.add(pair[0])
+    available = [a for a in _available_repo_aliases() if a not in provided_aliases]
+    if available:
+        return [a for a in available if a.startswith(prefix)]
+    return []
+
+
+def _complete_workspace_name(prefix, parsed_args, **kwargs):
+    """Tab completion for workspace name."""
+    try:
+        root = find_root()
+        workspaces_dir = root / "workspaces"
+        if workspaces_dir.exists():
+            names = [d.name for d in workspaces_dir.iterdir() if d.is_dir() and (d / ".ow" / "config").exists()]
+            return [n for n in names if n.startswith(prefix)]
+    except FileNotFoundError:
+        pass
+    return []
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(prog="ow", description="Odoo workspace manager")
+    parser.add_argument(
+        "-v", "--version", action="version", version=f"%(prog)s {__version__}"
+    )
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    p_create = subparsers.add_parser(
+        "create", help="Create a new workspace"
+    )
+    p_create.add_argument(
+        "-n", "--name", help="Workspace name"
+    )
+    p_create.add_argument(
+        "-c", "--configuration", help="Path to existing workspace config to duplicate"
+    )
+    p_create.add_argument(
+        "-t", "--template", nargs="*", metavar="TEMPLATE",
+        help="Templates to apply (space-separated)",
+    ).completer = _complete_gen_templates  # type: ignore[attr-defined]
+    p_create.add_argument(
+        "-r", "--repo", nargs=2, action="append", metavar=("ALIAS", "SPEC"),
+        help="Repo alias and branch spec (repeatable, e.g. -r community master..x)",
+    ).completer = _complete_gen_repos  # type: ignore[attr-defined]
+
+    p_update = subparsers.add_parser(
+        "update", help="Re-render templates and materialize worktrees"
+    )
+    p_update.add_argument(
+        "workspace", nargs="?", help="Workspace name (default: resolve from cwd)"
+    ).completer = _complete_workspace_name  # type: ignore[attr-defined]
+
+    p_status = subparsers.add_parser("status", help="Show workspace status")
+    p_status.add_argument(
+        "workspace", nargs="?", help="Workspace name (default: resolve from cwd)"
+    ).completer = _complete_workspace_name  # type: ignore[attr-defined]
+
+    p_rebase = subparsers.add_parser(
+        "rebase", help="Fetch and rebase workspace branches"
+    )
+    p_rebase.add_argument(
+        "workspace", nargs="?", help="Workspace name (default: resolve from cwd)"
+    ).completer = _complete_workspace_name  # type: ignore[attr-defined]
+
+    p_prune = subparsers.add_parser(
+        "prune", help="Clean up stale worktree references and orphaned branches"
+    )
+
+    p_init = subparsers.add_parser(
+        "init", help="Initialize a new ow project"
+    )
+    p_init.add_argument(
+        "--force", action="store_true",
+        help="Overwrite existing files without backup"
+    )
+    p_init.add_argument(
+        "--force-with-backup", action="store_true",
+        help="Backup existing files before overwrite"
+    )
+
+    # Tab completion for create subcommand
+    argcomplete.autocomplete(parser)
+    args = parser.parse_args()
+
+    # Handle 'init' command separately (doesn't require existing ow.toml)
+    if args.command == "init":
+        cmd_init(
+            path=None,
+            force=args.force,
+            with_backup=args.force_with_backup
+        )
+        return
+
+    # All other commands require an existing ow.toml
+    try:
+        root = find_root()
+    except FileNotFoundError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    toml_path = root / "ow.toml"
+    if not toml_path.exists():
+        minimal_config = """\
+[remotes]
+community.origin.url = "git@github.com:odoo/odoo.git"
+"""
+        toml_path.write_text(minimal_config)
+        print("Created ow.toml with default configuration. Edit it to suit your needs.")
+
+    config = load_config(toml_path)
+
+    if args.command == "create":
+        # Parse repo pairs from --repo args
+        repo_pairs = {}
+        if args.repo:
+            for alias, spec in args.repo:
+                repo_pairs[alias] = parse_branch_spec(spec)
+
+        cmd_create(config, name=args.name, templates=args.template, repos=repo_pairs, configuration=args.configuration)
+    elif args.command == "update":
+        cmd_update(config, workspace=args.workspace)
+    elif args.command == "status":
+        cmd_status(config, workspace=args.workspace)
+    elif args.command == "rebase":
+        cmd_rebase(config, workspace=args.workspace)
+    elif args.command == "prune":
+        cmd_prune(config)
+
+
+if __name__ == "__main__":
+    main()

ow/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '1.1.0'
+__version_tuple__ = version_tuple = (1, 1, 0)
+
+__commit_id__ = commit_id = None

ow/config.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+import re
+import tomllib
+import tomli_w
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+@dataclass
+class BranchSpec:
+    base_ref: str  # e.g. "origin/master", "dev/master-phoenix"
+    local_branch: str | None = None  # None = detached
+
+    @property
+    def is_detached(self) -> bool:
+        return self.local_branch is None
+
+    @property
+    def remote(self) -> str:
+        return self.base_ref.split("/")[0]
+
+    @property
+    def branch(self) -> str:
+        return "/".join(self.base_ref.split("/")[1:])
+
+    def to_spec_str(self) -> str:
+        base = self.branch if self.remote == "origin" else self.base_ref
+        if self.local_branch is None:
+            return base
+        return f"{base}..{self.local_branch}"
+
+
+def parse_branch_spec(spec: str) -> BranchSpec:
+    """
+    "master"                  → BranchSpec("origin/master")
+    "master..master-feature"  → BranchSpec("origin/master", "master-feature")
+    "dev/master-phoenix..fix" → BranchSpec("dev/master-phoenix", "fix")
+    "origin/master"           → BranchSpec("origin/master")
+    """
+    if ".." in spec:
+        base, local = spec.split("..", 1)
+        if "/" not in base:
+            base = f"origin/{base}"
+        return BranchSpec(base, local)
+    if "/" in spec:
+        return BranchSpec(spec)
+    return BranchSpec(f"origin/{spec}")
+
+
+@dataclass
+class RemoteConfig:
+    url: str
+    pushurl: str | None = None
+    fetch: str | None = None
+
+
+@dataclass
+class WorkspaceConfig:
+    repos: dict[str, BranchSpec]
+    templates: list[str]
+    vars: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class Config:
+    vars: dict[str, Any]
+    remotes: dict[str, dict[str, RemoteConfig]]  # alias -> remote_name -> cfg
+    root_dir: Path
+
+
+def load_workspace_config(path: Path) -> WorkspaceConfig:
+    """Read a .ow/config TOML file from an individual workspace."""
+    with open(path, "rb") as f:
+        data = tomllib.load(f)
+
+    repos = {}
+    for alias, spec_str in data.get("repos", {}).items():
+        repos[alias] = parse_branch_spec(spec_str)
+
+    templates = data.get("templates")
+    if templates is None:
+        raise ValueError(f"Workspace config '{path}' missing required 'templates' field")
+    if not isinstance(templates, list):
+        raise ValueError(f"Workspace config '{path}' 'templates' must be a list")
+
+    return WorkspaceConfig(
+        repos=repos,
+        templates=templates,
+        vars=data.get("vars", {}),
+    )
+
+
+def write_workspace_config(path: Path, ws: WorkspaceConfig) -> None:
+    """Write a .ow/config TOML file for an individual workspace."""
+    data: dict[str, Any] = {
+        "templates": ws.templates,
+        "repos": {alias: spec.to_spec_str() for alias, spec in ws.repos.items()},
+    }
+    if ws.vars:
+        data["vars"] = ws.vars
+
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with open(path, "wb") as f:
+        tomli_w.dump(data, f)
+
+
+def load_config(path: Path) -> Config:
+    with open(path, "rb") as f:
+        data = tomllib.load(f)
+
+    vars = data.get("vars", {})
+
+    remotes: dict[str, dict[str, RemoteConfig]] = {}
+    for alias, remote_dict in data.get("remotes", {}).items():
+        remotes[alias] = {}
+        for remote_name, remote_cfg in remote_dict.items():
+            remotes[alias][remote_name] = RemoteConfig(
+                url=remote_cfg["url"],
+                pushurl=remote_cfg.get("pushurl"),
+                fetch=remote_cfg.get("fetch"),
+            )
+
+    return Config(
+        vars=vars,
+        remotes=remotes,
+        root_dir=path.parent,
+    )