onde-cli 0.2.0__tar.gz

onde_cli-0.2.0/.github/workflows/ci.yml

@@ -0,0 +1,150 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ci-${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  fmt:
+    name: Format
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          components: rustfmt
+
+      - name: Check formatting
+        run: cargo fmt -- --check
+
+  clippy:
+    name: Clippy
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          components: clippy
+
+      - name: Install system dependencies
+        run: sudo apt-get install -y libclang-dev
+
+      - name: Cache cargo registry and build artifacts
+        uses: Swatinem/rust-cache@v2
+
+      - name: Lint
+        run: cargo clippy --all-targets -- -D warnings
+        env:
+          ONDE_APP_ID: ${{ secrets.ONDE_APP_ID }}
+          ONDE_APP_SECRET: ${{ secrets.ONDE_APP_SECRET }}
+          GRESIQ_API_KEY: ${{ secrets.GRESIQ_API_KEY }}
+          GRESIQ_API_SECRET: ${{ secrets.GRESIQ_API_SECRET }}
+
+  test:
+    name: Test
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Install system dependencies
+        run: sudo apt-get install -y libclang-dev
+
+      - name: Cache cargo registry and build artifacts
+        uses: Swatinem/rust-cache@v2
+
+      - name: Run tests
+        run: cargo test --locked --verbose
+        env:
+          ONDE_APP_ID: ${{ secrets.ONDE_APP_ID }}
+          ONDE_APP_SECRET: ${{ secrets.ONDE_APP_SECRET }}
+          GRESIQ_API_KEY: ${{ secrets.GRESIQ_API_KEY }}
+          GRESIQ_API_SECRET: ${{ secrets.GRESIQ_API_SECRET }}
+
+  check:
+    name: Cargo check
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Install system dependencies
+        run: sudo apt-get install -y libclang-dev
+
+      - name: Cache cargo registry and build artifacts
+        uses: Swatinem/rust-cache@v2
+
+      - name: Cargo check
+        run: cargo check --locked
+        env:
+          ONDE_APP_ID: ${{ secrets.ONDE_APP_ID }}
+          ONDE_APP_SECRET: ${{ secrets.ONDE_APP_SECRET }}
+          GRESIQ_API_KEY: ${{ secrets.GRESIQ_API_KEY }}
+          GRESIQ_API_SECRET: ${{ secrets.GRESIQ_API_SECRET }}
+
+  build:
+    name: Build (aarch64-apple-darwin)
+    runs-on: macos-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: aarch64-apple-darwin
+
+      - name: Cache cargo registry and build artifacts
+        uses: Swatinem/rust-cache@v2
+
+      - name: Build release binary
+        run: cargo build --release --locked --target aarch64-apple-darwin
+        env:
+          ONDE_APP_ID: ${{ secrets.ONDE_APP_ID }}
+          ONDE_APP_SECRET: ${{ secrets.ONDE_APP_SECRET }}
+          GRESIQ_API_KEY: ${{ secrets.GRESIQ_API_KEY }}
+          GRESIQ_API_SECRET: ${{ secrets.GRESIQ_API_SECRET }}
+
+  ci:
+    name: CI status
+    runs-on: ubuntu-latest
+    needs:
+      - fmt
+      - clippy
+      - test
+      - check
+      - build
+    if: always()
+    steps:
+      - name: Verify all required jobs succeeded
+        run: |
+          test "${{ needs.fmt.result }}"    = "success"
+          test "${{ needs.clippy.result }}" = "success"
+          test "${{ needs.test.result }}"   = "success"
+          test "${{ needs.check.result }}"  = "success"
+          test "${{ needs.build.result }}"  = "success"

onde_cli-0.2.0/.github/workflows/release-crates.yml

@@ -0,0 +1,120 @@
+name: Release crates.io
+
+on:
+  push:
+    tags:
+      - "v*"
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: release-crates-${{ github.ref }}
+  cancel-in-progress: false
+
+env:
+  CARGO_TERM_COLOR: always
+  ONDE_APP_ID: ${{ secrets.ONDE_APP_ID }}
+  ONDE_APP_SECRET: ${{ secrets.ONDE_APP_SECRET }}
+  GRESIQ_API_KEY: ${{ secrets.GRESIQ_API_KEY }}
+  GRESIQ_API_SECRET: ${{ secrets.GRESIQ_API_SECRET }}
+
+jobs:
+  verify:
+    name: Verify release
+    runs-on: ubuntu-latest
+    outputs:
+      version: ${{ steps.package.outputs.version }}
+      tag: ${{ steps.tag.outputs.tag }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          components: clippy, rustfmt
+
+      - name: Cache cargo registry and build artifacts
+        uses: Swatinem/rust-cache@v2
+
+      - name: Read package version
+        id: package
+        shell: bash
+        run: |
+          version="$(sed -n 's/^version = "\(.*\)"/\1/p' Cargo.toml | head -n 1)"
+          if [ -z "$version" ]; then
+            echo "Failed to read package version from Cargo.toml" >&2
+            exit 1
+          fi
+          echo "version=$version" >> "$GITHUB_OUTPUT"
+
+      - name: Read git tag version
+        id: tag
+        shell: bash
+        run: |
+          ref="${GITHUB_REF_NAME}"
+          tag="${ref#v}"
+          echo "tag=$tag" >> "$GITHUB_OUTPUT"
+
+      - name: Ensure tag matches Cargo.toml version
+        if: github.event_name == 'push'
+        shell: bash
+        run: |
+          test "${{ steps.package.outputs.version }}" = "${{ steps.tag.outputs.tag }}"
+
+      - name: Check formatting
+        run: cargo fmt --all -- --check
+
+      - name: Run clippy
+        run: cargo clippy --all-targets --all-features -- -D warnings
+
+      - name: Run tests
+        run: cargo test --all-features --locked --verbose
+
+      - name: Run cargo check
+        run: cargo check --locked
+
+      - name: Verify package contents
+        run: cargo package --locked --allow-dirty
+
+  publish:
+    name: Publish to crates.io
+    runs-on: ubuntu-latest
+    needs: verify
+    environment:
+      name: crates-io
+    permissions:
+      contents: read
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Cache cargo registry and build artifacts
+        uses: Swatinem/rust-cache@v2
+
+      - name: Publish crate
+        env:
+          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}
+        run: cargo publish --locked
+
+  github-release:
+    name: Create GitHub release
+    runs-on: ubuntu-latest
+    needs:
+      - verify
+      - publish
+    if: github.event_name == 'push'
+    permissions:
+      contents: write
+    steps:
+      - name: Create release
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: v${{ needs.verify.outputs.version }}
+          generate_release_notes: true
+          name: onde-cli v${{ needs.verify.outputs.version }}

onde_cli-0.2.0/.github/workflows/release-github.yml

@@ -0,0 +1,191 @@
+name: GitHub Release
+
+on:
+  push:
+    tags:
+      - "v*.*.*"
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: "Release tag (e.g. v0.1.1)"
+        required: true
+
+permissions:
+  contents: write
+  actions: write
+
+env:
+  PROJECT_NAME: onde
+  CARGO_TERM_COLOR: always
+  ONDE_APP_ID: ${{ secrets.ONDE_APP_ID }}
+  ONDE_APP_SECRET: ${{ secrets.ONDE_APP_SECRET }}
+  GRESIQ_API_KEY: ${{ secrets.GRESIQ_API_KEY }}
+  GRESIQ_API_SECRET: ${{ secrets.GRESIQ_API_SECRET }}
+
+jobs:
+  build:
+    name: Build binary (${{ matrix.name }})
+    runs-on: ${{ matrix.runner }}
+
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - name: linux-amd64
+            runner: ubuntu-latest
+            target: x86_64-unknown-linux-gnu
+          - name: linux-arm64
+            runner: ubuntu-24.04-arm
+            target: aarch64-unknown-linux-gnu
+          - name: win-amd64
+            runner: windows-latest
+            target: x86_64-pc-windows-msvc
+          - name: win-arm64
+            runner: windows-latest
+            target: aarch64-pc-windows-msvc
+          - name: macos-amd64
+            runner: macos-15-intel
+            target: x86_64-apple-darwin
+          - name: macos-arm64
+            runner: macos-latest
+            target: aarch64-apple-darwin
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+        with:
+          ref: ${{ github.event.inputs.tag || github.ref }}
+
+      - name: Set the release version
+        shell: bash
+        run: |
+          if [[ "${GITHUB_REF_TYPE}" == "tag" ]]; then
+            release_version="${GITHUB_REF_NAME#v}"
+          else
+            release_version="${{ github.event.inputs.tag }}"
+            release_version="${release_version#v}"
+          fi
+          echo "RELEASE_VERSION=${release_version}" >> "$GITHUB_ENV"
+
+      - name: Read Rust toolchain
+        shell: bash
+        run: |
+          rust_toolchain="$(sed -n 's/^channel = "\(.*\)"/\1/p' rust-toolchain.toml | head -n 1)"
+          if [ -z "$rust_toolchain" ]; then
+            echo "Failed to read Rust toolchain from rust-toolchain.toml" >&2
+            exit 1
+          fi
+          echo "RUST_TOOLCHAIN=${rust_toolchain}" >> "$GITHUB_ENV"
+
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@3c5f7ea28cd621ae0bf5283f0e981fb97b8a7af9
+        with:
+          toolchain: ${{ env.RUST_TOOLCHAIN }}
+          targets: ${{ matrix.target }}
+
+      - name: Setup Rust cache
+        uses: Swatinem/rust-cache@v2
+        with:
+          key: github-${{ matrix.target }}
+
+      - name: Build binary
+        shell: bash
+        run: cargo build --locked --release --target ${{ matrix.target }}
+
+      - name: Package binary
+        shell: bash
+        run: |
+          BIN_SUFFIX=""
+          if [[ "${{ matrix.runner }}" == "windows-latest" ]]; then
+            BIN_SUFFIX=".exe"
+          fi
+
+          BIN_OUTPUT="target/${{ matrix.target }}/release/${PROJECT_NAME}${BIN_SUFFIX}"
+          BIN_RELEASE="${PROJECT_NAME}-${{ matrix.name }}${BIN_SUFFIX}"
+
+          mkdir -p ./release
+          mv "${BIN_OUTPUT}" "./release/${BIN_RELEASE}"
+
+      - name: Package macOS tarball for Homebrew
+        if: contains(matrix.target, 'apple-darwin')
+        shell: bash
+        run: |
+          ARCHIVE_NAME="${PROJECT_NAME}-${{ matrix.name }}.tar.gz"
+
+          mkdir -p staging-brew
+          cp "./release/${PROJECT_NAME}-${{ matrix.name }}" "staging-brew/${PROJECT_NAME}"
+          strip "staging-brew/${PROJECT_NAME}"
+
+          tar -C staging-brew -czf "${ARCHIVE_NAME}" "${PROJECT_NAME}"
+
+          shasum -a 256 "${ARCHIVE_NAME}" | awk '{print $1}' > "${ARCHIVE_NAME}.sha256"
+
+          echo "Archive: ${ARCHIVE_NAME}"
+          echo "SHA256:  $(cat "${ARCHIVE_NAME}.sha256")"
+
+      - name: Upload binary artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: binary-${{ matrix.name }}
+          path: release/*
+
+      - name: Upload macOS Homebrew artifacts
+        if: contains(matrix.target, 'apple-darwin')
+        uses: actions/upload-artifact@v4
+        with:
+          name: homebrew-${{ matrix.name }}
+          path: |
+            ${{ env.PROJECT_NAME }}-${{ matrix.name }}.tar.gz
+            ${{ env.PROJECT_NAME }}-${{ matrix.name }}.tar.gz.sha256
+
+  release:
+    name: Create GitHub Release
+    needs: build
+    runs-on: ubuntu-latest
+    if: github.ref_type == 'tag' || github.event_name == 'workflow_dispatch'
+
+    steps:
+      - name: Resolve tag
+        id: tag
+        shell: bash
+        run: |
+          if [[ "${{ github.event_name }}" == "workflow_dispatch" ]]; then
+            echo "tag=${{ github.event.inputs.tag }}" >> "$GITHUB_OUTPUT"
+          else
+            echo "tag=${{ github.ref_name }}" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Download binary artifacts
+        uses: actions/download-artifact@v4
+        with:
+          pattern: "binary-*"
+          path: release
+          merge-multiple: true
+
+      - name: Download Homebrew artifacts
+        uses: actions/download-artifact@v4
+        with:
+          pattern: "homebrew-*"
+          path: release
+          merge-multiple: true
+
+      - name: Release
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: ${{ steps.tag.outputs.tag }}
+          files: release/*
+
+      - name: Trigger Homebrew release
+        uses: actions/github-script@v7
+        with:
+          script: |
+            await github.rest.actions.createWorkflowDispatch({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              workflow_id: 'release-homebrew.yml',
+              ref: 'main',
+              inputs: {
+                tag: '${{ steps.tag.outputs.tag }}'
+              }
+            })
+            console.log('Dispatched release-homebrew.yml for tag ${{ steps.tag.outputs.tag }}')

onde_cli-0.2.0/.github/workflows/release-homebrew.yml

@@ -0,0 +1,116 @@
+name: Homebrew CLI Release
+
+on:
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: "Release tag (e.g. v0.1.1)"
+        required: true
+
+permissions:
+  contents: read
+
+env:
+  REPO: ondeinference/onde-cli
+
+jobs:
+  update-homebrew-tap:
+    name: Update Homebrew tap
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Resolve tag and version
+        id: release
+        shell: bash
+        run: |
+          TAG="${{ github.event.inputs.tag }}"
+          VERSION="${TAG#v}"
+
+          echo "tag=${TAG}" >> "$GITHUB_OUTPUT"
+          echo "version=${VERSION}" >> "$GITHUB_OUTPUT"
+
+      - name: Read SHA256 checksums from release
+        id: sha
+        env:
+          GH_TOKEN: ${{ github.token }}
+        shell: bash
+        run: |
+          mkdir -p artifacts
+
+          gh release download "${{ steps.release.outputs.tag }}" \
+            --repo "${{ env.REPO }}" \
+            --pattern "onde-macos-*.tar.gz.sha256" \
+            --dir artifacts/
+
+          ARM64_SHA=$(cat artifacts/onde-macos-arm64.tar.gz.sha256)
+          AMD64_SHA=$(cat artifacts/onde-macos-amd64.tar.gz.sha256)
+
+          echo "arm64=${ARM64_SHA}" >> "$GITHUB_OUTPUT"
+          echo "amd64=${AMD64_SHA}" >> "$GITHUB_OUTPUT"
+
+          echo "ARM64 SHA256: ${ARM64_SHA}"
+          echo "AMD64 SHA256: ${AMD64_SHA}"
+
+      - name: Checkout Homebrew tap
+        uses: actions/checkout@v6
+        with:
+          repository: ondeinference/homebrew-tap
+          token: ${{ secrets.HOMEBREW_TAP_TOKEN }}
+          path: homebrew-tap
+
+      - name: Generate formula
+        shell: bash
+        run: |
+          VERSION="${{ steps.release.outputs.version }}"
+          TAG="${{ steps.release.outputs.tag }}"
+          ARM64_SHA="${{ steps.sha.outputs.arm64 }}"
+          AMD64_SHA="${{ steps.sha.outputs.amd64 }}"
+
+          mkdir -p homebrew-tap/Formula
+
+          cat > homebrew-tap/Formula/onde.rb <<FORMULA
+          # frozen_string_literal: true
+
+          # Homebrew formula for the Onde Inference CLI (\`onde\` binary).
+          class Onde < Formula
+            desc 'Command-line interface for Onde Inference'
+            homepage 'https://ondeinference.com'
+            version '${VERSION}'
+            license 'MIT OR Apache-2.0'
+
+            on_macos do
+              on_arm do
+                url 'https://github.com/${REPO}/releases/download/${TAG}/onde-macos-arm64.tar.gz'
+                sha256 '${ARM64_SHA}'
+              end
+              on_intel do
+                url 'https://github.com/${REPO}/releases/download/${TAG}/onde-macos-amd64.tar.gz'
+                sha256 '${AMD64_SHA}'
+              end
+            end
+
+            def install
+              bin.install 'onde'
+            end
+
+            test do
+              assert_match version.to_s, shell_output("#{bin}/onde --version", 1)
+            end
+          end
+          FORMULA
+
+          echo "Generated formula:"
+          cat homebrew-tap/Formula/onde.rb
+
+      - name: Commit and push
+        shell: bash
+        run: |
+          VERSION="${{ steps.release.outputs.version }}"
+
+          cd homebrew-tap
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add Formula/onde.rb
+          git diff --cached --quiet && echo "No changes to commit" && exit 0
+          git commit -m "Update onde to ${VERSION}"
+          git push