tuff - GitLite

KO | EN

gitlite — search

#containers #react #automation #framework #data-science #html #claude #developer-tools #list #ai-agent

tuff

(★ 9)

Equip your agent. Define, diff, and deploy your own skills, tools, and hooks - portable across any coding agent harness.

파일 탐색기

ZIP 다운로드

- hook.json
- mcp.json
- settings.json
- marketplace.json
- - commit-message.yml
  - crates.yml
  - pypi.yml
  - release.yml
  - tuff-check.yml
- release.yml
- tuff-readme-banner-logo.png
- tuff-readme-banner.png
- - Cargo.toml
- - Cargo.toml
- - Cargo.toml
- - Cargo.toml
- - Cargo.toml
  - pyproject.toml
  - README-pypi.md
- - Cargo.toml
- - Cargo.toml
  - README.md
- - .DS_Store
  - .gitignore
  - .vscodeignore
  - CHANGELOG.md
  - LICENSE
  - package-lock.json
  - package.json
  - README.md
  - tsconfig.json
- .DS_Store
- - README.md
- - README.md
- README.md
- - README.md
- check-branch-name.sh
- check-commit-message.sh
- check-plugin.sh
- check-spec.sh
- generate-alien-block-tuff.swift
- generate-doc-screenshot.sh
- generate-tuff.py
- - hooks-spec.json
  - hooks-spec.schema.json
  - SPEC.md
- README.md
- - favicon.svg
  - robots.txt
- - sync-changelog.mjs
  - sync-hooks-spec.mjs
  - sync-mcp-catalog.mjs
- - content.config.ts
- .npmrc
- astro.config.mjs
- package-lock.json
- package.json
- tsconfig.json
.DS_Store
.gitignore
.ignore
.pre-commit-config.yaml
.rgignore
AGENTS.md
Cargo.lock
Cargo.toml
CHANGELOG.md
CODE_OF_CONDUCT.md
CONTRIBUTING.md
install.sh
LICENSE
mise.lock
mise.toml
package.json
README.md
skills-lock.json
tuff.lock

# CDN으로 사용하기

jsDelivr

jsDelivr는 공개 GitHub 리포지토리를 별도 설정 없이 CDN으로 즉시 서빙합니다. 버전과 파일을 고르면 웹페이지에 바로 붙일 수 있는 링크와 예시 코드가 만들어집니다.

버전

파일

링크

예시

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

<p align="center"><img src="assets/tuff-readme-banner.png" alt="Tuff banner" width="1100" /></p>

<h1 align="center">Tuff</h1>

<p align="center"><strong>Make your coding-agent playbook reproducible.</strong></p>

<p align="center">Install, version, diff, and update the skills, tools, hooks, and workflows that make your agents useful.</p>

<p align="center">
  <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="License: MIT" /></a>
  <a href="https://crates.io/crates/tuffcli"><img src="https://img.shields.io/crates/v/tuffcli.svg" alt="crates.io" /></a>
  <a href="https://pypi.org/project/tuffcli/"><img src="https://img.shields.io/pypi/v/tuffcli.svg" alt="PyPI" /></a>
</p>

Agent capabilities quickly become part of your engineering infrastructure. But once skills and automation are copied across `.agents/`, `.claude/`, and `.cursor/`, teams lose track of where they came from, what changed, and whether every developer is running the same version.

**Tuff turns that copy-paste into a managed lifecycle.** Capabilities stay as ordinary, project-owned files while Tuff records their source and baseline, emits harness-native output, exposes local drift, and makes upstream updates reviewable.

## See it work in 60 seconds

Install Tuff on macOS or Linux:

```sh
curl -fsSL https://raw.githubusercontent.com/kannandreams/tuff/main/install.sh | sh
```

Then run this inside a project:

```sh
tuff init

# Install a real Rust skill directly from a public Git repository.
tuff add skill https://github.com/pproenca/dot-skills rust-implement \
  --agent open-agents

# Create your own tracked skill for two harnesses.
tuff create skill release-checklist \
  --agent open-agents \
  --agent claude

# Edit .agents/skills/release-checklist/SKILL.md, then review the change.
tuff list
tuff diff release-checklist
tuff update release-checklist
tuff check
```

Tuff installs [`rust-implement`](https://github.com/pproenca/dot-skills/tree/master/skills/.curated/rust-implement) into `.agents/skills/`, records its Git revision, and creates your project skill in `.agents/` and `.claude/`. Each target is tracked in `tuff.lock` with a pristine baseline for drift checks. Commit the capability files and lockfile so the whole team gets the same setup.

Tuff ships dedicated adapters for Claude Code, Codex, and Cursor. The `open-agents` target writes skills to `.agents/skills/`, which GitHub Copilot, Gemini CLI, OpenCode, Windsurf, Amp, Goose, and JetBrains Junie also read.

## What changes with Tuff

| Without Tuff | With Tuff |
|---|---|
| Agent files are copied between repos and machines. | Capabilities are created, adopted, or installed with a repeatable command. |
| Local edits become invisible forks. | `tuff list` and `tuff diff` show drift from the recorded baseline. |
| Every harness needs hand-maintained configuration. | Adapters emit the capability into each harness's native layout. |
| Pulling an upstream update risks losing local changes. | `tuff diff --upstream` previews the change, and updates refuse to overwrite local drift unless you explicitly force them. |
| CI cannot tell whether agent setup has changed. | `tuff check` validates tracked capabilities and fails on drift or missing files. |

## One lifecycle for every capability

| Capability | What it gives an agent |
|---|---|
| **Skill** | Reusable instructions, conventions, and domain context. |
| **Tool** | Executable behavior with a clear contract. |
| **Hook** | Automation triggered at meaningful agent events. |
| **Workflow** | A composable sequence of capabilities. |

All four use the same lifecycle:

```text
local files / git repository / existing agent assets
                         │
                    tuff create
                      or tuff add
                         │
             ┌───────────┼───────────┐
             ▼           ▼           ▼
         .agents/    .claude/    .cursor/
             └───────────┬───────────┘
                         ▼
             tracking metadata + baseline
                         │
              list → diff → update → check
```

Tuff manages the lifecycle around these files; Git remains the source of truth for your repository, and your existing agent runtime continues to execute the capabilities.

## Common workflows

```sh
# Adopt an existing project skill without moving it.
tuff add skill .agents/skills/security-review --agent open-agents

# Install a capability from Git into multiple harnesses.
tuff add skill https://github.com/owner/agent-capabilities security-review \
  --agent open-agents \
  --agent claude

# Build the project's reviewed capabilities and install the release atomically.
tuff pack build --name crm-integration --version 1.2.0
tuff pack verify ./tuff-dist/crm-integration-1.2.0.tuffpack
tuff pack push ./tuff-dist/crm-integration-1.2.0.tuffpack ghcr.io/yourorg/crm-integration:1.2.0
tuff pack pull ghcr.io/yourorg/crm-integration:1.2.0 --output ./tuff-dist/downloaded.tuffpack
tuff add pack ./tuff-dist/downloaded.tuffpack --agent open-agents

# Review and reconcile an upstream change.
tuff outdated
tuff diff security-review --upstream
tuff update security-review --check
tuff update security-review
```

Tuff supports project and global scopes. Project capabilities are designed to be committed with the repository; global capabilities are useful for personal capabilities shared across projects.

### Upgrading from 0.7 or earlier

`tuff.lock` is JSON from 0.8.0, so the formatters and pre-commit hooks a repository runs over its JSON files leave it unchanged. Nothing needs recreating: the new Tuff reads the old TOML file as it is, and the first command that writes the lockfile converts it. To land the conversion as its own commit, once everyone on the project is on 0.8.0 or newer:

```sh
tuff lock migrate
```

Older releases cannot read the converted file, so upgrade before migrating. The VS Code extension runs the `tuff` on your machine and needs no separate step.

## Other installation options

```sh
cargo install tuffcli       # crates.io
uv tool install tuffcli     # PyPI, isolated environment
pip install tuffcli         # PyPI

brew tap kannandreams/tuff  # Homebrew
brew install tuff
```

The package is named `tuffcli`; every installation method provides the `tuff` command.

### Claude Code plugin

Install the plugin to drive Tuff from a Claude Code session:

```sh
claude plugin marketplace add kannandreams/tuff
claude plugin install tuff@tuff
```

It ships the Tuff command reference as a skill and expects the `tuff` command on your PATH. See the [plugin guide](https://tuffcli.dev/guides/claude-code-plugin/).

### VS Code extension

See installed capabilities, drift, and available updates in the editor sidebar. It lives in `editors/vscode` and is on the Visual Studio Marketplace:

```sh
code --install-extension kannandreams.tuff
```

Cursor searches Open VSX rather than the Marketplace, and the extension is not there yet, so install the `.vsix` by hand for now. Like the plugin, it ships no binary and runs the `tuff` on your PATH. See the [extension guide](https://tuffcli.dev/guides/vscode-extension/).

## Documentation

- [Getting started](https://tuffcli.dev/getting-started/)
- [When to use Tuff](https://tuffcli.dev/usage-scenarios/)
- [CLI reference](https://tuffcli.dev/cli/)
- [Lifecycle and drift detection](https://tuffcli.dev/concepts/lifecycle/)
- [Claude Code plugin](https://tuffcli.dev/guides/claude-code-plugin/)
- [VS Code extension](https://tuffcli.dev/guides/vscode-extension/)
- [Changelog](CHANGELOG.md)

## Contributing

Contributions are welcome. See [CONTRIBUTING.md](CONTRIBUTING.md) for project guidelines and [AGENTS.md](AGENTS.md) for repository layout, development commands, and verification guidance. Please follow the [Code of Conduct](CODE_OF_CONDUCT.md).

## License

Tuff is released under the [MIT License](LICENSE).