odoo-workspaces 1.1.0__tar.gz

odoo_workspaces-1.1.0/.bare-git-repos/.gitkeep

@@ -0,0 +1,4 @@
+This is where the Odoo workspaces bare repositories will live.
+This file is here to ensure that the directory exists,
+as git does not track empty directories and more than that:
+this directory is gitignore'd, so it won't be tracked even if it had content.

odoo_workspaces-1.1.0/.github/workflows/release.yml

@@ -0,0 +1,36 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
+      - name: Build package
+        run: |
+          pip install build
+          python -m build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          password: ${{ secrets.PYPI_API_TOKEN }}
+
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v1
+        with:
+          files: dist/*
+          generate_release_notes: true

odoo_workspaces-1.1.0/.gitignore

@@ -0,0 +1,24 @@
+.bare-git-repos/
+.claude/
+ow/services/volumes/
+ow/services/compose.local.yml
+workspaces/*
+.ow/
+mise.local.toml
+ow.toml
+.ow.toml.archived-workspaces
+templates/*
+ow/templates/*
+!ow/templates/common
+!ow/templates/common/**
+!ow/templates/vscode
+!ow/templates/vscode/**
+!ow/templates/zed
+!ow/templates/zed/**
+!ow/templates/bwrap
+!ow/templates/bwrap/**
+docs/superpowers/
+*.egg-info
+.pytest_cache
+__pycache__
+ow/_version.py

odoo_workspaces-1.1.0/.vscode/launch.json

@@ -0,0 +1,65 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "Debug OW: apply",
+      "type": "debugpy",
+      "request": "launch",
+      "module": "ow",
+      "args": ["apply"],
+      "console": "integratedTerminal",
+      "justMyCode": false,
+      "cwd": "${workspaceFolder}"
+    },
+    {
+      "name": "Debug OW: status",
+      "type": "debugpy",
+      "request": "launch",
+      "module": "ow",
+      "args": ["status"],
+      "console": "integratedTerminal",
+      "justMyCode": false,
+      "cwd": "${workspaceFolder}"
+    },
+    {
+      "name": "Debug OW: rebase",
+      "type": "debugpy",
+      "request": "launch",
+      "module": "ow",
+      "args": ["rebase"],
+      "console": "integratedTerminal",
+      "justMyCode": false,
+      "cwd": "${workspaceFolder}"
+    },
+    {
+      "name": "Debug OW: create",
+      "type": "debugpy",
+      "request": "launch",
+      "module": "ow",
+      "args": ["create", "test-ws", "community:master", "templates=common"],
+      "console": "integratedTerminal",
+      "justMyCode": false,
+      "cwd": "${workspaceFolder}"
+    },
+    {
+      "name": "Debug OW: remove",
+      "type": "debugpy",
+      "request": "launch",
+      "module": "ow",
+      "args": ["remove", "test-ws"],
+      "console": "integratedTerminal",
+      "justMyCode": false,
+      "cwd": "${workspaceFolder}"
+    },
+    {
+      "name": "Debug Tests",
+      "type": "debugpy",
+      "request": "launch",
+      "module": "pytest",
+      "args": ["-v", "ow/tests/"],
+      "console": "integratedTerminal",
+      "justMyCode": false,
+      "cwd": "${workspaceFolder}"
+    }
+  ]
+}

odoo_workspaces-1.1.0/.vscode/settings.json

@@ -0,0 +1,14 @@
+{
+  "python.testing.pytestEnabled": true,
+  "python.testing.unittestEnabled": false,
+  "python.testing.cwd": "${workspaceFolder}",
+  "python.testing.autoTestDiscoverOnSaveEnabled": true,
+  "files.exclude": {
+    "**/__pycache__": true,
+    "**/*.pyc": true,
+    "**/.pytest_cache": true,
+    "**/*.egg-info": true
+  },
+  "editor.formatOnSave": true,
+  "editor.rulers": [88]
+}

odoo_workspaces-1.1.0/AGENTS.md

@@ -0,0 +1,95 @@
+# ow — Module Structure
+
+```
+ow/
+├── __init__.py          # empty
+├── __main__.py          # CLI entry point (argparse + argcomplete)
+├── config.py            # Config dataclasses, TOML loading/writing
+├── git.py               # All git operations via subprocess
+├── workspace.py         # File generators + command implementations + drift detection
+├── tests/
+│   ├── __init__.py
+│   ├── test_config.py   # parse_branch_spec, load_config, load_workspace_config
+│   ├── test_git.py      # git functions (subprocess mocked)
+│   ├── test_workspace.py # file generators, template rendering, cache/drift, DriftResult
+│   └── test_commands.py # cmd_status, cmd_rebase integration tests
+├── bwrap-opencode       # Opencode sandbox wrapper (for developing on ow)
+├── bwrap-claude         # Claude Code sandbox wrapper (for developing on ow)
+├── scripts/
+│   └── migrate-to-1.0.0.py  # One-time migration script for v1.0.0
+└── templates/
+    ├── bwrap/           # Sandbox scripts template for workspaces
+    │   ├── bwrap-opencode.j2
+    │   └── bwrap-claude.j2
+```
+
+`ow/__main__.py` is the CLI entry point. `init` is handled before the config-loading block (it doesn't require an existing `ow.toml`) and returns early; all other commands go through `find_root()` + config loading.
+
+## Key abstractions
+
+- **`BranchSpec`** — represents `"master"` / `"master..feature"` / `"dev/master-phoenix..fix"`. Knows remote, branch, local_branch, detached vs attached.
+- **`Config`** — parsed from `ow.toml`. `Config.vars` holds global template variable defaults. Merged at render time: `{**config.vars, **ws.vars}`.
+- **`WorkspaceConfig`** — parsed from `.ow/config` inside each workspace. `WorkspaceConfig.vars` holds per-workspace overrides.
+- **`ow/git.py`** — stateless git helpers. All bare-repo operations run with `git -C <bare_repo>`, worktree operations with `git -C <worktree>`. `get_remote_ref_for_branch` scans ow.toml-configured remotes for a pushed local branch (non-base remotes checked first). `get_remote_url` falls back to `git remote get-url` for remotes not in ow.toml.
+  - `run_cmd(args, quiet=False)` wraps `subprocess.run`, printing `$ cmd` to stderr unless `quiet=True`. Action functions (clone, fetch, worktree add/remove, switch, rebase) use `run_cmd`; probes (rev-parse, symbolic-ref, rev-list) use `subprocess.run` directly.
+  - `git(repo, *args)` — central wrapper that adds `-C` automatically. Use this for all git commands.
+  - `git_fetch(repo, remote, refspec, *, force=False)` — fetch with optional force (+refspec).
+  - `git_switch(worktree, ref, *, detach=False, create=False)` — unified switch with detach/create options.
+  - `git_rebase(worktree, onto)` — rebase onto ref, returns CompletedProcess for caller to check.
+  - `git_merge_base_fork_point(worktree, upstream, branch)` — find fork-point between branch and upstream; returns None if upstream was rewritten.
+  - `git_rev_list(repo, commit_range, *, reverse=False)` — return list of commit hashes in range.
+  - `git_log_oneline(repo, commit)` — return one-line log for a commit: 'hash message'.
+  - `git_cherry_pick(worktree, commit)` — cherry-pick a commit, returns CompletedProcess.
+  - `git_reset_hard(worktree, ref)` — reset worktree to ref with --hard.
+  - `ordered_remotes(alias_remotes)` returns remote names with `origin` first, then alphabetical. Used in `resolve_spec`, `resolve_spec_local`, `get_remote_ref_for_branch`, `ensure_bare_repo`.
+  - `get_worktree_branch(worktree_path)` returns the current branch name or `None` if detached (uses `rev-parse --abbrev-ref HEAD`).
+- **`ow/workspace.py`** — file generators + command functions (`cmd_*`). Commands call git helpers then render Jinja2 templates. Also owns cache/drift helpers and worktree drift detection (see below).
+  - `_copy_packaged_templates(dest)` — copies all bundled template directories from the installed package to `dest`.
+  - `_copy_ow_services(dest)` — copies the bundled `services/` files from the installed package to `dest`.
+  - `resolve_workspace(path, config)` — resolves a workspace from explicit path, `OW_WORKSPACE` env var, or cwd walk-up for `.ow/config`.
+  - `DriftResult` / `check_drift` / `warn_if_drifted` — detect when worktree branch state doesn't match config. `cmd_status`, `cmd_rebase`, `cmd_update` call `warn_if_drifted` to display warnings but proceed anyway.
+  - `RebasePlan` / `_analyze_repo_for_rebase` — analyze the rebase situation for a single repo: track ref, upstream, fork_point, commits_to_reapply, local commits, unpushed commits, whether upstream was rewritten.
+  - `_recover_with_cherry_pick(worktree, upstream, commits)` — reset hard to upstream and cherry-pick commits sequentially. Returns None on success, or the failing commit hash on conflict.
+  - `cmd_rebase` handles four cases: (1) detached worktree → switch to track ref, (2) upstream rewritten with fork-point → recovery via reset + cherry-pick, (3) upstream rewritten without fork-point → skip with manual recovery instructions, (4) normal rebase → two-step rebase onto upstream then track ref. Displays summary and asks for confirmation before proceeding.
+
+## Commands
+
+| Command | Signature | Purpose |
+|---------|-----------|---------|
+| `ow init` | `cmd_init(path, *, force, with_backup)` | Initialize new project directory (no `ow.toml` required) |
+| `ow create` | `cmd_create(config, ...)` | Interactive form → create workspace + `.ow/config` |
+| `ow update` | `cmd_update(config)` | Re-render templates + materialize worktrees |
+| `ow status` | `cmd_status(config)` | Show workspace branch status |
+| `ow rebase` | `cmd_rebase(config)` | Fetch + rebase workspace branches |
+| `ow prune` | `cmd_prune(config)` | Clean up stale worktree references from bare repos |
+
+All commands resolve the current workspace via `OW_WORKSPACE` env var or cwd walk-up for `.ow/config`.
+
+## Template system
+
+Workspace files are generated from `templates/` at the project root. Each subdirectory is a template bundle. Workspaces declare templates via the `templates` field (required array). Templates are applied in order — later templates can override files from earlier ones.
+
+Bundled templates (git-tracked):
+- `templates/common/` — core files: mise.toml, odoorc, odools.toml, pyrightconfig.json, requirements-dev.txt
+- `templates/vscode/.vscode/` — VSCode settings and debug config
+- `templates/zed/.zed/` — Zed settings and debug config
+- `templates/bwrap/` — sandbox scripts for AI coding assistants (bwrap-opencode, bwrap-claude)
+
+Templates are Jinja2 (`.j2` extension); static files are copied as-is.
+
+Template context keys:
+- `ws_name` — workspace name
+- `vars` — merged dict of `config.vars` and `ws.vars` (use `{{ vars.key | default(fallback) }}`)
+- `addons_paths` — ordered list of absolute addon paths
+- `odools_path_items` — relative paths for odools.toml
+- `repos` — list of repo aliases
+- `main_repo_alias` — alias of the Odoo core repo (has `odoo-bin`), or `None`
+
+## Conventions
+
+- Bare repos live in `.bare-git-repos/<alias>.git`.
+- Workspace dirs are `workspaces/<name>/`, with subdirs matching repo aliases.
+- `community` is always the Odoo core repo; its addons are at `community/addons` and `community/odoo/addons`. Note that `community` is the default proposed alias for the main `odoo/odoo` repository, but it can be changed. There is `is_odoo_main_repo` that is made to discover which repo is the main.
+- `ow.toml` is user-local (gitignored). Contains only `[vars]` and `[remotes]`. No workspace declarations.
+- Each workspace has its own `.ow/config` file (gitignored) that stores its config: name, templates, repos, vars.
+- `templates/` contains git-tracked template bundles; subdirectories like `common/`, `vscode/`, `zed/` are whitelisted in `.gitignore`.

odoo_workspaces-1.1.0/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/PKG-INFO

@@ -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.