odoo-dev 1.0.0__tar.gz → 1.2.0__tar.gz

odoo_dev-1.2.0/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "1.2.0"
+}

odoo_dev-1.2.0/CHANGELOG.md

@@ -0,0 +1,50 @@
+# Changelog
+
+## [1.2.0](https://github.com/bemade/odoo-dev/compare/v1.1.0...v1.2.0) (2026-07-07)
+
+
+### Features
+
+* add 'vendor' command for per-addon vendoring ([7dfe8cb](https://github.com/bemade/odoo-dev/commit/7dfe8cbbf20031b012bc3326485f9aa3b634146c))
+* **setup:** add --no-docker and --yes for headless agentic setup ([daa62c4](https://github.com/bemade/odoo-dev/commit/daa62c496ceb923152305091c5f94958014f1a51))
+* **setup:** skip submodule init for fully-vendored repos ([83b7818](https://github.com/bemade/odoo-dev/commit/83b78186a0a23b3d33eb12a5364d312794315158))
+* **vendor:** add `vendor develop` local dev-loop for vendored addons ([89325f8](https://github.com/bemade/odoo-dev/commit/89325f88a9a51bfc4d4cb4ea755381c55e62989a))
+* **vendor:** add `vendor update` — the pull side of vendoring ([fb88c1e](https://github.com/bemade/odoo-dev/commit/fb88c1e3b62604f59932811b772cd5e420eb5152))
+* **vendor:** add vendored/ to the addons_path when present ([0fdc512](https://github.com/bemade/odoo-dev/commit/0fdc512a9c9df2541028a8743d1afb33240ac6de))
+* **vendor:** assert-no-hybrid guard in `vendor check --no-hybrid` ([d424eca](https://github.com/bemade/odoo-dev/commit/d424eca69fac72f27a44e24ea3ca68fe9e7b37af))
+* **vendor:** test and cover vendored/ addons alongside local ones ([a989d17](https://github.com/bemade/odoo-dev/commit/a989d174cc6cc84da5cae7fad327c017cbaf8030))
+
+
+### Bug Fixes
+
+* **vendor:** compare python-dep package NAMES, not full spec strings ([6903fa3](https://github.com/bemade/odoo-dev/commit/6903fa307dfab977cb40b9d7dfee2d017f67a0ff))
+
+
+### Documentation
+
+* document the vendor command + agentic setup flag ([523ac05](https://github.com/bemade/odoo-dev/commit/523ac050bcd103d18b99abc8cc3a50ab0c6886c4))
+
+## [1.1.0](https://github.com/bemade/odoo-dev/compare/v1.0.0...v1.1.0) (2026-06-26)
+
+
+### Features
+
+* add `bump` command for series-agnostic manifest version bumps ([#7](https://github.com/bemade/odoo-dev/issues/7)) ([992c8aa](https://github.com/bemade/odoo-dev/commit/992c8aa3731d262803a6f329209275462d88d80a))
+
+## [1.0.0](https://github.com/bemade/odoo-dev/compare/v0.4.0...v1.0.0) (2026-06-11)
+
+
+### ⚠ BREAKING CHANGES
+
+* macOS `setup` no longer installs PostgreSQL. Fresh macOS setups must install a server themselves (or point DB_HOST/DB_PORT at a remote/Docker server).
+
+### Features
+
+* treat PostgreSQL as an external prerequisite on all platforms ([#5](https://github.com/bemade/odoo-dev/issues/5)) ([e817107](https://github.com/bemade/odoo-dev/commit/e817107ac434a5b23dd2675d59a95d1a6f8d1e71))
+
+## [0.4.0](https://github.com/bemade/odoo-dev/compare/v0.3.3...v0.4.0) (2026-06-11)
+
+
+### Features
+
+* configurable DB connection + connectivity preflight ([#3](https://github.com/bemade/odoo-dev/issues/3)) ([632738e](https://github.com/bemade/odoo-dev/commit/632738e37c1d22d79ec4a03cba72a28ca580f7c8))

{odoo_dev-1.0.0 → odoo_dev-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: odoo-dev
-Version: 1.0.0
+Version: 1.2.0
 Summary: Odoo Development Environment Helper
 Project-URL: Homepage, https://git.bemade.org/bemade/odoo-dev
 Project-URL: Repository, https://git.bemade.org/bemade/odoo-dev
@@ -102,7 +102,7 @@ odoo-dev shell mydb                   # Open an Odoo shell
 odoo-dev update base -d mydb          # Update modules
 odoo-dev test my_module               # Run a module's tests (coverage on by default)
 odoo-dev test my_module --test-tags my_module --no-coverage
-odoo-dev test                         # Auto-discover & test all addons in addons/
+odoo-dev test                         # Auto-discover & test all addons in addons/ + vendored/
 odoo-dev scaffold my_module           # Create a new module
 ```
 
@@ -133,12 +133,58 @@ odoo-dev docker psql                  # PostgreSQL shell
 ### Setup Commands
 
 ```bash
-odoo-dev setup                        # Full setup
+odoo-dev setup                        # Full setup (interactive; offers Docker)
 odoo-dev setup --community            # Community edition only
+odoo-dev setup --no-docker --yes      # Headless/agentic: clone + venv + conf, no Docker, no prompts
 odoo-dev setup-venv                   # Just create the venv (no repo clone)
 odoo-dev vscode                       # Configure VSCode debugging
 ```
 
+### Vendored Addons
+
+Shared addons can be **vendored** — materialized as real committed directories
+under `vendored/`, pinned per-addon by `addons.lock` — instead of pulled in as
+`.repos/` git submodules. This makes each promotion a normal, reviewable file
+diff and deploys as plain files (what Odoo.sh needs). `vendored/` and `addons/`
+are both on the addons path.
+
+```bash
+odoo-dev vendor migrate               # Convert .repos submodule+symlink addons -> vendored/
+odoo-dev vendor migrate --dry-run     # Preview the pins without changing anything
+odoo-dev vendor sync                  # Materialize vendored/ from addons.lock
+odoo-dev vendor check                 # CI gate: verify vendored/ byte-matches the pins
+odoo-dev vendor add fsm --source github.com/bemade/bemade-addons --version 18.0.1.3.2
+odoo-dev vendor bump fsm --version 18.0.1.4.0   # Move a pin and re-materialize
+odoo-dev vendor update                # Pull newest upstream for all tracked addons
+odoo-dev vendor update fsm --dry-run  # Show what would update, change nothing
+odoo-dev vendor develop fsm           # Edit fsm against a live source clone
+odoo-dev vendor develop fsm --stop    # Leave develop mode (keeps the clone)
+odoo-dev vendor status                # Show vendored pins, symlinks, develop mode
+```
+
+Because `vendored/<addon>` is a materialized copy (re-`sync` clobbers it), you
+don't edit it in place. `vendor develop <addon>` clones the addon's source repo
+into a git-ignored `.vendor-dev/`, checks out a work branch at the pinned commit,
+and prepends an overlay to your **local** `conf/odoo.conf` addons_path so Odoo
+loads the live tree instead of the vendored copy (first path wins). `vendored/`
+stays byte-for-byte pristine and only the local conf is touched, so nothing
+dev-only can leak into a commit or into CI/prod. Edit in the clone, run/test in
+this project's Odoo, commit + push upstream, then `vendor bump` once the new
+version is tagged. `--branch NAME` names the work branch; `--base REF` bases it on
+something other than the current pin.
+
+`vendor check` verifies, per addon: the vendored files byte-match the pinned
+commit; a `version` tag (if set) still resolves to that commit; every manifest
+`external_dependencies['python']` is named in `requirements.txt`; and no addon
+name collides between `addons/` and `vendored/`.
+
+`vendor update` is the **pull** side: each client owns its pins. For every addon
+that tracks upstream — a `version` (bump to the newest `<addon>/<version>` tag) or
+a `branch` (bump to its HEAD) — it moves the pin forward and re-materializes.
+Addons pinned to a bare commit are left alone. Run it on a schedule (a client's own
+CI, its own token, opening a `vendor-bump/…` MR) so shared-addon changes propagate
+without any per-source push/fan-out machinery.
+
 ## Project Structure
 
 odoo-dev expects this project structure:
@@ -147,6 +193,8 @@ odoo-dev expects this project structure:
 my-odoo-project/
 ├── .env                 # Optional: ODOO_VERSION, PYTHON_VERSION
 ├── addons/              # Your custom addons
+├── vendored/            # Vendored shared addons (real files, pinned by addons.lock)
+├── addons.lock          # Per-addon pins for vendored/ (see `vendor`)
 ├── requirements.txt     # Project-specific Python deps
 ├── odoo/                # Cloned by setup
 ├── enterprise/          # Cloned by setup (unless --community)
@@ -156,6 +204,10 @@ my-odoo-project/
     └── odoo.conf        # Created by setup
 ```
 
+`vendored/` and `addons.lock` are only present once a project adopts vendoring
+(`odoo-dev vendor migrate`); submodule-based projects use `.repos/` + symlinks
+into `addons/` instead.
+
 ## Configuration
 
 Create a `.env` file in your project root:

{odoo_dev-1.0.0 → odoo_dev-1.2.0}/README.md

@@ -88,7 +88,7 @@ odoo-dev shell mydb                   # Open an Odoo shell
 odoo-dev update base -d mydb          # Update modules
 odoo-dev test my_module               # Run a module's tests (coverage on by default)
 odoo-dev test my_module --test-tags my_module --no-coverage
-odoo-dev test                         # Auto-discover & test all addons in addons/
+odoo-dev test                         # Auto-discover & test all addons in addons/ + vendored/
 odoo-dev scaffold my_module           # Create a new module
 ```
 
@@ -119,12 +119,58 @@ odoo-dev docker psql                  # PostgreSQL shell
 ### Setup Commands
 
 ```bash
-odoo-dev setup                        # Full setup
+odoo-dev setup                        # Full setup (interactive; offers Docker)
 odoo-dev setup --community            # Community edition only
+odoo-dev setup --no-docker --yes      # Headless/agentic: clone + venv + conf, no Docker, no prompts
 odoo-dev setup-venv                   # Just create the venv (no repo clone)
 odoo-dev vscode                       # Configure VSCode debugging
 ```
 
+### Vendored Addons
+
+Shared addons can be **vendored** — materialized as real committed directories
+under `vendored/`, pinned per-addon by `addons.lock` — instead of pulled in as
+`.repos/` git submodules. This makes each promotion a normal, reviewable file
+diff and deploys as plain files (what Odoo.sh needs). `vendored/` and `addons/`
+are both on the addons path.
+
+```bash
+odoo-dev vendor migrate               # Convert .repos submodule+symlink addons -> vendored/
+odoo-dev vendor migrate --dry-run     # Preview the pins without changing anything
+odoo-dev vendor sync                  # Materialize vendored/ from addons.lock
+odoo-dev vendor check                 # CI gate: verify vendored/ byte-matches the pins
+odoo-dev vendor add fsm --source github.com/bemade/bemade-addons --version 18.0.1.3.2
+odoo-dev vendor bump fsm --version 18.0.1.4.0   # Move a pin and re-materialize
+odoo-dev vendor update                # Pull newest upstream for all tracked addons
+odoo-dev vendor update fsm --dry-run  # Show what would update, change nothing
+odoo-dev vendor develop fsm           # Edit fsm against a live source clone
+odoo-dev vendor develop fsm --stop    # Leave develop mode (keeps the clone)
+odoo-dev vendor status                # Show vendored pins, symlinks, develop mode
+```
+
+Because `vendored/<addon>` is a materialized copy (re-`sync` clobbers it), you
+don't edit it in place. `vendor develop <addon>` clones the addon's source repo
+into a git-ignored `.vendor-dev/`, checks out a work branch at the pinned commit,
+and prepends an overlay to your **local** `conf/odoo.conf` addons_path so Odoo
+loads the live tree instead of the vendored copy (first path wins). `vendored/`
+stays byte-for-byte pristine and only the local conf is touched, so nothing
+dev-only can leak into a commit or into CI/prod. Edit in the clone, run/test in
+this project's Odoo, commit + push upstream, then `vendor bump` once the new
+version is tagged. `--branch NAME` names the work branch; `--base REF` bases it on
+something other than the current pin.
+
+`vendor check` verifies, per addon: the vendored files byte-match the pinned
+commit; a `version` tag (if set) still resolves to that commit; every manifest
+`external_dependencies['python']` is named in `requirements.txt`; and no addon
+name collides between `addons/` and `vendored/`.
+
+`vendor update` is the **pull** side: each client owns its pins. For every addon
+that tracks upstream — a `version` (bump to the newest `<addon>/<version>` tag) or
+a `branch` (bump to its HEAD) — it moves the pin forward and re-materializes.
+Addons pinned to a bare commit are left alone. Run it on a schedule (a client's own
+CI, its own token, opening a `vendor-bump/…` MR) so shared-addon changes propagate
+without any per-source push/fan-out machinery.
+
 ## Project Structure
 
 odoo-dev expects this project structure:
@@ -133,6 +179,8 @@ odoo-dev expects this project structure:
 my-odoo-project/
 ├── .env                 # Optional: ODOO_VERSION, PYTHON_VERSION
 ├── addons/              # Your custom addons
+├── vendored/            # Vendored shared addons (real files, pinned by addons.lock)
+├── addons.lock          # Per-addon pins for vendored/ (see `vendor`)
 ├── requirements.txt     # Project-specific Python deps
 ├── odoo/                # Cloned by setup
 ├── enterprise/          # Cloned by setup (unless --community)
@@ -142,6 +190,10 @@ my-odoo-project/
     └── odoo.conf        # Created by setup
 ```
 
+`vendored/` and `addons.lock` are only present once a project adopts vendoring
+(`odoo-dev vendor migrate`); submodule-based projects use `.repos/` + symlinks
+into `addons/` instead.
+
 ## Configuration
 
 Create a `.env` file in your project root:

{odoo_dev-1.0.0 → odoo_dev-1.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "odoo-dev"
-version = "1.0.0"
+version = "1.2.0"
 description = "Odoo Development Environment Helper"
 readme = "README.md"
 requires-python = ">=3.12"

odoo_dev-1.2.0/src/odoo_dev/__init__.py

@@ -0,0 +1,3 @@
+"""Odoo Development Environment Helper."""
+
+__version__ = "1.2.0"  # x-release-please-version

{odoo_dev-1.0.0 → odoo_dev-1.2.0}/src/odoo_dev/cli.py

@@ -5,7 +5,9 @@ from typing import Optional
 import typer
 
 from odoo_dev import __version__
+from odoo_dev.commands import bump as bump_cmd
 from odoo_dev.commands import db, docker, run, setup
+from odoo_dev.commands import vendor as vendor_cmd
 
 
 def _version_callback(value: bool) -> None:
@@ -39,6 +41,7 @@ def _main(
 # Command groups
 app.add_typer(db.app, name="db")
 app.add_typer(docker.app, name="docker")
+app.add_typer(vendor_cmd.app, name="vendor")
 
 # Setup commands
 app.command()(setup.setup)
@@ -52,6 +55,9 @@ app.command()(run.update)
 app.command()(run.test)
 app.command()(run.scaffold)
 
+# Versioning
+app.command()(bump_cmd.bump)
+
 
 def main() -> None:
     """Entry point for the CLI."""

odoo_dev-1.2.0/src/odoo_dev/commands/bump.py

@@ -0,0 +1,88 @@
+"""Bump an Odoo module's manifest version."""
+
+import subprocess
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from odoo_dev.config import load_config
+from odoo_dev.utils.console import error, info, success
+from odoo_dev.utils.manifest import (
+    bump_version_string,
+    find_module_root,
+    manifest_path,
+    read_version,
+    set_version,
+)
+
+
+def bump(
+    module: Annotated[
+        str,
+        typer.Argument(help="Module name (under addons/) or path to a module dir"),
+    ],
+    level: Annotated[
+        str, typer.Argument(help="Bump level: patch | minor | major")
+    ] = "patch",
+    no_stage: Annotated[
+        bool, typer.Option("--no-stage", help="Do not git add the changed manifest")
+    ] = False,
+) -> None:
+    """Bump a module's __manifest__.py version (patch | minor | major).
+
+    Series-agnostic: only the trailing major.minor.patch segments move, never the
+    Odoo series prefix. Edits the manifest in place and stages it, so the bump
+    lands in the commit you're about to make (which the version-bump check
+    requires for any module you've changed).
+    """
+    if level not in ("patch", "minor", "major"):
+        error(f"level must be one of patch|minor|major (got {level!r})")
+        raise typer.Exit(2)
+
+    # Resolve the module: an explicit path, else a name under addons/.
+    candidate = Path(module)
+    root = find_module_root(candidate) if candidate.exists() else None
+    if root is None and candidate.is_dir():
+        root = candidate
+    if root is None:
+        cfg = load_config()
+        under_addons = cfg.addons_dir / module
+        if under_addons.exists():
+            root = under_addons
+        else:
+            error(
+                f"No module found for {module!r} "
+                f"(checked the path and {cfg.addons_dir}/{module})"
+            )
+            raise typer.Exit(1)
+
+    mf = manifest_path(root)
+    if mf is None:
+        error(f"No __manifest__.py in {root}")
+        raise typer.Exit(1)
+
+    # Resolve through any addons/ -> .repos/ symlink so we edit and stage the
+    # real file in whichever repo (parent or submodule) actually owns it.
+    real_mf = mf.resolve()
+    text = real_mf.read_text()
+    current = read_version(text)
+    if current is None:
+        error(f"No version string in {real_mf}")
+        raise typer.Exit(1)
+
+    try:
+        new_version = bump_version_string(current, level)
+    except ValueError as exc:
+        error(str(exc))
+        raise typer.Exit(1)
+
+    real_mf.write_text(set_version(text, new_version))
+    success(f"{root.name}: {current} -> {new_version}")
+
+    if not no_stage:
+        result = subprocess.run(
+            ["git", "add", real_mf.name], cwd=real_mf.parent, check=False
+        )
+        if result.returncode != 0:
+            info(f"(could not git add {real_mf}; stage it yourself)")

{odoo_dev-1.0.0 → odoo_dev-1.2.0}/src/odoo_dev/commands/run.py

@@ -268,7 +268,9 @@ def test(
 
     # Determine modules to test
     if modules is None:
-        # Use manifestoo to list addons in the addons directory
+        # Use manifestoo to list addons across addons/ and vendored/, so a no-args
+        # run tests all custom AND vendored addons together (catches vendored
+        # addons that break when combined with local addons or with each other).
         manifestoo_cmd = [
             str(venv_python),
             "-m",
@@ -276,6 +278,8 @@ def test(
             "--select-addons-dir",
             str(cfg.addons_dir),
         ]
+        if cfg.vendored_dir.is_dir():
+            manifestoo_cmd.extend(["--select-addons-dir", str(cfg.vendored_dir)])
         if exclude:
             manifestoo_cmd.extend(["--select-exclude", exclude])
         manifestoo_cmd.extend(["list", "--separator=,"])
@@ -287,7 +291,7 @@ def test(
         )
         modules = result.stdout.strip()
         if not modules:
-            error(f"No addons found in {cfg.addons_dir}")
+            error(f"No addons found in {cfg.addons_dir} or {cfg.vendored_dir}")
             raise typer.Exit(1)
 
     # Clone external repo dependencies declared in repo_deps.yaml and symlink into addons_dir
@@ -387,9 +391,9 @@ def test(
         success(f"Running tests: {modules}")
 
         if coverage:
-            # Build coverage source paths
+            # Build coverage source paths (a module may live in addons/ or vendored/)
             coverage_source = ",".join(
-                str(cfg.addons_dir / m) for m in modules.split(",")
+                str(_module_dir(cfg, m)) for m in modules.split(",")
             )
 
             test_cmd = [
@@ -575,6 +579,14 @@ def _terminate_connections(db_name: str, db_config: dict[str, str]) -> None:
     )
 
 
+def _module_dir(cfg, module: str) -> Path:
+    """Return the directory of ``module`` — under addons/ or vendored/."""
+    for base in (cfg.addons_dir, cfg.vendored_dir):
+        if (base / module).is_dir():
+            return base / module
+    return cfg.addons_dir / module
+
+
 def _get_addons_path(config_file) -> str:
     """Extract addons_path from odoo.conf."""
     for line in config_file.read_text().splitlines():

{odoo_dev-1.0.0 → odoo_dev-1.2.0}/src/odoo_dev/commands/setup.py

@@ -18,11 +18,13 @@ from odoo_dev.config import (
 from odoo_dev.utils.console import info, success, warning
 
 
-def _prompt_for_versions() -> None:
-    """Prompt for ODOO_VERSION and PYTHON_VERSION if not set.
+def _prompt_for_versions(non_interactive: bool = False) -> None:
+    """Resolve ODOO_VERSION and PYTHON_VERSION.
 
-    Checks environment and .env file. If not found, prompts interactively
-    and optionally saves to .env.
+    Checks environment and .env file. If unset and ``non_interactive`` is False,
+    prompts interactively and optionally saves to .env. If ``non_interactive``,
+    falls back to the defaults with no prompts (agentic/headless use) and records
+    them to .env silently.
     """
     project_dir = find_project_root()
     env_file = project_dir / ".env"
@@ -36,24 +38,28 @@ def _prompt_for_versions() -> None:
     updates = {}
 
     if not odoo_version:
-        odoo_version = typer.prompt(
-            "Odoo version",
-            default=DEFAULT_ODOO_VERSION,
+        odoo_version = (
+            DEFAULT_ODOO_VERSION
+            if non_interactive
+            else typer.prompt("Odoo version", default=DEFAULT_ODOO_VERSION)
         )
         os.environ["ODOO_VERSION"] = odoo_version
         updates["ODOO_VERSION"] = odoo_version
 
     if not python_version:
-        python_version = typer.prompt(
-            "Python version",
-            default=DEFAULT_PYTHON_VERSION,
+        python_version = (
+            DEFAULT_PYTHON_VERSION
+            if non_interactive
+            else typer.prompt("Python version", default=DEFAULT_PYTHON_VERSION)
         )
         os.environ["PYTHON_VERSION"] = python_version
         updates["PYTHON_VERSION"] = python_version
 
-    # Offer to save to .env if we prompted for anything
+    # Persist anything we resolved. Non-interactive saves silently; interactive asks.
     if updates:
-        if typer.confirm("Save these settings to .env?", default=True):
+        if non_interactive or typer.confirm(
+            "Save these settings to .env?", default=True
+        ):
             _update_env_file(env_file, updates)
             success(f"Settings saved to {env_file}")
 
@@ -98,10 +104,27 @@ def setup(
         "--clean",
         help="Clean up before setup (remove existing venv, etc.)",
     ),
+    no_docker: bool = typer.Option(
+        False,
+        "--no-docker",
+        help="Skip Docker file setup and image build (local venv only).",
+    ),
+    yes: bool = typer.Option(
+        False,
+        "--yes",
+        "-y",
+        help="Non-interactive: no prompts, use defaults. For agentic/headless use "
+        "(combine with --no-docker for a fully unattended local setup).",
+    ),
 ) -> None:
-    """Complete setup: clone Odoo repos, configure VSCode, build image."""
-    # Prompt for versions if not configured
-    _prompt_for_versions()
+    """Complete setup: clone Odoo repos, configure VSCode, build image.
+
+    For headless/agentic use run ``odoo-dev setup --no-docker --yes``: clones the
+    Odoo repos, builds the local venv and odoo.conf, and never prompts or touches
+    Docker.
+    """
+    # Resolve versions (no prompts under --yes)
+    _prompt_for_versions(non_interactive=yes)
 
     cfg = load_config()
 
@@ -128,9 +151,14 @@ def setup(
     )
     setup_venv()
 
-    # Prompt for Docker setup
-    warning("\nDo you want to set up the Docker environment?")
-    if typer.confirm("Continue with Docker setup?", default=True):
+    # Docker setup — skipped entirely under --no-docker; auto-confirmed under --yes.
+    if no_docker:
+        info(
+            "Skipping Docker setup (--no-docker). Run 'odoo-dev build' later if needed."
+        )
+    elif yes or typer.confirm(
+        "\nDo you want to set up the Docker environment?", default=True
+    ):
         # Set up Docker files first
         _setup_docker_files(cfg, community_only=community)
 
@@ -254,6 +282,22 @@ def vscode(cfg=None) -> None:
     success("VSCode configuration set up successfully!")
 
 
+def _fully_vendored(project_dir: Path) -> bool:
+    """True if the repo is fully vendored: ``addons.lock`` present and no
+    ``addons/`` symlink still points into ``.repos/``.
+
+    Such a repo needs no submodule checkout — its shared addons are committed real
+    files under ``vendored/``. A hybrid (still carries ``.repos`` symlinks) does
+    need its submodules, so this returns False there.
+    """
+    from odoo_dev.vendor.verify import hybrid_submodule_addons
+
+    project_dir = Path(project_dir)
+    return (project_dir / "addons.lock").exists() and not hybrid_submodule_addons(
+        project_dir
+    )
+
+
 def _init_submodules(cfg) -> None:
     """Initialize and update git submodules if present."""
     gitmodules = cfg.project_dir / ".gitmodules"
@@ -261,6 +305,10 @@ def _init_submodules(cfg) -> None:
     if not gitmodules.exists():
         return
 
+    if _fully_vendored(cfg.project_dir):
+        info("Fully vendored (addons.lock, no .repos symlinks); skipping submodule init.")
+        return
+
     success("Initializing git submodules...")
 
     result = subprocess.run(
@@ -303,6 +351,7 @@ def _setup_odoo_config(cfg, community_only: bool = False) -> None:
         [
             str(cfg.project_dir / "design-themes"),
             str(cfg.project_dir / "addons"),
+            str(cfg.project_dir / "vendored"),
         ]
     )
 
@@ -360,7 +409,9 @@ def _setup_docker_files(cfg, community_only: bool = False) -> None:
     _setup_docker_odoo_config(cfg, community_only=community_only)
 
 
-def _generate_docker_odoo_conf(community_only: bool = False) -> str:
+def _generate_docker_odoo_conf(
+    community_only: bool = False, has_vendored: bool = False
+) -> str:
     """Generate Docker-specific odoo.conf content."""
     # Build addons path for Docker (using /opt/project paths)
     addons_paths = [
@@ -378,6 +429,10 @@ def _generate_docker_odoo_conf(community_only: bool = False) -> str:
             "/opt/project/addons",
         ]
     )
+    # Only add vendored/ when the repo actually has it — an addons_path entry that
+    # doesn't exist makes Odoo warn on every boot.
+    if has_vendored:
+        addons_paths.append("/opt/project/vendored")
 
     return f"""[options]
 addons_path = {",".join(addons_paths)}
@@ -411,7 +466,12 @@ def _setup_docker_odoo_config(cfg, community_only: bool = False) -> None:
         return
 
     success("Creating Docker Odoo configuration file...")
-    conf_file.write_text(_generate_docker_odoo_conf(community_only=community_only))
+    has_vendored = (cfg.project_dir / "vendored").is_dir()
+    conf_file.write_text(
+        _generate_docker_odoo_conf(
+            community_only=community_only, has_vendored=has_vendored
+        )
+    )
     conf_file.chmod(0o600)
     success(f"Docker config file created at {conf_file}")