introduce run —quiet-pull to align with up

Signed-off-by: Nicolas De Loof <nicolas.deloof@gmail.com>

.dockerignore

@@ -1 +1,3 @@
+.git/
 bin/
+dist/

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,64 @@
+<!--
+If you are reporting a new issue, make sure that we do not have any duplicates
+already open. You can ensure this by searching the issue list for this
+repository. If there is a duplicate, please close your issue and add a comment
+to the existing issue instead.
+
+If you suspect your issue is a bug, please edit your issue description to
+include the BUG REPORT INFORMATION shown below. If you fail to provide this
+information within 7 days, we cannot debug your issue and will close it. We
+will, however, reopen it if you later provide the information.
+
+For more information about reporting issues, see
+https://github.com/docker/compose-cli/blob/master/CONTRIBUTING.md#reporting-other-issues
+
+---------------------------------------------------
+GENERAL SUPPORT INFORMATION
+---------------------------------------------------
+
+The GitHub issue tracker is for bug reports and feature requests.
+General support can be found at the following locations:
+
+- Docker Support Forums - https://forums.docker.com
+- Docker Community Slack - https://dockr.ly/slack
+- Post a question on StackOverflow, using the Docker tag
+
+---------------------------------------------------
+BUG REPORT INFORMATION
+---------------------------------------------------
+Use the commands below to provide key information from your environment:
+You do NOT have to include this information if this is a FEATURE REQUEST
+-->
+
+**Description**
+
+<!--
+Briefly describe the problem you are having in a few paragraphs.
+-->
+
+**Steps to reproduce the issue:**
+1.
+2.
+3.
+
+**Describe the results you received:**
+
+
+**Describe the results you expected:**
+
+
+**Additional information you deem important (e.g. issue happens only occasionally):**
+
+**Output of `docker compose version`:**
+
+```
+(paste your output here)
+```
+
+**Output of `docker info`:**
+
+```
+(paste your output here)
+```
+
+**Additional environment details:**

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -1,49 +0,0 @@
-name: 🐞 Bug
-description: File a bug/issue
-title: "[BUG] <title>"
-labels: ['status/0-triage', 'kind/bug']
-body:
-  - type: textarea
-    attributes:
-      label: Description
-      description: |
-        Briefly describe the problem you are having.
-
-        Include both the current behavior (what you are seeing) as well as what you expected to happen.
-    validations:
-      required: true
-  - type: textarea
-    attributes:
-      label: Steps To Reproduce
-      description: Steps to reproduce the behavior.
-      placeholder: |
-        1. In this environment...
-        2. With this config...
-        3. Run '...'
-        4. See error...
-    validations:
-      required: false
-  - type: textarea
-    attributes:
-      label: Compose Version
-      description: |
-        Paste output of `docker compose version` and `docker-compose version`.
-      render: Text
-    validations:
-      required: false
-  - type: textarea
-    attributes:
-      label: Docker Environment
-      description: Paste output of `docker info`.
-      render: Text
-    validations:
-      required: false
-  - type: textarea
-    attributes:
-      label: Anything else?
-      description: |
-        Links? References? Anything that will give us more context about the issue you are encountering!
-
-        Tip: You can attach images or log files by clicking this area to highlight it and then dragging files in.
-    validations:
-      required: false

.github/ISSUE_TEMPLATE/config.yml

@@ -1,11 +0,0 @@
-blank_issues_enabled: true
-contact_links:
-  - name: Docker Community Slack
-    url: https://dockr.ly/slack
-    about: 'Use the #docker-compose channel'
-  - name: Docker Support Forums
-    url: https://forums.docker.com/c/open-source-projects/compose/15
-    about: 'Use the "Open Source Projects > Compose" category'
-  - name: 'Ask on Stack Overflow'
-    url: https://stackoverflow.com/questions/tagged/docker-compose
-    about: 'Use the [docker-compose] tag when creating new questions'

.github/ISSUE_TEMPLATE/feature_request.yaml

@@ -1,13 +0,0 @@
-name: Feature request
-description: Missing functionality? Come tell us about it!
-labels:
-  - kind/feature
-  - status/0-triage
-body:
-  - type: textarea
-    id: description
-    attributes:
-      label: Description
-      description: What is the feature you want to see?
-    validations:
-      required: true

.github/PULL_REQUEST_TEMPLATE.md

@@ -3,4 +3,4 @@
 **Related issue**
 <!-- If this is a bug fix, make sure your description includes "fixes #xxxx", or "closes #xxxx" -->
 
-**(not mandatory) A picture of a cute animal, if possible in relation to what you did**
+**(not mandatory) A picture of a cute animal, if possible in relation with what you did**

.github/dependabot.yml

@@ -1,18 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: gomod
-    directory: /
-    schedule:
-      interval: daily
-    ignore:
-      # docker/buildx + docker/cli + docker/docker require coordination to
-      # ensure compatibility between them
-      - dependency-name: "github.com/docker/buildx"
-        # buildx is still 0.x
-        update-types: ["version-update:semver-minor"]
-      - dependency-name: "github.com/docker/cli"
-        # docker/cli uses CalVer rather than SemVer
-        update-types: ["version-update:semver-major", "version-update:semver-minor"]
-      - dependency-name: "github.com/docker/docker"
-        # docker/docker uses CalVer rather than SemVer
-        update-types: ["version-update:semver-major", "version-update:semver-minor"]

.github/stale.yml

@@ -12,7 +12,7 @@ onlyLabels: []
 
 # Issues or Pull Requests with these labels will never be considered stale. Set to `[]` to disable
 exemptLabels:
-  - "kind/feature"
+  - "enhancement ✨"
 
 # Set to true to ignore issues in a project (defaults to false)
 exemptProjects: false

.github/workflows/artifacts.yml

@@ -0,0 +1,57 @@
+name: Publish Artifacts
+on:
+  issue_comment:
+    types: [created]
+jobs:
+  publish-artifacts:
+    if: github.event.issue.pull_request != '' && contains(github.event.comment.body, '/generate-artifacts')
+    runs-on: ubuntu-latest
+    steps:
+      - name: Set up Go 1.17
+        uses: actions/setup-go@v2
+        with:
+          go-version: 1.17
+        id: go
+
+      - name: Checkout code into the Go module directory
+        uses: actions/checkout@v2
+
+      - uses: actions/cache@v2
+        with:
+          path: ~/go/pkg/mod
+          key: go-${{ hashFiles('**/go.sum') }}
+
+      - name: Build cross platform compose-plugin binaries
+        run: make -f builder.Makefile cross
+
+      - name: Upload macos-amd64 binary
+        uses: actions/upload-artifact@v2
+        with:
+          name: docker-compose-darwin-amd64
+          path: ${{ github.workspace }}/bin/docker-compose-darwin-amd64
+
+      - name: Upload macos-arm64 binary
+        uses: actions/upload-artifact@v2
+        with:
+          name: docker-compose-darwin-arm64
+          path: ${{ github.workspace }}/bin/docker-compose-darwin-arm64
+
+      - name: Upload linux-amd64 binary
+        uses: actions/upload-artifact@v2
+        with:
+          name: docker-compose-linux-amd64
+          path: ${{ github.workspace }}/bin/docker-compose-linux-amd64
+
+      - name: Upload windows-amd64 binary
+        uses: actions/upload-artifact@v2
+        with:
+          name: docker-compose-windows-amd64.exe
+          path: ${{ github.workspace }}/bin/docker-compose-windows-amd64.exe
+
+      - name: Update comment
+        uses: peter-evans/create-or-update-comment@v1
+        with:
+          comment-id: ${{ github.event.comment.id }}
+          body: |
+            This PR can be tested using [binaries](https://github.com/docker/compose-cli/actions/runs/${{ github.run_id }}).
+          reactions: eyes

.github/workflows/ci.yml

@@ -1,234 +1,102 @@
-name: ci
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
+name: Continuous integration
 
 on:
   push:
     branches:
-      - 'v2'
-    tags:
-      - 'v*'
+      - v2
   pull_request:
-  workflow_dispatch:
-    inputs:
-      debug_enabled:
-        description: 'To run with tmate enter "debug_enabled"'
-        required: false
-        default: "false"
-
-env:
-  DESTDIR: "./bin"
-  DOCKER_CLI_VERSION: "20.10.17"
-
-permissions:
-  contents: read # to fetch code (actions/checkout)
 
 jobs:
-  prepare:
-    runs-on: ubuntu-latest
-    outputs:
-      matrix: ${{ steps.platforms.outputs.matrix }}
-    steps:
-      -
-        name: Checkout
-        uses: actions/checkout@v3
-      -
-        name: Create matrix
-        id: platforms
-        run: |
-          echo ::set-output name=matrix::$(docker buildx bake binary-cross --print | jq -cr '.target."binary-cross".platforms')
-      -
-        name: Show matrix
-        run: |
-          echo ${{ steps.platforms.outputs.matrix }}
-
-  validate:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        target:
-          - lint
-          - validate-go-mod
-          - validate-headers
-          - validate-docs
-    steps:
-      -
-        name: Checkout
-        uses: actions/checkout@v3
-      -
-        name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
-      -
-        name: Run
-        run: |
-          make ${{ matrix.target }}
-
-  binary:
-    runs-on: ubuntu-latest
-    needs:
-      - prepare
-    strategy:
-      fail-fast: false
-      matrix:
-        platform: ${{ fromJson(needs.prepare.outputs.matrix) }}
-    steps:
-      -
-        name: Prepare
-        run: |
-          platform=${{ matrix.platform }}
-          echo "PLATFORM_PAIR=${platform//\//-}" >> $GITHUB_ENV
-      -
-        name: Checkout
-        uses: actions/checkout@v3
-      -
-        name: Set up QEMU
-        uses: docker/setup-qemu-action@v2
-      -
-        name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
-      -
-        name: Build
-        uses: docker/bake-action@v2
-        with:
-          targets: release
-          set: |
-            *.platform=${{ matrix.platform }}
-            *.cache-from=type=gha,scope=binary-${{ env.PLATFORM_PAIR }}
-            *.cache-to=type=gha,scope=binary-${{ env.PLATFORM_PAIR }},mode=max
-      -
-        name: Upload artifacts
-        uses: actions/upload-artifact@v3
-        with:
-          name: compose
-          path: ${{ env.DESTDIR }}/*
-          if-no-files-found: error
-
-  test:
-    runs-on: ubuntu-latest
-    steps:
-      -
-        name: Checkout
-        uses: actions/checkout@v3
-      -
-        name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
-      -
-        name: Test
-        uses: docker/bake-action@v2
-        with:
-          targets: test
-          set: |
-            *.cache-from=type=gha,scope=test
-            *.cache-to=type=gha,scope=test
-
-  e2e:
+  lint:
+    name: Lint
     runs-on: ubuntu-latest
     env:
-      DESTDIR: "./bin/build"
-    strategy:
-      fail-fast: false
-      matrix:
-        mode:
-          - plugin
-          - standalone
+      GO111MODULE: "on"
     steps:
-      -
-        name: Checkout
-        uses: actions/checkout@v3
-      -
-        name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
-      -
-        name: Set up Go
-        uses: actions/setup-go@v3
+      - name: Set up Go 1.17
+        uses: actions/setup-go@v2
         with:
-          go-version-file: 'go.mod'
-          check-latest: true
-          cache: true
-      -
-        name: Setup docker CLI
-        run: |
-          curl https://download.docker.com/linux/static/stable/x86_64/docker-${DOCKER_CLI_VERSION}.tgz | tar xz
-          sudo cp ./docker/docker /usr/bin/ && rm -rf docker && docker version
-      -
-        name: Build
-        uses: docker/bake-action@v2
-        with:
-          targets: binary
-          set: |
-            *.cache-from=type=gha,scope=binary-linux-amd64
-            *.cache-from=type=gha,scope=binary-e2e-${{ matrix.mode }}
-            *.cache-to=type=gha,scope=binary-e2e-${{ matrix.mode }},mode=max
+          go-version: 1.17
+        id: go
+
+      - name: Checkout code into the Go module directory
+        uses: actions/checkout@v2
+
+      - name: Validate go-mod is up-to-date and license headers
+        run: make validate
+
+      - name: Run golangci-lint
         env:
           BUILD_TAGS: e2e
-      -
-        name: Setup tmate session
-        if: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.debug_enabled }}
-        uses: mxschmitt/action-tmate@8b4e4ac71822ed7e0ad5fb3d1c33483e9e8fb270 # v3.11
-        with:
-          limit-access-to-actor: true
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-      -
-        name: Test plugin mode
-        if: ${{ matrix.mode == 'plugin' }}
         run: |
-          make e2e-compose
-      -
-        name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v3
-      -
-        name: Test standalone mode
-        if: ${{ matrix.mode == 'standalone' }}
-        run: |
-          rm -f /usr/local/bin/docker-compose
-          cp bin/build/docker-compose /usr/local/bin
-          make e2e-compose-standalone
-
-  release:
-    permissions:
-      contents: write # to create a release (ncipollo/release-action)
+          curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sudo sh -s -- -b /usr/bin/ v1.39.0
+          make -f builder.Makefile lint
 
+  # only on main branch, costs too much for the gain on every PR
+  validate-cross-build:
+    name: Validate cross build
     runs-on: ubuntu-latest
-    needs:
-      - binary
+    if: github.ref == 'refs/heads/main'
+    env:
+      GO111MODULE: "on"
     steps:
-      -
-        name: Checkout
-        uses: actions/checkout@v3
-      -
-        name: Download artifacts
-        uses: actions/download-artifact@v3
+      - name: Set up Go 1.17
+        uses: actions/setup-go@v2
         with:
-          name: compose
-          path: ${{ env.DESTDIR }}
-      -
-        name: Create checksums
-        working-directory: ${{ env.DESTDIR }}
-        run: |
-          find . -type f -print0 | sort -z | xargs -r0 shasum -a 256 -b | sed 's# \*\./# *#' > $RUNNER_TEMP/checksums.txt
-          shasum -a 256 -U -c $RUNNER_TEMP/checksums.txt
-          mv $RUNNER_TEMP/checksums.txt .
-          cat checksums.txt | while read sum file; do echo "$sum $file" > ${file#\*}.sha256; done
-      -
-        name: License
-        run: cp packaging/* ${{ env.DESTDIR }}/
-      -
-        name: List artifacts
-        run: |
-          tree -nh ${{ env.DESTDIR }}
-      -
-        name: Check artifacts
-        run: |
-          find ${{ env.DESTDIR }} -type f -exec file -e ascii -- {} +
-      -
-        name: GitHub Release
-        if: startsWith(github.ref, 'refs/tags/v')
-        uses: ncipollo/release-action@58ae73b360456532aafd58ee170c045abbeaee37 # v1.10.0
+          go-version: 1.17
+        id: go
+
+      - name: Checkout code into the Go module directory
+        uses: actions/checkout@v2
+
+      - uses: actions/cache@v2
         with:
-          artifacts: ${{ env.DESTDIR }}/*
-          generateReleaseNotes: true
-          draft: true
-          token: ${{ secrets.GITHUB_TOKEN }}
+          path: ~/go/pkg/mod
+          key: go-${{ hashFiles('**/go.sum') }}
+
+      # Ensure we don't discover cross platform build issues at release time.
+      # Time used to build linux here is gained back in the build for local E2E step
+      - name: Build packages
+        run: make -f builder.Makefile cross
+
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    env:
+      GO111MODULE: "on"
+    steps:
+      - name: Set up Go 1.17
+        uses: actions/setup-go@v2
+        with:
+          go-version: 1.17
+        id: go
+
+      - name: Set up gosum
+        run: |
+          go get -u gotest.tools/gotestsum
+
+      - name: Setup docker CLI
+        run: |
+          curl https://download.docker.com/linux/static/stable/x86_64/docker-20.10.3.tgz | tar xz
+          sudo cp ./docker/docker /usr/bin/ && rm -rf docker && docker version
+
+      - name: Checkout code into the Go module directory
+        uses: actions/checkout@v2
+
+      - uses: actions/cache@v2
+        with:
+          path: ~/go/pkg/mod
+          key: go-${{ hashFiles('**/go.sum') }}
+
+      - name: Test
+        env:
+          BUILD_TAGS: kube
+        run: make -f builder.Makefile test
+
+      - name: Build for local E2E
+        env:
+          BUILD_TAGS: e2e
+        run: make -f builder.Makefile compose-plugin
+
+      - name: E2E Test
+        run: make e2e-compose

.github/workflows/docs.yml

@@ -1,56 +0,0 @@
-name: Docs
-
-on:
-  release:
-    types: [published]
-
-permissions: {}
-jobs:
-  open-pr:
-    permissions:
-      contents: write # to create branch (peter-evans/create-pull-request)
-      pull-requests: write # to create a PR (peter-evans/create-pull-request)
-
-    runs-on: ubuntu-latest
-    steps:
-      -
-        name: Checkout docs repo
-        uses: actions/checkout@v3
-        with:
-          token: ${{ secrets.GHPAT_DOCS_DISPATCH }}
-          repository: docker/docs
-          ref: main
-      -
-        name: Prepare
-        run: |
-          rm -rf ./_data/compose-cli/*
-      -
-        name: Build
-        uses: docker/build-push-action@v3
-        with:
-          context: ${{ github.server_url }}/${{ github.repository }}.git#${{ github.event.release.name }}
-          target: docs-reference
-          outputs: ./_data/compose-cli
-      -
-        name: Update compose_version in _config.yml
-        run: |
-          sed -i "s|^compose_version\:.*|compose_version\: \"${{ github.event.release.name }}\"|g" _config.yml
-          cat _config.yml | yq .compose_version
-      -
-        name: Commit changes
-        run: |
-          git add -A .
-      -
-        name: Create PR on docs repo
-        uses: peter-evans/create-pull-request@923ad837f191474af6b1721408744feb989a4c27 # v4.0.4
-        with:
-          token: ${{ secrets.GHPAT_DOCS_DISPATCH }}
-          push-to-fork: docker-tools-robot/docker.github.io
-          commit-message: Update Compose reference API to ${{ github.event.release.name }}
-          signoff: true
-          branch: dispatch/compose-api-reference-${{ github.event.release.name }}
-          delete-branch: true
-          title: Update Compose reference API to ${{ github.event.release.name }}
-          body: |
-            Update the Compose reference API documentation to keep in sync with the latest release `${{ github.event.release.name }}`
-          draft: false

.github/workflows/merge.yml

@@ -1,74 +0,0 @@
-name: merge
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
-on:
-  push:
-    branches:
-      - 'v2'
-    tags:
-      - 'v*'
-  workflow_dispatch:
-
-permissions:
-  contents: read # to fetch code (actions/checkout)
-
-jobs:
-  e2e:
-    name: Build and test
-    runs-on: ${{ matrix.os }}
-    timeout-minutes: 15
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [desktop-windows, desktop-macos, desktop-m1]
-        # mode: [plugin, standalone]
-        mode: [plugin]
-    env:
-      GO111MODULE: "on"
-    steps:
-      - uses: actions/checkout@v3
-
-      - uses: actions/setup-go@v3
-        with:
-          go-version-file: go.mod
-          cache: true
-          check-latest: true
-
-      - name: List Docker resources on machine
-        run: |
-          docker ps --all
-          docker volume ls
-          docker network ls
-          docker image ls
-      - name: Remove Docker resources on machine
-        continue-on-error: true
-        run: |
-          docker kill $(docker ps -q)
-          docker rm -f $(docker ps -aq)
-          docker volume rm -f $(docker volume ls -q)
-          docker ps --all
-
-      - name: Unit tests
-        run: make test
-
-      - name: Build binaries
-        run: |
-          make
-      - name: Check arch of go compose binary
-        run: |
-          file ./bin/build/docker-compose
-        if: ${{ !contains(matrix.os, 'desktop-windows') }}
-      -
-        name: Test plugin mode
-        if: ${{ matrix.mode == 'plugin' }}
-        run: |
-          make e2e-compose
-      -
-        name: Test standalone mode
-        if: ${{ matrix.mode == 'standalone' }}
-        run: |
-          make e2e-compose-standalone
-

.github/workflows/pr-closed.yml

@@ -0,0 +1,11 @@
+name: PR cleanup
+on:
+  pull_request:
+    types: [closed]
+jobs:
+  delete_pr_artifacts:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: stefanluptak/delete-old-pr-artifacts@v1
+        with:
+          workflow_filename: ci.yaml

.github/workflows/rebase.yml

@@ -0,0 +1,19 @@
+name: Automatic Rebase
+on:
+  issue_comment:
+    types: [created]
+jobs:
+  rebase:
+    name: Rebase
+    if: github.event.issue.pull_request != '' && contains(github.event.comment.body, '/rebase')
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout the latest code
+        uses: actions/checkout@v2
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          fetch-depth: 0 # otherwise, you will fail to push refs to dest repo
+      - name: Automatic Rebase
+        uses: cirrus-actions/rebase@1.4
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/release.yaml

@@ -0,0 +1,50 @@
+name: Releaser
+
+on:
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: "Release Tag"
+        required: true
+
+jobs:
+  upload-release:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Set up Go 1.17
+        uses: actions/setup-go@v2
+        with:
+          go-version: 1.17
+        id: go
+
+      - name: Setup docker CLI
+        run: |
+          curl https://download.docker.com/linux/static/stable/x86_64/docker-20.10.3.tgz | tar xz
+          sudo cp ./docker/docker /usr/bin/ && rm -rf docker && docker version
+
+      - name: Checkout code into the Go module directory
+        uses: actions/checkout@v2
+
+      - uses: actions/cache@v2
+        with:
+          path: ~/go/pkg/mod
+          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
+          restore-keys: |
+            ${{ runner.os }}-go-
+
+      - name: Build
+        run: make GIT_TAG=${{ github.event.inputs.tag }} -f builder.Makefile cross
+
+      - name: Compute checksums
+        run: cd bin; for f in *; do shasum --algorithm 256 $f > $f.sha256; done
+
+      - name: License
+        run: cp packaging/* bin/
+
+      - uses: ncipollo/release-action@v1
+        with:
+          artifacts: "bin/*"
+          prerelease: true
+          commit: "v2"
+          token: ${{ secrets.GITHUB_TOKEN }}
+          tag: ${{ github.event.inputs.tag }}

.github/workflows/scorecards.yml

@@ -1,54 +0,0 @@
-name: Scorecards supply-chain security
-on:
-  # Only the default branch is supported.
-  branch_protection_rule:
-  schedule:
-    - cron: '44 9 * * 4'
-  push:
-    branches: [ "v2" ]
-
-# Declare default permissions as read only.
-permissions: read-all
-
-jobs:
-  analysis:
-    name: Scorecards analysis
-    runs-on: ubuntu-latest
-    permissions:
-      # Needed to upload the results to code-scanning dashboard.
-      security-events: write
-      # Used to receive a badge.
-      id-token: write
-    
-    steps:
-      - name: "Checkout code"
-        uses: actions/checkout@a12a3943b4bdde767164f792f33f40b04645d846 # tag=v3.0.0
-        with:
-          persist-credentials: false
-
-      - name: "Run analysis"
-        uses: ossf/scorecard-action@99c53751e09b9529366343771cc321ec74e9bd3d # tag=v2.0.6
-        with:
-          results_file: results.sarif
-          results_format: sarif
-
-          # Publish the results for public repositories to enable scorecard badges. For more details, see
-          # https://github.com/ossf/scorecard-action#publishing-results. 
-          # For private repositories, `publish_results` will automatically be set to `false`, regardless 
-          # of the value entered here.
-          publish_results: true
-
-      # Upload the results as artifacts (optional). Commenting out will disable uploads of run results in SARIF
-      # format to the repository Actions tab.
-      - name: "Upload artifact"
-        uses: actions/upload-artifact@6673cd052c4cd6fcf4b4e6e60ea986c889389535 # tag=v3.0.0
-        with:
-          name: SARIF file
-          path: results.sarif
-          retention-days: 5
-      
-      # Upload the results to GitHub's code scanning dashboard.
-      - name: "Upload to code-scanning"
-        uses: github/codeql-action/upload-sarif@5f532563584d71fdef14ee64d17bafb34f751ce5 # tag=v1.0.26
-        with:
-          sarif_file: results.sarif

.gitignore

@@ -1,3 +1,3 @@
 bin/
+dist/
 /.vscode/
-coverage.out

.golangci.yml

@@ -1,17 +1,16 @@
-run:
-  concurrency: 2
-  timeout: 10m
 linters:
+  run:
+    concurrency: 2
+    skip-dirs:
+      - tests/composefiles
   enable-all: false
   disable-all: true
   enable:
-    - depguard
+    - deadcode
     - errcheck
-    - gocritic
     - gocyclo
     - gofmt
     - goimports
-    - gomodguard
     - revive
     - gosimple
     - govet
@@ -19,41 +18,14 @@ linters:
     - lll
     - misspell
     - nakedret
-    - nolintlint
     - staticcheck
+    - structcheck
     - typecheck
     - unconvert
     - unparam
     - unused
+    - varcheck
 linters-settings:
-  revive:
-    rules:
-      - name: package-comments
-        disabled: true
-  depguard:
-    list-type: denylist
-    include-go-root: true
-    packages:
-      # The io/ioutil package has been deprecated.
-      # https://go.dev/doc/go1.16#ioutil
-      - io/ioutil
-  gomodguard:
-    blocked:
-      versions:
-        - gotest.tools:
-            version: "< 3.0.0"
-            reason: "deprecated, pre-modules version"
-  gocritic:
-    # Enable multiple checks by tags, run `GL_DEBUG=gocritic golangci-lint run` to see all tags and checks.
-    # Empty list by default. See https://github.com/go-critic/go-critic#usage -> section "Tags".
-    enabled-tags:
-      - diagnostic
-      - opinionated
-      - style
-    disabled-checks:
-      - paramTypeCombine
-      - unnamedResult
-      - whyNoLint
   gocyclo:
     min-complexity: 16
   lll:

BUILDING.md

@@ -8,7 +8,7 @@
   * [Docker Desktop](https://hub.docker.com/editions/community/docker-ce-desktop-mac)
   * make
 * Linux:
-  * [Docker 20.10 or later](https://docs.docker.com/engine/install/)
+  * [Docker 19.03 or later](https://docs.docker.com/engine/install/)
   * make
 
 ### Building the CLI
@@ -19,8 +19,7 @@ Once you have the prerequisites installed, you can build the CLI using:
 make
 ```
 
-This will output a `docker-compose` CLI plugin for your host machine in
-`./bin/build`.
+This will output a `docker-compose` CLI plugin for your host machine in `./bin`.
 
 You can statically cross compile the CLI for Windows, macOS, and Linux using the
 `cross` target.
@@ -35,57 +34,21 @@ make test
 
 If you need to update a golden file simply do `go test ./... -test.update-golden`.
 
-### End-to-end tests
-To run e2e tests, the Compose CLI binary needs to be built. All the commands to run e2e tests propose a version
-with the prefix `build-and-e2e` to first build the CLI before executing tests.
+### End to end tests
 
-Note that this requires a local Docker Engine to be running.
-
-#### Whole end-to-end tests suite
-
-To execute both CLI and standalone e2e tests, run :
-
-```console
-make e2e
-```
-
-Or if you need to build the CLI, run: 
-```console
-make build-and-e2e
-```
-
-#### Plugin end-to-end tests suite
-
-To execute CLI plugin e2e tests, run :
+To run the end to end tests, run:
 
 ```console
 make e2e-compose
 ```
 
-Or if you need to build the CLI, run:
-```console
-make build-and-e2e-compose
-```
-
-#### Standalone end-to-end tests suite
-
-To execute the standalone CLI e2e tests, run :
-
-```console
-make e2e-compose-standalone
-```
-
-Or if you need to build the CLI, run:
-
-```console
-make build-and-e2e-compose-standalone
-```
+Note that this requires a local Docker Engine to be running.
 
 ## Releases
 
 To create a new release:
-* Check that the CI is green on the main branch for the commit you want to release
-* Run the release Github Actions workflow with a tag of form vx.y.z following existing tags.
+* Check that the CI is green on the main branch for commit you want to release
+* Run the release Github Actions workflow with a tag of the form vx.y.z following existing tags.
 
 This will automatically create a new tag, release and make binaries for
 Windows, macOS, and Linux available for download on the

CONTRIBUTING.md

@@ -2,7 +2,7 @@
 
 Want to hack on Docker? Awesome!  We have a contributor's guide that explains
 [setting up a Docker development environment and the contribution
-process](https://docs.docker.com/contribute/overview/).
+process](https://docs.docker.com/opensource/project/who-written-for/).
 
 This page contains information about reporting issues as well as some tips and
 guidelines useful to experienced open source contributors. Finally, make sure
@@ -11,31 +11,23 @@ start participating.
 
 ## Topics
 
-- [Contributing to Docker](#contributing-to-docker)
-  - [Topics](#topics)
-  - [Reporting security issues](#reporting-security-issues)
-  - [Reporting other issues](#reporting-other-issues)
-  - [Quick contribution tips and guidelines](#quick-contribution-tips-and-guidelines)
-    - [Pull requests are always welcome](#pull-requests-are-always-welcome)
-    - [Talking to other Docker users and contributors](#talking-to-other-docker-users-and-contributors)
-    - [Conventions](#conventions)
-    - [Merge approval](#merge-approval)
-    - [Sign your work](#sign-your-work)
-    - [How can I become a maintainer?](#how-can-i-become-a-maintainer)
-  - [Docker community guidelines](#docker-community-guidelines)
-  - [Coding Style](#coding-style)
+* [Reporting Security Issues](#reporting-security-issues)
+* [Design and Cleanup Proposals](#design-and-cleanup-proposals)
+* [Reporting Issues](#reporting-other-issues)
+* [Quick Contribution Tips and Guidelines](#quick-contribution-tips-and-guidelines)
+* [Community Guidelines](#docker-community-guidelines)
 
 ## Reporting security issues
 
 The Docker maintainers take security seriously. If you discover a security
 issue, please bring it to their attention right away!
 
-Please **DO NOT** file a public issue, instead, send your report privately to
+Please **DO NOT** file a public issue, instead send your report privately to
 [security@docker.com](mailto:security@docker.com).
 
-Security reports are greatly appreciated and we will publicly thank you for them.
+Security reports are greatly appreciated and we will publicly thank you for it.
 We also like to send gifts—if you're into Docker swag, make sure to let
-us know. We currently do not offer a paid security bounty program but are not
+us know. We currently do not offer a paid security bounty program, but are not
 ruling it out in the future.
 
 
@@ -47,11 +39,11 @@ and will thank you for it!
 
 Check that [our issue database](https://github.com/docker/compose/labels/Docker%20Compose%20V2)
 doesn't already include that problem or suggestion before submitting an issue.
-If you find a match, you can use the "subscribe" button to get notified of
+If you find a match, you can use the "subscribe" button to get notified on
 updates. Do *not* leave random "+1" or "I have this too" comments, as they
 only clutter the discussion, and don't help to resolve it. However, if you
 have ways to reproduce the issue or have additional information that may help
-resolve the issue, please leave a comment.
+resolving the issue, please leave a comment.
 
 When reporting issues, always include:
 
@@ -59,7 +51,7 @@ When reporting issues, always include:
 * The output of `docker context show`.
 * The output of `docker info`.
 
-Also, include the steps required to reproduce the problem if possible and
+Also include the steps required to reproduce the problem if possible and
 applicable. This information will help us review and fix your issue faster.
 When sending lengthy log files, consider posting them as a gist
 (https://gist.github.com).
@@ -91,7 +83,7 @@ don't get discouraged! Our contributor's guide explains
   <tr>
     <td>Community Slack</td>
     <td>
-      The Docker Community has a dedicated Slack chat to discuss features and issues.  You can sign-up <a href="https://www.docker.com/docker-community" target="_blank">with this link</a>.
+      The Docker Community has a dedicated Slack chat to discuss features and issues.  You can sign-up <a href="https://dockercommunity.slack.com/ssb/redirect" target="_blank">with this link</a>.
     </td>
   </tr>
   <tr>
@@ -132,10 +124,9 @@ Fork the repository and make changes on your fork in a feature branch:
     issue.
 
 Submit unit tests for your changes. Go has a great test framework built in; use
-it! Take a look at existing tests for inspiration. Also, end-to-end tests are
-available. Run the full test suite, both unit tests and e2e tests on your
-branch before submitting a pull request. See [BUILDING.md](BUILDING.md) for
-instructions to build and run tests.
+it! Take a look at existing tests for inspiration. [Run the full test
+suite](README.md) on your branch before
+submitting a pull request.
 
 Write clean code. Universally formatted code promotes ease of writing, reading,
 and maintenance. Always run `gofmt -s -w file.go` on each changed file before
@@ -153,7 +144,7 @@ suggested modifications and push additional commits to your feature branch. Post
 a comment after pushing. New commits show up in the pull request automatically,
 but the reviewers are notified only when you comment.
 
-Pull requests must be cleanly rebased on top of the base branch without multiple branches
+Pull requests must be cleanly rebased on top of master without multiple branches
 mixed into the PR.
 
 **Git tip**: If your PR no longer merges cleanly, use `rebase master` in your
@@ -173,7 +164,7 @@ changes in the same pull request so that a revert would remove all traces of
 the feature or fix.
 
 Include an issue reference like `Closes #XXXX` or `Fixes #XXXX` in the pull
-request description that closes an issue. Including references automatically
+request description that close an issue. Including references automatically
 closes the issue on a merge.
 
 Please do not add yourself to the `AUTHORS` file, as it is regenerated regularly
@@ -264,7 +255,7 @@ your help to keep it that way. To help with this we've come up with some general
 guidelines for the community as a whole:
 
 * Be nice: Be courteous, respectful and polite to fellow community members:
-  no regional, racial, gender or other abuse will be tolerated. We like
+  no regional, racial, gender, or other abuse will be tolerated. We like
   nice people way better than mean ones!
 
 * Encourage diversity and participation: Make everyone in our community feel
@@ -278,10 +269,10 @@ guidelines for the community as a whole:
 
 * Stay on topic: Make sure that you are posting to the correct channel and
   avoid off-topic discussions. Remember when you update an issue or respond
-  to an email you are potentially sending it to a large number of people. Please
-  consider this before you update. Also, remember that nobody likes spam.
+  to an email you are potentially sending to a large number of people. Please
+  consider this before you update. Also remember that nobody likes spam.
 
-* Don't send emails to the maintainers: There's no need to send emails to the
+* Don't send email to the maintainers: There's no need to send email to the
   maintainers to ask them to investigate an issue or to take a look at a
   pull request. Instead of sending an email, GitHub mentions should be
   used to ping maintainers to review a pull request, a proposal or an
@@ -295,7 +286,7 @@ to result in a solid, consistent codebase.
 
 It is possible that the code base does not currently comply with these
 guidelines. We are not looking for a massive PR that fixes this, since that
-goes against the spirit of the guidelines. All new contributors should make their
+goes against the spirit of the guidelines. All new contributions should make a
 best effort to clean up and make the code base better than they left it.
 Obviously, apply your best judgement. Remember, the goal here is to make the
 code base easier for humans to navigate and understand. Always keep that in
@@ -309,7 +300,7 @@ The rules:
 3. All code should follow the guidelines covered in [Effective
    Go](http://golang.org/doc/effective_go.html) and [Go Code Review
    Comments](https://github.com/golang/go/wiki/CodeReviewComments).
-4. Include code comments. Tell us the why, the history and the context.
+4. Comment the code. Tell us the why, the history and the context.
 5. Document _all_ declarations and methods, even private ones. Declare
    expectations, caveats and anything else that may be important. If a type
    gets exported, having the comments already there will ensure it's ready.

Dockerfile

@@ -1,4 +1,4 @@
-# syntax=docker/dockerfile:1
+# syntax=docker/dockerfile:1.2
 
 
 #   Copyright 2020 Docker Compose CLI authors
@@ -15,169 +15,93 @@
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
 
-ARG GO_VERSION=1.19.4
-ARG XX_VERSION=1.1.2
-ARG GOLANGCI_LINT_VERSION=v1.49.0
-ARG ADDLICENSE_VERSION=v1.0.0
+ARG GO_VERSION=1.17-alpine
+ARG GOLANGCI_LINT_VERSION=v1.40.1-alpine
+ARG PROTOC_GEN_GO_VERSION=v1.4.3
 
-ARG BUILD_TAGS="e2e,kube"
-ARG DOCS_FORMATS="md,yaml"
-ARG LICENSE_FILES=".*\(Dockerfile\|Makefile\|\.go\|\.hcl\|\.sh\)"
-
-# xx is a helper for cross-compilation
-FROM --platform=${BUILDPLATFORM} tonistiigi/xx:${XX_VERSION} AS xx
-
-FROM golangci/golangci-lint:${GOLANGCI_LINT_VERSION}-alpine AS golangci-lint
-FROM ghcr.io/google/addlicense:${ADDLICENSE_VERSION} AS addlicense
-
-FROM --platform=${BUILDPLATFORM} golang:${GO_VERSION}-alpine AS base
-COPY --from=xx / /
-RUN apk add --no-cache \
-      docker \
-      file \
-      git \
-      make \
-      protoc \
-      protobuf-dev
-WORKDIR /src
-ENV CGO_ENABLED=0
-
-FROM base AS build-base
+FROM --platform=${BUILDPLATFORM} golang:${GO_VERSION} AS base
+WORKDIR /compose-cli
+RUN apk add --no-cache -vv \
+    git \
+    docker \
+    make \
+    protoc \
+    protobuf-dev
 COPY go.* .
 RUN --mount=type=cache,target=/go/pkg/mod \
     --mount=type=cache,target=/root/.cache/go-build \
     go mod download
 
-FROM build-base AS vendored
-RUN --mount=type=bind,target=.,rw \
-    --mount=type=cache,target=/go/pkg/mod \
-    go mod tidy && mkdir /out && cp go.mod go.sum /out
-
-FROM scratch AS vendor-update
-COPY --from=vendored /out /
-
-FROM vendored AS vendor-validate
-RUN --mount=type=bind,target=.,rw <<EOT
-  set -e
-  git add -A
-  cp -rf /out/* .
-  diff=$(git status --porcelain -- go.mod go.sum)
-  if [ -n "$diff" ]; then
-    echo >&2 'ERROR: Vendor result differs. Please vendor your package with "make go-mod-tidy"'
-    echo "$diff"
-    exit 1
-  fi
-EOT
-
-FROM build-base AS build
+FROM base AS lint
+ENV CGO_ENABLED=0
+COPY --from=golangci/golangci-lint /usr/bin/golangci-lint /usr/bin/golangci-lint
 ARG BUILD_TAGS
-ARG TARGETPLATFORM
-RUN xx-go --wrap
-RUN --mount=type=bind,target=. \
-    --mount=type=cache,target=/root/.cache \
-    --mount=type=cache,target=/go/pkg/mod \
-    make build GO_BUILDTAGS="$BUILD_TAGS" DESTDIR=/usr/bin && \
-    xx-verify --static /usr/bin/docker-compose
-
-FROM build-base AS lint
-ARG BUILD_TAGS
-RUN --mount=type=bind,target=. \
-    --mount=type=cache,target=/root/.cache \
-    --mount=from=golangci-lint,source=/usr/bin/golangci-lint,target=/usr/bin/golangci-lint \
-    golangci-lint run --build-tags "$BUILD_TAGS" ./...
-
-FROM build-base AS test
-ARG CGO_ENABLED=0
-ARG BUILD_TAGS
-RUN --mount=type=bind,target=. \
-    --mount=type=cache,target=/root/.cache \
-    --mount=type=cache,target=/go/pkg/mod \
-    go test -tags "$BUILD_TAGS" -v -coverprofile=/tmp/coverage.txt -covermode=atomic $(go list  $(TAGS) ./... | grep -vE 'e2e') && \
-    go tool cover -func=/tmp/coverage.txt
-
-FROM scratch AS test-coverage
-COPY --from=test /tmp/coverage.txt /coverage.txt
-
-FROM base AS license-set
-ARG LICENSE_FILES
-RUN --mount=type=bind,target=.,rw \
-    --mount=from=addlicense,source=/app/addlicense,target=/usr/bin/addlicense \
-    find . -regex "${LICENSE_FILES}" | xargs addlicense -c 'Docker Compose CLI' -l apache && \
-    mkdir /out && \
-    find . -regex "${LICENSE_FILES}" | cpio -pdm /out
-
-FROM scratch AS license-update
-COPY --from=set /out /
-
-FROM base AS license-validate
-ARG LICENSE_FILES
-RUN --mount=type=bind,target=. \
-    --mount=from=addlicense,source=/app/addlicense,target=/usr/bin/addlicense \
-    find . -regex "${LICENSE_FILES}" | xargs addlicense -check -c 'Docker Compose CLI' -l apache -ignore validate -ignore testdata -ignore resolvepath -v
-
-FROM base AS docsgen
-WORKDIR /src
+ARG GIT_TAG
 RUN --mount=target=. \
-    --mount=target=/root/.cache,type=cache \
-    go build -o /out/docsgen ./docs/yaml/main/generate.go
+    --mount=type=cache,target=/go/pkg/mod \
+    --mount=type=cache,target=/root/.cache/go-build \
+    --mount=type=cache,target=/root/.cache/golangci-lint \
+    BUILD_TAGS=${BUILD_TAGS} \
+    GIT_TAG=${GIT_TAG} \
+    make -f builder.Makefile lint
 
-FROM --platform=${BUILDPLATFORM} alpine AS docs-build
-RUN apk add --no-cache rsync git
-WORKDIR /src
-COPY --from=docsgen /out/docsgen /usr/bin
-ARG DOCS_FORMATS
-RUN --mount=target=/context \
-    --mount=target=.,type=tmpfs <<EOT
-  set -e
-  rsync -a /context/. .
-  docsgen --formats "$DOCS_FORMATS" --source "docs/reference"
-  mkdir /out
-  cp -r docs/reference /out
-EOT
-
-FROM scratch AS docs-update
-COPY --from=docs-build /out /out
-
-FROM docs-build AS docs-validate
-RUN --mount=target=/context \
-    --mount=target=.,type=tmpfs <<EOT
-  set -e
-  rsync -a /context/. .
-  git add -A
-  rm -rf docs/reference/*
-  cp -rf /out/* ./docs/
-  if [ -n "$(git status --porcelain -- docs/reference)" ]; then
-    echo >&2 'ERROR: Docs result differs. Please update with "make docs"'
-    git status --porcelain -- docs/reference
-    exit 1
-  fi
-EOT
-
-FROM scratch AS binary-unix
-COPY --link --from=build /usr/bin/docker-compose /
-FROM binary-unix AS binary-darwin
-FROM binary-unix AS binary-linux
-FROM scratch AS binary-windows
-COPY --link --from=build /usr/bin/docker-compose /docker-compose.exe
-FROM binary-$TARGETOS AS binary
-
-FROM --platform=$BUILDPLATFORM alpine AS releaser
-WORKDIR /work
+FROM base AS make-compose-plugin
+ENV CGO_ENABLED=0
 ARG TARGETOS
 ARG TARGETARCH
-ARG TARGETVARIANT
-RUN --mount=from=binary \
-    mkdir -p /out && \
-    # TODO: should just use standard arch
-    TARGETARCH=$([ "$TARGETARCH" = "amd64" ] && echo "x86_64" || echo "$TARGETARCH"); \
-    TARGETARCH=$([ "$TARGETARCH" = "arm64" ] && echo "aarch64" || echo "$TARGETARCH"); \
-    cp docker-compose* "/out/docker-compose-${TARGETOS}-${TARGETARCH}${TARGETVARIANT}$(ls docker-compose* | sed -e 's/^docker-compose//')"
+ARG BUILD_TAGS
+ARG GIT_TAG
+RUN --mount=target=. \
+    --mount=type=cache,target=/go/pkg/mod \
+    --mount=type=cache,target=/root/.cache/go-build \
+    GOOS=${TARGETOS} \
+    GOARCH=${TARGETARCH} \
+    BUILD_TAGS=${BUILD_TAGS} \
+    GIT_TAG=${GIT_TAG} \
+    make COMPOSE_BINARY=/out/docker-compose -f builder.Makefile compose-plugin
 
-FROM scratch AS release
-COPY --from=releaser /out/ /
+FROM base AS make-cross
+ARG BUILD_TAGS
+ARG GIT_TAG
+RUN --mount=target=. \
+    --mount=type=cache,target=/go/pkg/mod \
+    --mount=type=cache,target=/root/.cache/go-build \
+    BUILD_TAGS=${BUILD_TAGS} \
+    GIT_TAG=${GIT_TAG} \
+    make COMPOSE_BINARY=/out/docker-compose -f builder.Makefile cross
 
-# docs-reference is a target used as remote context to update docs on release
-# with latest changes on docs.docker.com.
-# see open-pr job in .github/workflows/docs.yml for more details
-FROM scratch AS docs-reference
-COPY docs/reference/*.yaml .
+FROM scratch AS compose-plugin
+COPY --from=make-compose-plugin /out/* .
+
+FROM scratch AS cross
+COPY --from=make-cross /out/* .
+
+FROM base AS test
+ENV CGO_ENABLED=0
+ARG BUILD_TAGS
+ARG GIT_TAG
+RUN --mount=target=. \
+    --mount=type=cache,target=/go/pkg/mod \
+    --mount=type=cache,target=/root/.cache/go-build \
+    BUILD_TAGS=${BUILD_TAGS} \
+    GIT_TAG=${GIT_TAG} \
+    make -f builder.Makefile test
+
+FROM base AS check-license-headers
+RUN go get -u github.com/kunalkushwaha/ltag
+RUN --mount=target=. \
+    make -f builder.Makefile check-license-headers
+
+FROM base AS make-go-mod-tidy
+COPY . .
+RUN --mount=type=cache,target=/go/pkg/mod \
+    --mount=type=cache,target=/root/.cache/go-build \
+    go mod tidy
+
+FROM scratch AS go-mod-tidy
+COPY --from=make-go-mod-tidy /compose-cli/go.mod .
+COPY --from=make-go-mod-tidy /compose-cli/go.sum .
+
+FROM base AS check-go-mod
+COPY . .
+RUN make -f builder.Makefile check-go-mod

Makefile

@@ -12,109 +12,63 @@
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
 
-PKG := github.com/docker/compose/v2
-VERSION ?= $(shell git describe --match 'v[0-9]*' --dirty='.m' --always --tags)
+export DOCKER_BUILDKIT=1
 
-GO_LDFLAGS ?= -s -w -X ${PKG}/internal.Version=${VERSION}
-GO_BUILDTAGS ?= e2e,kube
-
-ifeq ($(OS),Windows_NT)
-    DETECTED_OS = Windows
-else
-    DETECTED_OS = $(shell uname -s)
-endif
-ifeq ($(DETECTED_OS),Linux)
+UNAME_S := $(shell uname -s)
+ifeq ($(UNAME_S),Linux)
 	MOBY_DOCKER=/usr/bin/docker
 endif
-ifeq ($(DETECTED_OS),Darwin)
+ifeq ($(UNAME_S),Darwin)
 	MOBY_DOCKER=/Applications/Docker.app/Contents/Resources/bin/docker
 endif
-ifeq ($(DETECTED_OS),Windows)
-	BINARY_EXT=.exe
-endif
 
-TEST_COVERAGE_FLAGS = -race -coverprofile=coverage.out -covermode=atomic
-TEST_FLAGS?= -timeout 15m
+BINARY_FOLDER=$(shell pwd)/bin
+GIT_TAG?=$(shell git describe --tags --match "v[0-9]*")
+TEST_FLAGS?=
 E2E_TEST?=
 ifeq ($(E2E_TEST),)
 else
 	TEST_FLAGS=-run $(E2E_TEST)
 endif
 
-BUILDX_CMD ?= docker buildx
-DESTDIR ?= ./bin/build
+all: compose-plugin
 
-all: build
-
-.PHONY: build ## Build the compose cli-plugin
-build:
-	CGO_ENABLED=0 GO111MODULE=on go build -trimpath -tags "$(GO_BUILDTAGS)" -ldflags "$(GO_LDFLAGS)" -o "$(DESTDIR)/docker-compose$(BINARY_EXT)" ./cmd
-
-.PHONY: binary
-binary:
-	$(BUILDX_CMD) bake binary
-
-.PHONY: install
-install: binary
-	mkdir -p ~/.docker/cli-plugins
-	install bin/build/docker-compose ~/.docker/cli-plugins/docker-compose
+.PHONY: compose-plugin
+compose-plugin: ## Compile the compose cli-plugin
+	@docker build . --target compose-plugin \
+	--platform local \
+	--build-arg BUILD_TAGS=e2e,kube \
+	--build-arg GIT_TAG=$(GIT_TAG) \
+	--output ./bin
 
 .PHONY: e2e-compose
-e2e-compose: ## Run end to end local tests in plugin mode. Set E2E_TEST=TestName to run a single test
-	docker compose version
-	go test $(TEST_FLAGS) $(TEST_COVERAGE_FLAGS) -count=1 ./pkg/e2e
-
-.PHONY: e2e-compose-standalone
-e2e-compose-standalone: ## Run End to end local tests in standalone mode. Set E2E_TEST=TestName to run a single test
-	docker-compose version
-	go test $(TEST_FLAGS) -v -count=1 -parallel=1 --tags=standalone ./pkg/e2e
-
-.PHONY: build-and-e2e-compose
-build-and-e2e-compose: build e2e-compose ## Compile the compose cli-plugin and run end to end local tests in plugin mode. Set E2E_TEST=TestName to run a single test
-
-.PHONY: build-and-e2e-compose-standalone
-build-and-e2e-compose-standalone: build e2e-compose-standalone ## Compile the compose cli-plugin and run End to end local tests in standalone mode. Set E2E_TEST=TestName to run a single test
-
-.PHONY: mocks
-mocks:
-	mockgen --version >/dev/null 2>&1 || go install github.com/golang/mock/mockgen@v1.6.0
-	mockgen -destination pkg/mocks/mock_docker_cli.go -package mocks github.com/docker/cli/cli/command Cli
-	mockgen -destination pkg/mocks/mock_docker_api.go -package mocks github.com/docker/docker/client APIClient
-	mockgen -destination pkg/mocks/mock_docker_compose_api.go -package mocks -source=./pkg/api/api.go Service
-
-.PHONY: e2e
-e2e: e2e-compose e2e-compose-standalone ## Run end to end local tests in both modes. Set E2E_TEST=TestName to run a single test
-
-.PHONY: build-and-e2e
-build-and-e2e: build e2e-compose e2e-compose-standalone ## Compile the compose cli-plugin and run end to end local tests in both modes. Set E2E_TEST=TestName to run a single test
+e2e-compose: ## Run End to end local tests. Set E2E_TEST=TestName to run a single test
+	gotestsum $(TEST_FLAGS) ./pkg/e2e -- -count=1
 
 .PHONY: cross
 cross: ## Compile the CLI for linux, darwin and windows
-	$(BUILDX_CMD) bake binary-cross
+	@docker build . --target cross \
+	--build-arg BUILD_TAGS \
+	--build-arg GIT_TAG=$(GIT_TAG) \
+	--output ./bin \
 
 .PHONY: test
 test: ## Run unit tests
-	$(BUILDX_CMD) bake test
+	@docker build --progress=plain . \
+	--build-arg BUILD_TAGS=kube \
+	--build-arg GIT_TAG=$(GIT_TAG) \
+	--target test
 
 .PHONY: cache-clear
 cache-clear: ## Clear the builder cache
-	$(BUILDX_CMD) prune --force --filter type=exec.cachemount --filter=unused-for=24h
+	@docker builder prune --force --filter type=exec.cachemount --filter=unused-for=24h
 
 .PHONY: lint
 lint: ## run linter(s)
-	$(BUILDX_CMD) bake lint
-
-.PHONY: docs
-docs: ## generate documentation
-	$(eval $@_TMP_OUT := $(shell mktemp -d -t compose-output.XXXXXXXXXX))
-	$(BUILDX_CMD) bake --set "*.output=type=local,dest=$($@_TMP_OUT)" docs-update
-	rm -rf ./docs/internal
-	cp -R "$($@_TMP_OUT)"/out/* ./docs/
-	rm -rf "$($@_TMP_OUT)"/*
-
-.PHONY: validate-docs
-validate-docs: ## validate the doc does not change
-	$(BUILDX_CMD) bake docs-validate
+	@docker build . \
+	--build-arg BUILD_TAGS=kube,e2e \
+	--build-arg GIT_TAG=$(GIT_TAG) \
+	--target lint
 
 .PHONY: check-dependencies
 check-dependencies: ## check dependency updates
@@ -122,19 +76,19 @@ check-dependencies: ## check dependency updates
 
 .PHONY: validate-headers
 validate-headers: ## Check license header for all files
-	$(BUILDX_CMD) bake license-validate
+	@docker build . --target check-license-headers
 
 .PHONY: go-mod-tidy
 go-mod-tidy: ## Run go mod tidy in a container and output resulting go.mod and go.sum
-	$(BUILDX_CMD) bake vendor-update
+	@docker build . --target go-mod-tidy --output .
 
 .PHONY: validate-go-mod
 validate-go-mod: ## Validate go.mod and go.sum are up-to-date
-	$(BUILDX_CMD) bake vendor-validate
+	@docker build . --target check-go-mod
 
-validate: validate-go-mod validate-headers validate-docs  ## Validate sources
+validate: validate-go-mod validate-headers ## Validate sources
 
-pre-commit: validate check-dependencies lint build test e2e-compose
+pre-commit: validate check-dependencies lint compose-plugin test e2e-compose
 
 help: ## Show help
 	@echo Please specify a build target. The choices are:

README.md

@@ -1,24 +1,12 @@
-# Table of Contents
-- [Docker Compose v2](#docker-compose-v2)
-- [About update and backward compatibility](#about-update-and-backward-compatibility)
-- [Where to get Docker Compose](#where-to-get-docker-compose)
-    + [Windows and macOS](#windows-and-macos)
-    + [Linux](#linux)
-- [Quick Start](#quick-start)
-- [Contributing](#contributing)
 # Docker Compose v2
 
-[![GitHub release](https://img.shields.io/github/release/docker/compose.svg?style=flat-square)](https://github.com/docker/compose/releases/latest)
-[![PkgGoDev](https://img.shields.io/badge/go.dev-docs-007d9c?style=flat-square&logo=go&logoColor=white)](https://pkg.go.dev/github.com/docker/compose/v2)
-[![Build Status](https://img.shields.io/github/workflow/status/docker/compose/ci?label=ci&logo=github&style=flat-square)](https://github.com/docker/compose/actions?query=workflow%3Aci)
-[![Go Report Card](https://goreportcard.com/badge/github.com/docker/compose/v2?style=flat-square)](https://goreportcard.com/report/github.com/docker/compose/v2)
-[![Codecov](https://codecov.io/gh/docker/compose/branch/master/graph/badge.svg?token=HP3K4Y4ctu)](https://codecov.io/gh/docker/compose)
-[![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/docker/compose/badge)](https://api.securityscorecards.dev/projects/github.com/docker/compose)
+[![Actions Status](https://github.com/docker/compose/workflows/Continuous%20integration/badge.svg)](https://github.com/docker/compose/actions)
+
 ![Docker Compose](logo.png?raw=true "Docker Compose Logo")
 
 Docker Compose is a tool for running multi-container applications on Docker
 defined using the [Compose file format](https://compose-spec.io).
-A Compose file is used to define how one or more containers that make up
+A Compose file is used to define how the one or more containers that make up
 your application are configured.
 Once you have a Compose file, you can create and start your application with a
 single command: `docker compose up`.
@@ -42,20 +30,20 @@ for Windows and macOS.
 You can download Docker Compose binaries from the
 [release page](https://github.com/docker/compose/releases) on this repository.
 
-Rename the relevant binary for your OS to `docker-compose` and copy it to `$HOME/.docker/cli-plugins`
+Rename the relevant binary for your OS to `docker-compose` and copy it to `$HOME/.docker/cli-plugins` 
 
-Or copy it into one of these folders to install it system-wide:
+Or copy it into one of these folders for installing it system-wide:
 
 * `/usr/local/lib/docker/cli-plugins` OR `/usr/local/libexec/docker/cli-plugins`
 * `/usr/lib/docker/cli-plugins` OR `/usr/libexec/docker/cli-plugins`
 
-(might require making the downloaded file executable with `chmod +x`)
+(might require to make the downloaded file executable with `chmod +x`)
 
 
 Quick Start
 -----------
 
-Using Docker Compose is a three-step process:
+Using Docker Compose is basically a three-step process:
 1. Define your app's environment with a `Dockerfile` so it can be
    reproduced anywhere.
 2. Define the services that make up your app in `docker-compose.yml` so

builder.Makefile

@@ -0,0 +1,76 @@
+#   Copyright 2020 Docker Compose CLI authors
+
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+
+#       http://www.apache.org/licenses/LICENSE-2.0
+
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+GOOS?=$(shell go env GOOS)
+GOARCH?=$(shell go env GOARCH)
+
+PKG_NAME := github.com/docker/compose/v2
+
+EXTENSION:=
+ifeq ($(GOOS),windows)
+  EXTENSION:=.exe
+endif
+
+STATIC_FLAGS=CGO_ENABLED=0
+
+GIT_TAG?=$(shell git describe --tags --match "v[0-9]*")
+
+LDFLAGS="-s -w -X $(PKG_NAME)/internal.Version=${GIT_TAG}"
+GO_BUILD=$(STATIC_FLAGS) go build -trimpath -ldflags=$(LDFLAGS)
+
+COMPOSE_BINARY?=bin/docker-compose
+COMPOSE_BINARY_WITH_EXTENSION=$(COMPOSE_BINARY)$(EXTENSION)
+
+WORK_DIR:=$(shell mktemp -d)
+
+TAGS:=
+ifdef BUILD_TAGS
+  TAGS=-tags $(BUILD_TAGS)
+  LINT_TAGS=--build-tags $(BUILD_TAGS)
+endif
+
+.PHONY: compose-plugin
+compose-plugin:
+	GOOS=${GOOS} GOARCH=${GOARCH} $(GO_BUILD) $(TAGS) -o $(COMPOSE_BINARY_WITH_EXTENSION) ./cmd
+
+.PHONY: cross
+cross:
+	GOOS=linux   GOARCH=amd64 $(GO_BUILD) $(TAGS) -o $(COMPOSE_BINARY)-linux-x86_64 ./cmd
+	GOOS=linux   GOARCH=arm64 $(GO_BUILD) $(TAGS) -o $(COMPOSE_BINARY)-linux-aarch64 ./cmd
+	GOOS=linux   GOARM=6 GOARCH=arm $(GO_BUILD) $(TAGS) -o $(COMPOSE_BINARY)-linux-armv6 ./cmd
+	GOOS=linux   GOARM=7 GOARCH=arm $(GO_BUILD) $(TAGS) -o $(COMPOSE_BINARY)-linux-armv7 ./cmd
+	GOOS=linux   GOARCH=s390x $(GO_BUILD) $(TAGS) -o $(COMPOSE_BINARY)-linux-s390x ./cmd
+	GOOS=darwin  GOARCH=amd64 $(GO_BUILD) $(TAGS) -o $(COMPOSE_BINARY)-darwin-x86_64 ./cmd
+	GOOS=darwin  GOARCH=arm64 $(GO_BUILD) $(TAGS) -o $(COMPOSE_BINARY)-darwin-aarch64 ./cmd
+	GOOS=windows GOARCH=amd64 $(GO_BUILD) $(TAGS) -o $(COMPOSE_BINARY)-windows-x86_64.exe ./cmd
+
+.PHONY: test
+test:
+	go test $(TAGS) -cover $(shell go list  $(TAGS) ./... | grep -vE 'e2e')
+
+.PHONY: lint
+lint:
+	golangci-lint run $(LINT_TAGS) --timeout 10m0s ./...
+
+.PHONY: check-license-headers
+check-license-headers:
+	./scripts/validate/fileheader
+
+.PHONY: check-go-mod
+check-go-mod:
+	./scripts/validate/check-go-mod
+
+.PHONY: yamldocs
+yamldocs:
+	go run docs/yaml/main/generate.go

cmd/compatibility/convert.go

@@ -1,109 +0,0 @@
-/*
-   Copyright 2020 Docker Compose CLI authors
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-*/
-
-package compatibility
-
-import (
-	"fmt"
-	"os"
-
-	"github.com/docker/compose/v2/cmd/compose"
-)
-
-func getCompletionCommands() []string {
-	return []string{
-		"__complete",
-		"__completeNoDesc",
-	}
-}
-
-func getBoolFlags() []string {
-	return []string{
-		"--debug", "-D",
-		"--verbose",
-		"--tls",
-		"--tlsverify",
-	}
-}
-
-func getStringFlags() []string {
-	return []string{
-		"--tlscacert",
-		"--tlscert",
-		"--tlskey",
-		"--host", "-H",
-		"--context",
-		"--log-level",
-	}
-}
-
-// Convert transforms standalone docker-compose args into CLI plugin compliant ones
-func Convert(args []string) []string {
-	var rootFlags []string
-	command := []string{compose.PluginName}
-	l := len(args)
-	for i := 0; i < l; i++ {
-		arg := args[i]
-		if contains(getCompletionCommands(), arg) {
-			command = append([]string{arg}, command...)
-			continue
-		}
-		if len(arg) > 0 && arg[0] != '-' {
-			// not a top-level flag anymore, keep the rest of the command unmodified
-			if arg == compose.PluginName {
-				i++
-			}
-			command = append(command, args[i:]...)
-			break
-		}
-
-		switch arg {
-		case "--verbose":
-			arg = "--debug"
-		case "-h":
-			// docker cli has deprecated -h to avoid ambiguity with -H, while docker-compose still support it
-			arg = "--help"
-		case "--version", "-v":
-			// redirect --version pseudo-command to actual command
-			arg = "version"
-		}
-
-		if contains(getBoolFlags(), arg) {
-			rootFlags = append(rootFlags, arg)
-			continue
-		}
-		if contains(getStringFlags(), arg) {
-			i++
-			if i >= l {
-				fmt.Fprintf(os.Stderr, "flag needs an argument: '%s'\n", arg)
-				os.Exit(1)
-			}
-			rootFlags = append(rootFlags, arg, args[i])
-			continue
-		}
-		command = append(command, arg)
-	}
-	return append(rootFlags, command...)
-}
-
-func contains(array []string, needle string) bool {
-	for _, val := range array {
-		if val == needle {
-			return true
-		}
-	}
-	return false
-}

cmd/compatibility/convert_test.go

@@ -1,93 +0,0 @@
-/*
-   Copyright 2020 Docker Compose CLI authors
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-*/
-
-package compatibility
-
-import (
-	"testing"
-
-	"gotest.tools/v3/assert"
-)
-
-func Test_convert(t *testing.T) {
-	tests := []struct {
-		name string
-		args []string
-		want []string
-	}{
-		{
-			name: "compose only",
-			args: []string{"up"},
-			want: []string{"compose", "up"},
-		},
-		{
-			name: "with context",
-			args: []string{"--context", "foo", "-f", "compose.yaml", "up"},
-			want: []string{"--context", "foo", "compose", "-f", "compose.yaml", "up"},
-		},
-		{
-			name: "with host",
-			args: []string{"--host", "tcp://1.2.3.4", "up"},
-			want: []string{"--host", "tcp://1.2.3.4", "compose", "up"},
-		},
-		{
-			name: "compose --verbose",
-			args: []string{"--verbose"},
-			want: []string{"--debug", "compose"},
-		},
-		{
-			name: "compose --version",
-			args: []string{"--version"},
-			want: []string{"compose", "version"},
-		},
-		{
-			name: "compose -v",
-			args: []string{"-v"},
-			want: []string{"compose", "version"},
-		},
-		{
-			name: "help",
-			args: []string{"-h"},
-			want: []string{"compose", "--help"},
-		},
-		{
-			name: "issues/1962",
-			args: []string{"psql", "-h", "postgres"},
-			want: []string{"compose", "psql", "-h", "postgres"}, // -h should not be converted to --help
-		},
-		{
-			name: "issues/8648",
-			args: []string{"exec", "mongo", "mongo", "--host", "mongo"},
-			want: []string{"compose", "exec", "mongo", "mongo", "--host", "mongo"}, // --host is passed to exec
-		},
-		{
-			name: "issues/12",
-			args: []string{"--log-level", "INFO", "up"},
-			want: []string{"--log-level", "INFO", "compose", "up"},
-		},
-		{
-			name: "empty string argument",
-			args: []string{"--project-directory", "", "ps"},
-			want: []string{"compose", "--project-directory", "", "ps"},
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := Convert(tt.args)
-			assert.DeepEqual(t, tt.want, got)
-		})
-	}
-}

cmd/compose/build.go

@@ -23,10 +23,8 @@ import (
 	"strings"
 
 	"github.com/compose-spec/compose-go/cli"
-	"github.com/compose-spec/compose-go/loader"
 	"github.com/compose-spec/compose-go/types"
 	buildx "github.com/docker/buildx/util/progress"
-	"github.com/docker/compose/v2/pkg/progress"
 	"github.com/docker/compose/v2/pkg/utils"
 	"github.com/spf13/cobra"
 
@@ -42,28 +40,6 @@ type buildOptions struct {
 	args     []string
 	noCache  bool
 	memory   string
-	ssh      string
-}
-
-func (opts buildOptions) toAPIBuildOptions(services []string) (api.BuildOptions, error) {
-	var SSHKeys []types.SSHKey
-	var err error
-	if opts.ssh != "" {
-		SSHKeys, err = loader.ParseShortSSHSyntax(opts.ssh)
-		if err != nil {
-			return api.BuildOptions{}, err
-		}
-	}
-
-	return api.BuildOptions{
-		Pull:     opts.pull,
-		Progress: opts.progress,
-		Args:     types.NewMappingWithEquals(opts.args),
-		NoCache:  opts.noCache,
-		Quiet:    opts.quiet,
-		Services: services,
-		SSHs:     SSHKeys,
-	}, nil
 }
 
 var printerModes = []string{
@@ -78,7 +54,7 @@ func buildCommand(p *projectOptions, backend api.Service) *cobra.Command {
 		projectOptions: p,
 	}
 	cmd := &cobra.Command{
-		Use:   "build [OPTIONS] [SERVICE...]",
+		Use:   "build [SERVICE...]",
 		Short: "Build or rebuild services",
 		PreRunE: Adapt(func(ctx context.Context, args []string) error {
 			if opts.memory != "" {
@@ -97,22 +73,15 @@ func buildCommand(p *projectOptions, backend api.Service) *cobra.Command {
 			}
 			return nil
 		}),
-		RunE: AdaptCmd(func(ctx context.Context, cmd *cobra.Command, args []string) error {
-			if cmd.Flags().Changed("ssh") && opts.ssh == "" {
-				opts.ssh = "default"
-			}
-			if progress.Mode == progress.ModePlain && !cmd.Flags().Changed("progress") {
-				opts.progress = buildx.PrinterModePlain
-			}
+		RunE: Adapt(func(ctx context.Context, args []string) error {
 			return runBuild(ctx, backend, opts, args)
 		}),
-		ValidArgsFunction: completeServiceNames(p),
+		ValidArgsFunction: serviceCompletion(p),
 	}
 	cmd.Flags().BoolVarP(&opts.quiet, "quiet", "q", false, "Don't print anything to STDOUT")
 	cmd.Flags().BoolVar(&opts.pull, "pull", false, "Always attempt to pull a newer version of the image.")
 	cmd.Flags().StringVar(&opts.progress, "progress", buildx.PrinterModeAuto, fmt.Sprintf(`Set type of progress output (%s)`, strings.Join(printerModes, ", ")))
 	cmd.Flags().StringArrayVar(&opts.args, "build-arg", []string{}, "Set build-time variables for services.")
-	cmd.Flags().StringVar(&opts.ssh, "ssh", "", "Set SSH authentications used when building service images. (use 'default' for using your default SSH Agent)")
 	cmd.Flags().Bool("parallel", true, "Build images in parallel. DEPRECATED")
 	cmd.Flags().MarkHidden("parallel") //nolint:errcheck
 	cmd.Flags().Bool("compress", true, "Compress the build context using gzip. DEPRECATED")
@@ -134,9 +103,12 @@ func runBuild(ctx context.Context, backend api.Service, opts buildOptions, servi
 		return err
 	}
 
-	apiBuildOptions, err := opts.toAPIBuildOptions(services)
-	if err != nil {
-		return err
-	}
-	return backend.Build(ctx, project, apiBuildOptions)
+	return backend.Build(ctx, project, api.BuildOptions{
+		Pull:     opts.pull,
+		Progress: opts.progress,
+		Args:     types.NewMappingWithEquals(opts.args),
+		NoCache:  opts.noCache,
+		Quiet:    opts.quiet,
+		Services: services,
+	})
 }

cmd/compose/completion.go

@@ -19,7 +19,6 @@ package compose
 import (
 	"strings"
 
-	"github.com/docker/compose/v2/pkg/api"
 	"github.com/spf13/cobra"
 )
 
@@ -28,11 +27,11 @@ type validArgsFn func(cmd *cobra.Command, args []string, toComplete string) ([]s
 
 func noCompletion() validArgsFn {
 	return func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
-		return []string{}, cobra.ShellCompDirectiveNoSpace
+		return nil, cobra.ShellCompDirectiveNoFileComp
 	}
 }
 
-func completeServiceNames(p *projectOptions) validArgsFn {
+func serviceCompletion(p *projectOptions) validArgsFn {
 	return func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
 		project, err := p.toProject(nil)
 		if err != nil {
@@ -47,21 +46,3 @@ func completeServiceNames(p *projectOptions) validArgsFn {
 		return serviceNames, cobra.ShellCompDirectiveNoFileComp
 	}
 }
-
-func completeProjectNames(backend api.Service) func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
-	return func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
-		list, err := backend.List(cmd.Context(), api.ListOptions{
-			All: true,
-		})
-		if err != nil {
-			return nil, cobra.ShellCompDirectiveError
-		}
-		var values []string
-		for _, stack := range list {
-			if strings.HasPrefix(stack.Name, toComplete) {
-				values = append(values, stack.Name)
-			}
-		}
-		return values, cobra.ShellCompDirectiveNoFileComp
-	}
-}

cmd/compose/compose.go

@@ -27,22 +27,17 @@ import (
 
 	"github.com/compose-spec/compose-go/cli"
 	"github.com/compose-spec/compose-go/types"
-	composegoutils "github.com/compose-spec/compose-go/utils"
-	"github.com/docker/buildx/util/logutil"
 	dockercli "github.com/docker/cli/cli"
 	"github.com/docker/cli/cli-plugins/manager"
-	"github.com/docker/cli/cli/command"
+	"github.com/docker/compose/v2/cmd/formatter"
 	"github.com/morikuni/aec"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
 
-	"github.com/docker/compose/v2/cmd/formatter"
 	"github.com/docker/compose/v2/pkg/api"
 	"github.com/docker/compose/v2/pkg/compose"
-	"github.com/docker/compose/v2/pkg/progress"
-	"github.com/docker/compose/v2/pkg/utils"
 )
 
 // Command defines a compose CLI command as a func with args
@@ -91,6 +86,9 @@ func Adapt(fn Command) func(cmd *cobra.Command, args []string) error {
 	})
 }
 
+// Warning is a global warning to be displayed to user on command failure
+var Warning string
+
 type projectOptions struct {
 	ProjectName   string
 	Profiles      []string
@@ -122,6 +120,24 @@ func (o *projectOptions) WithServices(fn ProjectServicesFunc) func(cmd *cobra.Co
 			return err
 		}
 
+		if o.EnvFile != "" {
+			var services types.Services
+			for _, s := range project.Services {
+				ef := o.EnvFile
+				if ef != "" {
+					if !filepath.IsAbs(ef) {
+						ef = filepath.Join(project.WorkingDir, o.EnvFile)
+					}
+					if s.Labels == nil {
+						s.Labels = make(map[string]string)
+					}
+					s.Labels[api.EnvironmentFileLabel] = ef
+					services = append(services, s)
+				}
+			}
+			project.Services = services
+		}
+
 		return fn(ctx, project, args)
 	})
 }
@@ -131,40 +147,17 @@ func (o *projectOptions) addProjectFlags(f *pflag.FlagSet) {
 	f.StringVarP(&o.ProjectName, "project-name", "p", "", "Project name")
 	f.StringArrayVarP(&o.ConfigPaths, "file", "f", []string{}, "Compose configuration files")
 	f.StringVar(&o.EnvFile, "env-file", "", "Specify an alternate environment file.")
-	f.StringVar(&o.ProjectDir, "project-directory", "", "Specify an alternate working directory\n(default: the path of the, first specified, Compose file)")
-	f.StringVar(&o.WorkDir, "workdir", "", "DEPRECATED! USE --project-directory INSTEAD.\nSpecify an alternate working directory\n(default: the path of the, first specified, Compose file)")
+	f.StringVar(&o.ProjectDir, "project-directory", "", "Specify an alternate working directory\n(default: the path of the Compose file)")
+	f.StringVar(&o.WorkDir, "workdir", "", "DEPRECATED! USE --project-directory INSTEAD.\nSpecify an alternate working directory\n(default: the path of the Compose file)")
 	f.BoolVar(&o.Compatibility, "compatibility", false, "Run compose in backward compatibility mode")
 	_ = f.MarkHidden("workdir")
 }
 
-func (o *projectOptions) projectOrName(services ...string) (*types.Project, string, error) {
-	name := o.ProjectName
-	var project *types.Project
-	if len(o.ConfigPaths) > 0 || o.ProjectName == "" {
-		p, err := o.toProject(services)
-		if err != nil {
-			envProjectName := os.Getenv("COMPOSE_PROJECT_NAME")
-			if envProjectName != "" {
-				return nil, envProjectName, nil
-			}
-			return nil, "", err
-		}
-		project = p
-		name = p.Name
-	}
-	return project, name, nil
-}
-
 func (o *projectOptions) toProjectName() (string, error) {
 	if o.ProjectName != "" {
 		return o.ProjectName, nil
 	}
 
-	envProjectName := os.Getenv("COMPOSE_PROJECT_NAME")
-	if envProjectName != "" {
-		return envProjectName, nil
-	}
-
 	project, err := o.toProject(nil)
 	if err != nil {
 		return "", err
@@ -178,32 +171,13 @@ func (o *projectOptions) toProject(services []string, po ...cli.ProjectOptionsFn
 		return nil, compose.WrapComposeError(err)
 	}
 
-	if o.Compatibility || utils.StringToBool(options.Environment["COMPOSE_COMPATIBILITY"]) {
-		api.Separator = "_"
-	}
-
 	project, err := cli.ProjectFromOptions(options)
 	if err != nil {
 		return nil, compose.WrapComposeError(err)
 	}
 
-	for i, s := range project.Services {
-		s.CustomLabels = map[string]string{
-			api.ProjectLabel:     project.Name,
-			api.ServiceLabel:     s.Name,
-			api.VersionLabel:     api.ComposeVersion,
-			api.WorkingDirLabel:  project.WorkingDir,
-			api.ConfigFilesLabel: strings.Join(project.ComposeFiles, ","),
-			api.OneoffLabel:      "False", // default, will be overridden by `run` command
-		}
-		if o.EnvFile != "" {
-			s.CustomLabels[api.EnvironmentFileLabel] = o.EnvFile
-		}
-		project.Services[i] = s
-	}
-
-	if profiles, ok := options.Environment["COMPOSE_PROFILES"]; ok && len(o.Profiles) == 0 {
-		o.Profiles = append(o.Profiles, strings.Split(profiles, ",")...)
+	if o.Compatibility || project.Environment["COMPOSE_COMPATIBILITY"] == "true" {
+		compose.Separator = "_"
 	}
 
 	if len(services) > 0 {
@@ -214,6 +188,10 @@ func (o *projectOptions) toProject(services []string, po ...cli.ProjectOptionsFn
 		o.Profiles = append(o.Profiles, s.GetProfiles()...)
 	}
 
+	if profiles, ok := options.Environment["COMPOSE_PROFILES"]; ok {
+		o.Profiles = append(o.Profiles, strings.Split(profiles, ",")...)
+	}
+
 	project.ApplyProfiles(o.Profiles)
 
 	project.WithoutUnnecessaryResources()
@@ -226,47 +204,35 @@ func (o *projectOptions) toProjectOptions(po ...cli.ProjectOptionsFn) (*cli.Proj
 	return cli.NewProjectOptions(o.ConfigPaths,
 		append(po,
 			cli.WithWorkingDirectory(o.ProjectDir),
-			cli.WithOsEnv,
 			cli.WithEnvFile(o.EnvFile),
 			cli.WithDotEnv,
+			cli.WithOsEnv,
 			cli.WithConfigFileEnv,
 			cli.WithDefaultConfigPath,
 			cli.WithName(o.ProjectName))...)
 }
 
-// PluginName is the name of the plugin
-const PluginName = "compose"
+const pluginName = "compose"
 
 // RunningAsStandalone detects when running as a standalone program
 func RunningAsStandalone() bool {
-	return len(os.Args) < 2 || os.Args[1] != manager.MetadataSubcommandName && os.Args[1] != PluginName
+	return len(os.Args) < 2 || os.Args[1] != manager.MetadataSubcommandName && os.Args[1] != pluginName
 }
 
 // RootCommand returns the compose command with its child commands
-func RootCommand(dockerCli command.Cli, backend api.Service) *cobra.Command { //nolint:gocyclo
-	// filter out useless commandConn.CloseWrite warning message that can occur
-	// when using a remote context that is unreachable: "commandConn.CloseWrite: commandconn: failed to wait: signal: killed"
-	// https://github.com/docker/cli/blob/e1f24d3c93df6752d3c27c8d61d18260f141310c/cli/connhelper/commandconn/commandconn.go#L203-L215
-	logrus.AddHook(logutil.NewFilter([]logrus.Level{
-		logrus.WarnLevel,
-	},
-		"commandConn.CloseWrite:",
-		"commandConn.CloseRead:",
-	))
-
+func RootCommand(backend api.Service) *cobra.Command {
 	opts := projectOptions{}
 	var (
-		ansi     string
-		noAnsi   bool
-		verbose  bool
-		version  bool
-		parallel int
+		ansi    string
+		noAnsi  bool
+		verbose bool
+		version bool
 	)
-	c := &cobra.Command{
+	command := &cobra.Command{
 		Short:            "Docker Compose",
-		Use:              PluginName,
+		Use:              pluginName,
 		TraverseChildren: true,
-		// By default (no Run/RunE in parent c) for typos in subcommands, cobra displays the help of parent c but exit(0) !
+		// By default (no Run/RunE in parent command) for typos in subcommands, cobra displays the help of parent command but exit(0) !
 		RunE: func(cmd *cobra.Command, args []string) error {
 			if len(args) == 0 {
 				return cmd.Help()
@@ -281,10 +247,6 @@ func RootCommand(dockerCli command.Cli, backend api.Service) *cobra.Command { //
 			}
 		},
 		PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
-			err := setEnvWithDotEnv(&opts)
-			if err != nil {
-				return err
-			}
 			parent := cmd.Root()
 			if parent != nil {
 				parentPrerun := parent.PersistentPreRunE
@@ -300,18 +262,12 @@ func RootCommand(dockerCli command.Cli, backend api.Service) *cobra.Command { //
 					return errors.New(`cannot specify DEPRECATED "--no-ansi" and "--ansi". Please use only "--ansi"`)
 				}
 				ansi = "never"
-				fmt.Fprint(os.Stderr, "option '--no-ansi' is DEPRECATED ! Please use '--ansi' instead.\n")
+				fmt.Fprint(os.Stderr, aec.Apply("option '--no-ansi' is DEPRECATED ! Please use '--ansi' instead.\n", aec.RedF))
 			}
 			if verbose {
 				logrus.SetLevel(logrus.TraceLevel)
 			}
 			formatter.SetANSIMode(ansi)
-			switch ansi {
-			case "never":
-				progress.Mode = progress.ModePlain
-			case "tty":
-				progress.Mode = progress.ModeTTY
-			}
 			if opts.WorkDir != "" {
 				if opts.ProjectDir != "" {
 					return errors.New(`cannot specify DEPRECATED "--workdir" and "--project-directory". Please use only "--project-directory" instead`)
@@ -319,20 +275,11 @@ func RootCommand(dockerCli command.Cli, backend api.Service) *cobra.Command { //
 				opts.ProjectDir = opts.WorkDir
 				fmt.Fprint(os.Stderr, aec.Apply("option '--workdir' is DEPRECATED at root level! Please use '--project-directory' instead.\n", aec.RedF))
 			}
-			if opts.EnvFile != "" && !filepath.IsAbs(opts.EnvFile) {
-				opts.EnvFile, err = filepath.Abs(opts.EnvFile)
-				if err != nil {
-					return err
-				}
-			}
-			if parallel > 0 {
-				backend.MaxConcurrency(parallel)
-			}
 			return nil
 		},
 	}
 
-	c.AddCommand(
+	command.AddCommand(
 		upCommand(&opts, backend),
 		downCommand(&opts, backend),
 		startCommand(&opts, backend),
@@ -343,9 +290,9 @@ func RootCommand(dockerCli command.Cli, backend api.Service) *cobra.Command { //
 		logsCommand(&opts, backend),
 		convertCommand(&opts, backend),
 		killCommand(&opts, backend),
-		runCommand(&opts, dockerCli, backend),
+		runCommand(&opts, backend),
 		removeCommand(&opts, backend),
-		execCommand(&opts, dockerCli, backend),
+		execCommand(&opts, backend),
 		pauseCommand(&opts, backend),
 		unpauseCommand(&opts, backend),
 		topCommand(&opts, backend),
@@ -359,50 +306,14 @@ func RootCommand(dockerCli command.Cli, backend api.Service) *cobra.Command { //
 		createCommand(&opts, backend),
 		copyCommand(&opts, backend),
 	)
-	c.Flags().SetInterspersed(false)
-	opts.addProjectFlags(c.Flags())
-	c.RegisterFlagCompletionFunc( //nolint:errcheck
-		"project-name",
-		completeProjectNames(backend),
-	)
-	c.RegisterFlagCompletionFunc( //nolint:errcheck
-		"file",
-		func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
-			return []string{"yaml", "yml"}, cobra.ShellCompDirectiveFilterFileExt
-		},
-	)
-
-	c.Flags().StringVar(&ansi, "ansi", "auto", `Control when to print ANSI control characters ("never"|"always"|"auto")`)
-	c.Flags().IntVar(&parallel, "parallel", -1, `Control max parallelism, -1 for unlimited`)
-	c.Flags().BoolVarP(&version, "version", "v", false, "Show the Docker Compose version information")
-	c.Flags().MarkHidden("version") //nolint:errcheck
-	c.Flags().BoolVar(&noAnsi, "no-ansi", false, `Do not print ANSI control characters (DEPRECATED)`)
-	c.Flags().MarkHidden("no-ansi") //nolint:errcheck
-	c.Flags().BoolVar(&verbose, "verbose", false, "Show more output")
-	c.Flags().MarkHidden("verbose") //nolint:errcheck
-	return c
-}
-
-func setEnvWithDotEnv(prjOpts *projectOptions) error {
-	options, err := prjOpts.toProjectOptions()
-	if err != nil {
-		return compose.WrapComposeError(err)
-	}
-	workingDir, err := options.GetWorkingDir()
-	if err != nil {
-		return err
-	}
-
-	envFromFile, err := cli.GetEnvFromFile(composegoutils.GetAsEqualsMap(os.Environ()), workingDir, options.EnvFile)
-	if err != nil {
-		return err
-	}
-	for k, v := range envFromFile {
-		if _, ok := os.LookupEnv(k); !ok { // Precedence to OS Env
-			if err := os.Setenv(k, v); err != nil {
-				return err
-			}
-		}
-	}
-	return nil
+	command.Flags().SetInterspersed(false)
+	opts.addProjectFlags(command.Flags())
+	command.Flags().StringVar(&ansi, "ansi", "auto", `Control when to print ANSI control characters ("never"|"always"|"auto")`)
+	command.Flags().BoolVarP(&version, "version", "v", false, "Show the Docker Compose version information")
+	command.Flags().MarkHidden("version") //nolint:errcheck
+	command.Flags().BoolVar(&noAnsi, "no-ansi", false, `Do not print ANSI control characters (DEPRECATED)`)
+	command.Flags().MarkHidden("no-ansi") //nolint:errcheck
+	command.Flags().BoolVar(&verbose, "verbose", false, "Show more output")
+	command.Flags().MarkHidden("verbose") //nolint:errcheck
+	return command
 }

cmd/compose/convert.go

@@ -18,7 +18,6 @@ package compose
 
 import (
 	"bufio"
-	"bytes"
 	"context"
 	"fmt"
 	"io"
@@ -26,8 +25,12 @@ import (
 	"sort"
 	"strings"
 
+	"github.com/cnabio/cnab-to-oci/remotes"
 	"github.com/compose-spec/compose-go/cli"
 	"github.com/compose-spec/compose-go/types"
+	"github.com/distribution/distribution/v3/reference"
+	cliconfig "github.com/docker/cli/cli/config"
+	"github.com/opencontainers/go-digest"
 	"github.com/spf13/cobra"
 
 	"github.com/docker/compose/v2/pkg/api"
@@ -41,13 +44,10 @@ type convertOptions struct {
 	quiet               bool
 	resolveImageDigests bool
 	noInterpolate       bool
-	noNormalize         bool
 	services            bool
 	volumes             bool
 	profiles            bool
-	images              bool
 	hash                string
-	noConsistency       bool
 }
 
 func convertCommand(p *projectOptions, backend api.Service) *cobra.Command {
@@ -56,7 +56,7 @@ func convertCommand(p *projectOptions, backend api.Service) *cobra.Command {
 	}
 	cmd := &cobra.Command{
 		Aliases: []string{"config"},
-		Use:     "convert [OPTIONS] [SERVICE...]",
+		Use:     "convert SERVICES",
 		Short:   "Converts the compose file to platform's canonical format",
 		PreRunE: Adapt(func(ctx context.Context, args []string) error {
 			if opts.quiet {
@@ -66,9 +66,6 @@ func convertCommand(p *projectOptions, backend api.Service) *cobra.Command {
 				}
 				os.Stdout = devnull
 			}
-			if p.Compatibility {
-				opts.noNormalize = true
-			}
 			return nil
 		}),
 		RunE: Adapt(func(ctx context.Context, args []string) error {
@@ -84,26 +81,20 @@ func convertCommand(p *projectOptions, backend api.Service) *cobra.Command {
 			if opts.profiles {
 				return runProfiles(opts, args)
 			}
-			if opts.images {
-				return runConfigImages(opts, args)
-			}
 
 			return runConvert(ctx, backend, opts, args)
 		}),
-		ValidArgsFunction: completeServiceNames(p),
+		ValidArgsFunction: serviceCompletion(p),
 	}
 	flags := cmd.Flags()
 	flags.StringVar(&opts.Format, "format", "yaml", "Format the output. Values: [yaml | json]")
 	flags.BoolVar(&opts.resolveImageDigests, "resolve-image-digests", false, "Pin image tags to digests.")
 	flags.BoolVarP(&opts.quiet, "quiet", "q", false, "Only validate the configuration, don't print anything.")
 	flags.BoolVar(&opts.noInterpolate, "no-interpolate", false, "Don't interpolate environment variables.")
-	flags.BoolVar(&opts.noNormalize, "no-normalize", false, "Don't normalize compose model.")
-	flags.BoolVar(&opts.noConsistency, "no-consistency", false, "Don't check model consistency - warning: may produce invalid Compose output")
 
 	flags.BoolVar(&opts.services, "services", false, "Print the service names, one per line.")
 	flags.BoolVar(&opts.volumes, "volumes", false, "Print the volume names, one per line.")
 	flags.BoolVar(&opts.profiles, "profiles", false, "Print the profile names, one per line.")
-	flags.BoolVar(&opts.images, "images", false, "Print the image names, one per line.")
 	flags.StringVar(&opts.hash, "hash", "", "Print the service config hash, one per line.")
 	flags.StringVarP(&opts.Output, "output", "o", "", "Save to file (default to stdout)")
 
@@ -111,44 +102,46 @@ func convertCommand(p *projectOptions, backend api.Service) *cobra.Command {
 }
 
 func runConvert(ctx context.Context, backend api.Service, opts convertOptions, services []string) error {
-	var content []byte
-	project, err := opts.toProject(services,
-		cli.WithInterpolation(!opts.noInterpolate),
-		cli.WithResolvedPaths(true),
-		cli.WithNormalization(!opts.noNormalize),
-		cli.WithConsistency(!opts.noConsistency),
-		cli.WithDiscardEnvFile)
-
+	var json []byte
+	project, err := opts.toProject(services, cli.WithInterpolation(!opts.noInterpolate), cli.WithResolvedPaths(true))
 	if err != nil {
 		return err
 	}
 
-	content, err = backend.Convert(ctx, project, api.ConvertOptions{
-		Format:              opts.Format,
-		Output:              opts.Output,
-		ResolveImageDigests: opts.resolveImageDigests,
+	if opts.resolveImageDigests {
+		configFile := cliconfig.LoadDefaultConfigFile(os.Stderr)
+
+		resolver := remotes.CreateResolver(configFile)
+		err = project.ResolveImages(func(named reference.Named) (digest.Digest, error) {
+			_, desc, err := resolver.Resolve(ctx, named.String())
+			return desc.Digest, err
+		})
+		if err != nil {
+			return err
+		}
+	}
+
+	json, err = backend.Convert(ctx, project, api.ConvertOptions{
+		Format: opts.Format,
+		Output: opts.Output,
 	})
 	if err != nil {
 		return err
 	}
 
-	if !opts.noInterpolate {
-		content = escapeDollarSign(content)
-	}
-
 	if opts.quiet {
 		return nil
 	}
 
 	var out io.Writer = os.Stdout
-	if opts.Output != "" && len(content) > 0 {
+	if opts.Output != "" && len(json) > 0 {
 		file, err := os.Create(opts.Output)
 		if err != nil {
 			return err
 		}
 		out = bufio.NewWriter(file)
 	}
-	_, err = fmt.Fprint(out, string(content))
+	_, err = fmt.Fprint(out, string(json))
 	return err
 }
 
@@ -214,24 +207,3 @@ func runProfiles(opts convertOptions, services []string) error {
 	}
 	return nil
 }
-
-func runConfigImages(opts convertOptions, services []string) error {
-	project, err := opts.toProject(services)
-	if err != nil {
-		return err
-	}
-	for _, s := range project.Services {
-		if s.Image != "" {
-			fmt.Println(s.Image)
-		} else {
-			fmt.Printf("%s%s%s\n", project.Name, api.Separator, s.Name)
-		}
-	}
-	return nil
-}
-
-func escapeDollarSign(marshal []byte) []byte {
-	dollar := []byte{'$'}
-	escDollar := []byte{'$', '$'}
-	return bytes.ReplaceAll(marshal, dollar, escDollar)
-}

cmd/compose/cp.go

@@ -55,19 +55,17 @@ func copyCommand(p *projectOptions, backend api.Service) *cobra.Command {
 			}
 			return nil
 		}),
-		RunE: AdaptCmd(func(ctx context.Context, cmd *cobra.Command, args []string) error {
+		RunE: Adapt(func(ctx context.Context, args []string) error {
 			opts.source = args[0]
 			opts.destination = args[1]
 			return runCopy(ctx, backend, opts)
 		}),
-		ValidArgsFunction: completeServiceNames(p),
+		ValidArgsFunction: serviceCompletion(p),
 	}
 
 	flags := copyCmd.Flags()
-	flags.IntVar(&opts.index, "index", 0, "Index of the container if there are multiple instances of a service .")
+	flags.IntVar(&opts.index, "index", 1, "Index of the container if there are multiple instances of a service [default: 1].")
 	flags.BoolVar(&opts.all, "all", false, "Copy to all the containers of the service.")
-	flags.MarkHidden("all")                                                                                                      //nolint:errcheck
-	flags.MarkDeprecated("all", "By default all the containers of the service will get the source file/directory to be copied.") //nolint:errcheck
 	flags.BoolVarP(&opts.followLink, "follow-link", "L", false, "Always follow symbol link in SRC_PATH")
 	flags.BoolVarP(&opts.copyUIDGID, "archive", "a", false, "Archive mode (copy all uid/gid information)")
 
@@ -75,12 +73,12 @@ func copyCommand(p *projectOptions, backend api.Service) *cobra.Command {
 }
 
 func runCopy(ctx context.Context, backend api.Service, opts copyOptions) error {
-	name, err := opts.toProjectName()
+	projects, err := opts.toProject(nil)
 	if err != nil {
 		return err
 	}
 
-	return backend.Copy(ctx, name, api.CopyOptions{
+	return backend.Copy(ctx, projects, api.CopyOptions{
 		Source:      opts.source,
 		Destination: opts.destination,
 		All:         opts.all,

cmd/compose/create.go

@@ -30,8 +30,6 @@ import (
 type createOptions struct {
 	Build         bool
 	noBuild       bool
-	Pull          string
-	pullChanged   bool
 	removeOrphans bool
 	ignoreOrphans bool
 	forceRecreate bool
@@ -46,10 +44,9 @@ type createOptions struct {
 func createCommand(p *projectOptions, backend api.Service) *cobra.Command {
 	opts := createOptions{}
 	cmd := &cobra.Command{
-		Use:   "create [OPTIONS] [SERVICE...]",
+		Use:   "create [SERVICE...]",
 		Short: "Creates containers for a service.",
-		PreRunE: AdaptCmd(func(ctx context.Context, cmd *cobra.Command, args []string) error {
-			opts.pullChanged = cmd.Flags().Changed("pull")
+		PreRunE: Adapt(func(ctx context.Context, args []string) error {
 			if opts.Build && opts.noBuild {
 				return fmt.Errorf("--build and --no-build are incompatible")
 			}
@@ -59,7 +56,6 @@ func createCommand(p *projectOptions, backend api.Service) *cobra.Command {
 			return nil
 		}),
 		RunE: p.WithProject(func(ctx context.Context, project *types.Project) error {
-			opts.Apply(project)
 			return backend.Create(ctx, project, api.CreateOptions{
 				RemoveOrphans:        opts.removeOrphans,
 				IgnoreOrphans:        opts.ignoreOrphans,
@@ -70,12 +66,11 @@ func createCommand(p *projectOptions, backend api.Service) *cobra.Command {
 				QuietPull:            false,
 			})
 		}),
-		ValidArgsFunction: completeServiceNames(p),
+		ValidArgsFunction: serviceCompletion(p),
 	}
 	flags := cmd.Flags()
 	flags.BoolVar(&opts.Build, "build", false, "Build images before starting containers.")
 	flags.BoolVar(&opts.noBuild, "no-build", false, "Don't build an image, even if it's missing.")
-	flags.StringVar(&opts.Pull, "pull", "missing", `Pull image before running ("always"|"missing"|"never")`)
 	flags.BoolVar(&opts.forceRecreate, "force-recreate", false, "Recreate containers even if their configuration and image haven't changed.")
 	flags.BoolVar(&opts.noRecreate, "no-recreate", false, "If containers already exist, don't recreate them. Incompatible with --force-recreate.")
 	return cmd
@@ -110,12 +105,6 @@ func (opts createOptions) GetTimeout() *time.Duration {
 }
 
 func (opts createOptions) Apply(project *types.Project) {
-	if opts.pullChanged {
-		for i, service := range project.Services {
-			service.PullPolicy = opts.Pull
-			project.Services[i] = service
-		}
-	}
 	if opts.Build {
 		for i, service := range project.Services {
 			if service.Build == nil {
@@ -128,9 +117,6 @@ func (opts createOptions) Apply(project *types.Project) {
 	if opts.noBuild {
 		for i, service := range project.Services {
 			service.Build = nil
-			if service.Image == "" {
-				service.Image = api.GetImageNameOrDefault(service, project.Name)
-			}
 			project.Services[i] = service
 		}
 	}

cmd/compose/down.go

@@ -19,13 +19,10 @@ package compose
 import (
 	"context"
 	"fmt"
-	"os"
 	"time"
 
-	"github.com/docker/compose/v2/pkg/utils"
-	"github.com/sirupsen/logrus"
+	"github.com/compose-spec/compose-go/types"
 	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
 
 	"github.com/docker/compose/v2/pkg/api"
 )
@@ -44,7 +41,7 @@ func downCommand(p *projectOptions, backend api.Service) *cobra.Command {
 		projectOptions: p,
 	}
 	downCmd := &cobra.Command{
-		Use:   "down [OPTIONS]",
+		Use:   "down",
 		Short: "Stop and remove containers, networks",
 		PreRunE: AdaptCmd(func(ctx context.Context, cmd *cobra.Command, args []string) error {
 			opts.timeChanged = cmd.Flags().Changed("timeout")
@@ -58,29 +55,26 @@ func downCommand(p *projectOptions, backend api.Service) *cobra.Command {
 		RunE: Adapt(func(ctx context.Context, args []string) error {
 			return runDown(ctx, backend, opts)
 		}),
-		Args:              cobra.NoArgs,
 		ValidArgsFunction: noCompletion(),
 	}
 	flags := downCmd.Flags()
-	removeOrphans := utils.StringToBool(os.Getenv("COMPOSE_REMOVE_ORPHANS"))
-	flags.BoolVar(&opts.removeOrphans, "remove-orphans", removeOrphans, "Remove containers for services not defined in the Compose file.")
+	flags.BoolVar(&opts.removeOrphans, "remove-orphans", false, "Remove containers for services not defined in the Compose file.")
 	flags.IntVarP(&opts.timeout, "timeout", "t", 10, "Specify a shutdown timeout in seconds")
-	flags.BoolVarP(&opts.volumes, "volumes", "v", false, "Remove named volumes declared in the `volumes` section of the Compose file and anonymous volumes attached to containers.")
+	flags.BoolVarP(&opts.volumes, "volumes", "v", false, " Remove named volumes declared in the `volumes` section of the Compose file and anonymous volumes attached to containers.")
 	flags.StringVar(&opts.images, "rmi", "", `Remove images used by services. "local" remove only images that don't have a custom tag ("local"|"all")`)
-	flags.SetNormalizeFunc(func(f *pflag.FlagSet, name string) pflag.NormalizedName {
-		if name == "volume" {
-			name = "volumes"
-			logrus.Warn("--volume is deprecated, please use --volumes")
-		}
-		return pflag.NormalizedName(name)
-	})
 	return downCmd
 }
 
 func runDown(ctx context.Context, backend api.Service, opts downOptions) error {
-	project, name, err := opts.projectOrName()
-	if err != nil {
-		return err
+	name := opts.ProjectName
+	var project *types.Project
+	if opts.ProjectName == "" {
+		p, err := opts.toProject(nil)
+		if err != nil {
+			return err
+		}
+		project = p
+		name = p.Name
 	}
 
 	var timeout *time.Duration

cmd/compose/events.go

@@ -38,12 +38,12 @@ func eventsCommand(p *projectOptions, backend api.Service) *cobra.Command {
 		},
 	}
 	cmd := &cobra.Command{
-		Use:   "events [OPTIONS] [SERVICE...]",
+		Use:   "events [options] [--] [SERVICE...]",
 		Short: "Receive real time events from containers.",
 		RunE: Adapt(func(ctx context.Context, args []string) error {
 			return runEvents(ctx, backend, opts, args)
 		}),
-		ValidArgsFunction: completeServiceNames(p),
+		ValidArgsFunction: serviceCompletion(p),
 	}
 
 	cmd.Flags().BoolVar(&opts.json, "json", false, "Output events as a stream of json objects")
@@ -51,12 +51,12 @@ func eventsCommand(p *projectOptions, backend api.Service) *cobra.Command {
 }
 
 func runEvents(ctx context.Context, backend api.Service, opts eventsOpts, services []string) error {
-	name, err := opts.toProjectName()
+	project, err := opts.toProjectName()
 	if err != nil {
 		return err
 	}
 
-	return backend.Events(ctx, name, api.EventsOptions{
+	return backend.Events(ctx, project, api.EventsOptions{
 		Services: services,
 		Consumer: func(event api.Event) error {
 			if opts.json {

cmd/compose/exec.go

@@ -18,10 +18,12 @@ package compose
 
 import (
 	"context"
+	"fmt"
+	"os"
 
 	"github.com/compose-spec/compose-go/types"
+	"github.com/containerd/console"
 	"github.com/docker/cli/cli"
-	"github.com/docker/cli/cli/command"
 	"github.com/docker/compose/v2/pkg/api"
 	"github.com/docker/compose/v2/pkg/compose"
 	"github.com/spf13/cobra"
@@ -35,22 +37,21 @@ type execOpts struct {
 	environment []string
 	workingDir  string
 
-	noTty       bool
-	user        string
-	detach      bool
-	index       int
-	privileged  bool
-	interactive bool
+	noTty      bool
+	user       string
+	detach     bool
+	index      int
+	privileged bool
 }
 
-func execCommand(p *projectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
+func execCommand(p *projectOptions, backend api.Service) *cobra.Command {
 	opts := execOpts{
 		composeOptions: &composeOptions{
 			projectOptions: p,
 		},
 	}
 	runCmd := &cobra.Command{
-		Use:   "exec [OPTIONS] SERVICE COMMAND [ARGS...]",
+		Use:   "exec [options] [-e KEY=VAL...] [--] SERVICE COMMAND [ARGS...]",
 		Short: "Execute a command in a running container.",
 		Args:  cobra.MinimumNArgs(2),
 		PreRunE: Adapt(func(ctx context.Context, args []string) error {
@@ -61,7 +62,7 @@ func execCommand(p *projectOptions, dockerCli command.Cli, backend api.Service)
 		RunE: Adapt(func(ctx context.Context, args []string) error {
 			return runExec(ctx, backend, opts)
 		}),
-		ValidArgsFunction: completeServiceNames(p),
+		ValidArgsFunction: serviceCompletion(p),
 	}
 
 	runCmd.Flags().BoolVarP(&opts.detach, "detach", "d", false, "Detached mode: Run command in the background.")
@@ -69,14 +70,9 @@ func execCommand(p *projectOptions, dockerCli command.Cli, backend api.Service)
 	runCmd.Flags().IntVar(&opts.index, "index", 1, "index of the container if there are multiple instances of a service [default: 1].")
 	runCmd.Flags().BoolVarP(&opts.privileged, "privileged", "", false, "Give extended privileges to the process.")
 	runCmd.Flags().StringVarP(&opts.user, "user", "u", "", "Run the command as this user.")
-	runCmd.Flags().BoolVarP(&opts.noTty, "no-TTY", "T", !dockerCli.Out().IsTerminal(), "Disable pseudo-TTY allocation. By default `docker compose exec` allocates a TTY.")
+	runCmd.Flags().BoolVarP(&opts.noTty, "no-TTY", "T", notAtTTY(), "Disable pseudo-TTY allocation. By default `docker compose exec` allocates a TTY.")
 	runCmd.Flags().StringVarP(&opts.workingDir, "workdir", "w", "", "Path to workdir directory for this command.")
 
-	runCmd.Flags().BoolVarP(&opts.interactive, "interactive", "i", true, "Keep STDIN open even if not attached.")
-	runCmd.Flags().MarkHidden("interactive") //nolint:errcheck
-	runCmd.Flags().BoolP("tty", "t", true, "Allocate a pseudo-TTY.")
-	runCmd.Flags().MarkHidden("tty") //nolint:errcheck
-
 	runCmd.Flags().SetInterspersed(false)
 	return runCmd
 }
@@ -104,9 +100,27 @@ func runExec(ctx context.Context, backend api.Service, opts execOpts) error {
 		Index:       opts.index,
 		Detach:      opts.detach,
 		WorkingDir:  opts.workingDir,
-		Interactive: opts.interactive,
+
+		Stdin:  os.Stdin,
+		Stdout: os.Stdout,
+		Stderr: os.Stderr,
 	}
 
+	if execOpts.Tty {
+		con := console.Current()
+		if err := con.SetRaw(); err != nil {
+			return err
+		}
+		defer func() {
+			if err := con.Reset(); err != nil {
+				fmt.Println("Unable to close the console")
+			}
+		}()
+
+		execOpts.Stdin = con
+		execOpts.Stdout = con
+		execOpts.Stderr = con
+	}
 	exitCode, err := backend.Exec(ctx, projectName, execOpts)
 	if exitCode != 0 {
 		errMsg := ""

cmd/compose/images.go

@@ -35,8 +35,7 @@ import (
 
 type imageOptions struct {
 	*projectOptions
-	Quiet  bool
-	Format string
+	Quiet bool
 }
 
 func imagesCommand(p *projectOptions, backend api.Service) *cobra.Command {
@@ -44,14 +43,13 @@ func imagesCommand(p *projectOptions, backend api.Service) *cobra.Command {
 		projectOptions: p,
 	}
 	imgCmd := &cobra.Command{
-		Use:   "images [OPTIONS] [SERVICE...]",
+		Use:   "images [SERVICE...]",
 		Short: "List images used by the created containers",
 		RunE: Adapt(func(ctx context.Context, args []string) error {
 			return runImages(ctx, backend, opts, args)
 		}),
-		ValidArgsFunction: completeServiceNames(p),
+		ValidArgsFunction: serviceCompletion(p),
 	}
-	imgCmd.Flags().StringVar(&opts.Format, "format", "table", "Format the output. Values: [table | json].")
 	imgCmd.Flags().BoolVarP(&opts.Quiet, "quiet", "q", false, "Only display IDs")
 	return imgCmd
 }
@@ -90,7 +88,7 @@ func runImages(ctx context.Context, backend api.Service, opts imageOptions, serv
 		return images[i].ContainerName < images[j].ContainerName
 	})
 
-	return formatter.Print(images, opts.Format, os.Stdout,
+	return formatter.Print(images, formatter.PRETTY, os.Stdout,
 		func(w io.Writer) {
 			for _, img := range images {
 				id := stringid.TruncateID(img.ID)
@@ -106,5 +104,5 @@ func runImages(ctx context.Context, backend api.Service, opts imageOptions, serv
 				_, _ = fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\n", img.ContainerName, repo, tag, id, size)
 			}
 		},
-		"CONTAINER", "REPOSITORY", "TAG", "IMAGE ID", "SIZE")
+		"Container", "Repository", "Tag", "Image Id", "Size")
 }

cmd/compose/kill.go

@@ -18,52 +18,26 @@ package compose
 
 import (
 	"context"
-	"os"
 
+	"github.com/compose-spec/compose-go/types"
 	"github.com/spf13/cobra"
 
 	"github.com/docker/compose/v2/pkg/api"
-	"github.com/docker/compose/v2/pkg/utils"
 )
 
-type killOptions struct {
-	*projectOptions
-	removeOrphans bool
-	signal        string
-}
-
 func killCommand(p *projectOptions, backend api.Service) *cobra.Command {
-	opts := killOptions{
-		projectOptions: p,
-	}
+	var opts api.KillOptions
 	cmd := &cobra.Command{
-		Use:   "kill [OPTIONS] [SERVICE...]",
+		Use:   "kill [options] [SERVICE...]",
 		Short: "Force stop service containers.",
-		RunE: Adapt(func(ctx context.Context, args []string) error {
-			return runKill(ctx, backend, opts, args)
+		RunE: p.WithProject(func(ctx context.Context, project *types.Project) error {
+			return backend.Kill(ctx, project, opts)
 		}),
-		ValidArgsFunction: completeServiceNames(p),
+		ValidArgsFunction: serviceCompletion(p),
 	}
 
 	flags := cmd.Flags()
-	removeOrphans := utils.StringToBool(os.Getenv("COMPOSE_REMOVE_ORPHANS"))
-	flags.BoolVar(&opts.removeOrphans, "remove-orphans", removeOrphans, "Remove containers for services not defined in the Compose file.")
-	flags.StringVarP(&opts.signal, "signal", "s", "SIGKILL", "SIGNAL to send to the container.")
+	flags.StringVarP(&opts.Signal, "signal", "s", "SIGKILL", "SIGNAL to send to the container.")
 
 	return cmd
 }
-
-func runKill(ctx context.Context, backend api.Service, opts killOptions, services []string) error {
-	project, name, err := opts.projectOrName(services...)
-	if err != nil {
-		return err
-	}
-
-	return backend.Kill(ctx, name, api.KillOptions{
-		RemoveOrphans: opts.removeOrphans,
-		Project:       project,
-		Services:      services,
-		Signal:        opts.signal,
-	})
-
-}

cmd/compose/list.go

@@ -39,20 +39,19 @@ type lsOptions struct {
 }
 
 func listCommand(backend api.Service) *cobra.Command {
-	lsOpts := lsOptions{Filter: opts.NewFilterOpt()}
+	opts := lsOptions{Filter: opts.NewFilterOpt()}
 	lsCmd := &cobra.Command{
-		Use:   "ls [OPTIONS]",
+		Use:   "ls",
 		Short: "List running compose projects",
 		RunE: Adapt(func(ctx context.Context, args []string) error {
-			return runList(ctx, backend, lsOpts)
+			return runList(ctx, backend, opts)
 		}),
-		Args:              cobra.NoArgs,
 		ValidArgsFunction: noCompletion(),
 	}
-	lsCmd.Flags().StringVar(&lsOpts.Format, "format", "table", "Format the output. Values: [table | json].")
-	lsCmd.Flags().BoolVarP(&lsOpts.Quiet, "quiet", "q", false, "Only display IDs.")
-	lsCmd.Flags().Var(&lsOpts.Filter, "filter", "Filter output based on conditions provided.")
-	lsCmd.Flags().BoolVarP(&lsOpts.All, "all", "a", false, "Show all stopped Compose projects")
+	lsCmd.Flags().StringVar(&opts.Format, "format", "pretty", "Format the output. Values: [pretty | json].")
+	lsCmd.Flags().BoolVarP(&opts.Quiet, "quiet", "q", false, "Only display IDs.")
+	lsCmd.Flags().Var(&opts.Filter, "filter", "Filter output based on conditions provided.")
+	lsCmd.Flags().BoolVarP(&opts.All, "all", "a", false, "Show all stopped Compose projects")
 
 	return lsCmd
 }
@@ -61,18 +60,18 @@ var acceptedListFilters = map[string]bool{
 	"name": true,
 }
 
-func runList(ctx context.Context, backend api.Service, lsOpts lsOptions) error {
-	filters := lsOpts.Filter.Value()
+func runList(ctx context.Context, backend api.Service, opts lsOptions) error {
+	filters := opts.Filter.Value()
 	err := filters.Validate(acceptedListFilters)
 	if err != nil {
 		return err
 	}
 
-	stackList, err := backend.List(ctx, api.ListOptions{All: lsOpts.All})
+	stackList, err := backend.List(ctx, api.ListOptions{All: opts.All})
 	if err != nil {
 		return err
 	}
-	if lsOpts.Quiet {
+	if opts.Quiet {
 		for _, s := range stackList {
 			fmt.Println(s.Name)
 		}
@@ -91,26 +90,24 @@ func runList(ctx context.Context, backend api.Service, lsOpts lsOptions) error {
 	}
 
 	view := viewFromStackList(stackList)
-	return formatter.Print(view, lsOpts.Format, os.Stdout, func(w io.Writer) {
+	return formatter.Print(view, opts.Format, os.Stdout, func(w io.Writer) {
 		for _, stack := range view {
-			_, _ = fmt.Fprintf(w, "%s\t%s\t%s\n", stack.Name, stack.Status, stack.ConfigFiles)
+			_, _ = fmt.Fprintf(w, "%s\t%s\n", stack.Name, stack.Status)
 		}
-	}, "NAME", "STATUS", "CONFIG FILES")
+	}, "NAME", "STATUS")
 }
 
 type stackView struct {
-	Name        string
-	Status      string
-	ConfigFiles string
+	Name   string
+	Status string
 }
 
 func viewFromStackList(stackList []api.Stack) []stackView {
 	retList := make([]stackView, len(stackList))
 	for i, s := range stackList {
 		retList[i] = stackView{
-			Name:        s.Name,
-			Status:      strings.TrimSpace(fmt.Sprintf("%s %s", s.Status, s.Reason)),
-			ConfigFiles: s.ConfigFiles,
+			Name:   s.Name,
+			Status: strings.TrimSpace(fmt.Sprintf("%s %s", s.Status, s.Reason)),
 		}
 	}
 	return retList

cmd/compose/logs.go

@@ -20,9 +20,10 @@ import (
 	"context"
 	"os"
 
+	"github.com/docker/compose/v2/cmd/formatter"
+
 	"github.com/spf13/cobra"
 
-	"github.com/docker/compose/v2/cmd/formatter"
 	"github.com/docker/compose/v2/pkg/api"
 )
 
@@ -43,12 +44,12 @@ func logsCommand(p *projectOptions, backend api.Service) *cobra.Command {
 		projectOptions: p,
 	}
 	logsCmd := &cobra.Command{
-		Use:   "logs [OPTIONS] [SERVICE...]",
+		Use:   "logs [SERVICE...]",
 		Short: "View output from containers",
 		RunE: Adapt(func(ctx context.Context, args []string) error {
 			return runLogs(ctx, backend, opts, args)
 		}),
-		ValidArgsFunction: completeServiceNames(p),
+		ValidArgsFunction: serviceCompletion(p),
 	}
 	flags := logsCmd.Flags()
 	flags.BoolVarP(&opts.follow, "follow", "f", false, "Follow log output.")
@@ -62,13 +63,12 @@ func logsCommand(p *projectOptions, backend api.Service) *cobra.Command {
 }
 
 func runLogs(ctx context.Context, backend api.Service, opts logsOptions, services []string) error {
-	project, name, err := opts.projectOrName(services...)
+	projectName, err := opts.toProjectName()
 	if err != nil {
 		return err
 	}
-	consumer := formatter.NewLogConsumer(ctx, os.Stdout, os.Stderr, !opts.noColor, !opts.noPrefix, false)
-	return backend.Logs(ctx, name, consumer, api.LogOptions{
-		Project:    project,
+	consumer := formatter.NewLogConsumer(ctx, os.Stdout, !opts.noColor, !opts.noPrefix)
+	return backend.Logs(ctx, projectName, consumer, api.LogOptions{
 		Services:   services,
 		Follow:     opts.follow,
 		Tail:       opts.tail,

cmd/compose/pause.go

@@ -38,20 +38,19 @@ func pauseCommand(p *projectOptions, backend api.Service) *cobra.Command {
 		RunE: Adapt(func(ctx context.Context, args []string) error {
 			return runPause(ctx, backend, opts, args)
 		}),
-		ValidArgsFunction: completeServiceNames(p),
+		ValidArgsFunction: serviceCompletion(p),
 	}
 	return cmd
 }
 
 func runPause(ctx context.Context, backend api.Service, opts pauseOptions, services []string) error {
-	project, name, err := opts.projectOrName(services...)
+	project, err := opts.toProjectName()
 	if err != nil {
 		return err
 	}
 
-	return backend.Pause(ctx, name, api.PauseOptions{
+	return backend.Pause(ctx, project, api.PauseOptions{
 		Services: services,
-		Project:  project,
 	})
 }
 
@@ -69,19 +68,18 @@ func unpauseCommand(p *projectOptions, backend api.Service) *cobra.Command {
 		RunE: Adapt(func(ctx context.Context, args []string) error {
 			return runUnPause(ctx, backend, opts, args)
 		}),
-		ValidArgsFunction: completeServiceNames(p),
+		ValidArgsFunction: serviceCompletion(p),
 	}
 	return cmd
 }
 
 func runUnPause(ctx context.Context, backend api.Service, opts unpauseOptions, services []string) error {
-	project, name, err := opts.projectOrName(services...)
+	project, err := opts.toProjectName()
 	if err != nil {
 		return err
 	}
 
-	return backend.UnPause(ctx, name, api.PauseOptions{
+	return backend.UnPause(ctx, project, api.PauseOptions{
 		Services: services,
-		Project:  project,
 	})
 }

cmd/compose/port.go

@@ -20,7 +20,6 @@ import (
 	"context"
 	"fmt"
 	"strconv"
-	"strings"
 
 	"github.com/spf13/cobra"
 
@@ -29,7 +28,7 @@ import (
 
 type portOptions struct {
 	*projectOptions
-	port     uint16
+	port     int
 	protocol string
 	index    int
 }
@@ -39,22 +38,21 @@ func portCommand(p *projectOptions, backend api.Service) *cobra.Command {
 		projectOptions: p,
 	}
 	cmd := &cobra.Command{
-		Use:   "port [OPTIONS] SERVICE PRIVATE_PORT",
+		Use:   "port [options] [--] SERVICE PRIVATE_PORT",
 		Short: "Print the public port for a port binding.",
 		Args:  cobra.MinimumNArgs(2),
 		PreRunE: Adapt(func(ctx context.Context, args []string) error {
-			port, err := strconv.ParseUint(args[1], 10, 16)
+			port, err := strconv.Atoi(args[1])
 			if err != nil {
 				return err
 			}
-			opts.port = uint16(port)
-			opts.protocol = strings.ToLower(opts.protocol)
+			opts.port = port
 			return nil
 		}),
 		RunE: Adapt(func(ctx context.Context, args []string) error {
 			return runPort(ctx, backend, opts, args[0])
 		}),
-		ValidArgsFunction: completeServiceNames(p),
+		ValidArgsFunction: serviceCompletion(p),
 	}
 	cmd.Flags().StringVar(&opts.protocol, "protocol", "tcp", "tcp or udp")
 	cmd.Flags().IntVar(&opts.index, "index", 1, "index of the container if service has multiple replicas")

cmd/compose/ps.go

@@ -24,14 +24,11 @@ import (
 	"sort"
 	"strconv"
 	"strings"
-	"time"
 
 	"github.com/docker/compose/v2/cmd/formatter"
 	"github.com/docker/compose/v2/pkg/utils"
-	"github.com/docker/docker/api/types"
 
 	formatter2 "github.com/docker/cli/cli/command/formatter"
-	"github.com/docker/go-units"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 
@@ -62,7 +59,7 @@ func (p *psOptions) parseFilter() error {
 	case "source":
 		return api.ErrNotImplemented
 	default:
-		return fmt.Errorf("unknown filter %s", parts[0])
+		return fmt.Errorf("unknow filter %s", parts[0])
 	}
 	return nil
 }
@@ -72,7 +69,7 @@ func psCommand(p *projectOptions, backend api.Service) *cobra.Command {
 		projectOptions: p,
 	}
 	psCmd := &cobra.Command{
-		Use:   "ps [OPTIONS] [SERVICE...]",
+		Use:   "ps [SERVICE...]",
 		Short: "List containers",
 		PreRunE: func(cmd *cobra.Command, args []string) error {
 			return opts.parseFilter()
@@ -80,25 +77,25 @@ func psCommand(p *projectOptions, backend api.Service) *cobra.Command {
 		RunE: Adapt(func(ctx context.Context, args []string) error {
 			return runPs(ctx, backend, args, opts)
 		}),
-		ValidArgsFunction: completeServiceNames(p),
+		ValidArgsFunction: serviceCompletion(p),
 	}
 	flags := psCmd.Flags()
-	flags.StringVar(&opts.Format, "format", "table", "Format the output. Values: [table | json]")
-	flags.StringVar(&opts.Filter, "filter", "", "Filter services by a property (supported filters: status).")
+	flags.StringVar(&opts.Format, "format", "pretty", "Format the output. Values: [pretty | json]")
+	flags.StringVar(&opts.Filter, "filter", "", "Filter services by a property. Deprecated, use --status instead")
 	flags.StringArrayVar(&opts.Status, "status", []string{}, "Filter services by status. Values: [paused | restarting | removing | running | dead | created | exited]")
 	flags.BoolVarP(&opts.Quiet, "quiet", "q", false, "Only display IDs")
 	flags.BoolVar(&opts.Services, "services", false, "Display services")
 	flags.BoolVarP(&opts.All, "all", "a", false, "Show all stopped containers (including those created by the run command)")
+	flags.Lookup("filter").Hidden = true
 	return psCmd
 }
 
 func runPs(ctx context.Context, backend api.Service, services []string, opts psOptions) error {
-	project, name, err := opts.projectOrName(services...)
+	projectName, err := opts.toProjectName()
 	if err != nil {
 		return err
 	}
-	containers, err := backend.Ps(ctx, name, api.PsOptions{
-		Project:  project,
+	containers, err := backend.Ps(ctx, projectName, api.PsOptions{
 		All:      opts.All,
 		Services: services,
 	})
@@ -143,19 +140,22 @@ SERVICES:
 	}
 
 	return formatter.Print(containers, opts.Format, os.Stdout,
-		writer(containers),
-		"NAME", "IMAGE", "COMMAND", "SERVICE", "CREATED", "STATUS", "PORTS")
+		writter(containers),
+		"NAME", "COMMAND", "SERVICE", "STATUS", "PORTS")
 }
 
-func writer(containers []api.ContainerSummary) func(w io.Writer) {
+func writter(containers []api.ContainerSummary) func(w io.Writer) {
 	return func(w io.Writer) {
 		for _, container := range containers {
-			ports := displayablePorts(container)
-			createdAt := time.Unix(container.Created, 0)
-			created := units.HumanDuration(time.Now().UTC().Sub(createdAt)) + " ago"
-			status := container.Status
+			ports := DisplayablePorts(container)
+			status := container.State
+			if status == "running" && container.Health != "" {
+				status = fmt.Sprintf("%s (%s)", container.State, container.Health)
+			} else if status == "exited" || status == "dead" {
+				status = fmt.Sprintf("%s (%d)", container.State, container.ExitCode)
+			}
 			command := formatter2.Ellipsis(container.Command, 20)
-			_, _ = fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\t%s\t%s\n", container.Name, container.Image, strconv.Quote(command), container.Service, created, status, ports)
+			_, _ = fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\n", container.Name, strconv.Quote(command), container.Service, status, ports)
 		}
 	}
 }
@@ -179,20 +179,72 @@ func hasStatus(c api.ContainerSummary, statuses []string) bool {
 	return false
 }
 
-func displayablePorts(c api.ContainerSummary) string {
+type portRange struct {
+	pStart   int
+	pEnd     int
+	tStart   int
+	tEnd     int
+	IP       string
+	protocol string
+}
+
+func (pr portRange) String() string {
+	var (
+		pub string
+		tgt string
+	)
+
+	if pr.pEnd > pr.pStart {
+		pub = fmt.Sprintf("%s:%d-%d->", pr.IP, pr.pStart, pr.pEnd)
+	} else if pr.pStart > 0 {
+		pub = fmt.Sprintf("%s:%d->", pr.IP, pr.pStart)
+	}
+	if pr.tEnd > pr.tStart {
+		tgt = fmt.Sprintf("%d-%d", pr.tStart, pr.tEnd)
+	} else {
+		tgt = fmt.Sprintf("%d", pr.tStart)
+	}
+	return fmt.Sprintf("%s%s/%s", pub, tgt, pr.protocol)
+}
+
+// DisplayablePorts is copy pasted from https://github.com/docker/cli/pull/581/files
+func DisplayablePorts(c api.ContainerSummary) string {
 	if c.Publishers == nil {
 		return ""
 	}
 
-	ports := make([]types.Port, len(c.Publishers))
-	for i, pub := range c.Publishers {
-		ports[i] = types.Port{
-			IP:          pub.URL,
-			PrivatePort: uint16(pub.TargetPort),
-			PublicPort:  uint16(pub.PublishedPort),
-			Type:        pub.Protocol,
-		}
-	}
+	sort.Sort(c.Publishers)
 
-	return formatter2.DisplayablePorts(ports)
+	pr := portRange{}
+	ports := []string{}
+	for _, p := range c.Publishers {
+		prIsRange := pr.tEnd != pr.tStart
+		tOverlaps := p.TargetPort <= pr.tEnd
+
+		// Start a new port-range if:
+		// - the protocol is different from the current port-range
+		// - published or target port are not consecutive to the current port-range
+		// - the current port-range is a _range_, and the target port overlaps with the current range's target-ports
+		if p.Protocol != pr.protocol || p.URL != pr.IP || p.PublishedPort-pr.pEnd > 1 || p.TargetPort-pr.tEnd > 1 || prIsRange && tOverlaps {
+			// start a new port-range, and print the previous port-range (if any)
+			if pr.pStart > 0 {
+				ports = append(ports, pr.String())
+			}
+			pr = portRange{
+				pStart:   p.PublishedPort,
+				pEnd:     p.PublishedPort,
+				tStart:   p.TargetPort,
+				tEnd:     p.TargetPort,
+				protocol: p.Protocol,
+				IP:       p.URL,
+			}
+			continue
+		}
+		pr.pEnd = p.PublishedPort
+		pr.tEnd = p.TargetPort
+	}
+	if pr.tStart > 0 {
+		ports = append(ports, pr.String())
+	}
+	return strings.Join(ports, ", ")
 }

cmd/compose/ps_test.go

@@ -1,85 +0,0 @@
-/*
-   Copyright 2020 Docker Compose CLI authors
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-*/
-
-package compose
-
-import (
-	"context"
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/docker/compose/v2/pkg/api"
-	"github.com/docker/compose/v2/pkg/mocks"
-	"github.com/golang/mock/gomock"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestPsTable(t *testing.T) {
-	ctx := context.Background()
-	origStdout := os.Stdout
-	t.Cleanup(func() {
-		os.Stdout = origStdout
-	})
-	dir := t.TempDir()
-	out := filepath.Join(dir, "output.txt")
-	f, err := os.Create(out)
-	if err != nil {
-		t.Fatal("could not create output file")
-	}
-	defer func() { _ = f.Close() }()
-
-	os.Stdout = f
-	ctrl := gomock.NewController(t)
-	defer ctrl.Finish()
-
-	backend := mocks.NewMockService(ctrl)
-	backend.EXPECT().
-		Ps(gomock.Eq(ctx), gomock.Any(), gomock.Any()).
-		DoAndReturn(func(ctx context.Context, projectName string, options api.PsOptions) ([]api.ContainerSummary, error) {
-			return []api.ContainerSummary{
-				{
-					ID:    "abc123",
-					Name:  "ABC",
-					Image: "foo/bar",
-					Publishers: api.PortPublishers{
-						{
-							TargetPort:    8080,
-							PublishedPort: 8080,
-							Protocol:      "tcp",
-						},
-						{
-							TargetPort:    8443,
-							PublishedPort: 8443,
-							Protocol:      "tcp",
-						},
-					},
-				},
-			}, nil
-		}).AnyTimes()
-
-	opts := psOptions{projectOptions: &projectOptions{ProjectName: "test"}}
-	err = runPs(ctx, backend, nil, opts)
-	assert.NoError(t, err)
-
-	_, err = f.Seek(0, 0)
-	assert.NoError(t, err)
-
-	output, err := os.ReadFile(out)
-	assert.NoError(t, err)
-
-	assert.Contains(t, string(output), "8080/tcp, 8443/tcp")
-}

cmd/compose/pull.go

@@ -21,7 +21,6 @@ import (
 	"fmt"
 	"os"
 
-	"github.com/compose-spec/compose-go/types"
 	"github.com/morikuni/aec"
 	"github.com/spf13/cobra"
 
@@ -44,7 +43,7 @@ func pullCommand(p *projectOptions, backend api.Service) *cobra.Command {
 		projectOptions: p,
 	}
 	cmd := &cobra.Command{
-		Use:   "pull [OPTIONS] [SERVICE...]",
+		Use:   "pull [SERVICE...]",
 		Short: "Pull service images",
 		PreRunE: Adapt(func(ctx context.Context, args []string) error {
 			if opts.noParallel {
@@ -55,7 +54,7 @@ func pullCommand(p *projectOptions, backend api.Service) *cobra.Command {
 		RunE: Adapt(func(ctx context.Context, args []string) error {
 			return runPull(ctx, backend, opts, args)
 		}),
-		ValidArgsFunction: completeServiceNames(p),
+		ValidArgsFunction: serviceCompletion(p),
 	}
 	flags := cmd.Flags()
 	flags.BoolVarP(&opts.quiet, "quiet", "q", false, "Pull without printing progress information")
@@ -68,21 +67,6 @@ func pullCommand(p *projectOptions, backend api.Service) *cobra.Command {
 	return cmd
 }
 
-func withSelectedServicesOnly(project *types.Project, services []string) error {
-	enabled, err := project.GetServices(services...)
-	if err != nil {
-		return err
-	}
-	for _, s := range project.Services {
-		if !utils.StringContains(services, s.Name) {
-			project.DisabledServices = append(project.DisabledServices, s)
-		}
-	}
-	project.Services = enabled
-
-	return nil
-}
-
 func runPull(ctx context.Context, backend api.Service, opts pullOptions, services []string) error {
 	project, err := opts.toProject(services)
 	if err != nil {
@@ -90,10 +74,16 @@ func runPull(ctx context.Context, backend api.Service, opts pullOptions, service
 	}
 
 	if !opts.includeDeps {
-		err := withSelectedServicesOnly(project, services)
+		enabled, err := project.GetServices(services...)
 		if err != nil {
 			return err
 		}
+		for _, s := range project.Services {
+			if !utils.StringContains(services, s.Name) {
+				project.DisabledServices = append(project.DisabledServices, s)
+			}
+		}
+		project.Services = enabled
 	}
 
 	return backend.Pull(ctx, project, api.PullOptions{

cmd/compose/push.go

@@ -27,9 +27,8 @@ import (
 type pushOptions struct {
 	*projectOptions
 	composeOptions
-	IncludeDeps    bool
+
 	Ignorefailures bool
-	Quiet          bool
 }
 
 func pushCommand(p *projectOptions, backend api.Service) *cobra.Command {
@@ -37,16 +36,14 @@ func pushCommand(p *projectOptions, backend api.Service) *cobra.Command {
 		projectOptions: p,
 	}
 	pushCmd := &cobra.Command{
-		Use:   "push [OPTIONS] [SERVICE...]",
+		Use:   "push [SERVICE...]",
 		Short: "Push service images",
 		RunE: Adapt(func(ctx context.Context, args []string) error {
 			return runPush(ctx, backend, opts, args)
 		}),
-		ValidArgsFunction: completeServiceNames(p),
+		ValidArgsFunction: serviceCompletion(p),
 	}
 	pushCmd.Flags().BoolVar(&opts.Ignorefailures, "ignore-push-failures", false, "Push what it can and ignores images with push failures")
-	pushCmd.Flags().BoolVar(&opts.IncludeDeps, "include-deps", false, "Also push images of services declared as dependencies")
-	pushCmd.Flags().BoolVarP(&opts.Quiet, "quiet", "q", false, "Push without printing progress information")
 
 	return pushCmd
 }
@@ -57,15 +54,7 @@ func runPush(ctx context.Context, backend api.Service, opts pushOptions, service
 		return err
 	}
 
-	if !opts.IncludeDeps {
-		err := withSelectedServicesOnly(project, services)
-		if err != nil {
-			return err
-		}
-	}
-
 	return backend.Push(ctx, project, api.PushOptions{
 		IgnoreFailures: opts.Ignorefailures,
-		Quiet:          opts.Quiet,
 	})
 }

cmd/compose/remove.go

@@ -35,7 +35,7 @@ func removeCommand(p *projectOptions, backend api.Service) *cobra.Command {
 		projectOptions: p,
 	}
 	cmd := &cobra.Command{
-		Use:   "rm [OPTIONS] [SERVICE...]",
+		Use:   "rm [SERVICE...]",
 		Short: "Removes stopped service containers",
 		Long: `Removes stopped service containers
 
@@ -46,7 +46,7 @@ Any data which is not in a volume will be lost.`,
 		RunE: Adapt(func(ctx context.Context, args []string) error {
 			return runRemove(ctx, backend, opts, args)
 		}),
-		ValidArgsFunction: completeServiceNames(p),
+		ValidArgsFunction: serviceCompletion(p),
 	}
 	f := cmd.Flags()
 	f.BoolVarP(&opts.force, "force", "f", false, "Don't ask to confirm removal")
@@ -59,25 +59,23 @@ Any data which is not in a volume will be lost.`,
 }
 
 func runRemove(ctx context.Context, backend api.Service, opts removeOptions, services []string) error {
-	project, name, err := opts.projectOrName(services...)
+	project, err := opts.toProject(services)
 	if err != nil {
 		return err
 	}
 
 	if opts.stop {
-		err := backend.Stop(ctx, name, api.StopOptions{
+		err := backend.Stop(ctx, project, api.StopOptions{
 			Services: services,
-			Project:  project,
 		})
 		if err != nil {
 			return err
 		}
 	}
 
-	return backend.Remove(ctx, name, api.RemoveOptions{
+	return backend.Remove(ctx, project, api.RemoveOptions{
 		Services: services,
 		Force:    opts.force,
 		Volumes:  opts.volumes,
-		Project:  project,
 	})
 }

cmd/compose/restart.go

@@ -35,12 +35,12 @@ func restartCommand(p *projectOptions, backend api.Service) *cobra.Command {
 		projectOptions: p,
 	}
 	restartCmd := &cobra.Command{
-		Use:   "restart [OPTIONS] [SERVICE...]",
-		Short: "Restart service containers",
+		Use:   "restart",
+		Short: "Restart containers",
 		RunE: Adapt(func(ctx context.Context, args []string) error {
 			return runRestart(ctx, backend, opts, args)
 		}),
-		ValidArgsFunction: completeServiceNames(p),
+		ValidArgsFunction: serviceCompletion(p),
 	}
 	flags := restartCmd.Flags()
 	flags.IntVarP(&opts.timeout, "timeout", "t", 10, "Specify a shutdown timeout in seconds")
@@ -49,15 +49,14 @@ func restartCommand(p *projectOptions, backend api.Service) *cobra.Command {
 }
 
 func runRestart(ctx context.Context, backend api.Service, opts restartOptions, services []string) error {
-	project, name, err := opts.projectOrName(services...)
+	project, err := opts.toProject(services)
 	if err != nil {
 		return err
 	}
 
 	timeout := time.Duration(opts.timeout) * time.Second
-	return backend.Restart(ctx, name, api.RestartOptions{
+	return backend.Restart(ctx, project, api.RestartOptions{
 		Timeout:  &timeout,
 		Services: services,
-		Project:  project,
 	})
 }

cmd/compose/run.go

@@ -19,12 +19,13 @@ package compose
 import (
 	"context"
 	"fmt"
+	"os"
 	"strings"
 
 	cgo "github.com/compose-spec/compose-go/cli"
 	"github.com/compose-spec/compose-go/loader"
 	"github.com/compose-spec/compose-go/types"
-	"github.com/docker/cli/cli/command"
+	"github.com/mattn/go-isatty"
 	"github.com/mattn/go-shellwords"
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
@@ -32,7 +33,6 @@ import (
 	"github.com/docker/cli/cli"
 	"github.com/docker/compose/v2/pkg/api"
 	"github.com/docker/compose/v2/pkg/progress"
-	"github.com/docker/compose/v2/pkg/utils"
 )
 
 type runOptions struct {
@@ -43,7 +43,6 @@ type runOptions struct {
 	Detach        bool
 	Remove        bool
 	noTty         bool
-	interactive   bool
 	user          string
 	workdir       string
 	entrypoint    string
@@ -55,7 +54,6 @@ type runOptions struct {
 	servicePorts  bool
 	name          string
 	noDeps        bool
-	ignoreOrphans bool
 	quietPull     bool
 }
 
@@ -64,9 +62,6 @@ func (opts runOptions) apply(project *types.Project) error {
 	if err != nil {
 		return err
 	}
-
-	target.Tty = !opts.noTty
-	target.StdinOpen = opts.interactive
 	if !opts.servicePorts {
 		target.Ports = []types.ServicePortConfig{}
 	}
@@ -108,15 +103,14 @@ func (opts runOptions) apply(project *types.Project) error {
 	return nil
 }
 
-func runCommand(p *projectOptions, dockerCli command.Cli, backend api.Service) *cobra.Command {
+func runCommand(p *projectOptions, backend api.Service) *cobra.Command {
 	opts := runOptions{
 		composeOptions: &composeOptions{
 			projectOptions: p,
 		},
 	}
-	createOpts := createOptions{}
 	cmd := &cobra.Command{
-		Use:   "run [OPTIONS] SERVICE [COMMAND] [ARGS...]",
+		Use:   "run [options] [-v VOLUME...] [-p PORT...] [-e KEY=VAL...] [-l KEY=VALUE...] SERVICE [COMMAND] [ARGS...]",
 		Short: "Run a one-off command on a service.",
 		Args:  cobra.MinimumNArgs(1),
 		PreRunE: AdaptCmd(func(ctx context.Context, cmd *cobra.Command, args []string) error {
@@ -141,18 +135,17 @@ func runCommand(p *projectOptions, dockerCli command.Cli, backend api.Service) *
 			if err != nil {
 				return err
 			}
-			opts.ignoreOrphans = utils.StringToBool(project.Environment["COMPOSE_IGNORE_ORPHANS"])
-			return runRun(ctx, backend, project, opts, createOpts)
+			return runRun(ctx, backend, project, opts)
 		}),
-		ValidArgsFunction: completeServiceNames(p),
+		ValidArgsFunction: serviceCompletion(p),
 	}
 	flags := cmd.Flags()
 	flags.BoolVarP(&opts.Detach, "detach", "d", false, "Run container in background and print container ID")
 	flags.StringArrayVarP(&opts.environment, "env", "e", []string{}, "Set environment variables")
 	flags.StringArrayVarP(&opts.labels, "label", "l", []string{}, "Add or override a label")
 	flags.BoolVar(&opts.Remove, "rm", false, "Automatically remove the container when it exits")
-	flags.BoolVarP(&opts.noTty, "no-TTY", "T", !dockerCli.Out().IsTerminal(), "Disable pseudo-TTY allocation (default: auto-detected).")
-	flags.StringVar(&opts.name, "name", "", "Assign a name to the container")
+	flags.BoolVarP(&opts.noTty, "no-TTY", "T", notAtTTY(), "Disable pseudo-noTty allocation. By default docker compose run allocates a TTY")
+	flags.StringVar(&opts.name, "name", "", " Assign a name to the container")
 	flags.StringVarP(&opts.user, "user", "u", "", "Run as specified username or uid")
 	flags.StringVarP(&opts.workdir, "workdir", "w", "", "Working directory inside the container")
 	flags.StringVar(&opts.entrypoint, "entrypoint", "", "Override the entrypoint of the image")
@@ -162,11 +155,6 @@ func runCommand(p *projectOptions, dockerCli command.Cli, backend api.Service) *
 	flags.BoolVar(&opts.useAliases, "use-aliases", false, "Use the service's network useAliases in the network(s) the container connects to.")
 	flags.BoolVar(&opts.servicePorts, "service-ports", false, "Run command with the service's ports enabled and mapped to the host.")
 	flags.BoolVar(&opts.quietPull, "quiet-pull", false, "Pull without printing progress information.")
-	flags.BoolVar(&createOpts.Build, "build", false, "Build image before starting container.")
-
-	cmd.Flags().BoolVarP(&opts.interactive, "interactive", "i", true, "Keep STDIN open even if not attached.")
-	cmd.Flags().BoolP("tty", "t", true, "Allocate a pseudo-TTY.")
-	cmd.Flags().MarkHidden("tty") //nolint:errcheck
 
 	flags.SetNormalizeFunc(normalizeRunFlags)
 	flags.SetInterspersed(false)
@@ -183,16 +171,19 @@ func normalizeRunFlags(f *pflag.FlagSet, name string) pflag.NormalizedName {
 	return pflag.NormalizedName(name)
 }
 
-func runRun(ctx context.Context, backend api.Service, project *types.Project, opts runOptions, createOpts createOptions) error {
+func notAtTTY() bool {
+	b := isatty.IsTerminal(os.Stdout.Fd()) && isatty.IsTerminal(os.Stdin.Fd())
+	return !b
+}
+
+func runRun(ctx context.Context, backend api.Service, project *types.Project, opts runOptions) error {
 	err := opts.apply(project)
 	if err != nil {
 		return err
 	}
 
-	createOpts.Apply(project)
-
 	err = progress.Run(ctx, func(ctx context.Context) error {
-		return startDependencies(ctx, backend, *project, opts.Service, opts.ignoreOrphans)
+		return startDependencies(ctx, backend, *project, opts.Service)
 	})
 	if err != nil {
 		return err
@@ -214,8 +205,10 @@ func runRun(ctx context.Context, backend api.Service, project *types.Project, op
 		Command:           opts.Command,
 		Detach:            opts.Detach,
 		AutoRemove:        opts.Remove,
+		Stdin:             os.Stdin,
+		Stdout:            os.Stdout,
+		Stderr:            os.Stderr,
 		Tty:               !opts.noTty,
-		Interactive:       opts.interactive,
 		WorkingDir:        opts.workdir,
 		User:              opts.user,
 		Environment:       opts.environment,
@@ -226,14 +219,6 @@ func runRun(ctx context.Context, backend api.Service, project *types.Project, op
 		Index:             0,
 		QuietPull:         opts.quietPull,
 	}
-
-	for i, service := range project.Services {
-		if service.Name == opts.Service {
-			service.StdinOpen = opts.interactive
-			project.Services[i] = service
-		}
-	}
-
 	exitCode, err := backend.RunOneOffContainer(ctx, project, runOpts)
 	if exitCode != 0 {
 		errMsg := ""
@@ -245,7 +230,7 @@ func runRun(ctx context.Context, backend api.Service, project *types.Project, op
 	return err
 }
 
-func startDependencies(ctx context.Context, backend api.Service, project types.Project, requestedServiceName string, ignoreOrphans bool) error {
+func startDependencies(ctx context.Context, backend api.Service, project types.Project, requestedServiceName string) error {
 	dependencies := types.Services{}
 	var requestedService types.ServiceConfig
 	for _, service := range project.Services {
@@ -258,17 +243,8 @@ func startDependencies(ctx context.Context, backend api.Service, project types.P
 
 	project.Services = dependencies
 	project.DisabledServices = append(project.DisabledServices, requestedService)
-	err := backend.Create(ctx, &project, api.CreateOptions{
-		IgnoreOrphans: ignoreOrphans,
-	})
-	if err != nil {
+	if err := backend.Create(ctx, &project, api.CreateOptions{}); err != nil {
 		return err
 	}
-
-	if len(dependencies) > 0 {
-		return backend.Start(ctx, project.Name, api.StartOptions{
-			Project: &project,
-		})
-	}
-	return nil
+	return backend.Start(ctx, &project, api.StartOptions{})
 }

cmd/compose/start.go

@@ -37,20 +37,16 @@ func startCommand(p *projectOptions, backend api.Service) *cobra.Command {
 		RunE: Adapt(func(ctx context.Context, args []string) error {
 			return runStart(ctx, backend, opts, args)
 		}),
-		ValidArgsFunction: completeServiceNames(p),
+		ValidArgsFunction: serviceCompletion(p),
 	}
 	return startCmd
 }
 
 func runStart(ctx context.Context, backend api.Service, opts startOptions, services []string) error {
-	project, name, err := opts.projectOrName(services...)
+	project, err := opts.toProject(services)
 	if err != nil {
 		return err
 	}
 
-	return backend.Start(ctx, name, api.StartOptions{
-		AttachTo: services,
-		Project:  project,
-		Services: services,
-	})
+	return backend.Start(ctx, project, api.StartOptions{})
 }

cmd/compose/stop.go

@@ -36,7 +36,7 @@ func stopCommand(p *projectOptions, backend api.Service) *cobra.Command {
 		projectOptions: p,
 	}
 	cmd := &cobra.Command{
-		Use:   "stop [OPTIONS] [SERVICE...]",
+		Use:   "stop [SERVICE...]",
 		Short: "Stop services",
 		PreRun: func(cmd *cobra.Command, args []string) {
 			opts.timeChanged = cmd.Flags().Changed("timeout")
@@ -44,7 +44,7 @@ func stopCommand(p *projectOptions, backend api.Service) *cobra.Command {
 		RunE: Adapt(func(ctx context.Context, args []string) error {
 			return runStop(ctx, backend, opts, args)
 		}),
-		ValidArgsFunction: completeServiceNames(p),
+		ValidArgsFunction: serviceCompletion(p),
 	}
 	flags := cmd.Flags()
 	flags.IntVarP(&opts.timeout, "timeout", "t", 10, "Specify a shutdown timeout in seconds")
@@ -53,7 +53,7 @@ func stopCommand(p *projectOptions, backend api.Service) *cobra.Command {
 }
 
 func runStop(ctx context.Context, backend api.Service, opts stopOptions, services []string) error {
-	project, name, err := opts.projectOrName(services...)
+	project, err := opts.toProject(services)
 	if err != nil {
 		return err
 	}
@@ -63,9 +63,8 @@ func runStop(ctx context.Context, backend api.Service, opts stopOptions, service
 		timeoutValue := time.Duration(opts.timeout) * time.Second
 		timeout = &timeoutValue
 	}
-	return backend.Stop(ctx, name, api.StopOptions{
+	return backend.Stop(ctx, project, api.StopOptions{
 		Timeout:  timeout,
 		Services: services,
-		Project:  project,
 	})
 }

cmd/compose/top.go

@@ -44,7 +44,7 @@ func topCommand(p *projectOptions, backend api.Service) *cobra.Command {
 		RunE: Adapt(func(ctx context.Context, args []string) error {
 			return runTop(ctx, backend, opts, args)
 		}),
-		ValidArgsFunction: completeServiceNames(p),
+		ValidArgsFunction: serviceCompletion(p),
 	}
 	return topCmd
 }

cmd/compose/tracing.go

@@ -1,35 +0,0 @@
-/*
-   Copyright 2020 Docker Compose CLI authors
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-*/
-
-package compose
-
-import (
-	"github.com/moby/buildkit/util/tracing/detect"
-	"go.opentelemetry.io/otel"
-
-	_ "github.com/moby/buildkit/util/tracing/detect/delegated" //nolint:blank-imports
-	_ "github.com/moby/buildkit/util/tracing/env"              //nolint:blank-imports
-)
-
-func init() {
-	detect.ServiceName = "compose"
-	// do not log tracing errors to stdio
-	otel.SetErrorHandler(skipErrors{})
-}
-
-type skipErrors struct{}
-
-func (skipErrors) Handle(err error) {}

cmd/compose/up.go

@@ -49,16 +49,21 @@ type upOptions struct {
 	noPrefix           bool
 	attachDependencies bool
 	attach             []string
-	timestamp          bool
 	wait               bool
 }
 
 func (opts upOptions) apply(project *types.Project, services []string) error {
 	if opts.noDeps {
-		err := withSelectedServicesOnly(project, services)
+		enabled, err := project.GetServices(services...)
 		if err != nil {
 			return err
 		}
+		for _, s := range project.Services {
+			if !utils.StringContains(services, s.Name) {
+				project.DisabledServices = append(project.DisabledServices, s)
+			}
+		}
+		project.Services = enabled
 	}
 
 	if opts.exitCodeFrom != "" {
@@ -91,26 +96,26 @@ func upCommand(p *projectOptions, backend api.Service) *cobra.Command {
 	up := upOptions{}
 	create := createOptions{}
 	upCmd := &cobra.Command{
-		Use:   "up [OPTIONS] [SERVICE...]",
+		Use:   "up [SERVICE...]",
 		Short: "Create and start containers",
 		PreRunE: AdaptCmd(func(ctx context.Context, cmd *cobra.Command, args []string) error {
 			create.timeChanged = cmd.Flags().Changed("timeout")
 			return validateFlags(&up, &create)
 		}),
 		RunE: p.WithServices(func(ctx context.Context, project *types.Project, services []string) error {
-			create.ignoreOrphans = utils.StringToBool(project.Environment["COMPOSE_IGNORE_ORPHANS"])
+			ignore := project.Environment["COMPOSE_IGNORE_ORPHANS"]
+			create.ignoreOrphans = strings.ToLower(ignore) == "true"
 			if create.ignoreOrphans && create.removeOrphans {
 				return fmt.Errorf("COMPOSE_IGNORE_ORPHANS and --remove-orphans cannot be combined")
 			}
 			return runUp(ctx, backend, create, up, project, services)
 		}),
-		ValidArgsFunction: completeServiceNames(p),
+		ValidArgsFunction: serviceCompletion(p),
 	}
 	flags := upCmd.Flags()
 	flags.BoolVarP(&up.Detach, "detach", "d", false, "Detached mode: Run containers in the background")
 	flags.BoolVar(&create.Build, "build", false, "Build images before starting containers.")
 	flags.BoolVar(&create.noBuild, "no-build", false, "Don't build an image, even if it's missing.")
-	flags.StringVar(&create.Pull, "pull", "missing", `Pull image before running ("always"|"missing"|"never")`)
 	flags.BoolVar(&create.removeOrphans, "remove-orphans", false, "Remove containers for services not defined in the Compose file.")
 	flags.StringArrayVar(&up.scale, "scale", []string{}, "Scale SERVICE to NUM instances. Overrides the `scale` setting in the Compose file if present.")
 	flags.BoolVar(&up.noColor, "no-color", false, "Produce monochrome output.")
@@ -121,7 +126,6 @@ func upCommand(p *projectOptions, backend api.Service) *cobra.Command {
 	flags.BoolVar(&up.cascadeStop, "abort-on-container-exit", false, "Stops all containers if any container was stopped. Incompatible with -d")
 	flags.StringVar(&up.exitCodeFrom, "exit-code-from", "", "Return the exit code of the selected service container. Implies --abort-on-container-exit")
 	flags.IntVarP(&create.timeout, "timeout", "t", 10, "Use this timeout in seconds for container shutdown when attached or when containers are already running.")
-	flags.BoolVar(&up.timestamp, "timestamps", false, "Show timestamps.")
 	flags.BoolVar(&up.noDeps, "no-deps", false, "Don't start linked services.")
 	flags.BoolVar(&create.recreateDeps, "always-recreate-deps", false, "Recreate dependent containers. Incompatible with --no-recreate.")
 	flags.BoolVarP(&create.noInherit, "renew-anon-volumes", "V", false, "Recreate anonymous volumes instead of retrieving data from the previous containers.")
@@ -172,7 +176,7 @@ func runUp(ctx context.Context, backend api.Service, createOptions createOptions
 
 	var consumer api.LogConsumer
 	if !upOptions.Detach {
-		consumer = formatter.NewLogConsumer(ctx, os.Stdout, os.Stderr, !upOptions.noColor, !upOptions.noPrefix, upOptions.timestamp)
+		consumer = formatter.NewLogConsumer(ctx, os.Stdout, !upOptions.noColor, !upOptions.noPrefix)
 	}
 
 	attachTo := services
@@ -182,9 +186,6 @@ func runUp(ctx context.Context, backend api.Service, createOptions createOptions
 	if upOptions.attachDependencies {
 		attachTo = project.ServiceNames()
 	}
-	if len(attachTo) == 0 {
-		attachTo = project.ServiceNames()
-	}
 
 	create := api.CreateOptions{
 		Services:             services,
@@ -204,33 +205,29 @@ func runUp(ctx context.Context, backend api.Service, createOptions createOptions
 	return backend.Up(ctx, project, api.UpOptions{
 		Create: create,
 		Start: api.StartOptions{
-			Project:      project,
 			Attach:       consumer,
 			AttachTo:     attachTo,
 			ExitCodeFrom: upOptions.exitCodeFrom,
 			CascadeStop:  upOptions.cascadeStop,
 			Wait:         upOptions.wait,
-			Services:     services,
 		},
 	})
 }
 
 func setServiceScale(project *types.Project, name string, replicas uint64) error {
 	for i, s := range project.Services {
-		if s.Name != name {
-			continue
+		if s.Name == name {
+			service, err := project.GetService(name)
+			if err != nil {
+				return err
+			}
+			if service.Deploy == nil {
+				service.Deploy = &types.DeployConfig{}
+			}
+			service.Deploy.Replicas = &replicas
+			project.Services[i] = service
+			return nil
 		}
-
-		service, err := project.GetService(name)
-		if err != nil {
-			return err
-		}
-		if service.Deploy == nil {
-			service.Deploy = &types.DeployConfig{}
-		}
-		service.Deploy.Replicas = &replicas
-		project.Services[i] = service
-		return nil
 	}
 	return fmt.Errorf("unknown service %q", name)
 }

cmd/compose/version.go

@@ -18,7 +18,6 @@ package compose
 
 import (
 	"fmt"
-	"strings"
 
 	"github.com/docker/compose/v2/cmd/formatter"
 
@@ -35,18 +34,13 @@ type versionOptions struct {
 func versionCommand() *cobra.Command {
 	opts := versionOptions{}
 	cmd := &cobra.Command{
-		Use:   "version [OPTIONS]",
+		Use:   "version",
 		Short: "Show the Docker Compose version information",
-		Args:  cobra.NoArgs,
+		Args:  cobra.MaximumNArgs(0),
 		RunE: func(cmd *cobra.Command, _ []string) error {
 			runVersion(opts)
 			return nil
 		},
-		PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
-			// overwrite parent PersistentPreRunE to avoid trying to load
-			// compose file on version command if COMPOSE_FILE is set
-			return nil
-		},
 	}
 	// define flags for backward compatibility with com.docker.cli
 	flags := cmd.Flags()
@@ -58,11 +52,11 @@ func versionCommand() *cobra.Command {
 
 func runVersion(opts versionOptions) {
 	if opts.short {
-		fmt.Println(strings.TrimPrefix(internal.Version, "v"))
+		fmt.Println(internal.Version)
 		return
 	}
 	if opts.format == formatter.JSON {
-		fmt.Printf("{\"version\":%q}\n", internal.Version)
+		fmt.Printf(`{"version":%q}\n`, internal.Version)
 		return
 	}
 	fmt.Println("Docker Compose version", internal.Version)

cmd/formatter/consts.go

@@ -17,13 +17,10 @@
 package formatter
 
 const (
-	// JSON Print in JSON format
+	// JSON is the constant for Json formats on list commands
 	JSON = "json"
 	// TemplateLegacyJSON the legacy json formatting value using go template
 	TemplateLegacyJSON = "{{json.}}"
 	// PRETTY is the constant for default formats on list commands
-	// Deprecated: use TABLE
 	PRETTY = "pretty"
-	// TABLE Print output in table format with column headers (default)
-	TABLE = "table"
 )

cmd/formatter/formatter.go

@@ -30,7 +30,7 @@ import (
 // Print prints formatted lists in different formats
 func Print(toJSON interface{}, format string, outWriter io.Writer, writerFn func(w io.Writer), headers ...string) error {
 	switch strings.ToLower(format) {
-	case TABLE, PRETTY, "":
+	case PRETTY, "":
 		return PrintPrettySection(outWriter, writerFn, headers...)
 	case TemplateLegacyJSON:
 		switch reflect.TypeOf(toJSON).Kind() {

cmd/formatter/formatter_test.go

@@ -22,7 +22,7 @@ import (
 	"io"
 	"testing"
 
-	"gotest.tools/v3/assert"
+	"gotest.tools/assert"
 )
 
 type testStruct struct {

cmd/formatter/logs.go

@@ -23,35 +23,19 @@ import (
 	"strconv"
 	"strings"
 	"sync"
-	"time"
 
 	"github.com/docker/compose/v2/pkg/api"
-	"github.com/docker/docker/pkg/jsonmessage"
 )
 
-// LogConsumer consume logs from services and format them
-type logConsumer struct {
-	ctx        context.Context
-	presenters sync.Map // map[string]*presenter
-	width      int
-	stdout     io.Writer
-	stderr     io.Writer
-	color      bool
-	prefix     bool
-	timestamp  bool
-}
-
 // NewLogConsumer creates a new LogConsumer
-func NewLogConsumer(ctx context.Context, stdout, stderr io.Writer, color, prefix, timestamp bool) api.LogConsumer {
+func NewLogConsumer(ctx context.Context, w io.Writer, color bool, prefix bool) api.LogConsumer {
 	return &logConsumer{
 		ctx:        ctx,
 		presenters: sync.Map{},
 		width:      0,
-		stdout:     stdout,
-		stderr:     stderr,
+		writer:     w,
 		color:      color,
 		prefix:     prefix,
-		timestamp:  timestamp,
 	}
 }
 
@@ -89,34 +73,20 @@ func (l *logConsumer) getPresenter(container string) *presenter {
 }
 
 // Log formats a log message as received from name/container
-func (l *logConsumer) Log(container, message string) {
-	l.write(l.stdout, container, message)
-}
-
-// Log formats a log message as received from name/container
-func (l *logConsumer) Err(container, message string) {
-	l.write(l.stderr, container, message)
-}
-
-func (l *logConsumer) write(w io.Writer, container, message string) {
+func (l *logConsumer) Log(container, service, message string) {
 	if l.ctx.Err() != nil {
 		return
 	}
 	p := l.getPresenter(container)
-	timestamp := time.Now().Format(jsonmessage.RFC3339NanoFixed)
 	for _, line := range strings.Split(message, "\n") {
-		if l.timestamp {
-			fmt.Fprintf(w, "%s%s%s\n", p.prefix, timestamp, line)
-		} else {
-			fmt.Fprintf(w, "%s%s\n", p.prefix, line)
-		}
+		fmt.Fprintf(l.writer, "%s %s\n", p.prefix, line) // nolint:errcheck
 	}
 }
 
 func (l *logConsumer) Status(container, msg string) {
 	p := l.getPresenter(container)
 	s := p.colors(fmt.Sprintf("%s %s\n", container, msg))
-	l.stdout.Write([]byte(s)) //nolint:errcheck
+	l.writer.Write([]byte(s)) // nolint:errcheck
 }
 
 func (l *logConsumer) computeWidth() {
@@ -131,6 +101,16 @@ func (l *logConsumer) computeWidth() {
 	l.width = width + 1
 }
 
+// LogConsumer consume logs from services and format them
+type logConsumer struct {
+	ctx        context.Context
+	presenters sync.Map // map[string]*presenter
+	width      int
+	writer     io.Writer
+	color      bool
+	prefix     bool
+}
+
 type presenter struct {
 	colors colorFunc
 	name   string
@@ -138,5 +118,5 @@ type presenter struct {
 }
 
 func (p *presenter) setPrefix(width int) {
-	p.prefix = p.colors(fmt.Sprintf("%-"+strconv.Itoa(width)+"s | ", p.name))
+	p.prefix = p.colors(fmt.Sprintf("%-"+strconv.Itoa(width)+"s |", p.name))
 }

cmd/main.go

@@ -23,24 +23,30 @@ import (
 	"github.com/docker/cli/cli-plugins/manager"
 	"github.com/docker/cli/cli-plugins/plugin"
 	"github.com/docker/cli/cli/command"
+	"github.com/docker/compose-switch/redirect"
 	"github.com/spf13/cobra"
 
-	"github.com/docker/compose/v2/cmd/compatibility"
 	commands "github.com/docker/compose/v2/cmd/compose"
 	"github.com/docker/compose/v2/internal"
 	"github.com/docker/compose/v2/pkg/api"
 	"github.com/docker/compose/v2/pkg/compose"
 )
 
+func init() {
+	commands.Warning = "The new 'docker compose' command is currently experimental. " +
+		"To provide feedback or request new features please open issues at https://github.com/docker/compose"
+}
+
 func pluginMain() {
 	plugin.Run(func(dockerCli command.Cli) *cobra.Command {
-		serviceProxy := api.NewServiceProxy().WithService(compose.NewComposeService(dockerCli))
-		cmd := commands.RootCommand(dockerCli, serviceProxy)
+		lazyInit := api.NewServiceProxy()
+		cmd := commands.RootCommand(lazyInit)
 		originalPreRun := cmd.PersistentPreRunE
 		cmd.PersistentPreRunE = func(cmd *cobra.Command, args []string) error {
 			if err := plugin.PersistentPreRunE(cmd, args); err != nil {
 				return err
 			}
+			lazyInit.WithService(compose.NewComposeService(dockerCli.Client(), dockerCli.ConfigFile()))
 			if originalPreRun != nil {
 				return originalPreRun(cmd, args)
 			}
@@ -62,8 +68,8 @@ func pluginMain() {
 }
 
 func main() {
-	if plugin.RunningStandalone() {
-		os.Args = append([]string{"docker"}, compatibility.Convert(os.Args[1:])...)
+	if commands.RunningAsStandalone() {
+		os.Args = append([]string{"docker"}, redirect.Convert(os.Args[1:])...)
 	}
 	pluginMain()
 }

docker-bake.hcl

@@ -1,126 +0,0 @@
-// Copyright 2022 Docker Compose CLI authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//    http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-variable "GO_VERSION" {
-  default = "1.19.4"
-}
-
-variable "BUILD_TAGS" {
-  default = "e2e,kube"
-}
-
-variable "DOCS_FORMATS" {
-  default = "md,yaml"
-}
-
-# Defines the output folder
-variable "DESTDIR" {
-  default = ""
-}
-function "bindir" {
-  params = [defaultdir]
-  result = DESTDIR != "" ? DESTDIR : "./bin/${defaultdir}"
-}
-
-target "_common" {
-  args = {
-    GO_VERSION = GO_VERSION
-    BUILD_TAGS = BUILD_TAGS
-    BUILDKIT_CONTEXT_KEEP_GIT_DIR = 1
-  }
-}
-
-group "default" {
-  targets = ["binary"]
-}
-
-group "validate" {
-  targets = ["lint", "vendor-validate", "license-validate"]
-}
-
-target "lint" {
-  inherits = ["_common"]
-  target = "lint"
-  output = ["type=cacheonly"]
-}
-
-target "license-validate" {
-  target = "license-validate"
-  output = ["type=cacheonly"]
-}
-
-target "license-update" {
-  target = "license-update"
-  output = ["."]
-}
-
-target "vendor-validate" {
-  inherits = ["_common"]
-  target = "vendor-validate"
-  output = ["type=cacheonly"]
-}
-
-target "vendor-update" {
-  inherits = ["_common"]
-  target = "vendor-update"
-  output = ["."]
-}
-
-target "test" {
-  inherits = ["_common"]
-  target = "test-coverage"
-  output = [bindir("coverage")]
-}
-
-target "binary" {
-  inherits = ["_common"]
-  target = "binary"
-  output = [bindir("build")]
-  platforms = ["local"]
-}
-
-target "binary-cross" {
-  inherits = ["binary"]
-  platforms = [
-    "darwin/amd64",
-    "darwin/arm64",
-    "linux/amd64",
-    "linux/arm/v6",
-    "linux/arm/v7",
-    "linux/arm64",
-    "linux/ppc64le",
-    "linux/riscv64",
-    "linux/s390x",
-    "windows/amd64",
-    "windows/arm64"
-  ]
-}
-
-target "release" {
-  inherits = ["binary-cross"]
-  target = "release"
-  output = [bindir("release")]
-}
-
-target "docs-validate" {
-  inherits = ["_common"]
-  target = "docs-validate"
-  output = ["type=cacheonly"]
-}
-
-target "docs-update" {
-  inherits = ["_common"]
-  target = "docs-update"
-  output = ["./docs"]
-}

docs/reference/compose.md

@@ -1,67 +1,16 @@
-# docker compose
 
-<!---MARKER_GEN_START-->
-Docker Compose
-
-### Subcommands
-
-| Name | Description |
-| --- | --- |
-| [`build`](compose_build.md) | Build or rebuild services |
-| [`convert`](compose_convert.md) | Converts the compose file to platform's canonical format |
-| [`cp`](compose_cp.md) | Copy files/folders between a service container and the local filesystem |
-| [`create`](compose_create.md) | Creates containers for a service. |
-| [`down`](compose_down.md) | Stop and remove containers, networks |
-| [`events`](compose_events.md) | Receive real time events from containers. |
-| [`exec`](compose_exec.md) | Execute a command in a running container. |
-| [`images`](compose_images.md) | List images used by the created containers |
-| [`kill`](compose_kill.md) | Force stop service containers. |
-| [`logs`](compose_logs.md) | View output from containers |
-| [`ls`](compose_ls.md) | List running compose projects |
-| [`pause`](compose_pause.md) | Pause services |
-| [`port`](compose_port.md) | Print the public port for a port binding. |
-| [`ps`](compose_ps.md) | List containers |
-| [`pull`](compose_pull.md) | Pull service images |
-| [`push`](compose_push.md) | Push service images |
-| [`restart`](compose_restart.md) | Restart service containers |
-| [`rm`](compose_rm.md) | Removes stopped service containers |
-| [`run`](compose_run.md) | Run a one-off command on a service. |
-| [`start`](compose_start.md) | Start services |
-| [`stop`](compose_stop.md) | Stop services |
-| [`top`](compose_top.md) | Display the running processes |
-| [`unpause`](compose_unpause.md) | Unpause services |
-| [`up`](compose_up.md) | Create and start containers |
-| [`version`](compose_version.md) | Show the Docker Compose version information |
-
-
-### Options
-
-| Name | Type | Default | Description |
-| --- | --- | --- | --- |
-| `--ansi` | `string` | `auto` | Control when to print ANSI control characters ("never"\|"always"\|"auto") |
-| `--compatibility` |  |  | Run compose in backward compatibility mode |
-| `--env-file` | `string` |  | Specify an alternate environment file. |
-| `-f`, `--file` | `stringArray` |  | Compose configuration files |
-| `--parallel` | `int` | `-1` | Control max parallelism, -1 for unlimited |
-| `--profile` | `stringArray` |  | Specify a profile to enable |
-| `--project-directory` | `string` |  | Specify an alternate working directory
-(default: the path of the, first specified, Compose file) |
-| `-p`, `--project-name` | `string` |  | Project name |
-
-
-<!---MARKER_GEN_END-->
 
 ## Description
 
 You can use compose subcommand, `docker compose [-f <arg>...] [options] [COMMAND] [ARGS...]`, to build and manage
 multiple services in Docker containers.
 
-### Use `-f` to specify the name and path of one or more Compose files
+### Use `-f` to specify name and path of one or more Compose files
 Use the `-f` flag to specify the location of a Compose configuration file.
 
 #### Specifying multiple Compose files
-You can supply multiple `-f` configuration files. When you supply multiple files, Compose combines them into a single
-configuration. Compose builds the configuration in the order you supply the files. Subsequent files override and add
+You can supply multiple `-f` configuration files. When you supply multiple files, Compose combines them into a single 
+configuration. Compose builds the configuration in the order you supply the files. Subsequent files override and add 
 to their predecessors.
 
 For example, consider this command line:
@@ -81,7 +30,7 @@ services:
     volumes:
       - "/data"
 ```
-If the `docker-compose.admin.yml` also specifies this same service, any matching fields override the previous file.
+If the `docker-compose.admin.yml` also specifies this same service, any matching fields override the previous file. 
 New values, add to the `webapp` service configuration.
 
 ```yaml
@@ -92,22 +41,22 @@ services:
       - DEBUG=1
 ```
 
-When you use multiple Compose files, all paths in the files are relative to the first configuration file specified
+When you use multiple Compose files, all paths in the files are relative to the first configuration file specified 
 with `-f`. You can use the `--project-directory` option to override this base path.
 
-Use a `-f` with `-` (dash) as the filename to read the configuration from stdin. When stdin is used all paths in the
+Use a `-f` with `-` (dash) as the filename to read the configuration from stdin. When stdin is used all paths in the 
 configuration are relative to the current working directory.
 
-The `-f` flag is optional. If you don’t provide this flag on the command line, Compose traverses the working directory
+The `-f` flag is optional. If you don’t provide this flag on the command line, Compose traverses the working directory 
 and its parent directories looking for a `compose.yaml` or `docker-compose.yaml` file.
 
 #### Specifying a path to a single Compose file
-You can use the `-f` flag to specify a path to a Compose file that is not located in the current directory, either
+You can use the `-f` flag to specify a path to a Compose file that is not located in the current directory, either 
 from the command line or by setting up a `COMPOSE_FILE` environment variable in your shell or in an environment file.
 
-For an example of using the `-f` option at the command line, suppose you are running the Compose Rails sample, and
-have a `compose.yaml` file in a directory called `sandbox/rails`. You can use a command like `docker compose pull` to
-get the postgres image for the db service from anywhere by using the `-f` flag as follows:
+For an example of using the `-f` option at the command line, suppose you are running the Compose Rails sample, and 
+have a `compose.yaml` file in a directory called `sandbox/rails`. You can use a command like `docker compose pull` to 
+get the postgres image for the db service from anywhere by using the `-f` flag as follows: 
 
 ```console
 $ docker compose -f ~/sandbox/rails/compose.yaml pull db
@@ -115,17 +64,17 @@ $ docker compose -f ~/sandbox/rails/compose.yaml pull db
 
 ### Use `-p` to specify a project name
 
-Each configuration has a project name. If you supply a `-p` flag, you can specify a project name. If you don’t
-specify the flag, Compose uses the current directory name.
+Each configuration has a project name. If you supply a `-p` flag, you can specify a project name. If you don’t 
+specify the flag, Compose uses the current directory name. 
 Project name can also be set by `COMPOSE_PROJECT_NAME` environment variable.
 
-Many Compose subcommands can be run without a Compose file by passing
-the project name.
+Most compose subcommand can be ran without a compose file, just passing 
+project name to retrieve the relevant resources.
 
 ```console
 $ docker compose -p my_project ps -a
 NAME                 SERVICE    STATUS     PORTS
-my_project_demo_1    demo       running
+my_project_demo_1    demo       running             
 
 $ docker compose -p my_project logs
 demo_1  | PING localhost (127.0.0.1): 56 data bytes
@@ -135,8 +84,8 @@ demo_1  | 64 bytes from 127.0.0.1: seq=0 ttl=64 time=0.095 ms
 ### Use profiles to enable optional services
 
 Use `--profile` to specify one or more active profiles
-Calling `docker compose --profile frontend up` will start the services with the profile `frontend` and services
-without any specified profiles.
+Calling `docker compose --profile frontend up` will start the services with the profile `frontend` and services 
+without any specified profiles. 
 You can also enable multiple profiles, e.g. with `docker compose --profile frontend --profile debug up` the profiles `frontend` and `debug` will be enabled.
 
 Profiles can also be set by `COMPOSE_PROFILES` environment variable.
@@ -146,10 +95,7 @@ Profiles can also be set by `COMPOSE_PROFILES` environment variable.
 You can set environment variables for various docker compose options, including the `-f`, `-p` and `--profiles` flags.
 
 Setting the `COMPOSE_FILE` environment variable is equivalent to passing the `-f` flag,
-`COMPOSE_PROJECT_NAME` environment variable does the same as the `-p` flag,
-and `COMPOSE_PROFILES` environment variable is equivalent to the `--profiles` flag.
+`COMPOSE_PROJECT_NAME` environment variable does the same for to the `-p` flag,
+and so does `COMPOSE_PROFILES` environment variable for to the `--profiles` flag.
 
-If flags are explicitly set on the command line, the associated environment variable is ignored.
-
-Setting the `COMPOSE_IGNORE_ORPHANS` environment variable to `true` will stop docker compose from detecting orphaned
-containers for the project.
+If flags are explicitly set on command line, associated environment variable is ignored

docs/reference/compose_build.md

@@ -1,30 +1,12 @@
-# docker compose build
-
-<!---MARKER_GEN_START-->
-Build or rebuild services
-
-### Options
-
-| Name | Type | Default | Description |
-| --- | --- | --- | --- |
-| `--build-arg` | `stringArray` |  | Set build-time variables for services. |
-| `--no-cache` |  |  | Do not use cache when building the image |
-| `--progress` | `string` | `auto` | Set type of progress output (auto, tty, plain, quiet) |
-| `--pull` |  |  | Always attempt to pull a newer version of the image. |
-| `-q`, `--quiet` |  |  | Don't print anything to STDOUT |
-| `--ssh` | `string` |  | Set SSH authentications used when building service images. (use 'default' for using your default SSH Agent) |
-
-
-<!---MARKER_GEN_END-->
 
 ## Description
 
-Services are built once and then tagged, by default as `project_service`.
+Services are built once and then tagged, by default as `project_service`. 
 
 If the Compose file specifies an
-[image](https://github.com/compose-spec/compose-spec/blob/master/spec.md#image) name,
+[image](https://github.com/compose-spec/compose-spec/blob/master/spec.md#image) name, 
 the image is tagged with that name, substituting any variables beforehand. See
 [variable interpolation](https://github.com/compose-spec/compose-spec/blob/master/spec.md#interpolation).
 
-If you change a service's `Dockerfile` or the contents of its build directory,
+If you change a service's `Dockerfile` or the contents of its build directory, 
 run `docker compose build` to rebuild it.

docs/reference/compose_convert.md

@@ -1,36 +1,9 @@
-# docker compose convert
 
-<!---MARKER_GEN_START-->
-Converts the compose file to platform's canonical format
-
-### Aliases
-
-`docker compose convert`, `docker compose config`
-
-### Options
-
-| Name | Type | Default | Description |
-| --- | --- | --- | --- |
-| `--format` | `string` | `yaml` | Format the output. Values: [yaml \| json] |
-| `--hash` | `string` |  | Print the service config hash, one per line. |
-| `--images` |  |  | Print the image names, one per line. |
-| `--no-consistency` |  |  | Don't check model consistency - warning: may produce invalid Compose output |
-| `--no-interpolate` |  |  | Don't interpolate environment variables. |
-| `--no-normalize` |  |  | Don't normalize compose model. |
-| `-o`, `--output` | `string` |  | Save to file (default to stdout) |
-| `--profiles` |  |  | Print the profile names, one per line. |
-| `-q`, `--quiet` |  |  | Only validate the configuration, don't print anything. |
-| `--resolve-image-digests` |  |  | Pin image tags to digests. |
-| `--services` |  |  | Print the service names, one per line. |
-| `--volumes` |  |  | Print the volume names, one per line. |
-
-
-<!---MARKER_GEN_END-->
 
 ## Description
 
-`docker compose convert` renders the actual data model to be applied on the target platform. When used with the Docker engine,
-it merges the Compose files set by `-f` flags, resolves variables in the Compose file, and expands short-notation into
-the canonical format.
+`docker compose convert` render the actual data model to be applied on target platform. When used with Docker engine,
+it merges the Compose files set by `-f` flags, resolves variables in Compose file, and expands short-notation into 
+fully defined Compose model. 
 
 To allow smooth migration from docker-compose, this subcommand declares alias `docker compose config`

docs/reference/compose_cp.md

@@ -1,16 +0,0 @@
-# docker compose cp
-
-<!---MARKER_GEN_START-->
-Copy files/folders between a service container and the local filesystem
-
-### Options
-
-| Name | Type | Default | Description |
-| --- | --- | --- | --- |
-| `-a`, `--archive` |  |  | Archive mode (copy all uid/gid information) |
-| `-L`, `--follow-link` |  |  | Always follow symbol link in SRC_PATH |
-| `--index` | `int` | `0` | Index of the container if there are multiple instances of a service . |
-
-
-<!---MARKER_GEN_END-->
-

docs/reference/compose_create.md

@@ -1,18 +0,0 @@
-# docker compose create
-
-<!---MARKER_GEN_START-->
-Creates containers for a service.
-
-### Options
-
-| Name | Type | Default | Description |
-| --- | --- | --- | --- |
-| `--build` |  |  | Build images before starting containers. |
-| `--force-recreate` |  |  | Recreate containers even if their configuration and image haven't changed. |
-| `--no-build` |  |  | Don't build an image, even if it's missing. |
-| `--no-recreate` |  |  | If containers already exist, don't recreate them. Incompatible with --force-recreate. |
-| `--pull` | `string` | `missing` | Pull image before running ("always"\|"missing"\|"never") |
-
-
-<!---MARKER_GEN_END-->
-

docs/reference/compose_down.md

@@ -1,19 +1,4 @@
-# docker compose down
 
-<!---MARKER_GEN_START-->
-Stop and remove containers, networks
-
-### Options
-
-| Name | Type | Default | Description |
-| --- | --- | --- | --- |
-| `--remove-orphans` |  |  | Remove containers for services not defined in the Compose file. |
-| `--rmi` | `string` |  | Remove images used by services. "local" remove only images that don't have a custom tag ("local"\|"all") |
-| `-t`, `--timeout` | `int` | `10` | Specify a shutdown timeout in seconds |
-| `-v`, `--volumes` |  |  | Remove named volumes declared in the `volumes` section of the Compose file and anonymous volumes attached to containers. |
-
-
-<!---MARKER_GEN_END-->
 
 ## Description
 

docs/reference/compose_events.md

@@ -1,16 +1,3 @@
-# docker compose events
-
-<!---MARKER_GEN_START-->
-Receive real time events from containers.
-
-### Options
-
-| Name | Type | Default | Description |
-| --- | --- | --- | --- |
-| `--json` |  |  | Output events as a stream of json objects |
-
-
-<!---MARKER_GEN_END-->
 
 ## Description
 

docs/reference/compose_exec.md

@@ -1,26 +1,7 @@
-# docker compose exec
-
-<!---MARKER_GEN_START-->
-Execute a command in a running container.
-
-### Options
-
-| Name | Type | Default | Description |
-| --- | --- | --- | --- |
-| `-d`, `--detach` |  |  | Detached mode: Run command in the background. |
-| `-e`, `--env` | `stringArray` |  | Set environment variables |
-| `--index` | `int` | `1` | index of the container if there are multiple instances of a service [default: 1]. |
-| `-T`, `--no-TTY` |  |  | Disable pseudo-TTY allocation. By default `docker compose exec` allocates a TTY. |
-| `--privileged` |  |  | Give extended privileges to the process. |
-| `-u`, `--user` | `string` |  | Run the command as this user. |
-| `-w`, `--workdir` | `string` |  | Path to workdir directory for this command. |
-
-
-<!---MARKER_GEN_END-->
 
 ## Description
 
-This is the equivalent of `docker exec` targeting a Compose service.
+This is the equivalent of `docker exec` targeting a Compose service. 
 
-With this subcommand, you can run arbitrary commands in your services. Commands allocate a TTY by default, so
+With this subcommand you can run arbitrary commands in your services. Commands are by default allocating a TTY, so 
 you can use a command such as `docker compose exec web sh` to get an interactive prompt.

docs/reference/compose_images.md

@@ -1,15 +0,0 @@
-# docker compose images
-
-<!---MARKER_GEN_START-->
-List images used by the created containers
-
-### Options
-
-| Name | Type | Default | Description |
-| --- | --- | --- | --- |
-| `--format` | `string` | `table` | Format the output. Values: [table \| json]. |
-| `-q`, `--quiet` |  |  | Only display IDs |
-
-
-<!---MARKER_GEN_END-->
-

docs/reference/compose_kill.md

@@ -1,17 +1,3 @@
-# docker compose kill
-
-<!---MARKER_GEN_START-->
-Force stop service containers.
-
-### Options
-
-| Name | Type | Default | Description |
-| --- | --- | --- | --- |
-| `--remove-orphans` |  |  | Remove containers for services not defined in the Compose file. |
-| `-s`, `--signal` | `string` | `SIGKILL` | SIGNAL to send to the container. |
-
-
-<!---MARKER_GEN_END-->
 
 ## Description
 

docs/reference/compose_logs.md

@@ -1,22 +1,3 @@
-# docker compose logs
-
-<!---MARKER_GEN_START-->
-View output from containers
-
-### Options
-
-| Name | Type | Default | Description |
-| --- | --- | --- | --- |
-| `-f`, `--follow` |  |  | Follow log output. |
-| `--no-color` |  |  | Produce monochrome output. |
-| `--no-log-prefix` |  |  | Don't print prefix in logs. |
-| `--since` | `string` |  | Show logs since timestamp (e.g. 2013-01-02T13:23:37Z) or relative (e.g. 42m for 42 minutes) |
-| `--tail` | `string` | `all` | Number of lines to show from the end of the logs for each container. |
-| `-t`, `--timestamps` |  |  | Show timestamps. |
-| `--until` | `string` |  | Show logs before a timestamp (e.g. 2013-01-02T13:23:37Z) or relative (e.g. 42m for 42 minutes) |
-
-
-<!---MARKER_GEN_END-->
 
 ## Description
 

docs/reference/compose_ls.md

@@ -1,20 +1,4 @@
-# docker compose ls
-
-<!---MARKER_GEN_START-->
-List running compose projects
-
-### Options
-
-| Name | Type | Default | Description |
-| --- | --- | --- | --- |
-| `-a`, `--all` |  |  | Show all stopped Compose projects |
-| `--filter` | `filter` |  | Filter output based on conditions provided. |
-| `--format` | `string` | `table` | Format the output. Values: [table \| json]. |
-| `-q`, `--quiet` |  |  | Only display IDs. |
-
-
-<!---MARKER_GEN_END-->
 
 ## Description
 
-Lists running Compose projects.
+List Compose projects running on platform.

docs/reference/compose_pause.md

@@ -1,10 +1,3 @@
-# docker compose pause
-
-<!---MARKER_GEN_START-->
-Pause services
-
-
-<!---MARKER_GEN_END-->
 
 ## Description
 

docs/reference/compose_port.md

@@ -1,17 +1,3 @@
-# docker compose port
-
-<!---MARKER_GEN_START-->
-Print the public port for a port binding.
-
-### Options
-
-| Name | Type | Default | Description |
-| --- | --- | --- | --- |
-| `--index` | `int` | `1` | index of the container if service has multiple replicas |
-| `--protocol` | `string` | `tcp` | tcp or udp |
-
-
-<!---MARKER_GEN_END-->
 
 ## Description
 

docs/reference/compose_ps.md

@@ -1,117 +1,11 @@
-# docker compose ps
-
-<!---MARKER_GEN_START-->
-List containers
-
-### Options
-
-| Name | Type | Default | Description |
-| --- | --- | --- | --- |
-| `-a`, `--all` |  |  | Show all stopped containers (including those created by the run command) |
-| [`--filter`](#filter) | `string` |  | Filter services by a property (supported filters: status). |
-| [`--format`](#format) | `string` | `table` | Format the output. Values: [table \| json] |
-| `-q`, `--quiet` |  |  | Only display IDs |
-| `--services` |  |  | Display services |
-| [`--status`](#status) | `stringArray` |  | Filter services by status. Values: [paused \| restarting \| removing \| running \| dead \| created \| exited] |
-
-
-<!---MARKER_GEN_END-->
 
 ## Description
 
 Lists containers for a Compose project, with current status and exposed ports.
-By default, both running and stopped containers are shown:
 
 ```console
 $ docker compose ps
-NAME           COMMAND                  SERVICE   STATUS       PORTS
-example-bar-1  "/docker-entrypoint.…"   bar       exited (0)
-example-foo-1  "/docker-entrypoint.…"   foo       running      0.0.0.0:8080->80/tcp
+NAME                SERVICE             STATUS              PORTS
+example_foo_1       foo                 running (healthy)   0.0.0.0:8000->80/tcp
+example_bar_1       bar                 exited (1)          
 ```
-
-## Examples
-
-### <a name="format"></a> Format the output (--format)
-
-By default, the `docker compose ps` command uses a table ("pretty") format to
-show the containers. The `--format` flag allows you to specify alternative
-presentations for the output. Currently, supported options are `pretty` (default),
-and `json`, which outputs information about the containers as a JSON array:
-
-```console
-$ docker compose ps --format json
-[{"ID":"1553b0236cf4d2715845f053a4ee97042c4f9a2ef655731ee34f1f7940eaa41a","Name":"example-bar-1","Command":"/docker-entrypoint.sh nginx -g 'daemon off;'","Project":"example","Service":"bar","State":"exited","Health":"","ExitCode":0,"Publishers":null},{"ID":"f02a4efaabb67416e1ff127d51c4b5578634a0ad5743bd65225ff7d1909a3fa0","Name":"example-foo-1","Command":"/docker-entrypoint.sh nginx -g 'daemon off;'","Project":"example","Service":"foo","State":"running","Health":"","ExitCode":0,"Publishers":[{"URL":"0.0.0.0","TargetPort":80,"PublishedPort":8080,"Protocol":"tcp"}]}]
-```
-
-The JSON output allows you to use the information in other tools for further
-processing, for example, using the [`jq` utility](https://stedolan.github.io/jq/){:target="_blank" rel="noopener" class="_"}
-to pretty-print the JSON:
-
-```console
-$ docker compose ps --format json | jq .
-[
-  {
-    "ID": "1553b0236cf4d2715845f053a4ee97042c4f9a2ef655731ee34f1f7940eaa41a",
-    "Name": "example-bar-1",
-    "Command": "/docker-entrypoint.sh nginx -g 'daemon off;'",
-    "Project": "example",
-    "Service": "bar",
-    "State": "exited",
-    "Health": "",
-    "ExitCode": 0,
-    "Publishers": null
-  },
-  {
-    "ID": "f02a4efaabb67416e1ff127d51c4b5578634a0ad5743bd65225ff7d1909a3fa0",
-    "Name": "example-foo-1",
-    "Command": "/docker-entrypoint.sh nginx -g 'daemon off;'",
-    "Project": "example",
-    "Service": "foo",
-    "State": "running",
-    "Health": "",
-    "ExitCode": 0,
-    "Publishers": [
-      {
-        "URL": "0.0.0.0",
-        "TargetPort": 80,
-        "PublishedPort": 8080,
-        "Protocol": "tcp"
-      }
-    ]
-  }
-]
-```
-
-### <a name="status"></a> Filter containers by status (--status)
-
-Use the `--status` flag to filter the list of containers by status. For example,
-to show only containers that are running or only containers that have exited:
-
-```console
-$ docker compose ps --status=running
-NAME           COMMAND                  SERVICE   STATUS       PORTS
-example-foo-1  "/docker-entrypoint.…"   foo       running      0.0.0.0:8080->80/tcp
-
-$ docker compose ps --status=exited
-NAME           COMMAND                  SERVICE   STATUS       PORTS
-example-bar-1  "/docker-entrypoint.…"   bar       exited (0)
-```
-
-### <a name="filter"></a> Filter containers by status (--filter)
-
-The [`--status` flag](#status) is a convenient shorthand for the `--filter status=<status>`
-flag. The example below is the equivalent to the example from the previous section,
-this time using the `--filter` flag:
-
-```console
-$ docker compose ps --filter status=running
-NAME           COMMAND                  SERVICE   STATUS       PORTS
-example-foo-1  "/docker-entrypoint.…"   foo       running      0.0.0.0:8080->80/tcp
-
-$ docker compose ps --filter status=running
-NAME           COMMAND                  SERVICE   STATUS       PORTS
-example-bar-1  "/docker-entrypoint.…"   bar       exited (0)
-```
-
-The `docker compose ps` command currently only supports the `--filter status=<status>`
-option, but additional filter options may be added in the future.

docs/reference/compose_pull.md

@@ -1,26 +1,11 @@
-# docker compose pull
-
-<!---MARKER_GEN_START-->
-Pull service images
-
-### Options
-
-| Name | Type | Default | Description |
-| --- | --- | --- | --- |
-| `--ignore-pull-failures` |  |  | Pull what it can and ignores images with pull failures |
-| `--include-deps` |  |  | Also pull services declared as dependencies |
-| `-q`, `--quiet` |  |  | Pull without printing progress information |
-
-
-<!---MARKER_GEN_END-->
 
 ## Description
 
-Pulls an image associated with a service defined in a `compose.yaml` file, but does not start containers based on
+Pulls an image associated with a service defined in a `compose.yaml` file, but does not start containers based on 
 those images.
 
 
-## Examples
+## Examples 
 
 suppose you have this `compose.yaml`:
 
@@ -39,8 +24,8 @@ services:
       - db
 ```
 
-If you run `docker compose pull ServiceName` in the same directory as the `compose.yaml` file that defines the service,
-Docker pulls the associated image. For example, to call the postgres image configured as the db service in our example,
+If you run `docker compose pull ServiceName` in the same directory as the `compose.yaml` file that defines the service, 
+Docker pulls the associated image. For example, to call the postgres image configured as the db service in our example, 
 you would run `docker compose pull db`.
 
 ```console
@@ -61,4 +46,4 @@ $ docker compose pull db
    ⠹ f63c47038e66 Waiting                                                  9.3s
    ⠹ 77a0c198cde5 Waiting                                                  9.3s
    ⠹ c8752d5b785c Waiting                                                  9.3s
-```
+``̀

docs/reference/compose_push.md

@@ -1,18 +1,3 @@
-# docker compose push
-
-<!---MARKER_GEN_START-->
-Push service images
-
-### Options
-
-| Name | Type | Default | Description |
-| --- | --- | --- | --- |
-| `--ignore-push-failures` |  |  | Push what it can and ignores images with push failures |
-| `--include-deps` |  |  | Also push images of services declared as dependencies |
-| `-q`, `--quiet` |  |  | Push without printing progress information |
-
-
-<!---MARKER_GEN_END-->
 
 ## Description
 

docs/reference/compose_restart.md

@@ -1,24 +1,8 @@
-# docker compose restart
+Restarts all stopped and running services.
 
-<!---MARKER_GEN_START-->
-Restart service containers
-
-### Options
-
-| Name | Type | Default | Description |
-| --- | --- | --- | --- |
-| `-t`, `--timeout` | `int` | `10` | Specify a shutdown timeout in seconds |
-
-
-<!---MARKER_GEN_END-->
-
-## Description
-
-Restarts all stopped and running services, or the specified services only.
-
-If you make changes to your `compose.yml` configuration, these changes are not reflected
-after running this command. For example, changes to environment variables (which are added
-after a container is built, but before the container's command is executed) are not updated
+If you make changes to your `compose.yml` configuration, these changes are not reflected 
+after running this command. For example, changes to environment variables (which are added 
+after a container is built, but before the container's command is executed) are not updated 
 after restarting.
 
 If you are looking to configure a service's restart policy, please refer to

docs/reference/compose_rm.md

@@ -1,23 +1,3 @@
-# docker compose rm
-
-<!---MARKER_GEN_START-->
-Removes stopped service containers
-
-By default, anonymous volumes attached to containers will not be removed. You
-can override this with -v. To list all volumes, use "docker volume ls".
-
-Any data which is not in a volume will be lost.
-
-### Options
-
-| Name | Type | Default | Description |
-| --- | --- | --- | --- |
-| `-f`, `--force` |  |  | Don't ask to confirm removal |
-| `-s`, `--stop` |  |  | Stop the containers, if required, before removing |
-| `-v`, `--volumes` |  |  | Remove any anonymous volumes attached to containers |
-
-
-<!---MARKER_GEN_END-->
 
 ## Description
 

docs/reference/compose_run.md

@@ -1,36 +1,7 @@
-# docker compose run
-
-<!---MARKER_GEN_START-->
-Run a one-off command on a service.
-
-### Options
-
-| Name | Type | Default | Description |
-| --- | --- | --- | --- |
-| `--build` |  |  | Build image before starting container. |
-| `-d`, `--detach` |  |  | Run container in background and print container ID |
-| `--entrypoint` | `string` |  | Override the entrypoint of the image |
-| `-e`, `--env` | `stringArray` |  | Set environment variables |
-| `-i`, `--interactive` |  |  | Keep STDIN open even if not attached. |
-| `-l`, `--label` | `stringArray` |  | Add or override a label |
-| `--name` | `string` |  | Assign a name to the container |
-| `-T`, `--no-TTY` |  |  | Disable pseudo-TTY allocation (default: auto-detected). |
-| `--no-deps` |  |  | Don't start linked services. |
-| `-p`, `--publish` | `stringArray` |  | Publish a container's port(s) to the host. |
-| `--quiet-pull` |  |  | Pull without printing progress information. |
-| `--rm` |  |  | Automatically remove the container when it exits |
-| `--service-ports` |  |  | Run command with the service's ports enabled and mapped to the host. |
-| `--use-aliases` |  |  | Use the service's network useAliases in the network(s) the container connects to. |
-| `-u`, `--user` | `string` |  | Run as specified username or uid |
-| `-v`, `--volume` | `stringArray` |  | Bind mount a volume. |
-| `-w`, `--workdir` | `string` |  | Working directory inside the container |
-
-
-<!---MARKER_GEN_END-->
 
 ## Description
 
-Runs a one-time command against a service.
+Runs a one-time command against a service. 
 
 the following command starts the `web` service and runs `bash` as its command:
 
@@ -41,12 +12,12 @@ $ docker compose run web bash
 Commands you use with run start in new containers with configuration defined by that of the service,
 including volumes, links, and other details. However, there are two important differences:
 
-First, the command passed by `run` overrides the command defined in the service configuration. For example, if the
-`web` service configuration is started with `bash`, then `docker compose run web python app.py` overrides it with
+First, the command passed by `run` overrides the command defined in the service configuration. For example, if the 
+`web` service configuration is started with `bash`, then `docker compose run web python app.py` overrides it with 
 `python app.py`.
 
-The second difference is that the `docker compose run` command does not create any of the ports specified in the
-service configuration. This prevents port collisions with already-open ports. If you do want the service’s ports
+The second difference is that the `docker compose run` command does not create any of the ports specified in the 
+service configuration. This prevents port collisions with already-open ports. If you do want the service’s ports 
 to be created and mapped to the host, specify the `--service-ports`
 
 ```console
@@ -59,8 +30,8 @@ Alternatively, manual port mapping can be specified with the `--publish` or `-p`
 $ docker compose run --publish 8080:80 -p 2022:22 -p 127.0.0.1:2021:21 web python manage.py shell
 ```
 
-If you start a service configured with links, the run command first checks to see if the linked service is running
-and starts the service if it is stopped. Once all the linked services are running, the run executes the command you
+If you start a service configured with links, the run command first checks to see if the linked service is running 
+and starts the service if it is stopped. Once all the linked services are running, the run executes the command you 
 passed it. For example, you could run:
 
 ```console
@@ -81,5 +52,5 @@ If you want to remove the container after running while overriding the container
 $ docker compose run --rm web python manage.py db upgrade
 ```
 
-This runs a database upgrade script, and removes the container when finished running, even if a restart policy is
+This runs a database upgrade script, and removes the container when finished running, even if a restart policy is 
 specified in the service configuration.

docs/reference/compose_start.md

@@ -1,10 +1,3 @@
-# docker compose start
-
-<!---MARKER_GEN_START-->
-Start services
-
-
-<!---MARKER_GEN_END-->
 
 ## Description
 

docs/reference/compose_stop.md

@@ -1,16 +1,3 @@
-# docker compose stop
-
-<!---MARKER_GEN_START-->
-Stop services
-
-### Options
-
-| Name | Type | Default | Description |
-| --- | --- | --- | --- |
-| `-t`, `--timeout` | `int` | `10` | Specify a shutdown timeout in seconds |
-
-
-<!---MARKER_GEN_END-->
 
 ## Description
 

docs/reference/compose_top.md

@@ -1,10 +1,3 @@
-# docker compose top
-
-<!---MARKER_GEN_START-->
-Display the running processes
-
-
-<!---MARKER_GEN_END-->
 
 ## Description
 
@@ -16,5 +9,5 @@ Displays the running processes.
 $ docker compose top
 example_foo_1
 UID    PID      PPID     C    STIME   TTY   TIME       CMD
-root   142353   142331   2    15:33   ?     00:00:00   ping localhost -c 5
+root   142353   142331   2    15:33   ?     00:00:00   ping localhost -c 5 
 ```

docs/reference/compose_unpause.md

@@ -1,10 +1,3 @@
-# docker compose unpause
-
-<!---MARKER_GEN_START-->
-Unpause services
-
-
-<!---MARKER_GEN_END-->
 
 ## Description
 

docs/reference/compose_up.md

@@ -1,37 +1,3 @@
-# docker compose up
-
-<!---MARKER_GEN_START-->
-Create and start containers
-
-### Options
-
-| Name | Type | Default | Description |
-| --- | --- | --- | --- |
-| `--abort-on-container-exit` |  |  | Stops all containers if any container was stopped. Incompatible with -d |
-| `--always-recreate-deps` |  |  | Recreate dependent containers. Incompatible with --no-recreate. |
-| `--attach` | `stringArray` |  | Attach to service output. |
-| `--attach-dependencies` |  |  | Attach to dependent containers. |
-| `--build` |  |  | Build images before starting containers. |
-| `-d`, `--detach` |  |  | Detached mode: Run containers in the background |
-| `--exit-code-from` | `string` |  | Return the exit code of the selected service container. Implies --abort-on-container-exit |
-| `--force-recreate` |  |  | Recreate containers even if their configuration and image haven't changed. |
-| `--no-build` |  |  | Don't build an image, even if it's missing. |
-| `--no-color` |  |  | Produce monochrome output. |
-| `--no-deps` |  |  | Don't start linked services. |
-| `--no-log-prefix` |  |  | Don't print prefix in logs. |
-| `--no-recreate` |  |  | If containers already exist, don't recreate them. Incompatible with --force-recreate. |
-| `--no-start` |  |  | Don't start the services after creating them. |
-| `--pull` | `string` | `missing` | Pull image before running ("always"\|"missing"\|"never") |
-| `--quiet-pull` |  |  | Pull without printing progress information. |
-| `--remove-orphans` |  |  | Remove containers for services not defined in the Compose file. |
-| `-V`, `--renew-anon-volumes` |  |  | Recreate anonymous volumes instead of retrieving data from the previous containers. |
-| `--scale` | `stringArray` |  | Scale SERVICE to NUM instances. Overrides the `scale` setting in the Compose file if present. |
-| `-t`, `--timeout` | `int` | `10` | Use this timeout in seconds for container shutdown when attached or when containers are already running. |
-| `--timestamps` |  |  | Show timestamps. |
-| `--wait` |  |  | Wait for services to be running\|healthy. Implies detached mode. |
-
-
-<!---MARKER_GEN_END-->
 
 ## Description
 
@@ -39,12 +5,12 @@ Builds, (re)creates, starts, and attaches to containers for a service.
 
 Unless they are already running, this command also starts any linked services.
 
-The `docker compose up` command aggregates the output of each container (like `docker compose logs --follow` does).
-When the command exits, all containers are stopped. Running `docker compose up --detach` starts the containers in the
+The `docker compose up` command aggregates the output of each container (liked `docker compose logs --follow` does). 
+When the command exits, all containers are stopped. Running `docker compose up --detach` starts the containers in the 
 background and leaves them running.
 
-If there are existing containers for a service, and the service’s configuration or image was changed after the
-container’s creation, `docker compose up` picks up the changes by stopping and recreating the containers
+If there are existing containers for a service, and the service’s configuration or image was changed after the 
+container’s creation, `docker compose up` picks up the changes by stopping and recreating the containers 
 (preserving mounted volumes). To prevent Compose from picking up changes, use the `--no-recreate` flag.
 
 If you want to force Compose to stop and recreate all containers, use the `--force-recreate` flag.

docs/reference/compose_version.md

@@ -1,14 +0,0 @@
-# docker compose version
-
-<!---MARKER_GEN_START-->
-Show the Docker Compose version information
-
-### Options
-
-| Name | Type | Default | Description |
-| --- | --- | --- | --- |
-| `-f`, `--format` | `string` |  | Format the output. Values: [pretty \| json]. (Default: pretty) |
-| `--short` |  |  | Shows only Compose's version number. |
-
-
-<!---MARKER_GEN_END-->

docs/reference/docker_compose.yaml

@@ -1,287 +1,242 @@
 command: docker compose
 short: Docker Compose
 long: |-
-    You can use compose subcommand, `docker compose [-f <arg>...] [options] [COMMAND] [ARGS...]`, to build and manage
-    multiple services in Docker containers.
+  You can use compose subcommand, `docker compose [-f <arg>...] [options] [COMMAND] [ARGS...]`, to build and manage
+  multiple services in Docker containers.
 
-    ### Use `-f` to specify the name and path of one or more Compose files
-    Use the `-f` flag to specify the location of a Compose configuration file.
+  ### Use `-f` to specify name and path of one or more Compose files
+  Use the `-f` flag to specify the location of a Compose configuration file.
 
-    #### Specifying multiple Compose files
-    You can supply multiple `-f` configuration files. When you supply multiple files, Compose combines them into a single
-    configuration. Compose builds the configuration in the order you supply the files. Subsequent files override and add
-    to their predecessors.
+  #### Specifying multiple Compose files
+  You can supply multiple `-f` configuration files. When you supply multiple files, Compose combines them into a single
+  configuration. Compose builds the configuration in the order you supply the files. Subsequent files override and add
+  to their predecessors.
 
-    For example, consider this command line:
+  For example, consider this command line:
 
-    ```console
-    $ docker compose -f docker-compose.yml -f docker-compose.admin.yml run backup_db
-    ```
+  ```console
+  $ docker compose -f docker-compose.yml -f docker-compose.admin.yml run backup_db
+  ```
 
-    The `docker-compose.yml` file might specify a `webapp` service.
+  The `docker-compose.yml` file might specify a `webapp` service.
 
-    ```yaml
-    services:
-      webapp:
-        image: examples/web
-        ports:
-          - "8000:8000"
-        volumes:
-          - "/data"
-    ```
-    If the `docker-compose.admin.yml` also specifies this same service, any matching fields override the previous file.
-    New values, add to the `webapp` service configuration.
+  ```yaml
+  services:
+    webapp:
+      image: examples/web
+      ports:
+        - "8000:8000"
+      volumes:
+        - "/data"
+  ```
+  If the `docker-compose.admin.yml` also specifies this same service, any matching fields override the previous file.
+  New values, add to the `webapp` service configuration.
 
-    ```yaml
-    services:
-      webapp:
-        build: .
-        environment:
-          - DEBUG=1
-    ```
+  ```yaml
+  services:
+    webapp:
+      build: .
+      environment:
+        - DEBUG=1
+  ```
 
-    When you use multiple Compose files, all paths in the files are relative to the first configuration file specified
-    with `-f`. You can use the `--project-directory` option to override this base path.
+  When you use multiple Compose files, all paths in the files are relative to the first configuration file specified
+  with `-f`. You can use the `--project-directory` option to override this base path.
 
-    Use a `-f` with `-` (dash) as the filename to read the configuration from stdin. When stdin is used all paths in the
-    configuration are relative to the current working directory.
+  Use a `-f` with `-` (dash) as the filename to read the configuration from stdin. When stdin is used all paths in the
+  configuration are relative to the current working directory.
 
-    The `-f` flag is optional. If you don’t provide this flag on the command line, Compose traverses the working directory
-    and its parent directories looking for a `compose.yaml` or `docker-compose.yaml` file.
+  The `-f` flag is optional. If you don’t provide this flag on the command line, Compose traverses the working directory
+  and its parent directories looking for a `compose.yaml` or `docker-compose.yaml` file.
 
-    #### Specifying a path to a single Compose file
-    You can use the `-f` flag to specify a path to a Compose file that is not located in the current directory, either
-    from the command line or by setting up a `COMPOSE_FILE` environment variable in your shell or in an environment file.
+  #### Specifying a path to a single Compose file
+  You can use the `-f` flag to specify a path to a Compose file that is not located in the current directory, either
+  from the command line or by setting up a `COMPOSE_FILE` environment variable in your shell or in an environment file.
 
-    For an example of using the `-f` option at the command line, suppose you are running the Compose Rails sample, and
-    have a `compose.yaml` file in a directory called `sandbox/rails`. You can use a command like `docker compose pull` to
-    get the postgres image for the db service from anywhere by using the `-f` flag as follows:
+  For an example of using the `-f` option at the command line, suppose you are running the Compose Rails sample, and
+  have a `compose.yaml` file in a directory called `sandbox/rails`. You can use a command like `docker compose pull` to
+  get the postgres image for the db service from anywhere by using the `-f` flag as follows:
 
-    ```console
-    $ docker compose -f ~/sandbox/rails/compose.yaml pull db
-    ```
+  ```console
+  $ docker compose -f ~/sandbox/rails/compose.yaml pull db
+  ```
 
-    ### Use `-p` to specify a project name
+  ### Use `-p` to specify a project name
 
-    Each configuration has a project name. If you supply a `-p` flag, you can specify a project name. If you don’t
-    specify the flag, Compose uses the current directory name.
-    Project name can also be set by `COMPOSE_PROJECT_NAME` environment variable.
+  Each configuration has a project name. If you supply a `-p` flag, you can specify a project name. If you don’t
+  specify the flag, Compose uses the current directory name.
+  Project name can also be set by `COMPOSE_PROJECT_NAME` environment variable.
 
-    Many Compose subcommands can be run without a Compose file by passing
-    the project name.
+  Most compose subcommand can be ran without a compose file, just passing
+  project name to retrieve the relevant resources.
 
-    ```console
-    $ docker compose -p my_project ps -a
-    NAME                 SERVICE    STATUS     PORTS
-    my_project_demo_1    demo       running
+  ```console
+  $ docker compose -p my_project ps -a
+  NAME                 SERVICE    STATUS     PORTS
+  my_project_demo_1    demo       running
 
-    $ docker compose -p my_project logs
-    demo_1  | PING localhost (127.0.0.1): 56 data bytes
-    demo_1  | 64 bytes from 127.0.0.1: seq=0 ttl=64 time=0.095 ms
-    ```
+  $ docker compose -p my_project logs
+  demo_1  | PING localhost (127.0.0.1): 56 data bytes
+  demo_1  | 64 bytes from 127.0.0.1: seq=0 ttl=64 time=0.095 ms
+  ```
 
-    ### Use profiles to enable optional services
+  ### Use profiles to enable optional services
 
-    Use `--profile` to specify one or more active profiles
-    Calling `docker compose --profile frontend up` will start the services with the profile `frontend` and services
-    without any specified profiles.
-    You can also enable multiple profiles, e.g. with `docker compose --profile frontend --profile debug up` the profiles `frontend` and `debug` will be enabled.
+  Use `--profile` to specify one or more active profiles
+  Calling `docker compose --profile frontend up` will start the services with the profile `frontend` and services
+  without any specified profiles.
+  You can also enable multiple profiles, e.g. with `docker compose --profile frontend --profile debug up` the profiles `frontend` and `debug` will be enabled.
 
-    Profiles can also be set by `COMPOSE_PROFILES` environment variable.
+  Profiles can also be set by `COMPOSE_PROFILES` environment variable.
 
-    ### Set up environment variables
+  ### Set up environment variables
 
-    You can set environment variables for various docker compose options, including the `-f`, `-p` and `--profiles` flags.
+  You can set environment variables for various docker compose options, including the `-f`, `-p` and `--profiles` flags.
 
-    Setting the `COMPOSE_FILE` environment variable is equivalent to passing the `-f` flag,
-    `COMPOSE_PROJECT_NAME` environment variable does the same as the `-p` flag,
-    and `COMPOSE_PROFILES` environment variable is equivalent to the `--profiles` flag.
+  Setting the `COMPOSE_FILE` environment variable is equivalent to passing the `-f` flag,
+  `COMPOSE_PROJECT_NAME` environment variable does the same for to the `-p` flag,
+  and so does `COMPOSE_PROFILES` environment variable for to the `--profiles` flag.
 
-    If flags are explicitly set on the command line, the associated environment variable is ignored.
-
-    Setting the `COMPOSE_IGNORE_ORPHANS` environment variable to `true` will stop docker compose from detecting orphaned
-    containers for the project.
+  If flags are explicitly set on command line, associated environment variable is ignored
 usage: docker compose
 pname: docker
 plink: docker.yaml
 cname:
-    - docker compose build
-    - docker compose convert
-    - docker compose cp
-    - docker compose create
-    - docker compose down
-    - docker compose events
-    - docker compose exec
-    - docker compose images
-    - docker compose kill
-    - docker compose logs
-    - docker compose ls
-    - docker compose pause
-    - docker compose port
-    - docker compose ps
-    - docker compose pull
-    - docker compose push
-    - docker compose restart
-    - docker compose rm
-    - docker compose run
-    - docker compose start
-    - docker compose stop
-    - docker compose top
-    - docker compose unpause
-    - docker compose up
-    - docker compose version
+- docker compose build
+- docker compose convert
+- docker compose cp
+- docker compose create
+- docker compose down
+- docker compose events
+- docker compose exec
+- docker compose images
+- docker compose kill
+- docker compose logs
+- docker compose ls
+- docker compose pause
+- docker compose port
+- docker compose ps
+- docker compose pull
+- docker compose push
+- docker compose restart
+- docker compose rm
+- docker compose run
+- docker compose start
+- docker compose stop
+- docker compose top
+- docker compose unpause
+- docker compose up
 clink:
-    - docker_compose_build.yaml
-    - docker_compose_convert.yaml
-    - docker_compose_cp.yaml
-    - docker_compose_create.yaml
-    - docker_compose_down.yaml
-    - docker_compose_events.yaml
-    - docker_compose_exec.yaml
-    - docker_compose_images.yaml
-    - docker_compose_kill.yaml
-    - docker_compose_logs.yaml
-    - docker_compose_ls.yaml
-    - docker_compose_pause.yaml
-    - docker_compose_port.yaml
-    - docker_compose_ps.yaml
-    - docker_compose_pull.yaml
-    - docker_compose_push.yaml
-    - docker_compose_restart.yaml
-    - docker_compose_rm.yaml
-    - docker_compose_run.yaml
-    - docker_compose_start.yaml
-    - docker_compose_stop.yaml
-    - docker_compose_top.yaml
-    - docker_compose_unpause.yaml
-    - docker_compose_up.yaml
-    - docker_compose_version.yaml
+- docker_compose_build.yaml
+- docker_compose_convert.yaml
+- docker_compose_cp.yaml
+- docker_compose_create.yaml
+- docker_compose_down.yaml
+- docker_compose_events.yaml
+- docker_compose_exec.yaml
+- docker_compose_images.yaml
+- docker_compose_kill.yaml
+- docker_compose_logs.yaml
+- docker_compose_ls.yaml
+- docker_compose_pause.yaml
+- docker_compose_port.yaml
+- docker_compose_ps.yaml
+- docker_compose_pull.yaml
+- docker_compose_push.yaml
+- docker_compose_restart.yaml
+- docker_compose_rm.yaml
+- docker_compose_run.yaml
+- docker_compose_start.yaml
+- docker_compose_stop.yaml
+- docker_compose_top.yaml
+- docker_compose_unpause.yaml
+- docker_compose_up.yaml
 options:
-    - option: ansi
-      value_type: string
-      default_value: auto
-      description: |
-        Control when to print ANSI control characters ("never"|"always"|"auto")
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: compatibility
-      value_type: bool
-      default_value: "false"
-      description: Run compose in backward compatibility mode
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: env-file
-      value_type: string
-      description: Specify an alternate environment file.
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: file
-      shorthand: f
-      value_type: stringArray
-      default_value: '[]'
-      description: Compose configuration files
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: no-ansi
-      value_type: bool
-      default_value: "false"
-      description: Do not print ANSI control characters (DEPRECATED)
-      deprecated: false
-      hidden: true
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: parallel
-      value_type: int
-      default_value: "-1"
-      description: Control max parallelism, -1 for unlimited
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: profile
-      value_type: stringArray
-      default_value: '[]'
-      description: Specify a profile to enable
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: project-directory
-      value_type: string
-      description: |-
-        Specify an alternate working directory
-        (default: the path of the, first specified, Compose file)
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: project-name
-      shorthand: p
-      value_type: string
-      description: Project name
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: verbose
-      value_type: bool
-      default_value: "false"
-      description: Show more output
-      deprecated: false
-      hidden: true
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: version
-      shorthand: v
-      value_type: bool
-      default_value: "false"
-      description: Show the Docker Compose version information
-      deprecated: false
-      hidden: true
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: workdir
-      value_type: string
-      description: |-
-        DEPRECATED! USE --project-directory INSTEAD.
-        Specify an alternate working directory
-        (default: the path of the, first specified, Compose file)
-      deprecated: false
-      hidden: true
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
+- option: ansi
+  value_type: string
+  default_value: auto
+  description: |
+    Control when to print ANSI control characters ("never"|"always"|"auto")
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: env-file
+  value_type: string
+  description: Specify an alternate environment file.
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: file
+  shorthand: f
+  value_type: stringArray
+  default_value: '[]'
+  description: Compose configuration files
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: no-ansi
+  value_type: bool
+  default_value: "false"
+  description: Do not print ANSI control characters (DEPRECATED)
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: profile
+  value_type: stringArray
+  default_value: '[]'
+  description: Specify a profile to enable
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: project-directory
+  value_type: string
+  description: |-
+    Specify an alternate working directory
+    (default: the path of the Compose file)
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: project-name
+  shorthand: p
+  value_type: string
+  description: Project name
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: verbose
+  value_type: bool
+  default_value: "false"
+  description: Show more output
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: workdir
+  value_type: string
+  description: |-
+    DEPRECATED! USE --project-directory INSTEAD.
+    Specify an alternate working directory
+    (default: the path of the Compose file)
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
 deprecated: false
 experimental: false
 experimentalcli: false

docs/reference/docker_compose_build.yaml

@@ -1,132 +1,112 @@
 command: docker compose build
 short: Build or rebuild services
 long: |-
-    Services are built once and then tagged, by default as `project_service`.
+  Services are built once and then tagged, by default as `project_service`.
 
-    If the Compose file specifies an
-    [image](https://github.com/compose-spec/compose-spec/blob/master/spec.md#image) name,
-    the image is tagged with that name, substituting any variables beforehand. See
-    [variable interpolation](https://github.com/compose-spec/compose-spec/blob/master/spec.md#interpolation).
+  If the Compose file specifies an
+  [image](https://github.com/compose-spec/compose-spec/blob/master/spec.md#image) name,
+  the image is tagged with that name, substituting any variables beforehand. See
+  [variable interpolation](https://github.com/compose-spec/compose-spec/blob/master/spec.md#interpolation).
 
-    If you change a service's `Dockerfile` or the contents of its build directory,
-    run `docker compose build` to rebuild it.
-usage: docker compose build [OPTIONS] [SERVICE...]
+  If you change a service's `Dockerfile` or the contents of its build directory,
+  run `docker compose build` to rebuild it.
+usage: docker compose build [SERVICE...]
 pname: docker compose
 plink: docker_compose.yaml
 options:
-    - option: build-arg
-      value_type: stringArray
-      default_value: '[]'
-      description: Set build-time variables for services.
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: compress
-      value_type: bool
-      default_value: "true"
-      description: Compress the build context using gzip. DEPRECATED
-      deprecated: false
-      hidden: true
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: force-rm
-      value_type: bool
-      default_value: "true"
-      description: Always remove intermediate containers. DEPRECATED
-      deprecated: false
-      hidden: true
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: memory
-      shorthand: m
-      value_type: string
-      description: |
-        Set memory limit for the build container. Not supported on buildkit yet.
-      deprecated: false
-      hidden: true
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: no-cache
-      value_type: bool
-      default_value: "false"
-      description: Do not use cache when building the image
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: no-rm
-      value_type: bool
-      default_value: "false"
-      description: |
-        Do not remove intermediate containers after a successful build. DEPRECATED
-      deprecated: false
-      hidden: true
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: parallel
-      value_type: bool
-      default_value: "true"
-      description: Build images in parallel. DEPRECATED
-      deprecated: false
-      hidden: true
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: progress
-      value_type: string
-      default_value: auto
-      description: Set type of progress output (auto, tty, plain, quiet)
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: pull
-      value_type: bool
-      default_value: "false"
-      description: Always attempt to pull a newer version of the image.
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: quiet
-      shorthand: q
-      value_type: bool
-      default_value: "false"
-      description: Don't print anything to STDOUT
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: ssh
-      value_type: string
-      description: |
-        Set SSH authentications used when building service images. (use 'default' for using your default SSH Agent)
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
+- option: build-arg
+  value_type: stringArray
+  default_value: '[]'
+  description: Set build-time variables for services.
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: compress
+  value_type: bool
+  default_value: "true"
+  description: Compress the build context using gzip. DEPRECATED
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: force-rm
+  value_type: bool
+  default_value: "true"
+  description: Always remove intermediate containers. DEPRECATED
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: memory
+  shorthand: m
+  value_type: string
+  description: |
+    Set memory limit for the build container. Not supported on buildkit yet.
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: no-cache
+  value_type: bool
+  default_value: "false"
+  description: Do not use cache when building the image
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: no-rm
+  value_type: bool
+  default_value: "false"
+  description: |
+    Do not remove intermediate containers after a successful build. DEPRECATED
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: parallel
+  value_type: bool
+  default_value: "true"
+  description: Build images in parallel. DEPRECATED
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: progress
+  value_type: string
+  default_value: auto
+  description: Set type of progress output ("auto", "plain", "noTty")
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: pull
+  value_type: bool
+  default_value: "false"
+  description: Always attempt to pull a newer version of the image.
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: quiet
+  shorthand: q
+  value_type: bool
+  default_value: "false"
+  description: Don't print anything to STDOUT
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
 deprecated: false
 experimental: false
 experimentalcli: false

docs/reference/docker_compose_convert.yaml

@@ -1,137 +1,88 @@
 command: docker compose convert
-aliases: docker compose convert, docker compose config
+aliases: config
 short: Converts the compose file to platform's canonical format
 long: |-
-    `docker compose convert` renders the actual data model to be applied on the target platform. When used with the Docker engine,
-    it merges the Compose files set by `-f` flags, resolves variables in the Compose file, and expands short-notation into
-    the canonical format.
+  `docker compose convert` render the actual data model to be applied on target platform. When used with Docker engine,
+  it merges the Compose files set by `-f` flags, resolves variables in Compose file, and expands short-notation into
+  fully defined Compose model.
 
-    To allow smooth migration from docker-compose, this subcommand declares alias `docker compose config`
-usage: docker compose convert [OPTIONS] [SERVICE...]
+  To allow smooth migration from docker-compose, this subcommand declares alias `docker compose config`
+usage: docker compose convert SERVICES
 pname: docker compose
 plink: docker_compose.yaml
 options:
-    - option: format
-      value_type: string
-      default_value: yaml
-      description: 'Format the output. Values: [yaml | json]'
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: hash
-      value_type: string
-      description: Print the service config hash, one per line.
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: images
-      value_type: bool
-      default_value: "false"
-      description: Print the image names, one per line.
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: no-consistency
-      value_type: bool
-      default_value: "false"
-      description: |
-        Don't check model consistency - warning: may produce invalid Compose output
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: no-interpolate
-      value_type: bool
-      default_value: "false"
-      description: Don't interpolate environment variables.
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: no-normalize
-      value_type: bool
-      default_value: "false"
-      description: Don't normalize compose model.
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: output
-      shorthand: o
-      value_type: string
-      description: Save to file (default to stdout)
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: profiles
-      value_type: bool
-      default_value: "false"
-      description: Print the profile names, one per line.
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: quiet
-      shorthand: q
-      value_type: bool
-      default_value: "false"
-      description: Only validate the configuration, don't print anything.
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: resolve-image-digests
-      value_type: bool
-      default_value: "false"
-      description: Pin image tags to digests.
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: services
-      value_type: bool
-      default_value: "false"
-      description: Print the service names, one per line.
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: volumes
-      value_type: bool
-      default_value: "false"
-      description: Print the volume names, one per line.
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
+- option: format
+  value_type: string
+  default_value: yaml
+  description: 'Format the output. Values: [yaml | json]'
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: hash
+  value_type: string
+  description: Print the service config hash, one per line.
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: no-interpolate
+  value_type: bool
+  default_value: "false"
+  description: Don't interpolate environment variables.
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: profiles
+  value_type: bool
+  default_value: "false"
+  description: Print the profile names, one per line.
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: quiet
+  shorthand: q
+  value_type: bool
+  default_value: "false"
+  description: Only validate the configuration, don't print anything.
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: resolve-image-digests
+  value_type: bool
+  default_value: "false"
+  description: Pin image tags to digests.
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: services
+  value_type: bool
+  default_value: "false"
+  description: Print the service names, one per line.
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: volumes
+  value_type: bool
+  default_value: "false"
+  description: Print the volume names, one per line.
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
 deprecated: false
 experimental: false
 experimentalcli: false

docs/reference/docker_compose_cp.yaml

@@ -1,55 +1,50 @@
 command: docker compose cp
 short: Copy files/folders between a service container and the local filesystem
 long: Copy files/folders between a service container and the local filesystem
-usage: |-
-    docker compose cp [OPTIONS] SERVICE:SRC_PATH DEST_PATH|-
-    	docker compose cp [OPTIONS] SRC_PATH|- SERVICE:DEST_PATH
+usage: "docker compose cp [OPTIONS] SERVICE:SRC_PATH DEST_PATH|-\n\tdocker compose
+  cp [OPTIONS] SRC_PATH|- SERVICE:DEST_PATH"
 pname: docker compose
 plink: docker_compose.yaml
 options:
-    - option: all
-      value_type: bool
-      default_value: "false"
-      description: Copy to all the containers of the service.
-      deprecated: true
-      hidden: true
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: archive
-      shorthand: a
-      value_type: bool
-      default_value: "false"
-      description: Archive mode (copy all uid/gid information)
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: follow-link
-      shorthand: L
-      value_type: bool
-      default_value: "false"
-      description: Always follow symbol link in SRC_PATH
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: index
-      value_type: int
-      default_value: "0"
-      description: |
-        Index of the container if there are multiple instances of a service .
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
+- option: all
+  value_type: bool
+  default_value: "false"
+  description: Copy to all the containers of the service.
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: archive
+  shorthand: a
+  value_type: bool
+  default_value: "false"
+  description: Archive mode (copy all uid/gid information)
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: follow-link
+  shorthand: L
+  value_type: bool
+  default_value: "false"
+  description: Always follow symbol link in SRC_PATH
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: index
+  value_type: int
+  default_value: "1"
+  description: |
+    Index of the container if there are multiple instances of a service [default: 1].
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
 deprecated: false
 experimental: false
 experimentalcli: false

docs/reference/docker_compose_create.yaml

@@ -1,62 +1,48 @@
 command: docker compose create
 short: Creates containers for a service.
 long: Creates containers for a service.
-usage: docker compose create [OPTIONS] [SERVICE...]
+usage: docker compose create [SERVICE...]
 pname: docker compose
 plink: docker_compose.yaml
 options:
-    - option: build
-      value_type: bool
-      default_value: "false"
-      description: Build images before starting containers.
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: force-recreate
-      value_type: bool
-      default_value: "false"
-      description: |
-        Recreate containers even if their configuration and image haven't changed.
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: no-build
-      value_type: bool
-      default_value: "false"
-      description: Don't build an image, even if it's missing.
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: no-recreate
-      value_type: bool
-      default_value: "false"
-      description: |
-        If containers already exist, don't recreate them. Incompatible with --force-recreate.
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: pull
-      value_type: string
-      default_value: missing
-      description: Pull image before running ("always"|"missing"|"never")
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
+- option: build
+  value_type: bool
+  default_value: "false"
+  description: Build images before starting containers.
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: force-recreate
+  value_type: bool
+  default_value: "false"
+  description: |
+    Recreate containers even if their configuration and image haven't changed.
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: no-build
+  value_type: bool
+  default_value: "false"
+  description: Don't build an image, even if it's missing.
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: no-recreate
+  value_type: bool
+  default_value: "false"
+  description: |
+    If containers already exist, don't recreate them. Incompatible with --force-recreate.
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
 deprecated: false
 experimental: false
 experimentalcli: false

docs/reference/docker_compose_down.yaml

@@ -1,66 +1,62 @@
 command: docker compose down
 short: Stop and remove containers, networks
 long: |-
-    Stops containers and removes containers, networks, volumes, and images created by `up`.
+  Stops containers and removes containers, networks, volumes, and images created by `up`.
 
-    By default, the only things removed are:
+  By default, the only things removed are:
 
-    - Containers for services defined in the Compose file
-    - Networks defined in the networks section of the Compose file
-    - The default network, if one is used
+  - Containers for services defined in the Compose file
+  - Networks defined in the networks section of the Compose file
+  - The default network, if one is used
 
-    Networks and volumes defined as external are never removed.
+  Networks and volumes defined as external are never removed.
 
-    Anonymous volumes are not removed by default. However, as they don’t have a stable name, they will not be automatically
-    mounted by a subsequent `up`. For data that needs to persist between updates, use explicit paths as bind mounts or
-    named volumes.
-usage: docker compose down [OPTIONS]
+  Anonymous volumes are not removed by default. However, as they don’t have a stable name, they will not be automatically
+  mounted by a subsequent `up`. For data that needs to persist between updates, use explicit paths as bind mounts or
+  named volumes.
+usage: docker compose down
 pname: docker compose
 plink: docker_compose.yaml
 options:
-    - option: remove-orphans
-      value_type: bool
-      default_value: "false"
-      description: Remove containers for services not defined in the Compose file.
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: rmi
-      value_type: string
-      description: |
-        Remove images used by services. "local" remove only images that don't have a custom tag ("local"|"all")
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: timeout
-      shorthand: t
-      value_type: int
-      default_value: "10"
-      description: Specify a shutdown timeout in seconds
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: volumes
-      shorthand: v
-      value_type: bool
-      default_value: "false"
-      description: |
-        Remove named volumes declared in the `volumes` section of the Compose file and anonymous volumes attached to containers.
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
+- option: remove-orphans
+  value_type: bool
+  default_value: "false"
+  description: Remove containers for services not defined in the Compose file.
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: rmi
+  value_type: string
+  description: |
+    Remove images used by services. "local" remove only images that don't have a custom tag ("local"|"all")
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: timeout
+  shorthand: t
+  value_type: int
+  default_value: "10"
+  description: Specify a shutdown timeout in seconds
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: volumes
+  shorthand: v
+  value_type: bool
+  default_value: "false"
+  description: |
+    Remove named volumes declared in the `volumes` section of the Compose file and anonymous volumes attached to containers.
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
 deprecated: false
 experimental: false
 experimentalcli: false

docs/reference/docker_compose_events.yaml

@@ -1,39 +1,38 @@
 command: docker compose events
 short: Receive real time events from containers.
 long: |-
-    Stream container events for every container in the project.
+  Stream container events for every container in the project.
 
-    With the `--json` flag, a json object is printed one per line with the format:
+  With the `--json` flag, a json object is printed one per line with the format:
 
-    ```json
-    {
-        "time": "2015-11-20T18:01:03.615550",
-        "type": "container",
-        "action": "create",
-        "id": "213cf7...5fc39a",
-        "service": "web",
-        "attributes": {
-          "name": "application_web_1",
-          "image": "alpine:edge"
-        }
-    }
-    ```
+  ```json
+  {
+      "time": "2015-11-20T18:01:03.615550",
+      "type": "container",
+      "action": "create",
+      "id": "213cf7...5fc39a",
+      "service": "web",
+      "attributes": {
+        "name": "application_web_1",
+        "image": "alpine:edge"
+      }
+  }
+  ```
 
-    The events that can be received using this can be seen [here](/engine/reference/commandline/events/#object-types).
-usage: docker compose events [OPTIONS] [SERVICE...]
+  The events that can be received using this can be seen [here](/engine/reference/commandline/events/#object-types).
+usage: docker compose events [options] [--] [SERVICE...]
 pname: docker compose
 plink: docker_compose.yaml
 options:
-    - option: json
-      value_type: bool
-      default_value: "false"
-      description: Output events as a stream of json objects
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
+- option: json
+  value_type: bool
+  default_value: "false"
+  description: Output events as a stream of json objects
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
 deprecated: false
 experimental: false
 experimentalcli: false

docs/reference/docker_compose_exec.yaml

@@ -1,111 +1,82 @@
 command: docker compose exec
 short: Execute a command in a running container.
 long: |-
-    This is the equivalent of `docker exec` targeting a Compose service.
+  This is the equivalent of `docker exec` targeting a Compose service.
 
-    With this subcommand, you can run arbitrary commands in your services. Commands allocate a TTY by default, so
-    you can use a command such as `docker compose exec web sh` to get an interactive prompt.
-usage: docker compose exec [OPTIONS] SERVICE COMMAND [ARGS...]
+  With this subcommand you can run arbitrary commands in your services. Commands are by default allocating a TTY, so
+  you can use a command such as `docker compose exec web sh` to get an interactive prompt.
+usage: docker compose exec [options] [-e KEY=VAL...] [--] SERVICE COMMAND [ARGS...]
 pname: docker compose
 plink: docker_compose.yaml
 options:
-    - option: detach
-      shorthand: d
-      value_type: bool
-      default_value: "false"
-      description: 'Detached mode: Run command in the background.'
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: env
-      shorthand: e
-      value_type: stringArray
-      default_value: '[]'
-      description: Set environment variables
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: index
-      value_type: int
-      default_value: "1"
-      description: |
-        index of the container if there are multiple instances of a service [default: 1].
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: interactive
-      shorthand: i
-      value_type: bool
-      default_value: "true"
-      description: Keep STDIN open even if not attached.
-      deprecated: false
-      hidden: true
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: no-TTY
-      shorthand: T
-      value_type: bool
-      default_value: "true"
-      description: |
-        Disable pseudo-TTY allocation. By default `docker compose exec` allocates a TTY.
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: privileged
-      value_type: bool
-      default_value: "false"
-      description: Give extended privileges to the process.
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: tty
-      shorthand: t
-      value_type: bool
-      default_value: "true"
-      description: Allocate a pseudo-TTY.
-      deprecated: false
-      hidden: true
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: user
-      shorthand: u
-      value_type: string
-      description: Run the command as this user.
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: workdir
-      shorthand: w
-      value_type: string
-      description: Path to workdir directory for this command.
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
+- option: detach
+  shorthand: d
+  value_type: bool
+  default_value: "false"
+  description: 'Detached mode: Run command in the background.'
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: env
+  shorthand: e
+  value_type: stringArray
+  default_value: '[]'
+  description: Set environment variables
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: index
+  value_type: int
+  default_value: "1"
+  description: |
+    index of the container if there are multiple instances of a service [default: 1].
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: no-TTY
+  shorthand: T
+  value_type: bool
+  default_value: "false"
+  description: |
+    Disable pseudo-TTY allocation. By default `docker compose exec` allocates a TTY.
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: privileged
+  value_type: bool
+  default_value: "false"
+  description: Give extended privileges to the process.
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: user
+  shorthand: u
+  value_type: string
+  description: Run the command as this user.
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: workdir
+  shorthand: w
+  value_type: string
+  description: Path to workdir directory for this command.
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
 deprecated: false
 experimental: false
 experimentalcli: false

docs/reference/docker_compose_images.yaml

@@ -1,31 +1,20 @@
 command: docker compose images
 short: List images used by the created containers
 long: List images used by the created containers
-usage: docker compose images [OPTIONS] [SERVICE...]
+usage: docker compose images [SERVICE...]
 pname: docker compose
 plink: docker_compose.yaml
 options:
-    - option: format
-      value_type: string
-      default_value: table
-      description: 'Format the output. Values: [table | json].'
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: quiet
-      shorthand: q
-      value_type: bool
-      default_value: "false"
-      description: Only display IDs
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
+- option: quiet
+  shorthand: q
+  value_type: bool
+  default_value: "false"
+  description: Only display IDs
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
 deprecated: false
 experimental: false
 experimentalcli: false

docs/reference/docker_compose_kill.yaml

@@ -1,36 +1,25 @@
 command: docker compose kill
 short: Force stop service containers.
 long: |-
-    Forces running containers to stop by sending a `SIGKILL` signal. Optionally the signal can be passed, for example:
+  Forces running containers to stop by sending a `SIGKILL` signal. Optionally the signal can be passed, for example:
 
-    ```console
-    $ docker-compose kill -s SIGINT
-    ```
-usage: docker compose kill [OPTIONS] [SERVICE...]
+  ```console
+  $ docker-compose kill -s SIGINT
+  ```
+usage: docker compose kill [options] [SERVICE...]
 pname: docker compose
 plink: docker_compose.yaml
 options:
-    - option: remove-orphans
-      value_type: bool
-      default_value: "false"
-      description: Remove containers for services not defined in the Compose file.
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: signal
-      shorthand: s
-      value_type: string
-      default_value: SIGKILL
-      description: SIGNAL to send to the container.
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
+- option: signal
+  shorthand: s
+  value_type: string
+  default_value: SIGKILL
+  description: SIGNAL to send to the container.
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
 deprecated: false
 experimental: false
 experimentalcli: false

docs/reference/docker_compose_logs.yaml

@@ -1,83 +1,76 @@
 command: docker compose logs
 short: View output from containers
 long: Displays log output from services.
-usage: docker compose logs [OPTIONS] [SERVICE...]
+usage: docker compose logs [SERVICE...]
 pname: docker compose
 plink: docker_compose.yaml
 options:
-    - option: follow
-      shorthand: f
-      value_type: bool
-      default_value: "false"
-      description: Follow log output.
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: no-color
-      value_type: bool
-      default_value: "false"
-      description: Produce monochrome output.
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: no-log-prefix
-      value_type: bool
-      default_value: "false"
-      description: Don't print prefix in logs.
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: since
-      value_type: string
-      description: |
-        Show logs since timestamp (e.g. 2013-01-02T13:23:37Z) or relative (e.g. 42m for 42 minutes)
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: tail
-      value_type: string
-      default_value: all
-      description: |
-        Number of lines to show from the end of the logs for each container.
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: timestamps
-      shorthand: t
-      value_type: bool
-      default_value: "false"
-      description: Show timestamps.
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: until
-      value_type: string
-      description: |
-        Show logs before a timestamp (e.g. 2013-01-02T13:23:37Z) or relative (e.g. 42m for 42 minutes)
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
+- option: follow
+  shorthand: f
+  value_type: bool
+  default_value: "false"
+  description: Follow log output.
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: no-color
+  value_type: bool
+  default_value: "false"
+  description: Produce monochrome output.
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: no-log-prefix
+  value_type: bool
+  default_value: "false"
+  description: Don't print prefix in logs.
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: since
+  value_type: string
+  description: |
+    Show logs since timestamp (e.g. 2013-01-02T13:23:37Z) or relative (e.g. 42m for 42 minutes)
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: tail
+  value_type: string
+  default_value: all
+  description: |
+    Number of lines to show from the end of the logs for each container.
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: timestamps
+  shorthand: t
+  value_type: bool
+  default_value: "false"
+  description: Show timestamps.
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: until
+  value_type: string
+  description: |
+    Show logs before a timestamp (e.g. 2013-01-02T13:23:37Z) or relative (e.g. 42m for 42 minutes)
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
 deprecated: false
 experimental: false
 experimentalcli: false

docs/reference/docker_compose_ls.yaml

@@ -1,51 +1,47 @@
 command: docker compose ls
 short: List running compose projects
-long: Lists running Compose projects.
-usage: docker compose ls [OPTIONS]
+long: List Compose projects running on platform.
+usage: docker compose ls
 pname: docker compose
 plink: docker_compose.yaml
 options:
-    - option: all
-      shorthand: a
-      value_type: bool
-      default_value: "false"
-      description: Show all stopped Compose projects
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: filter
-      value_type: filter
-      description: Filter output based on conditions provided.
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: format
-      value_type: string
-      default_value: table
-      description: 'Format the output. Values: [table | json].'
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: quiet
-      shorthand: q
-      value_type: bool
-      default_value: "false"
-      description: Only display IDs.
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
+- option: all
+  shorthand: a
+  value_type: bool
+  default_value: "false"
+  description: Show all stopped Compose projects
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: filter
+  value_type: filter
+  description: Filter output based on conditions provided.
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: format
+  value_type: string
+  default_value: pretty
+  description: 'Format the output. Values: [pretty | json].'
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: quiet
+  shorthand: q
+  value_type: bool
+  default_value: "false"
+  description: Only display IDs.
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
 deprecated: false
 experimental: false
 experimentalcli: false

docs/reference/docker_compose_pause.yaml

@@ -1,7 +1,7 @@
 command: docker compose pause
-short: Pause services
+short: pause services
 long: |
-    Pauses running containers of a service. They can be unpaused with `docker compose unpause`.
+  Pauses running containers of a service. They can be unpaused with `docker compose unpause`.
 usage: docker compose pause [SERVICE...]
 pname: docker compose
 plink: docker_compose.yaml

docs/reference/docker_compose_port.yaml

@@ -1,30 +1,28 @@
 command: docker compose port
 short: Print the public port for a port binding.
 long: Prints the public port for a port binding.
-usage: docker compose port [OPTIONS] SERVICE PRIVATE_PORT
+usage: docker compose port [options] [--] SERVICE PRIVATE_PORT
 pname: docker compose
 plink: docker_compose.yaml
 options:
-    - option: index
-      value_type: int
-      default_value: "1"
-      description: index of the container if service has multiple replicas
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
-    - option: protocol
-      value_type: string
-      default_value: tcp
-      description: tcp or udp
-      deprecated: false
-      hidden: false
-      experimental: false
-      experimentalcli: false
-      kubernetes: false
-      swarm: false
+- option: index
+  value_type: int
+  default_value: "1"
+  description: index of the container if service has multiple replicas
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
+- option: protocol
+  value_type: string
+  default_value: tcp
+  description: tcp or udp
+  deprecated: false
+  experimental: false
+  experimentalcli: false
+  kubernetes: false
+  swarm: false
 deprecated: false
 experimental: false
 experimentalcli: false