GroundZero Package Manager (OpenPackage / opkg) — Summary

OpenPackage (opkg) is a TypeScript-based CLI package manager for AI coding agent configuration files — rules, commands, agents, skills, and MCP configs — that provides unified install, uninstall, sync, and packaging across 40+ AI coding platforms (Claude Code, Codex, Cursor, Kiro, Windsurf, Roo, OpenHands, Gemini CLI, Copilot, and many others).

Problem it solves: AI coding tools each store their configuration files (rules, commands, agents, skills, MCPs) in different directories with different naming conventions — managing these across multiple projects and platforms requires manual copying; OpenPackage provides a single opkg install <source> command that performs cross-platform conversion and installation automatically.

Distinctive trait: The only package manager in the batch with a Tauri-based desktop GUI (@opkg/gui), a path-based source-of-truth model with mutable vs. immutable source enforcement, and explicit support for 40+ AI coding platforms in a single platforms.jsonc configuration.

Target audience: Developers who work across multiple AI coding tools and need to manage rules, commands, agents, skills, and MCP configs consistently; team leads who want to share coding standards across tools.

Scope: TypeScript monorepo with CLI (opkg), core library (@opkg/core), and Tauri desktop GUI (@opkg/gui). 20 CLI subcommands covering install, uninstall, sync, add, remove, list, new, publish, pack, save, and more.

Differs from seeds: Unlike all seeds (which ship prompts/methodologies for Claude to follow), OpenPackage is a developer tool that manages the configuration files those methodologies live in. It's the file-system management layer beneath skill packs — "npm for agent configs" with cross-platform conversion.

GroundZero Package Manager (OpenPackage) — Overview

Origin

Created by Eric Lee (hyericlee). Package name opkg. Stars: 557 with 9 contributors. Apache-2.0. Active as of 2026-05-11. The GitHub repo is groundzero-ai/gpm but the package is named opkg/openpackage.

Note: The README explicitly names the product "OpenPackage" and the CLI binary opkg, though the GitHub slug is gpm. The GitHub URL appears to be a legacy name — "gpm" (groundzero package manager).

Philosophy

From the README:

"OpenPackage enables simple, modular management of coding agent configs, providing unified installation, management, and packaging of rules, commands, agents, skills, and MCPs for any platform, any codebase."

Design principles from specs/README.md:

• Focused: Each command serves one clear purpose, avoiding overload.
• Surgical: Strict separation of mutable development sources from immutable distribution snapshots, with enforcement via errors.
• Simple: Paths are the universal source of truth; a single unified index manages all tracking.
• Reliable: Built-in guards prevent common errors, like mutating published registry content.

Community

Discord: https://discord.gg/W5H54HZ8Fm

Self-Description

"It's basically a much more powerful, universal, and open source version of Vercel Skills and Claude Code Plugins."

This framing positions OpenPackage as a universal layer above both Vercel's skill format and Anthropic's plugin format.

Changelog Note

"The architecture introduces breaking changes with no automated migration — re-initialize workspaces."

The path-based model is a recent redesign; earlier versions had different architecture.

GroundZero Package Manager (OpenPackage) — Architecture

Distribution

• Type: npm CLI tool + Tauri desktop app
• Install: npm install -g opkg
• Binary: opkg (alias: openpackage)

Repository Structure (monorepo)

groundzero-ai/gpm/
├── bin/
│   └── openpackage      # Node.js CLI entry point
├── packages/
│   ├── cli/             # CLI package (@opkg/cli)
│   │   └── src/
│   │       ├── commands/ # 20 command files (.ts)
│   │       └── index.ts
│   ├── core/            # Core library (@opkg/core)
│   └── gui/             # Tauri desktop app (@opkg/gui)
│       ├── package.json  # Tauri + Vite
│       └── src-tauri/    # Rust (Tauri backend)
├── specs/               # Design specs for each command
├── schemas/             # JSON schemas
├── examples/            # Example packages
├── platforms.jsonc      # 40+ platform definitions
├── package.json         # name: opkg, version: 0.11.3
└── turbo.json           # Turborepo build config

Platform Coverage (platforms.jsonc)

40+ supported AI coding platforms with per-platform directory mappings:

Directory Model

~/.openpackage/
├── packages/          # Mutable development sources
├── registry/          # Immutable versioned snapshots
│   └── <name>/<version>/
└── config.yml

<workspace>/
├── .openpackage/
│   ├── openpackage.yml       # Root manifest (dependencies)
│   └── openpackage.index.yml # Unified index (all tracked packages)
└── <platform dirs>            # Sync targets

Key Design: Mutable vs. Immutable

• Mutable sources (packages/) — editable, can be modified via save/add
• Immutable registry (registry/<name>/<version>/) — version-locked snapshots; save/add fail with error
• The CLI enforces this separation: errors if you try to mutate registry content

Tauri GUI

@opkg/gui is a Tauri desktop application:

• Runtime: Rust (Tauri) + TypeScript (Vite frontend)
• Status: Ships in the monorepo but installation complexity not yet documented

Required Runtime

• node>=18
• npm
• Rust + Tauri CLI (for GUI only)

GroundZero Package Manager (OpenPackage) — Components

CLI Commands (20)

Install Sources Supported

opkg install essentials                                    # Named registry package
opkg install gh@<owner>/<repo>                             # GitHub repo
opkg install gh@wshobson/agents --plugins ui-design        # GitHub with filter
opkg install https://github.com/<owner>/<repo>/<path>      # GitHub URL
opkg install <path-to-dir>                                 # Local path
opkg install git@<host>:<org>/<repo>.git                   # SSH git URL
opkg install https://gitlab.com/<org>/<repo>.git#<ref>     # Git URL with ref

Platform Conversion

On install, opkg converts files to per-platform conventions:

• Renames files to match platform naming conventions
• Places in correct platform subdirectories
• Handles root-level files (CLAUDE.md, AGENTS.md, etc.)

Package Manifest (openpackage.yml)

name: <package-name>
version: <semver>
# ... dependencies, content paths

Unified Index (openpackage.index.yml)

Tracks all packages, sources, versions, and file mappings across the workspace. Single source of truth for what's installed and where.

Tauri Desktop GUI

@opkg/gui — Tauri-based desktop application for visual package management. Tech: Vite + TypeScript frontend, Rust backend.

Skills / Commands / Hooks / MCP

None — OpenPackage manages these files but does not ship any itself.

GroundZero Package Manager (OpenPackage) — Uniqueness

Differs from Seeds

OpenPackage occupies a unique position: it is a package manager for AI config files, not a skill framework. No seed framework does this.

• Unlike all seeds (superpowers, BMAD, spec-kit, etc.) — which ship prompts/skills for agents to follow — OpenPackage manages the infrastructure that those skills live in.
• The only other registry-oriented framework in this batch is TokRepo, but TokRepo is a cloud registry service; OpenPackage is a local file management CLI.
• The Tauri desktop GUI is unique in the corpus — no other framework ships a desktop application.
• The platforms.jsonc with 40+ platform definitions is the broadest cross-platform mapping in any framework in this batch.

Positioning

"npm for agent configs" — this is the tool you'd run before installing a skill pack, to ensure your environment is configured correctly for all your coding tools.

The self-description from the README:

"It's basically a much more powerful, universal, and open source version of Vercel Skills and Claude Code Plugins."

This is accurate: it generalizes both Vercel's skills install pattern and Anthropic's plugin system into a single universal CLI.

Most Interesting Design Choice

The mutable vs. immutable source separation with enforced errors when mutating registry content. This is a fundamental correctness guarantee that npm doesn't provide for published packages. It means teams can pin to a registry version and be confident it won't change silently.

The 40+ platform support via a JSON config (platforms.jsonc) means new platforms can be added without CLI code changes — the platform definitions drive the behavior.

Observable Failure Modes

1. No content — OpenPackage manages configs but ships none. A new user needs to find a source package to install.
2. Breaking changes warning — the architecture had recent breaking changes with no automated migration; existing users must re-initialize.
3. GUI is early-stage — Tauri GUI is in the repo but has minimal documentation.
4. Registry bootstrap — "install from registry" requires a registry to have content; the community registry at openpackage.dev must have sufficient packages to be useful.

Explicit Antipatterns

From the specs:

• Mutating immutable registry content (enforced error)
• Using save/add on registry sources (blocked)