# enozunu

> A declarative, reproducible cross-provider configuration materializer for AI agent tooling that centralizes agent configuration sources and materializes them into target AI-native paths.

Enozunu (役小角) is an open-source CLI tool written in Rust that solves the problem of managing AI agent configuration across multiple projects and machines. Built by GitHub user tooppoo and licensed under Apache 2.0, it takes a declarative approach — you define your agent skill sources once in an `enozunu.kdl` manifest, and the tool resolves and materializes them into the native configuration paths expected by supported AI targets. Currently in early development at v0.6.0, it targets Claude and Codex as supported AI environments.

## What It Is

Enozunu is a configuration materializer for AI agent tooling — specifically for the "Skills" and agent definitions that AI coding assistants like Claude and Codex consume. Rather than copying configuration files between projects by hand, developers declare sources (Git repositories, local paths, or GitHub Gists) in a single manifest file. Enozunu then resolves those sources, locks resolved commits in `enozunu.lock.json` for reproducibility, and writes the materialized output into each target AI's native configuration paths. The project explicitly describes itself as **not** a marketplace, GUI installer, or interactive resource manager — its scope is strictly the resolve, lock, materialize, and verify flow.

## How the Declarative Workflow Works

The core workflow follows four steps: declare, resolve, lock, and materialize.

- **Declare**: Write `enozunu.kdl` listing providers (skill sources via `git`, `local`, or `gist`) and consumers (which target AI uses which skills).
- **Resolve**: Run `enozunu summon` to fetch sources and write materialized files into target AI paths.
- **Lock**: On first run, resolved commits for `branch` and `tag` selections are recorded in `enozunu.lock.json`. Commit this file to make runs reproducible.
- **Verify in CI**: Use `enozunu summon --frozen` to materialize strictly from the lock file and fail if anything is missing or unresolved. A clean `git status` after that run confirms no drift from declared sources.

Additional commands include `enozunu init` (generates a starter manifest and a `.enozunu/.gitignore` to keep the resolver cache out of version control) and `enozunu validate` (checks the manifest without materializing).

## Supported Targets and Source Types

The README states that the currently supported target AIs are **Claude** and **Codex**. Both draw from the same declared source pool, and each selection is materialized into that target's native path. Source references in the manifest support three types:

- `git` — a remote Git repository with a URL, branch or tag, and a path within the repo
- `local` — a local filesystem path
- `gist` — a GitHub Gist

## Architecture and Design Philosophy

Enozunu is implemented in Rust and distributed via Homebrew (macOS/Linux), Scoop (Windows), and a curl install script. The manifest format uses KDL (a document language), keeping configuration human-readable and diff-friendly. The project maintains explicit Architecture Decision Records (ADRs) and versioned design goal documents (`v0.0.x-goal.md`, `v0.1.x-goal.md`), signaling a deliberate, phased approach to scope expansion. The design philosophy centers on declarativeness, reproducibility, and generated-output management — explicitly excluding discovery, recommendation, and interactive installation from its responsibility boundary.

## Update: Version 0.6.0

The latest release is **0.6.0**, published on 2026-08-24, with the repository last pushed on the same date. The project was created in July 2026 and has been actively developed since. The GitHub repository lists 4 open issues and 4 stars, consistent with an early-stage open-source project. The stated v0.1.x goal documents provide a roadmap signal for near-term scope, while the project's narrow, intentional design boundary suggests stability in its core resolve-lock-materialize flow even as target support may expand.

## Features
- Declarative manifest-based configuration via enozunu.kdl
- Reproducible builds via enozunu.lock.json lock file
- Cross-provider skill and agent source management
- Materializes configuration into Claude and Codex native paths
- Git, local, and GitHub Gist source references
- CI-safe frozen mode (enozunu summon --frozen)
- Lock file update support (enozunu summon --update)
- Manifest validation command (enozunu validate)
- Starter manifest generation (enozunu init)
- Resolver cache gitignore management
- Homebrew, Scoop, and curl install support
- Architecture Decision Records and versioned design docs

## Integrations
Claude, Codex, Git, GitHub Gist, Homebrew, Scoop

## Platforms
CLI, WINDOWS, MACOS, LINUX

## Pricing
Open Source

## Version
0.6.0

## Links
- Website: https://github.com/tooppoo/enozunu
- Documentation: https://github.com/tooppoo/enozunu/blob/main/docs/README.md
- Repository: https://github.com/tooppoo/enozunu
- EveryDev.ai: https://www.everydev.ai/tools/enozunu