odoo-wt 1.0.0__tar.gz

odoo_wt-1.0.0/.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+*.py[cod]
+*$py.class
+.venv/
+.env
+.pytest_cache/
+.vscode/

odoo_wt-1.0.0/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: odoo-wt
+Version: 1.0.0
+Summary: Modern TUI-driven Odoo Worktree Manager
+Requires-Python: >=3.11
+Requires-Dist: pyspellchecker>=0.8.1
+Requires-Dist: rich>=13.7.1
+Requires-Dist: textual>=0.52.1
+Description-Content-Type: text/markdown
+
+# Odoo Worktree Assistant (`odoo-wt`)
+
+A professional, modern TUI-driven Git worktree manager explicitly designed for Odoo developers. Built with Python, [Textual](https://textual.textualize.io/), and [uv](https://github.com/astral-sh/uv).
+
+![Python](https://img.shields.io/badge/Language-Python-blue) ![TUI](https://img.shields.io/badge/UI-Textual-green) ![Package Manager](https://img.shields.io/badge/Manager-uv-orange)
+
+## 🚀 Overview
+
+`odoo-wt` streamlines the process of spinning up new Odoo development environments. It handles the complex "handshake" between Git worktrees and Python virtual environments so you can focus on code.
+
+### Key Features
+
+-   **Modern TUI:** A sleek, reactive "All-in-One" form built with Textual.
+-   **Smart Branching:** Follows the Odoo standard: `[VERSION]-[description]-[SUFFIX]`.
+-   **Dual Repo Support:** Simultaneously creates worktrees for both `odoo` (Community) and `enterprise`.
+-   **Automated UV Environments:** 
+    -   Centralizes environments in `~/.envs/[VERSION]`.
+    -   Automatically runs `uv venv` and `uv pip install` if the environment is missing.
+    -   Instantly symlinks `.venv` into your new worktree folder for automatic VS Code detection.
+-   **Proactive Status Checks:** Checks `odoo-dev` and local remotes to detect if branches already exist before creation.
+
+## 🛠️ Installation
+
+The recommended way to install `odoo-wt` is using `uv tool`:
+
+```bash
+# From the project directory
+uv tool install . --force
+```
+
+This creates an isolated environment for the tool and places an `odoo-wt` executable in your `~/.local/bin/`.
+
+## ⚙️ Configuration
+
+The tool saves its configuration to `~/.config/odoo-wt.json`. You can edit paths directly in the **Settings** tab within the application.
+
+-   **`wt_root`**: Where your worktree folders live (e.g., `~/repos/Odoo/wt`).
+-   **`env_root`**: Where your centralized global Python environments are stored (e.g., `~/.envs`).
+-   **`suffix`**: Your default developer quadrigram (e.g., `pian`).
+
+## 📖 Usage
+
+### Interactive Mode (The Guide)
+Simply run the command with no arguments:
+```bash
+odoo-wt
+```
+-   Use **`Tab`** to switch between Version, Description, and Suffix.
+-   Type **`custom...`** in any dropdown to reveal a custom input field.
+-   Press **`Ctrl+S`** to instantly submit and deploy.
+-   Press **`Esc`** to cancel and exit.
+
+### Fast Mode
+If you already have a full branch name ready:
+```bash
+odoo-wt 17.0-fix-account-bug-pian
+```
+
+## ⚠️ Known Limitations
+
+- **Clipboard Interactions (Copy/Paste):** Because `odoo-wt` uses mouse-capture to enable clickable buttons and scrollbars in the terminal, your terminal emulator's native click-to-highlight features are disabled by default. 
+    - **To copy text manually:** Hold the `Shift` key while clicking and dragging over the text to bypass the app and use your terminal's native selection, then use `Ctrl+Shift+C`.
+    - **To paste text:** Sometimes native terminal paste (`Ctrl+Shift+V` or middle-click) events are intercepted unreliably by the underlying framework. If pasting into an input field fails, you may need to type the branch name manually.
+
+## 📝 Development
+
+The source code is located at `/home/odoo/repos/Scripts/odoo-wt/`.
+
+To apply changes made to the source:
+```bash
+uv tool install . --force
+```
+
+## 📜 License
+MIT

odoo_wt-1.0.0/README.md

@@ -0,0 +1,75 @@
+# Odoo Worktree Assistant (`odoo-wt`)
+
+A professional, modern TUI-driven Git worktree manager explicitly designed for Odoo developers. Built with Python, [Textual](https://textual.textualize.io/), and [uv](https://github.com/astral-sh/uv).
+
+![Python](https://img.shields.io/badge/Language-Python-blue) ![TUI](https://img.shields.io/badge/UI-Textual-green) ![Package Manager](https://img.shields.io/badge/Manager-uv-orange)
+
+## 🚀 Overview
+
+`odoo-wt` streamlines the process of spinning up new Odoo development environments. It handles the complex "handshake" between Git worktrees and Python virtual environments so you can focus on code.
+
+### Key Features
+
+-   **Modern TUI:** A sleek, reactive "All-in-One" form built with Textual.
+-   **Smart Branching:** Follows the Odoo standard: `[VERSION]-[description]-[SUFFIX]`.
+-   **Dual Repo Support:** Simultaneously creates worktrees for both `odoo` (Community) and `enterprise`.
+-   **Automated UV Environments:** 
+    -   Centralizes environments in `~/.envs/[VERSION]`.
+    -   Automatically runs `uv venv` and `uv pip install` if the environment is missing.
+    -   Instantly symlinks `.venv` into your new worktree folder for automatic VS Code detection.
+-   **Proactive Status Checks:** Checks `odoo-dev` and local remotes to detect if branches already exist before creation.
+
+## 🛠️ Installation
+
+The recommended way to install `odoo-wt` is using `uv tool`:
+
+```bash
+# From the project directory
+uv tool install . --force
+```
+
+This creates an isolated environment for the tool and places an `odoo-wt` executable in your `~/.local/bin/`.
+
+## ⚙️ Configuration
+
+The tool saves its configuration to `~/.config/odoo-wt.json`. You can edit paths directly in the **Settings** tab within the application.
+
+-   **`wt_root`**: Where your worktree folders live (e.g., `~/repos/Odoo/wt`).
+-   **`env_root`**: Where your centralized global Python environments are stored (e.g., `~/.envs`).
+-   **`suffix`**: Your default developer quadrigram (e.g., `pian`).
+
+## 📖 Usage
+
+### Interactive Mode (The Guide)
+Simply run the command with no arguments:
+```bash
+odoo-wt
+```
+-   Use **`Tab`** to switch between Version, Description, and Suffix.
+-   Type **`custom...`** in any dropdown to reveal a custom input field.
+-   Press **`Ctrl+S`** to instantly submit and deploy.
+-   Press **`Esc`** to cancel and exit.
+
+### Fast Mode
+If you already have a full branch name ready:
+```bash
+odoo-wt 17.0-fix-account-bug-pian
+```
+
+## ⚠️ Known Limitations
+
+- **Clipboard Interactions (Copy/Paste):** Because `odoo-wt` uses mouse-capture to enable clickable buttons and scrollbars in the terminal, your terminal emulator's native click-to-highlight features are disabled by default. 
+    - **To copy text manually:** Hold the `Shift` key while clicking and dragging over the text to bypass the app and use your terminal's native selection, then use `Ctrl+Shift+C`.
+    - **To paste text:** Sometimes native terminal paste (`Ctrl+Shift+V` or middle-click) events are intercepted unreliably by the underlying framework. If pasting into an input field fails, you may need to type the branch name manually.
+
+## 📝 Development
+
+The source code is located at `/home/odoo/repos/Scripts/odoo-wt/`.
+
+To apply changes made to the source:
+```bash
+uv tool install . --force
+```
+
+## 📜 License
+MIT

odoo_wt-1.0.0/pyproject.toml

@@ -0,0 +1,24 @@
+[project]
+name = "odoo-wt"
+version = "1.0.0"
+description = "Modern TUI-driven Odoo Worktree Manager"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = ["textual>=0.52.1", "rich>=13.7.1", "pyspellchecker>=0.8.1"]
+
+[project.scripts]
+odoo-wt = "odoo_wt.cli_main:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/odoo_wt"]
+
+[dependency-groups]
+dev = [
+    "pytest>=9.0.2",
+    "pytest-asyncio>=1.3.0",
+    "rich>=14.3.3",
+]

odoo_wt-1.0.0/src/odoo_wt/app_config.py

@@ -0,0 +1,41 @@
+import json
+import datetime
+import os
+from pathlib import Path
+
+# --- CONFIGURATION ---
+CONFIG_FILE = Path.home() / ".config" / "odoo-wt.json"
+LOG_FILE = Path.home() / ".config" / "odoo-wt-logs.jsonl"
+
+def append_log(action: str, details: dict = None):
+    if details is None: details = {}
+    entry = {"timestamp": datetime.datetime.now().isoformat(), "action": action, "details": details}
+    try:
+        with open(LOG_FILE, "a") as f:
+            f.write(json.dumps(entry) + "\n")
+    except: pass
+
+def load_config():
+    default_config = {
+        "wt_root": str(Path.home() / "repos" / "Odoo" / "wt"),
+        "env_root": str(Path.home() / ".envs"),
+        "suffix": "pian",
+        "remote_name": "odoo-dev",
+        "community_dir": "odoo",
+        "enterprise_dir": "enterprise",
+        "default_tab": "tab-create",
+        "ignored_versions": [],
+        "ignored_suffixes": []
+    }
+    if CONFIG_FILE.exists():
+        try:
+            with open(CONFIG_FILE, "r") as f:
+                default_config.update(json.load(f))
+        except:
+            pass
+    return default_config
+
+def save_config(config):
+    CONFIG_FILE.parent.mkdir(parents=True, exist_ok=True)
+    with open(CONFIG_FILE, "w") as f:
+        json.dump(config, f, indent=4)

odoo_wt-1.0.0/src/odoo_wt/cli_main.py

@@ -0,0 +1,50 @@
+import sys
+import os
+from .app_config import load_config, CONFIG_FILE
+from .system_discovery import discover_system_data
+from .setup_wizard import WizardApp
+from .main_tui import OdooWtApp
+
+def main():
+    if not CONFIG_FILE.exists():
+        app = WizardApp()
+        config = app.run()
+        if not config:
+            return
+    else:
+        config = load_config()
+
+    # CLI direct creation mode
+    if len(sys.argv) > 1:
+        branch = sys.argv[1]
+        v = branch.split("-")[0] if "-" in branch else "master"
+        # We manually build the data for DeployScreen
+        data = {"action": "create", "version": v, "desc": branch, "suffix": ""}
+        # In CLI mode, we still need to boot OdooWtApp to push the DeployScreen
+        # or we just boot a minimal app to host the DeployScreen.
+        # For now, let's just launch the full app and it will handle it if we modify init.
+        # But easier: just boot the app normally.
+        v_list, s_list, worktrees = discover_system_data(config["wt_root"], config["suffix"])
+        app = OdooWtApp(config, v_list, s_list, worktrees)
+        # We don't have an easy way to auto-start deployment from CLI yet, 
+        # let's just open the app for now. 
+        app.run()
+    else:
+        v_list, s_list, worktrees = discover_system_data(config["wt_root"], config["suffix"])
+        app = OdooWtApp(config, v_list, s_list, worktrees)
+        data = app.run()
+
+    # Handle deployment completion actions
+    if data and isinstance(data, dict):
+        action = data.get("action")
+        if action == "terminal":
+            target = data["path"]
+            os.chdir(target)
+            shell = os.environ.get("SHELL", "/bin/bash")
+            os.execv(shell, [shell])
+        elif action == "vscode":
+            target = data["path"]
+            os.system(f"code {target}")
+
+if __name__ == "__main__":
+    main()

odoo_wt-1.0.0/src/odoo_wt/custom_screens.py

@@ -0,0 +1,290 @@
+import asyncio
+import os
+import json
+from pathlib import Path
+from textual import on, work
+from textual.binding import Binding
+from textual.screen import ModalScreen, Screen
+from textual.widgets import Label, Button, ProgressBar, RichLog
+from textual.containers import Vertical, Horizontal, VerticalScroll
+
+from .app_config import append_log
+from .system_discovery import get_remote, check_local
+
+async def run_cmd_stream(cmd, cwd, log_widget, prefix=""):
+    process = await asyncio.create_subprocess_exec(
+        *cmd,
+        cwd=cwd,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.STDOUT
+    )
+    while True:
+        line = await process.stdout.readline()
+        if not line:
+            break
+        text = line.decode('utf-8', errors='replace').rstrip()
+        log_widget.write(f"{prefix}{text}")
+    await process.wait()
+    return process.returncode == 0
+
+class DeleteConfirmScreen(ModalScreen[bool]):
+    def __init__(self, wt_name: str):
+        super().__init__()
+        self.wt_name = wt_name
+        self.step = 1
+
+    def on_key(self, event) -> None:
+        if event.key == "left":
+            self.focus_previous()
+        elif event.key == "right":
+            self.focus_next()
+
+    def compose(self):
+        with Vertical(id="delete-dialog"):
+            yield Label(f"Delete worktree '{self.wt_name}'? (1/3)", id="del-msg")
+            with Horizontal(classes="del-btn-row", id="btn-container"):
+                yield Button("Yes, delete", variant="error", id="btn-yes")
+                yield Button("Cancel", variant="primary", id="btn-cancel")
+
+    @on(Button.Pressed, "#btn-yes")
+    async def on_yes(self):
+        append_log("Delete Confirm Step", {"step": self.step, "worktree": self.wt_name})
+        self.step += 1
+        if self.step > 3:
+            self.dismiss(True)
+            return
+        msg = self.query_one("#del-msg", Label)
+        container = self.query_one("#btn-container", Horizontal)
+        await container.query_children().remove()
+        if self.step == 2:
+            msg.update(f"Are you SURE? (2/3)")
+            await container.mount(Button("Cancel", variant="primary", id="btn-cancel"))
+            await container.mount(Button("Yes, delete", variant="error", id="btn-yes"))
+        elif self.step == 3:
+            msg.update(f"Final warning: NUKE '{self.wt_name}'? (3/3)")
+            await container.mount(Button("Yes, delete", variant="error", id="btn-yes"))
+            await container.mount(Button("Cancel", variant="primary", id="btn-cancel"))
+        self.query_one("#btn-cancel").focus()
+
+    @on(Button.Pressed, "#btn-cancel")
+    def on_cancel(self):
+        append_log("Delete Cancelled", {"worktree": self.wt_name})
+        self.dismiss(False)
+
+
+
+from textual.binding import Binding
+class DeployScreen(Screen):
+    BINDINGS = [
+        Binding("t", "terminal", "Terminal", show=False),
+        Binding("v", "vscode", "VS Code", show=False),
+        Binding("b", "back", "Back", show=False),
+        Binding("x", "exit", "Exit", show=False),
+    ]
+
+    def action_terminal(self):
+        if not self.query_one("#success-footer").has_class("hidden"):
+            self.on_terminal()
+            
+    def action_vscode(self):
+        if not self.query_one("#success-footer").has_class("hidden"):
+            self.on_vscode()
+            
+    def action_back(self):
+        if not self.query_one("#success-footer").has_class("hidden"):
+            self.on_back()
+            
+    def action_exit(self):
+        if not self.query_one("#success-footer").has_class("hidden"):
+            self.on_exit()
+
+    def __init__(self, data, config):
+        super().__init__()
+        self.data = data
+        self.config = config
+
+    def compose(self):
+        with VerticalScroll(id="deploy-logs-scroll"):
+            with Vertical(classes="log-box"):
+                with Horizontal(classes="log-header"):
+                    yield Label("Community", classes="log-title")
+                    yield ProgressBar(id="prog-odoo", show_eta=False)
+                yield RichLog(id="log-odoo", markup=False, highlight=False)
+                
+            with Vertical(classes="log-box"):
+                with Horizontal(classes="log-header"):
+                    yield Label("Enterprise", classes="log-title")
+                    yield ProgressBar(id="prog-ent", show_eta=False)
+                yield RichLog(id="log-ent", markup=False, highlight=False)
+                
+            with Vertical(classes="log-uv-box", id="uv-box"):
+                with Horizontal(classes="log-header"):
+                    yield Label("UV Env", classes="log-title")
+                    yield ProgressBar(id="prog-uv", show_eta=False)
+                yield RichLog(id="log-uv", markup=False, highlight=False)
+                
+        with Vertical(id="success-footer", classes="hidden"):
+            yield Label("", id="success-message", classes="success-msg")
+            with Horizontal(classes="success-btn-row"):
+                yield Button("(T)erminal", variant="success", id="btn-terminal")
+                yield Button("(V)S Code", variant="primary", id="btn-vscode")
+                yield Button("(B)ack to Tool", variant="warning", id="btn-back")
+                yield Button("E(x)it", variant="error", id="btn-exit")
+
+    def on_mount(self):
+        self.run_deployment()
+
+    @work(exclusive=True)
+    async def run_deployment(self):
+        wt_root = Path(self.config["wt_root"])
+        dev_remote = self.config.get("remote_name", "odoo-dev")
+        comm_dir = self.config.get("community_dir", "odoo")
+        ent_dir = self.config.get("enterprise_dir", "enterprise")
+        
+        clean_desc = self.data["desc"].strip().replace(" ", "_")
+        parts = [p for p in [self.data["version"], clean_desc, self.data["suffix"]] if p]
+        branch_name = "-".join(parts)
+        append_log("Deployment Started", {"branch": branch_name, "version": self.data["version"]})
+        target_dir = wt_root / branch_name
+        base_odoo = wt_root / "master" / comm_dir
+        base_ent = wt_root / "master" / ent_dir
+        base_v = self.data["version"] or "master"
+        
+        target_dir.mkdir(parents=True, exist_ok=True)
+        
+        async def deploy_repo(repo, dest, log_id, prog_id):
+            log = self.query_one(f"#{log_id}", RichLog)
+            prog = self.query_one(f"#{prog_id}", ProgressBar)
+            prog.update(total=3)
+            
+            remote = await asyncio.to_thread(get_remote, repo)
+            log.write(f"Detected base remote: {remote}")
+            prog.advance(1)
+
+            log.write(f"Fetching '{branch_name}' from '{dev_remote}'...")
+            success = await run_cmd_stream(["git", "fetch", dev_remote, f"{branch_name}:{branch_name}", "--force"], repo, log)
+            prog.advance(1)
+
+            if success:
+                log.write("Fetch successful. Creating worktree...")
+                append_log("Branch Strategy Selected", {"repo": dest, "strategy": "remote_pull", "remote": dev_remote, "branch": branch_name})
+                await run_cmd_stream(["git", "worktree", "add", str(target_dir / dest), branch_name], repo, log)
+            else:
+                log.write(f"Branch not found on '{dev_remote}'. Fetching '{base_v}' from '{remote}'...")
+                await run_cmd_stream(["git", "fetch", remote, base_v], repo, log)
+                
+                is_local = await asyncio.to_thread(check_local, repo, branch_name)
+                if is_local:
+                    log.write("Branch exists locally. Creating worktree...")
+                    append_log("Branch Strategy Selected", {"repo": dest, "strategy": "local_checkout", "branch": branch_name})
+                    await run_cmd_stream(["git", "worktree", "add", str(target_dir / dest), branch_name], repo, log)
+                else:
+                    log.write(f"Creating new branch from {remote}/{base_v}...")
+                    append_log("Branch Strategy Selected", {"repo": dest, "strategy": "new_branch", "base": f"{remote}/{base_v}", "branch": branch_name})
+                    await run_cmd_stream(["git", "worktree", "add", "-b", branch_name, str(target_dir / dest), f"{remote}/{base_v}"], repo, log)
+                    await run_cmd_stream(["git", "branch", "--set-upstream-to", f"{remote}/{base_v}", branch_name], repo, log)
+            
+            prog.advance(1)
+            log.write("✅ Done.")
+
+        async def setup_uv():
+            log_uv = self.query_one("#log-uv", RichLog)
+            prog_uv = self.query_one("#prog-uv", ProgressBar)
+            prog_uv.update(total=4)
+            
+            env_root = Path(self.config["env_root"])
+            env_root.mkdir(parents=True, exist_ok=True)
+            target_env = env_root / base_v
+            
+            if not target_env.exists():
+                log_uv.write(f"Initializing UV environment for {base_v}...")
+                await run_cmd_stream(["uv", "venv", str(target_env), "--python", "3.12"], env_root, log_uv)
+                prog_uv.advance(1)
+                
+                # Use base folder requirements to avoid waiting for worktree creation
+                base_req = wt_root / "master" / comm_dir / "requirements.txt"
+                if base_req.exists():
+                    log_uv.write(f"Installing requirements from base '{comm_dir}'...")
+                    await run_cmd_stream([
+                        "uv", "pip", "install", "-r", str(base_req), 
+                        "--python", str(target_env / "bin" / "python")
+                    ], env_root, log_uv)
+                prog_uv.advance(1)
+            else:
+                log_uv.write(f"UV environment '{base_v}' already exists.")
+                prog_uv.advance(2)
+
+            # Wait for target_dir to definitely exist (though we create it at start)
+            # but more importantly, we need to wait for odoo/enterprise worktrees 
+            # to finish before we can reliably symlink .venv into the target_dir
+            # actually target_dir is just a folder, we can symlink now!
+            venv_symlink = target_dir / ".venv"
+            if not venv_symlink.exists():
+                try:
+                    os.symlink(target_env, venv_symlink)
+                    log_uv.write("Created .venv symlink.")
+                except Exception as e:
+                    log_uv.write(f"Failed to create symlink: {e}")
+            prog_uv.advance(1)
+            log_uv.write("✅ Done.")
+            return True
+
+        await asyncio.gather(
+            deploy_repo(base_odoo, comm_dir, "log-odoo", "prog-odoo"),
+            deploy_repo(base_ent, ent_dir, "log-ent", "prog-ent"),
+            setup_uv()
+        )
+
+        append_log("Deployment Success", {"branch": branch_name, "path": str(target_dir)})
+        self.target_dir = target_dir
+        self.show_success_footer()
+
+    def show_success_footer(self):
+        msg = self.query_one("#success-message", Label)
+        msg.update(f"SUCCESS! Worktree ready at: {self.target_dir}\nWhat would you like to do next?")
+        self.query_one("#success-footer").remove_class("hidden")
+        self.query_one("#btn-terminal").focus()
+
+    @on(Button.Pressed, "#btn-terminal")
+    def on_terminal(self):
+        append_log("Deployment Complete", {"choice": "terminal"})
+        self.app.exit({"action": "terminal", "path": str(self.target_dir)})
+
+    @on(Button.Pressed, "#btn-vscode")
+    def on_vscode(self):
+        append_log("Deployment Complete", {"choice": "vscode"})
+        self.app.exit({"action": "vscode", "path": str(self.target_dir)})
+
+    @on(Button.Pressed, "#btn-back")
+    def on_back(self):
+        append_log("Deployment Complete", {"choice": "back"})
+        self.dismiss()
+
+    @on(Button.Pressed, "#btn-exit")
+    def on_exit(self):
+        append_log("Deployment Complete", {"choice": "exit"})
+        self.app.exit()
+
+class LogDetailScreen(ModalScreen[None]):
+    def __init__(self, ts, action, details):
+        super().__init__()
+        self.ts = ts
+        self.action = action
+        self.details = details
+
+    def compose(self):
+        with Vertical(id="log-detail-dialog"):
+            yield Label(f"[{self.ts}] {self.action}", classes="log-detail-title")
+            try:
+                parsed = json.loads(self.details)
+                pretty_details = json.dumps(parsed, indent=4)
+            except:
+                pretty_details = str(self.details)
+            with VerticalScroll():
+                yield Label(pretty_details, classes="log-detail-text")
+            with Horizontal(classes="log-detail-btn-row"):
+                yield Button("Close", variant="primary", id="btn-close-log")
+
+    @on(Button.Pressed, "#btn-close-log")
+    def on_close(self):
+        self.dismiss()