skill

repoctl

tyrchen/repoctlcommunitylistedunreviewed

Set up

Skills are installed by placing their folder where your agent loads skills.

Download ZIP from GitHub Open the repository

The download comes from github.com/tyrchen/repoctl itself, not from our server, so what you get is exactly what its author published.

Install instructions come from the README

Skills do not use an MCP config. Follow the steps in the README below.

README

synced Oct 25, 2026

repoctl

repoctl is a graph-aware control plane for functional monorepos. It gives a repository one validated model for humans, CI, and AI agents to share: project boundaries, workspace discovery, dependency graph, affected tasks, CI matrices, PR impact, templates, proto ownership, IaC routing, operations planning, and agent context.

The core workflow is available through a typed Rust facade and the repoctl CLI. v0.7 governance adds offline Cargo/Node/Python discovery, dependency-aware execution, opt-in local caching, Buf compatibility checks and executable CI.

Why repoctl exists

Large monorepos become hard to operate when every tool sees a different shape. Package managers know language workspaces, CI knows job matrices, platform teams know deployment and IaC, and AI agents need local boundaries before they can make safe edits.

repoctl keeps those concerns connected through repo-level and project-level manifests:

repo.yaml defines repo layout, defaults, proto roots, IaC roots, AI context paths, and global policies.
project.yaml defines one functional project: app, framework, foundation service, proto root, or core infrastructure.
Project manifests can also declare task commands, IaC stacks, DNS/CDN intent, runtime probes, and manual-state reconciliation records.
The generated graph powers validation, affected analysis, task planning, CI data, PR summaries, operations plans, and scoped AI context.

Repository layout

repoctl manages functional monorepos. Generated repositories are organized by product and capability instead of by language:

apps/<app>/
frameworks/<capability>/
foundations/<service>/
protos/
core-infra/
templates/
tools/

Language workspaces live inside those functional projects, for example apps/catalog/api/Cargo.toml or apps/catalog/web/package.json. A generated repository should not rely on root-level language workspaces such as a root Cargo.toml, package.json, or pyproject.toml.

This source repository is a Rust workspace because it builds the tool itself.

Install from source

git clone https://github.com/tyrchen/repoctl.git
cd repoctl
cargo install --path apps/repoctl-cli
repoctl --help

For local development without installing:

cargo run --bin repoctl -- --help

Quick start

Create a new functional monorepo:

repoctl init --name acme --repo ./acme
cd acme

Create projects:

repoctl new app catalog \
  --stack rust-api,bun-web \
  --iac pulumi \
  --owner @catalog

repoctl new framework runtime \
  --languages rust,typescript \
  --facade \
  --owner @platform

repoctl new foundation identity \
  --clients rust,typescript \
  --proto company.identity.v1 \
  --owner @identity

Validate and inspect the graph:

repoctl graph validate
repoctl graph print
repoctl explain apps.catalog

Plan affected work:

repoctl affected \
  --changed-file apps/catalog/api/src/lib.rs \
  --tasks check,test

repoctl run check --affected --dry-run

Generate CI data:

repoctl ci matrix \
  --tasks check,test,build \
  --format github-actions

Plan an operational infrastructure change:

repoctl ops plan \
  --base origin/main \
  --head HEAD \
  --env staging \
  --tasks check,test,build \
  --output target/repoctl/ops-plan.json

repoctl ops verify --plan target/repoctl/ops-plan.json
repoctl provider capabilities --workspace frameworks.operon:infra

Main command groups

Command	Purpose
`repoctl init`	Create a functional monorepo skeleton.
`repoctl new`	Scaffold app, framework, and foundation projects.
`repoctl graph`	Validate and print the repository graph.
`repoctl explain`	Explain a project or graph node and its edges.
`repoctl lint-boundaries`	Check graph and path boundary policies.
`repoctl affected`	Compute affected projects, tasks, workspaces, reviewers, and risk flags.
`repoctl run`	Plan or execute manifest-defined tasks.
`repoctl ci`	Build CI matrix output, including GitHub Actions output.
`repoctl template`	List and render built-in or local templates.
`repoctl codegen`	Detect direct edits to generated code.
`repoctl inspect`	Inspect code size for oversized files, functions, and nested blocks.
`repoctl proto`	Query proto owners and consumers, and check proto policy.
`repoctl context`	Build project-scoped AI context.
`repoctl pr`	Build PR impact summaries.
`repoctl iac`	Plan IaC provider commands without applying changes. `iac preview` is an alias for preview planning.
`repoctl ops`	Build non-mutating operations plans, verification command lists, journals, and reconciliation reports.
`repoctl provider`	Inspect provider package capabilities, especially Pulumi provider/schema gaps.
`repoctl skills`	Check or synchronize generated agent skills.

Most commands accept --repo and --format human|json|github-actions. Human output is for local use. JSON output is for automation. GitHub Actions output is specialized where CI needs a matrix-shaped payload.

Documentation

Developing repoctl

This repository uses Rust 2024 and the pinned toolchain in rust-toolchain.toml. Formatting uses nightly rustfmt, and CI runs the same formatter.

Useful commands:

make build
make test
cargo +nightly fmt
cargo clippy -- -D warnings

Run the smallest meaningful check for the surface you changed. Documentation-only changes should be proofread and link-checked instead of running the full Rust gate set mechanically.

License

This project is distributed under the terms of MIT. See LICENSE.md.