Skip to content

README.md

Latest commit

 

History

History
116 lines (88 loc) · 5.63 KB

README.md

File metadata and controls

116 lines (88 loc) · 5.63 KB
Raw

agentic-coding-registry — Template Registry

Template registry consumed by the create-ai-native-project CLI — documentation. The CLI shallow-clones this repo into a local cache and copies/retargets the selected templates into a target project — for Claude Code, OpenAI Codex, and OpenCode.

Core set (core.json)

core.json at the registry root lists skills/agents installed on every project regardless of what the user selects (they're hidden from the pickers):

{ "skills": ["engineering-standards", "knowledge-base", "using-create-ai-native-project"], "agents": ["code-reviewer", "security-reviewer"] }

Edit it to change what's always installed — no CLI release needed.

Layout

project-types/<id>/  project shape (monorepo, single, …)  → files copied to project root
stacks/<id>/         tech stack (react, flutter, laravel, python-*, …) → project root
                     (may bundle `.claude/agents/<id>.md` — auto-installed with the stack)
databases/<id>/      database (postgres, mysql, mongodb)   → sections + compose service
storage/<id>/        storage (minio, aws-s3)               → sections + compose service
auth/<id>/           auth (jwt, clerk)                     → sections + setup files
docker/<id>/         docker-compose base (compose)         → composed docker-compose.yml
ci/<id>/             CI (github-actions, gitlab-ci)        → base + per-stack jobs composed
docs/<id>/           docs tooling (docusaurus, …)          → files copied to project docs/
mcp/<id>/            MCP server (chrome-devtools, …)       → per-tool MCP config (see below)
skills/<id>/         one directory per skill               → copied to .claude/skills/<id>/
agents/<id>/         one directory per agent               → copied to .claude/agents/
claude/<id>/         base CLAUDE.md fallback               → e.g. claude/default/CLAUDE.md

Multi-tool: skills/agents are authored here in Claude Code's shape; the CLI retargets them per selected tool — agents to .claude/agents, .opencode/agents (.md), or .codex/agents (.toml); skills to .claude/skills, .opencode/skills, or .agents/skills. See the docs.

Each template directory may include a template.json describing it (used to render the interactive picker); the manifest itself is not copied:

{ "name": "Human-readable name", "description": "One-line summary" }

CLAUDE.md composition

The CLI builds the project's CLAUDE.md from templates rather than copying a single file:

  • The selected project-type may provide CLAUDE.md — the base knowledge base (falls back to claude/default/CLAUDE.md).
  • Each selected stack may provide CLAUDE.section.md — appended to the base, in selection order.

docker-compose composition

When the user opts into Docker, docker-compose.yml is composed (text-based, mirroring CLAUDE.md): the docker/compose base supplies the services: header, and each selected stack / database / storage may contribute a compose.service.yml fragment (one or more service entries, indented to sit under services:). Fragments are appended in selection order.

CI composition (per-stack)

A CI provider's template.json declares compose: { base, fragment }. The CLI takes the provider's base skeleton (which has the jobs: / stages: header) and appends each selected stack's fragment file — ci.github.yml (a job indented under jobs:) or ci.gitlab.yml (a top-level job). So the pipeline contains a job per chosen stack.

MCP server composition (per-tool)

An mcp/<id>/ entry describes an MCP server the agent can connect to. It ships:

  • template.json — picker metadata (name / description).
  • mcp.json — a tool-neutral spec: transport (stdio | http), then command + args (+ optional env) for stdio, or url (+ optional headers) for http. An optional note documents any key/runtime requirement.
  • CLAUDE.section.md — a short section appended to the instructions file.

The CLI reads the spec and generates each selected tool's own MCP config, merging into whatever the project already has (existing servers are never overwritten): .mcp.json (Claude Code), the mcp block of opencode.json (OpenCode), and .codex/config.toml (Codex). Cline has no project-committed MCP file, so it's documented rather than written.

package.json composition

For project-types and stacks, a package.json is merged (not copied): the project-type provides the base, each stack's package.json is merged in with first-wins semantics (existing keys — including individual deps/scripts — are never overwritten). This produces one runnable root package.json.

docs/ templates are self-contained sub-projects: their package.json is copied verbatim (into docs/), not merged into the root.

What's copied vs. composed

Per project-type / stack, these are composed (not copied): CLAUDE.md, CLAUDE.section.md, package.json, template.json. Every other file is copied verbatim into the target (preserving sub-paths) — how templates drop setup files (e.g. pnpm-workspace.yaml, vite.config.ts, docs/…). For other kinds (docs/skills/agents) only template.json is withheld.

Contributing a template

  1. Add a directory under skills/, agents/, or claude/.
  2. Add a template.json with name + description.
  3. Add the files to be copied into a target project.
  4. Open a PR against main.