Our review

Creates PKGBUILD files and related metadata for submitting software projects to the Arch User Repository (AUR).

Strengths

Automates PKGBUILD creation based on project structure
Supports multiple build systems (Cargo, Python, CMake, etc.)
Handles both release tarballs and VCS packages
Includes validation and submission guidance

Limitations

Requires an Arch Linux environment with makepkg and namcap installed
May not cover highly non-standard build configurations
Assumes familiarity with AUR submission process

When to use it

When you need to package a software project for distribution via the Arch User Repository.

When not to use it

For general package installation, managing existing packages, or for non-Arch Linux distributions.

Examples

Rust CLI tool packaging

Create an AUR package for my Rust CLI tool located at https://github.com/user/my-rust-tool (tag v1.2.0). Generate PKGBUILD and .SRCINFO.

Python library packaging

Generate a PKGBUILD for a Python package from PyPI called 'mylib' version 0.5.0. It uses setuptools, has dependencies on requests and click, and license is MIT.

CMake project with Git VCS

Package this CMake project from GitHub (https://github.com/user/project) for AUR as a VCS package. The project uses Git and builds with CMake. Provide PKGBUILD for the -git variant.

name: aur-bundler description: Creates Arch Linux packages (PKGBUILD) for AUR submission. Use when users want to "package for AUR", "create PKGBUILD", "build AUR package", "submit to AUR", or need Arch packaging for software projects. scope: global license: MIT

AUR Bundler Skill

When to use this skill

Use this skill when users need to:

Create PKGBUILD files for AUR submission
Package software projects for Arch Linux
Convert GitHub/GitLab projects into installable AUR packages
Build Rust, Python, CMake, Autotools, or other projects for AUR
Generate AUR metadata (.SRCINFO) and validate packages
Handle VCS packages (git, svn) or regular releases

Triggers: "AUR", "PKGBUILD", "Arch package", "aur-bundler", "package for Arch", "submit to AUR", "create AUR package"

Never use for: General package installation, system package management, non-Arch systems

Instructions

Step 1: Analyze Project Structure

Identify build system (Cargo.toml, package.json, Makefile, CMakeLists.txt, setup.py)
Extract metadata: name, version, description, license, URL
List all dependencies (runtime, build-time, optional)
Check for VCS needs (git, svn) or static releases

Step 2: Create PKGBUILD

Generate main build script with:

Mandatory fields: pkgname, pkgver, pkgrel, arch, pkgdesc, url, license
Source: Release tarball URL or VCS URL with branch/tag
Checksums: sha256sums for releases, SKIP for VCS
Dependencies: depends, makedepends, checkdepends, optdepends

Step 3: Implement Build Functions

build() {
  cd "$pkgname-$pkgver"
  # Build commands based on project type
}

package() {
  cd "$pkgname-$pkgver"
  # Install to $pkgdir with correct paths
}

Step 4: Test and Validate

Test build: makepkg --nodeps --skippgpcheck
Generate checksums: makepkg -g >> PKGBUILD
Validate: namcap PKGBUILD
Generate metadata: makepkg --printsrcinfo > .SRCINFO

Step 5: AUR Submission

Set up Git repository with PKGBUILD and .SRCINFO
Configure SSH for AUR access
Push to AUR git repository

Tools Required

makepkg: Package building (pacman)
namcap: PKGBUILD validation
git: For VCS packages and AUR submission
Build tools: base-devel, cargo, rust, cmake, etc.

AUR Bundler

Recommended for