gOdoo-cli 0.17.0__tar.gz → 1.0.1__tar.gz

godoo_cli-1.0.1/.agents/skills/godoo-changeset-review/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: godoo-changeset-review
+description:
+  Review a broad gOdoo working-tree changeset for regressions, compatibility, and simplification across CLI, workspace,
+  and runtime boundaries. Use for whole-changeset reviews, not routine single-file fixes.
+---
+
+# gOdoo changeset review
+
+Establish the review baseline from staged, unstaged, and untracked files. Distinguish existing user work from edits made
+during the review; do not stage or revert unrelated files.
+
+Partition substantial reviews by contracts: source ownership and generated configuration, runtime/database behavior, and
+CLI/public interfaces. Load only the matching source-workspace or runtime skill for each partition. Give workers file
+ownership, the baseline, and the questions they must resolve; the parent owns shared validation and integration.
+Delegate review slots from the parent so nested reviewers cannot exhaust capacity.
+
+Trace changed behavior through its callers, command registration, environment options, tests, and documentation. Include
+new untracked modules. Check host/container boundaries and retained compatibility paths where the diff crosses them. A
+smaller file is not evidence of a simpler design; examine duplicated state, lock ownership, and failure recovery.
+
+Return actionable findings with file locations, a concrete trigger, and the affected contract. Separate demonstrated
+regressions from optional cleanup. Review alone does not authorize implementation, source synchronization, or runtime
+replacement.
+
+For authorized fixes, give the existing worker its in-scope failures to repair. Run focused checks during implementation
+and `make lint` / `make test` after integration. Add editor or live-runtime checks only when the changed behavior needs
+them. Report skipped or blocked validation separately from passing checks, and inspect worker evidence and the final
+diff without repeating the entire investigation.

godoo_cli-1.0.1/.agents/skills/godoo-editor-validation/SKILL.md

@@ -0,0 +1,26 @@
+---
+name: godoo-editor-validation
+description:
+  Validate gOdoo editor diagnostics, VS Code Problems, and debugpy attachment against resolved shared sources.
+---
+
+# gOdoo editor validation
+
+Read `docs/workspace.md`, then open the generated `<project>.code-workspace`.
+
+gOdoo sets `python.languageServer` to `None` so the installed Odoo IDE extension provides Python and Odoo analysis
+without a competing Pylance server. Keep the Python extension for interpreter selection and debugging. The generated
+`python.analysis.extraPaths` covers the resolved project, Odoo, third-party, and archive addon roots. The supported
+source mapping is the generated multi-root workspace plus its generated extra paths.
+
+Reload the window after generation, save representative project, Odoo, and addon files, then inspect VS Code Problems.
+Confirm each diagnostic refers to the intended selected host worktree. Problems validate editor analysis, not execution.
+
+Inspect exact editor diagnostics in VS Code's Problems panel. Do not require a repository-specific extension or claim
+that command-line lint and tests reproduce the aggregate Problems view. The Problems API is available only inside VS
+Code's extension host, and Odoo IDE does not provide a supported external diagnostics transport. Record this UI check as
+unverified when the active editor is unavailable.
+
+Start the downstream debug service separately, attach with the generated `gOdoo: attach` configuration, set a breakpoint
+in exercised code, and confirm the selected host/container mappings and local variables. Runtime startup belongs to
+downstream/runtime validation.

godoo_cli-1.0.1/.agents/skills/godoo-runtime-validation/SKILL.md

@@ -0,0 +1,54 @@
+---
+name: godoo-runtime-validation
+description:
+  Validate gOdoo runtime lifecycle and upstream-change adoption in downstream Compose projects, including installed
+  revision checks, init/launch, subprocess output, debugging, endpoints, and real Odoo integration tests.
+---
+
+# gOdoo runtime validation
+
+Resolve the gOdoo checkout and downstream project first. Read `docs/lifecycle.md`, `docs/downstream.md`, and the
+relevant implementation/tests in that gOdoo checkout. Read the downstream Make target, Dockerfile, and selected Compose
+files for the behavior under investigation.
+
+## Identify what is being tested
+
+Record the upstream revision and relevant uncommitted changes, the downstream revision, and its configured gOdoo
+dependency or pin. For an available built or running target, also establish the image ID and installed gOdoo revision
+from build evidence or package metadata. A host checkout, Dockerfile pin, or package version alone does not prove which
+commit is running. If the revision cannot be established, report that gap before drawing runtime conclusions.
+
+Keep Odoo/addon source provenance separate from the installed gOdoo CLI revision. Resolve the selected Compose project,
+services, source mounts, and database/filestore target; avoid dumping unrelated environment values.
+
+## Check downstream adoption
+
+Trace each relevant upstream contract change to its downstream consumer and focused validation: command flags,
+environment options, source paths, lifecycle hooks, or generated proxy configuration. Keep source and CLI behavior
+upstream; downstream owns images, Compose, mounts, runtime users, service ordering, and project hooks. Check whether the
+downstream pin includes the required fix before proposing another implementation.
+
+`runtime init` owns restore, bootstrap, and reconciliation as a one-shot job. `runtime launch` only starts prepared
+state. Keep `init` ahead of `app` with `service_completed_successfully`. gOdoo provides no downstream service
+orchestration.
+
+Use the downstream Make/Compose path for authorized runtime validation. Reuse host-resolved workspace paths rather than
+assembling a substitute container with guessed addon mounts. A pin change needs a rebuilt artifact and, when live
+verification is in scope, a recreated target before it establishes runtime behavior. Temporary source overlays prove
+only the overlaid configuration.
+
+Start the downstream debug service separately before attaching with generated `gOdoo: attach`. Report source checks,
+built-artifact checks, runtime startup, debugger attachment, lifecycle state, and endpoint results separately. Never
+start services merely to validate source/editor configuration. A compatibility review does not itself authorize
+rebuilds, resets, restores, or upgrades; use any existing authorization and resolve the target before stateful work.
+
+## When progress or logging is the problem
+
+Trace child stdout/stderr through gOdoo, the init service, and Compose. Check terminal and captured-output behavior
+where relevant, including native progress streams, feedback during quiet finite phases, and process exit status. Input
+reaching 100% does not establish that a restore finished. Captured-output tests do not prove terminal redraw; check the
+reported Make/Compose surface when authorized and available, otherwise name that remaining verification.
+
+Finish with the affected contracts, incompatibilities and their owning repository, the smallest required repair, and
+checks tied to the revision/environment actually tested. Stop a review when those findings and remaining verification
+steps are clear; perform repairs or runtime operations only within the requested scope.

godoo_cli-1.0.1/.agents/skills/godoo-source-workspaces/SKILL.md

@@ -0,0 +1,20 @@
+---
+name: godoo-source-workspaces
+description:
+  Work on gOdoo manifests, shared source roots, Git worktrees, source locks, archive caches, or generated editor
+  workspace and debug files.
+---
+
+# gOdoo source workspaces
+
+Read `docs/workspace.md` first. `odoo_manifest.yml` is authoritative and requires `odoo`; third-party prefixes are
+validated before locks or paths and cannot alter host/container depth. Git owns pools, worktrees, branches, locks, and
+archive caches below the shared source root. Never hand-edit managed worktrees or generated `.godoo/` and workspace
+files.
+
+Run `workspace sync` only with authority for the shared source root; it may reset verified managed worktrees.
+`workspace configure` regenerates state from checked sources. `workspace check` is offline and read-only. Run workspace
+commands from the project directory because that cwd supplies `.env` and manifest-relative paths.
+
+Use the actual owning tests: `test_workspace_git.py` and `test_workspace_layout.py` for Git identity/confinement,
+`test_workspace.py` for generated state, and `test_workspace_storage.py` for storage.

godoo_cli-1.0.1/.dockerignore

@@ -0,0 +1,18 @@
+.env
+.git/
+dist/
+.env.*
+!.env.sample
+.venv/
+.vscode/
+*.code-workspace
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+**/__pycache__/
+**/*.py[cod]
+.coverage
+coverage.xml
+htmlcov/
+junit/
+.godoo/*

godoo_cli-1.0.1/.env.sample

@@ -0,0 +1,34 @@
+# Required workspace source root: absolute, outside this project, reachable by Docker Desktop.
+GODOO_SOURCES_ROOT=/Users/you/dev/sources
+# ODOO_MANIFEST defaults to ./odoo_manifest.yml.
+
+# Required runtime/database values. Provide downstream secrets outside source control.
+ODOO_MAIN_DB=odoo
+ODOO_DB_FILTER=odoo
+ODOO_DB_PASSWORD=change-me
+ODOO_DB_USER=odoo_user
+ODOO_DB_HOST=db
+ODOO_DB_PORT=5432
+
+# Runtime path overrides; representative downstream defaults are explicit.
+# ODOO_MAIN_FOLDER=/odoo/odoo
+# ODOO_WORKSPACE_ADDON_LOCATION=/odoo/godoo_workspace/addons
+# ODOO_CONF_PATH=/odoo/config/odoo.conf
+# ODOO_DATA_DIR=/var/lib/odoo
+# GODOO_X_SENDFILE=true
+# GODOO_REPORT_URL=http://nginx
+# GODOO_NGINX_CONFIG_PATH=/odoo/config/nginx-static.conf
+
+# Runtime lifecycle overrides. Hook directories must exist in the runtime environment.
+# GODOO_RUNTIME_SEED=/odoo_restore/runtime.zip
+# GODOO_VERIFY_ARCHIVE_CRC=false
+# GODOO_HOOK_DIRS=/odoo/godoo_workspace/hooks
+# GODOO_ENVIRONMENT=development
+# GODOO_RECONCILE_UPGRADE_PATH=/odoo/godoo_workspace/migration/upgrade
+# GODOO_RECONCILE_PRE_UPGRADE_SCRIPTS=/odoo/godoo_workspace/migration/pre-upgrade.py
+
+# Optional XML-RPC connection.
+# ODOO_RPC_HOST=http://localhost:8069
+# ODOO_RPC_USER=admin
+# ODOO_RPC_PASSWORD=admin
+# ODOO_RPC_DB_NAME=odoo

godoo_cli-1.0.1/.github/workflows/README.md

@@ -0,0 +1,88 @@
+# CI and releases
+
+[Documentation](../../README.md#documentation) · [Repository architecture](../../docs/architecture.md)
+
+CI checks the host package. Release workflows publish Python distributions to PyPI and create a GitHub Release; they do
+not publish runtime images or host-adapter bundles.
+
+## Workflow map
+
+| Workflow                                   | Trigger                                            | Result                                                           |
+| ------------------------------------------ | -------------------------------------------------- | ---------------------------------------------------------------- |
+| [Quality](quality.yml)                     | Pull request, push to `main`, or manual dispatch   | Python 3.11/3.12 checks and test/coverage artifacts              |
+| [Version bump](version-bump.yml)           | Manual dispatch with a bump type                   | Version change on `release/<version>` and an editable release PR |
+| [Release and publish](version-publish.yml) | Merged PR into `main` carrying the `release` label | Verified Python package publication, tag, and GitHub Release     |
+
+## Quality checks
+
+Arrows show the steps in each Python job. The final artifact upload uses `if: always()`, so it is also attempted when an
+earlier step fails; reports may be absent if their producing step never ran. The PR author diagnoses failures, and the
+reviewer checks the linked Actions results before accepting the change.
+
+```mermaid
+flowchart TD
+    Trigger["GitHub receives a pull request,<br/>a main push, or a manual Quality dispatch"]
+    Trigger --> Matrix["GitHub Actions runs two independent jobs:<br/>Python 3.11 and Python 3.12"]
+    Matrix --> Install["Each job: install locked uv dependencies"]
+    Install --> Wheel["Build wheel and install it in a fresh environment;<br/>check package import and CLI help outside checkout"]
+    Wheel --> Lint["make lint<br/>Check source rules and formatting"]
+    Lint --> Test["make test<br/>Run repository tests and produce JUnit and coverage XML"]
+    Test --> Upload["Upload test-results artifact<br/>for that Python version"]
+    Install -.->|if a later step fails, still attempt upload| Upload
+    Upload --> Review["PR author and reviewer inspect failures<br/>and test artifacts on the GitHub Actions run"]
+```
+
+The wheel smoke test installs into a fresh environment and checks imports and CLI help outside the checkout. The
+workflow installs PostgreSQL development headers and copies `.env.sample` for repository tests. JUnit and coverage
+upload is attempted even after failure. Real Odoo/PostgreSQL integration tests remain opt-in.
+
+```bash
+# Reproduce the main host checks locally after configuring the project .env.
+uv sync --locked
+make lint
+make test
+
+# Inspect recent CI runs with GitHub CLI.
+gh run list --workflow quality.yml --limit 5
+```
+
+## Create a release
+
+The maintainer chooses and reviews the release; GitHub Actions performs the version change and publication steps. The
+release notes are the PR description. They are separate from the JUnit test and coverage artifacts above.
+
+```mermaid
+flowchart TD
+    Maintainer["Maintainer manually runs<br/>Version Bump with a chosen bump type"]
+    Maintainer --> Bump["version-bump.yml: update package version,<br/>push release/version branch, and open release PR"]
+    Bump --> Review["Maintainer edits the PR's release notes<br/>and reviews its diff and available CI results"]
+    Review --> Merge["Maintainer merges the release-labeled PR into main"]
+    Merge --> Verify["version-publish.yml verifies release identity:<br/>repository, branch, PR title, version, merge commit, and tag"]
+    Verify --> Publish["Build Python distributions<br/>and publish them to PyPI"]
+    Publish --> Tag["Create vVERSION tag at the merge commit,<br/>or verify an existing tag points there"]
+    Tag --> Release["Create GitHub Release using the merged PR description;<br/>preserve an existing release"]
+```
+
+```bash
+# Maintainers: choose patch, minor, major, rc, beta, or alpha.
+# This dispatch creates and pushes a release branch and opens a PR.
+gh workflow run version-bump.yml --ref main -f bump_type=patch
+```
+
+Edit the generated PR description before merging: it becomes the release notes. Keep these identities aligned:
+
+| Identity          | Required value                      |
+| ----------------- | ----------------------------------- |
+| Source repository | This repository                     |
+| Target branch     | `main`                              |
+| PR title          | `🔖 Release <version>`              |
+| Source branch     | `release/<version>`                 |
+| Package version   | The same version, verified by Hatch |
+| Tag               | `v<version>` at the PR merge commit |
+
+The publication workflow rejects an existing tag pointing elsewhere. It publishes to PyPI before creating the tag and
+GitHub Release. Existing GitHub Releases keep their descriptions; alpha, beta, and release-candidate versions are marked
+as prereleases.
+
+If a run fails, inspect the failed step and existing PyPI/tag/release state before retrying that run. Do not move an
+existing release tag to bypass a mismatch.

godoo_cli-1.0.1/.github/workflows/quality.yml

@@ -0,0 +1,52 @@
+name: Quality
+
+on:
+  workflow_dispatch:
+  push:
+    branches: [main]
+  pull_request:
+
+concurrency:
+  group: quality-${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+
+jobs:
+  QualityChecks:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.11", "3.12"]
+    steps:
+      - uses: actions/checkout@v5
+      - uses: astral-sh/setup-uv@v6
+        with:
+          python-version: ${{ matrix.python-version }}
+          enable-cache: true
+      - run: sudo apt-get update && sudo apt-get install -y libpq-dev
+      - run: uv sync --locked
+      - name: Build and smoke test wheel
+        run: |
+          set -eu
+          smoke_dir="$(mktemp -d)"
+          trap 'rm -rf "$smoke_dir"' EXIT
+          uv build --wheel --out-dir "$smoke_dir"
+          uv venv "$smoke_dir/venv"
+          uv pip install --python "$smoke_dir/venv/bin/python" "$smoke_dir"/*.whl
+          cd "$smoke_dir"
+          env -u PYTHONPATH "$smoke_dir/venv/bin/python" -c "import godoo_cli"
+          env -u PYTHONPATH "$smoke_dir/venv/bin/godoo" --help
+      - run: cp .env.sample .env
+      - run: make lint
+      - run: make test PYTEST_ARGS="--junitxml=junit/pytest-results.xml --cov-report=xml -o junit_family=legacy"
+        env:
+          GODOO_SOURCES_ROOT: ""
+      - uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: test-results-${{ matrix.python-version }}
+          path: |
+            junit/pytest-results.xml
+            coverage.xml

{godoo_cli-0.17.0 → godoo_cli-1.0.1}/.github/workflows/version-bump.yml

@@ -69,7 +69,7 @@ jobs:
           # Commit and push the changes
           git add -A
           git commit -m "🔖 Bump version ${{ steps.version_info.outputs.CURRENT_VERSION }} → $NEW_VERSION"
-          git push --force origin "$RELEASE_BRANCH"
+          git push origin "$RELEASE_BRANCH"
 
       - name: Generate Release Notes
         id: changelog

godoo_cli-1.0.1/.github/workflows/version-publish.yml

@@ -0,0 +1,144 @@
+name: Release and Publish
+
+on:
+  pull_request:
+    types: [closed]
+    branches: [main]
+
+permissions:
+  contents: write
+  pull-requests: read
+
+concurrency:
+  group: release-${{ github.event.pull_request.head.ref }}
+  cancel-in-progress: false
+
+jobs:
+  release:
+    if: >-
+      github.event.pull_request.merged == true &&
+      contains(github.event.pull_request.labels.*.name, 'release')
+    runs-on: ubuntu-latest
+    env:
+      PR_TITLE: ${{ github.event.pull_request.title }}
+      PR_HEAD_REF: ${{ github.event.pull_request.head.ref }}
+      PR_HEAD_REPO: ${{ github.event.pull_request.head.repo.full_name }}
+      EXPECTED_REPO: ${{ github.repository }}
+      MERGE_SHA: ${{ github.event.pull_request.merge_commit_sha }}
+      PR_BODY: ${{ github.event.pull_request.body }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          ref: ${{ github.event.pull_request.merge_commit_sha }}
+
+      - name: Verify release pull request
+        id: release
+        shell: bash
+        run: |
+          set -euo pipefail
+          if [[ "$PR_HEAD_REPO" != "$EXPECTED_REPO" ]]; then
+            echo "Release pull request must come from this repository." >&2
+            exit 1
+          fi
+          if [[ "$PR_TITLE" != "🔖 Release "* ]]; then
+            echo "Release pull request title must start with '🔖 Release '." >&2
+            exit 1
+          fi
+          RELEASE_VERSION="${PR_TITLE#🔖 Release }"
+          if [[ ! "$RELEASE_VERSION" =~ ^[0-9]+\.[0-9]+\.[0-9]+(a[0-9]+|b[0-9]+|rc[0-9]+)?$ ]]; then
+            echo "Release pull request title must end with a semantic version." >&2
+            exit 1
+          fi
+          if [[ "$PR_HEAD_REF" != "release/$RELEASE_VERSION" ]]; then
+            echo "Expected release branch release/$RELEASE_VERSION, got $PR_HEAD_REF." >&2
+            exit 1
+          fi
+          if [[ "$(git rev-parse HEAD)" != "$MERGE_SHA" ]]; then
+            echo "Checked out commit does not match the release merge commit." >&2
+            exit 1
+          fi
+          echo "version=$RELEASE_VERSION" >> "$GITHUB_OUTPUT"
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install Hatch
+        uses: pypa/hatch@install
+
+      - name: Verify package version
+        env:
+          RELEASE_VERSION: ${{ steps.release.outputs.version }}
+        run: |
+          set -euo pipefail
+          VERSION="$(hatch version)"
+          if [[ "$VERSION" != "$RELEASE_VERSION" ]]; then
+            echo "Version mismatch: project has $VERSION, release pull request is $RELEASE_VERSION." >&2
+            exit 1
+          fi
+
+      - name: Preflight existing Git tag
+        env:
+          RELEASE_VERSION: ${{ steps.release.outputs.version }}
+        run: |
+          set -euo pipefail
+          TAG="v$RELEASE_VERSION"
+          git fetch --tags origin
+          if git show-ref --verify --quiet "refs/tags/$TAG"; then
+            TAG_COMMIT="$(git rev-parse "$TAG^{commit}")"
+            if [[ "$TAG_COMMIT" != "$MERGE_SHA" ]]; then
+              echo "Existing tag $TAG points to $TAG_COMMIT, expected $MERGE_SHA." >&2
+              exit 1
+            fi
+          fi
+
+      - name: Build distributions
+        run: hatch build
+
+      - name: Publish to PyPI
+        env:
+          HATCH_INDEX_USER: __token__
+          HATCH_INDEX_AUTH: ${{ secrets.PYPI_TOKEN }}
+        run: hatch publish
+
+      - name: Create or verify Git tag
+        env:
+          RELEASE_VERSION: ${{ steps.release.outputs.version }}
+        run: |
+          set -euo pipefail
+          TAG="v$RELEASE_VERSION"
+          git fetch --tags origin
+          if git show-ref --verify --quiet "refs/tags/$TAG"; then
+            TAG_COMMIT="$(git rev-parse "$TAG^{commit}")"
+            if [[ "$TAG_COMMIT" != "$MERGE_SHA" ]]; then
+              echo "Existing tag $TAG points to $TAG_COMMIT, expected $MERGE_SHA." >&2
+              exit 1
+            fi
+          else
+            git config user.name "github-actions[bot]"
+            git config user.email "github-actions[bot]@users.noreply.github.com"
+            git tag -a "$TAG" "$MERGE_SHA" -m "Release $TAG"
+            git push origin "refs/tags/$TAG"
+          fi
+
+      - name: Create GitHub Release if missing
+        env:
+          GH_TOKEN: ${{ github.token }}
+          RELEASE_VERSION: ${{ steps.release.outputs.version }}
+        shell: bash
+        run: |
+          set -euo pipefail
+          TAG="v$RELEASE_VERSION"
+          if gh release view "$TAG" >/dev/null 2>&1; then
+            echo "GitHub Release $TAG already exists; preserving its description."
+            exit 0
+          fi
+          NOTES_FILE="$RUNNER_TEMP/release-notes.md"
+          printf '%s' "$PR_BODY" > "$NOTES_FILE"
+          RELEASE_FLAGS=()
+          if [[ "$RELEASE_VERSION" =~ (a[0-9]+|b[0-9]+|rc[0-9]+)$ ]]; then
+            RELEASE_FLAGS+=(--prerelease)
+          fi
+          gh release create "$TAG" --verify-tag --title "$TAG" --notes-file "$NOTES_FILE" "${RELEASE_FLAGS[@]}"

{godoo_cli-0.17.0 → godoo_cli-1.0.1}/.gitignore

@@ -1,11 +1,15 @@
 .DS_Store
+node_modules/
+!.vscode/settings.json
 import
-pyrightconfig.json
 remote_instance_data/
 config/odoo.conf
 *.pass
 *.nogit.*
 .env
+.godoo/
+/*.code-workspace
+/pyrightconfig.json
 *:Zone.Identifier
 *.xlsx
 ### Python ###
@@ -116,7 +120,6 @@ celerybeat.pid
 *.sage.py
 
 # Environments
-.env
 .venv
 env/
 venv/

{godoo_cli-0.17.0 → godoo_cli-1.0.1}/.pre-commit-config.yaml

@@ -49,9 +49,9 @@ repos:
         args: ["--fix"]
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.10.0
+    rev: v0.16.5
     hooks:
-      - id: ruff
+      - id: ruff-check
         args: [--fix]
       - id: ruff-format
 
@@ -61,5 +61,5 @@ repos:
       - id: prettier
         name: prettier
         additional_dependencies:
-          - "prettier@2.7.1"
+          - "prettier@3.7.4"
         files: \.(css|htm|html|js|json|jsx|less|md|scss|toml|ts|yaml|yml)$

godoo_cli-1.0.1/.vscode/extensions.json

@@ -0,0 +1,16 @@
+{
+  "recommendations": [
+    "ms-python.python",
+    "ms-python.pylint",
+    "charliermarsh.ruff",
+    "esbenp.prettier-vscode",
+    "redhat.vscode-xml",
+    "mtxr.sqltools",
+    "mtxr.sqltools-driver-pg",
+    "jigar-patel.odoosnippets",
+    "trinhanhngoc.vscode-odoo",
+    "Odoo.owl-vision",
+    "eamodio.gitlens",
+    "github.vscode-github-actions"
+  ]
+}

godoo_cli-1.0.1/.vscode/settings.json

@@ -0,0 +1,35 @@
+{
+  "python.testing.unittestEnabled": false,
+  "python.testing.pytestEnabled": false,
+  "xml.symbols.enabled": false,
+  "python.languageServer": "Pylance",
+  "python.defaultInterpreterPath": "${workspaceFolder}/.venv/bin/python",
+  "ruff.path": ["${workspaceFolder}/.venv/bin/ruff"],
+  "ruff.configurationPreference": "filesystemFirst",
+  "prettier.prettierPath": "./node_modules/prettier",
+  "[python]": {
+    "editor.defaultFormatter": "charliermarsh.ruff",
+    "editor.formatOnSave": true,
+    "editor.codeActionsOnSave": {
+      "source.fixAll.ruff": "explicit",
+      "source.organizeImports.ruff": "explicit"
+    }
+  },
+  "editor.defaultFormatter": "esbenp.prettier-vscode",
+  "editor.formatOnSave": true,
+  "[json]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "[markdown]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "[yaml]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "[dockercompose]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "[github-actions-workflow]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  }
+}

godoo_cli-1.0.1/.vscode/tasks.json

@@ -0,0 +1,27 @@
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "label": "gOdoo: lint",
+      "type": "shell",
+      "command": "make",
+      "args": ["lint"],
+      "options": {
+        "cwd": "${workspaceFolder}"
+      },
+      "problemMatcher": [],
+      "group": "build"
+    },
+    {
+      "label": "gOdoo: tests",
+      "type": "shell",
+      "command": "make",
+      "args": ["test"],
+      "options": {
+        "cwd": "${workspaceFolder}"
+      },
+      "problemMatcher": [],
+      "group": "test"
+    }
+  ]
+}

godoo_cli-1.0.1/AGENTS.md

@@ -0,0 +1,37 @@
+# gOdoo repository contracts
+
+Keep only repo-specific behavior that code and tooling do not make obvious. Prefer existing patterns and the smallest
+coherent change.
+
+## Execution
+
+- The host owns Git, workspace commands, VS Code, linting, and the development `.venv`. Odoo runs in the selected
+  environment (`VIRTUAL_ENV`, otherwise the project `.venv`). Downstream owns Docker and system packages; gOdoo never
+  detects or orchestrates containers.
+- Load the matching skill under `.agents/skills/` for source-workspace or runtime work; load both only when a change
+  crosses those boundaries.
+- Use `godoo-editor-validation` for VS Code diagnostics and development-flow checks, and `godoo-changeset-review` for
+  whole-changeset reviews.
+- Keep shared Docker validation sequential.
+
+## Code and CLI
+
+- Every shell script under `scripts/` has a purpose comment immediately below its shebang.
+- Operational Python modules define and use `LOGGER = logging.getLogger(__name__)`; passive metadata, value-type, and
+  re-export modules do not carry unused loggers. Reserve `rich.print()` for user-facing output.
+- Export command groups through `src/godoo_cli/commands/__init__.py` and attach them in
+  `src/godoo_cli/commands/root.py`. Reuse env-first option metadata from `src/godoo_cli/commands/common.py`; new options
+  need an environment fallback unless there is a concrete reason not to provide one.
+- For Typer commands, keep behavior in the function docstring and parameter help in `Annotated` metadata.
+
+## Validation
+
+- Implementers run only focused proof for owned behavior; they never run full `make lint` or `make test` unless
+  explicitly the integration owner.
+- The coordinator or named integration owner runs `make lint` and `make test` sequentially on the final tree, plus
+  applicable editor, workspace, runtime, and live-surface checks.
+- For whole-changeset review, the validator receives a coordinator-generated current staged, unstaged, and untracked
+  diff snapshot and coverage manifest before implementer reports or prior findings; it performs an independent first
+  pass, then may consume those reports for a targeted second pass.
+- Validate relevant Python typing boundaries and editor configuration with the editor-validation skill; lint and unit
+  tests do not establish that editor diagnostics are clear.